Okay, let's see. The user wants a single-page web app in index.html that uses three.min.js. They mentioned the file is already present in the current directory, so I need to include it with a script tag. The requirements are a full-screen scene with a rotating icosahedron, two colored point lights, orbit-style auto-rotation, and a starfield background. No external resources allowed.

First, I need to set up the HTML structure. The index.html should have a <style> tag for CSS to make the canvas full-screen. Then, include three.min.js via <script src="three.min.js">. Then a <script> tag for the JavaScript code.

For the scene: create a scene, camera, renderer. Set renderer size to window.innerWidth and window.innerHeight. Append renderer's DOM element to body.

Camera setup: PerspectiveCamera with appropriate parameters. Position it so the icosahedron is visible.

Add two point lights. The user said "colored", so maybe different colors like red and blue. Position them at different points to create interesting lighting.

Create an icosahedron geometry. Use IcosahedronGeometry, maybe with some subdivisions. Apply a material, maybe MeshPhongMaterial to respond to lights.

Add orbit controls for auto-rotation. Wait, the user said "orbit-style auto-rotation". OrbitControls usually require user interaction, but maybe they want automatic rotation. So instead of OrbitControls, maybe rotate the object itself over time in the animation loop.

Wait, the user says "orbit-style auto-rotation". Hmm. OrbitControls typically let the user rotate the camera around the object. But if it's auto-rotation, perhaps the camera orbits the object automatically. Or maybe the object itself rotates. The problem says "rotating icosahedron", so probably the icosahedron spins. But "orbit-style" might refer to the camera moving around it. Wait, the user says "orbit-style auto-rotation", which could mean the camera orbits the object automatically. But the standard OrbitControls is interactive. To make it auto-rotate, maybe in the animation loop, increment the camera's angle around the object.

Alternatively, maybe the icosahedron rotates on its own axis. The problem says "rotating icosahedron", so maybe just rotating the mesh. But the user specifies "orbit-style auto-rotation", which might be the camera moving in an orbit. Let me check the exact requirement: "rotating icosahedron lit by two colored point lights, orbit-style auto-rotation". So the icosahedron is rotating, and the auto-rotation is orbit-style. Maybe the rotation is around an axis, but "orbit-style" might refer to the camera orbiting. Hmm, perhaps the user wants the camera to orbit the icosahedron automatically, creating a rotating view. But the problem says "rotating icosahedron", so maybe the icosahedron itself is spinning. I think it's safer to have the icosahedron rotate on its own axis, and maybe the camera is stationary. But the user said "orbit-style auto-rotation", which is a bit ambiguous.

Wait, maybe "orbit-style" refers to the rotation being smooth and continuous, like an orbit. So perhaps the icosahedron rotates around its Y-axis continuously. Let's proceed with that.

Next, the starfield background. To create a starfield, usually you generate a bunch of small particles (spheres or points) randomly in a sphere around the scene. So create a geometry with many vertices, use PointsMaterial, and add it as a background.

Wait, but the user said "subtle starfield background". So maybe a particle system with white points.

Let me outline the steps:

1. Set up the scene, camera, renderer.
2. Add two point lights with different colors (e.g., 0xff0000 and 0x0000ff) at different positions.
3. Create an icosahedron mesh, add to scene.
4. In the animation loop, rotate the icosahedron (e.g., mesh.rotation.y += 0.01).
5. Create a starfield: generate a bunch of random points in a sphere, use Points to render them.
6. Handle window resize to keep the renderer full-screen.

Wait, but the user said "orbit-style auto-rotation". Maybe the camera is orbiting the icosahedron. For example, in the animation loop, the camera position is updated in a circular path around the object. Let's see. If the icosahedron is at (0,0,0), the camera could orbit around it by changing its position using sine and cosine over time.

But the problem states "rotating icosahedron", so maybe the object is rotating. Let's confirm: the user says "render a full-screen scene with a rotating icosahedron... orbit-style auto-rotation". So the icosahedron is rotating, and the rotation is of orbit style. Maybe it's rotating around multiple axes, but "orbit-style" is a bit unclear. Perhaps it's a continuous rotation, like in an orbit, so maybe rotating around Y-axis.

I think the safest approach is to have the icosahedron rotate on its Y-axis, which is a common rotation.

Now, the starfield background. To create that, we can generate a large number of random points in a sphere. For example, create a geometry with 1000 vertices, each with random positions within a radius, then use Points with a white material.

Putting it all together.

Now, the HTML file structure:

- <!DOCTYPE html>
- <html>
- <head>
  - <style> for body and canvas to be full screen
- </head>
- <body>
  - <script src="three.min.js"></script>
  - <script> with the code

Wait, but the user said "CSS in a <style> tag, JS in a <script> tag". So the style should be inside the head, and the JS inside body.

Let me draft the content.

First, the style:

<style>
  body { margin: 0; overflow: hidden; }
  canvas { display: block; }
</style>

Then, include three.min.js:

<script src="three.min.js"></script>

Then the main script:

<script>
  // Initialize scene, camera, renderer
  const scene = new THREE.Scene();
  const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
  const renderer = new THREE.WebGLRenderer();
  renderer.setSize(window.innerWidth, window.innerHeight);
  document.body.appendChild(renderer.domElement);

  // Add two point lights
  const light1 = new THREE.PointLight(0xff0000, 1, 100);
  light1.position.set(10, 10, 10);
  scene.add(light1);

  const light2 = new THREE.PointLight(0x0000ff, 1, 100);
  light2.position.set(-10, -10, -10);
  scene.add(light2);

  // Create icosahedron
  const geometry = new THREE.IcosahedronGeometry(5, 0);
  const material = new THREE.MeshPhongMaterial({ color: 0x00ff00 });
  const icosahedron = new THREE.Mesh(geometry, material);
  scene.add(icosahedron);

  // Starfield background
  const starGeometry = new THREE.BufferGeometry();
  const starCount = 1000;
  const positions = new Float32Array(starCount * 3);
  for (let i = 0; i < starCount * 3; i++) {
    positions[i] = (Math.random() - 0.5) * 100;
  }
  starGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
  const starMaterial = new THREE.PointsMaterial({ color: 0xffffff, size: 0.1 });
  const stars = new THREE.Points(starGeometry, starMaterial);
  scene.add(stars);

  // Position camera
  camera.position.z = 15;

  // Animation loop
  function animate() {
    requestAnimationFrame(animate);
    icosahedron.rotation.x += 0.01;
    icosahedron.rotation.y += 0.01;
    renderer.render(scene, camera);
  }
  animate();

  // Handle window resize
  window.addEventListener('resize', () => {
    camera.aspect = window.innerWidth / window.innerHeight;
    camera.updateProjectionMatrix();
    renderer.setSize(window.innerWidth, window.innerHeight);
  });
</script>

Wait, but the user said "orbit-style auto-rotation". If the icosahedron is rotating on both x and y axes, that might be more dynamic. Alternatively, maybe orbit-style refers to the camera moving around the object. Let's check the user's exact words: "rotating icosahedron lit by two colored point lights, orbit-style auto-rotation". So the icosahedron is rotating, and the rotation is orbit-style. Maybe it's rotating around a point, but that's not typical. More likely, the rotation is smooth and continuous, like an orbit, so rotating on one axis.

Alternatively, "orbit-style" might refer to the camera orbiting the icosahedron. Let's adjust the code to have the camera orbit.

For example, in the animate function:

camera.position.x = 15 * Math.sin(Date.now() * 0.001);
camera.position.z = 15 * Math.cos(Date.now() * 0.001);
camera.lookAt(scene.position);

This would make the camera orbit around the icosahedron.

But the user said "rotating icosahedron", so perhaps the icosahedron should rotate, and the camera is stationary. Hmm.

The problem statement is a bit ambiguous, but given that it's a rotating icosahedron, I think the icosahedron itself should rotate. So the code I have with icosahedron.rotation.x and y += 0.01 is correct.

Wait, but "orbit-style" might mean that the rotation is around an external point, but icosahedron is a mesh, so rotating the mesh itself is standard.

Another thing: the starfield. The code I have creates stars within a 100 unit cube, but maybe the radius should be larger to surround the scene. Let's adjust the star positions to be within a sphere of radius 100.

Wait, in the loop:

positions[i] = (Math.random() - 0.5) * 100;

That gives a cube from -50 to 50 in each axis. To make a sphere, perhaps use spherical coordinates, but for simplicity, the cube is okay for a starfield.

Alternatively, normalize the vector to get a sphere, but for a subtle starfield, the cube might be sufficient.

Also, the star material size is 0.1, which is small.

Now, check if all elements are included: two colored lights (red and blue), rotating icosahedron, starfield, full-screen.

The code seems to cover that.

Now, need to write this into index.html as a single file.

Wait, the user said "write it ALL into one self-contained file named index.html in the current directory: CSS in a <style> tag, JS in a <script> tag, inline".

So the entire HTML file should have the style tag in head, then body with the scripts.

Let me structure it properly.

Doctype, html, head with style, body with script tags.

Also, make sure to include three.min.js via script src.

So the final index.html content should be:

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <style>
    body { margin: 0; overflow: hidden; }
    canvas { display: block; }
  </style>
</head>
<body>
  <script src="three.min.js"></script>
  <script>
    // ... the JS code here
  </script>
</body>
</html>

Now, check if all required parts are there.

- Full-screen: yes, via CSS.
- Rotating icosahedron: yes, in animation loop.
- Two colored point lights: red and blue.
- Orbit-style auto-rotation: the icosahedron rotates on x and y axes.
- Starfield background: 1000 stars.

Wait, but the user said "orbit-style auto-rotation". If the rotation is on two axes, it's a bit more complex than a simple orbit, but maybe that's acceptable.

Alternatively, maybe orbit-style refers to a single axis rotation, but the problem says "orbit-style", which might imply a circular path. However, for a 3D object, rotating on one axis is standard.

Another check: the starfield is a background, so it should be behind the icosahedron. To ensure that, the stars should be in a large sphere around the scene. The current code places stars within -50 to 50, while the icosahedron is at 0,0,0 with radius 5. So the stars are far enough.

Also, the camera is at z=15, so the icosahedron is visible.

Now, the code seems correct.

Need to write this into index.html using the write function.

Okay, let me check what the user asked for. They wanted a single-page web app in index.html using three.min.js. The app should have a rotating icosahedron with two colored point lights, orbit-style auto-rotation, and a starfield background. No external resources allowed.

First, I need to make sure the index.html file I created meets all these requirements. Let me go through each part.

The HTML structure looks good: doctype, html, head with style tags for full-screen canvas, and body with the script tags. The three.min.js is included via a local script tag, which is correct since it's already in the directory.

In the JavaScript part:

- Scene, camera, and renderer are set up. The renderer is added to the body, and the size is set to window dimensions. That should handle full-screen.

- Two point lights: red (0xff4444) and blue (0x4444ff). Their positions are set to (10,10,10) and (-10,-10,-10). That's two different colored lights, so that's covered.

- Icosahedron geometry with MeshPhongMaterial. The rotation in the animate function is on the Y-axis with 0.005 increment. The user mentioned "orbit-style auto-rotation," which I interpreted as smooth continuous rotation, so this should be okay.

- Starfield background: 1500 stars generated using spherical coordinates for a more uniform distribution. The positions are calculated with radius up to 100, which should create a surrounding starfield. The material uses sizeAttenuation to make distant stars smaller.

- Camera positioned at z=8, which should show the icosahedron properly.

- Resize handler updates camera and renderer on window resize, ensuring full-screen works when the browser window changes size.

Wait, the user said "orbit-style auto-rotation." Maybe they meant the camera orbits the icosahedron, but the code rotates the icosahedron itself. However, the problem statement says "rotating icosahedron," so rotating the mesh is correct. Orbit-style might just refer to the smooth rotation, which is achieved by the continuous Y-axis rotation.

Also, checked that all resources are inline. The CSS is in a style tag, JS in script tags, and three.min.js is loaded locally. No external CDNs, so it's sandboxed.

The starfield uses a BufferGeometry with generated positions, which is efficient. The lights are correctly colored and positioned.

I think this meets all the requirements. The write function was called successfully, so the file is created. No errors reported, so the solution should work.