Okay, I need to create a single index.html file that includes a rotating icosahedron with two colored point lights, orbit-style auto-rotation, and a subtle starfield background using three.min.js. Let me break this down step by step.

First, I'll start with the basic HTML structure. The file needs to have a <style> tag for CSS and a <script> tag for the JavaScript. Since the user specified not to use external resources, all CSS and JS will be inline.

For the CSS, I want the scene to take up the full screen, so I'll set the html and body to have height: 100% and margin: 0. The canvas should be positioned absolutely to fill the window.

Now, the JavaScript part. I'll need to set up the Three.js scene. The main components are the scene, camera, renderer, the icosahedron geometry, materials, lights, and the starfield.

Starting with the scene setup: create a scene, a perspective camera, and a WebGLRenderer. The renderer should set the pixel ratio to window.devicePixelRatio and the size to window.innerWidth and window.innerHeight. Append the renderer's DOM element to the body.

Next, the icosahedron. Three.js has an IcosahedronGeometry, so I'll use that. For the material, maybe a MeshStandardMaterial with a color that's not too bright. Then create a mesh and add it to the scene.

For the lights, two point lights with different colors. Position them at different places, maybe one on the left and one on the right. Set their intensity appropriately so they don't overpower each other.

OrbitControls are needed for the auto-rotation. Wait, but the user mentioned "orbit-style auto-rotation". Oh right, OrbitControls allows the user to interact, but the auto-rotation is a feature of the controls. So I need to enable autoRotate and set the autoRotateSpeed. But wait, does OrbitControls have that by default? I think the auto rotation isn't enabled by default. So after creating the controls, I need to set controls.autoRotate = true and maybe adjust the speed.

Then the starfield background. The simplest way is to create a bunch of particles. Create a Geometry, add random points in a sphere around the scene, then use a PointsMaterial with a color, and create a Points object. Add that to the scene. Alternatively, a starfield texture could be used, but since I can't use external resources, generating points is better.

Handling window resizing: add an event listener to update the camera's aspect ratio and renderer size when the window is resized. Also, in the animation loop, call controls.update() if using OrbitControls.

In the animation loop, rotate the icosahedron a bit each frame, and render the scene. Also, if the auto-rotation is handled by the controls, maybe the rotation is managed automatically.

Wait, but the user said "orbit-style auto-rotation". Maybe they mean that the camera orbits around the object automatically. Alternatively, the object itself rotates. Let me check the requirements again. The user said "orbit-style auto-rotation", which usually refers to the camera orbiting, but with OrbitControls, autoRotate makes the camera rotate around the target. But if the user wants the object to rotate, then maybe just rotating the mesh in the animation loop. However, the mention of OrbitControls suggests that the camera is controlled with orbit controls, which includes auto-rotation. So perhaps the user wants the camera to auto-rotate around the object. So I'll set up the controls, enable autoRotate, and have the camera orbit around the icosahedron.

Putting it all together:

1. Scene setup with camera and renderer.
2. Create icosahedron mesh with material.
3. Add two colored point lights.
4. Create starfield using Points.
5. Add OrbitControls and enable autoRotate.
6. Handle window resizing.
7. Animation loop: rotate the mesh (if needed?), update controls, render.

Wait, but if the autoRotate is enabled on the controls, the camera's rotation is handled automatically, which would make the icosahedron appear to rotate as the camera moves around it. Alternatively, if the user wants the icosahedron itself to rotate, then in the animation loop, increment its rotation. Maybe both? The user might want the object to rotate while the camera orbits. Hmm, the question says "orbit-style auto-rotation", which probably refers to the camera's orbit. But the icosahedron should also rotate. Wait, the original request says "rotating icosahedron" and "orbit-style auto-rotation". So two things: the icosahedron is rotating on its own, and the camera has orbit controls with auto-rotation. Or maybe the orbit-style auto-rotation refers to the object's rotation. Need to clarify.

Alternatively, perhaps "orbit-style" refers to the rotation being around the object, like the camera orbits while the object stays still. But the user says "rotating icosahedron", so the object itself is rotating. So in the animation loop, the icosahedron's rotation should be updated, and the camera's auto-rotation is handled by OrbitControls. Wait, but if the camera is auto-rotating, that would also create a rotation effect around the object. Maybe the user wants both? Or just one. To cover both, perhaps add auto-rotation via controls and also rotate the object. But maybe the user just wants the object to rotate. Let me think. The problem statement says "render a full-screen scene with a rotating icosahedron lit by two colored point lights, orbit-style auto-rotation, and a subtle starfield background." The "orbit-style auto-rotation" could be referring to the camera's orbit controls with auto-rotation enabled. So the camera auto-rotates around the object, and the icosahedron itself is rotating. Or maybe the orbit-style auto-rotation is the camera moving. So in the code, I'll include OrbitControls with autoRotate enabled, and in the animation loop, rotate the icosahedron.

Now, for the starfield. Create a Points system with a large number of vertices positioned randomly in a sphere. The material can be a PointsMaterial with a white color and a small size. Alternatively, use a shader for a more efficient starfield, but for simplicity, using a geometry with many points.

Potential issues: performance with many points. But since it's a simple example, maybe 1000 points would suffice.

Putting it all together in code:

- Initialize scene, camera, renderer.
- Create icosahedron with MeshStandardMaterial.
- Add two point lights with different colors (e.g., red and blue) at different positions.
- Create starfield geometry and material, add to scene.
- Add OrbitControls, set autoRotate to true.
- Handle resize.
- Animation loop: rotate the icosahedron, update controls, render.

Wait, but if the controls are auto-rotating, do I need to call controls.update() in the animation loop? Yes, I think so.

Testing the code structure:

In the script:

Initialize all objects.

Then the animate function:

function animate() {
    requestAnimationFrame(animate);
    mesh.rotation.y += 0.01;
    controls.update();
    renderer.render(scene, camera);
}

But if the controls have autoRotate enabled, then they will update their rotation automatically. So the camera's rotation is handled by the controls. So in addition to rotating the mesh, the camera is orbiting around. But maybe the user wants the mesh to rotate on its own axis. So combining both effects.

So in the code:

mesh.rotation.y += 0.01; // Rotate the object

and controls.autoRotate = true; // Rotate the camera.

This would create a more dynamic scene.

Now, code steps:

Import three.min.js via script tag.

Then, in the script:

Set up scene, camera, renderer.

Create the icosahedron:

const geometry = new THREE.IcosahedronGeometry(1, 0);
const material = new THREE.MeshStandardMaterial({ color: 0x00ffcc, flatShading: true });
const mesh = new THREE.Mesh(geometry, material);
scene.add(mesh);

Add two lights:

const light1 = new THREE.PointLight(0xff0000, 1);
light1.position.set(-2, 2, 2);
scene.add(light1);

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

Create the starfield:

const starGeometry = new THREE.BufferGeometry();
const starCount = 1000;
const starVertices = [];

for (let i = 0; i < starCount; i++) {
    const theta = Math.random() * Math.PI * 2;
    const phi = Math.acos((Math.random() * 2) - 1);
    const radius = 100; // Large radius to surround the scene

    const x = radius * Math.sin(phi) * Math.cos(theta);
    const y = radius * Math.sin(phi) * Math.sin(theta);
    const z = radius * Math.cos(phi);

    starVertices.push(x, y, z);
}

starGeometry.setAttribute('position', new THREE.Float32BufferAttribute(starVertices, 3));

const starMaterial = new THREE.PointsMaterial({ color: 0xffffff, size: 0.5 });
const stars = new THREE.Points(starGeometry, starMaterial);
scene.add(stars);

But wait, BufferGeometry and Float32BufferAttribute are correct. However, in older versions of Three.js, BufferAttribute might be used directly. But assuming three.min.js is recent enough.

Set up the camera position:

camera.position.z = 3;

Create OrbitControls:

const controls = new THREE.OrbitControls(camera, renderer.domElement);
controls.autoRotate = true;
controls.autoRotateSpeed = 0.5;

Handle window resize:

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

Animation loop:

function animate() {
    requestAnimationFrame(animate);
    mesh.rotation.y += 0.01;
    controls.update();
    renderer.render(scene, camera);
}
animate();

Wait, but the starfield is part of the scene, so it should be rendered as well. Since it's added to the scene, the renderer will handle it.

Now, putting all this into the index.html file.

Potential issues:

- OrbitControls might need to be imported separately. Oh wait, the user provided three.min.js, but OrbitControls is part of the examples in Three.js. So if the three.min.js includes the controls, then it's okay. Otherwise, the code would need to include it. However, the user hasn't provided any other files. So this is a problem. Because OrbitControls is not part of the core three.min.js. It's in the examples. So the code would need to include a script tag for OrbitControls.

Wait, the user said that the library files already present are three.min.js. So how to include OrbitControls? The user didn't mention it. Therefore, perhaps the code cannot use OrbitControls, which complicates the auto-rotation.

This is a critical point. If the user only has three.min.js, then the OrbitControls is not available. So the auto-rotation has to be simulated by rotating the camera around the object.

So the user's requirement says "orbit-style auto-rotation". Without OrbitControls, how to achieve that?

Alternative approach: manually rotate the camera around the object in the animation loop.

For example, in the animate function, update the camera's position to orbit around the icosahedron.

Let me think. The camera can be moved in a circular path around the Y-axis. So:

In the animation loop:

camera.position.x = radius * Math.sin(angle);
camera.position.z = radius * Math.cos(angle);
camera.lookAt(mesh.position);
angle += 0.01;

This would create an orbiting effect.

So this would replace the need for OrbitControls. Then, the auto-rotation is handled by the code, not the controls. So the user can't interact, but the problem says "orbit-style auto-rotation", which could be the automatic rotation without user input.

But the user might expect the camera to orbit, but the original problem says "rotating icosahedron". Maybe the orbit-style refers to the rotation of the object. Alternatively, perhaps the user wants the object to rotate in a way that suggests orbiting.

Alternatively, the orbit-style auto-rotation could be the object rotating continuously. So the code would rotate the icosahedron in the animation loop.

But the user mentioned both "rotating icosahedron" and "orbit-style auto-rotation", implying two different effects.

So perhaps the orbit-style refers to the camera orbiting around the object automatically. Without OrbitControls, this has to be done manually.

So in the code, in the animation loop, update the camera's position in a circular path around the object.

So let's proceed with that approach.

So removing the OrbitControls part and instead handle camera rotation manually.

Let me adjust the code:

In the animation function:

let angle = 0;

function animate() {
    requestAnimationFrame(animate);
    angle += 0.01;
    camera.position.x = 3 * Math.sin(angle);
    camera.position.z = 3 * Math.cos(angle);
    camera.lookAt(mesh.position);
    mesh.rotation.y += 0.01;
    renderer.render(scene, camera);
}

This way, the camera orbits around the icosahedron while the icosahedron itself rotates.

But camera.lookAt(mesh.position) is necessary to have the camera face the object as it moves.

This approach doesn't require OrbitControls, so it works with just three.min.js.

This seems feasible.

Now, considering that the user wants a self-contained index.html, with all CSS and JS inline, and only three.min.js loaded via script tag.

Putting it all together.

Now, code outline:

<!DOCTYPE html>
<html>
<head>
    <title>Rotating Icosahedron</title>
    <style>
        html, body {
            height: 100%;
            margin: 0;
            overflow: hidden;
        }
        canvas {
            display: block;
            width: 100%;
            height: 100%;
        }
    </style>
</head>
<body>
    <script src="three.min.js"></script>
    <script>
        // JavaScript code here
    </script>
</body>
</html>

Now, the JavaScript code:

Initialize scene, camera, renderer.

scene = new THREE.Scene();
camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000);
renderer = new THREE.WebGLRenderer({antialias: true});
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);

Create the icosahedron:

geometry = new THREE.IcosahedronGeometry(1, 0);
material = new THREE.MeshStandardMaterial({color: 0x00ffcc, flatShading: true});
mesh = new THREE.Mesh(geometry, material);
scene.add(mesh);

Add two colored point lights:

light1 = new THREE.PointLight(0xff0000, 1);
light1.position.set(-2, 2, 2);
scene.add(light1);

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

Starfield:

starGeometry = new THREE.BufferGeometry();
starCount = 1000;
starVertices = [];

for (let i = 0; i < starCount; i++) {
    theta = Math.random() * Math.PI * 2;
    phi = Math.acos((Math.random() * 2) - 1);
    radius = 100;

    x = radius * Math.sin(phi) * Math.cos(theta);
    y = radius * Math.sin(phi) * Math.sin(theta);
    z = radius * Math.cos(phi);

    starVertices.push(x, y, z);
}

starGeometry.setAttribute('position', new THREE.Float32BufferAttribute(starVertices, 3));

starMaterial = new THREE.PointsMaterial({color: 0xffffff, size: 0.5});
stars = new THREE.Points(starGeometry, starMaterial);
scene.add(stars);

Camera initial position:

camera.position.z = 3;

Animation loop:

let angle = 0;

function animate() {
    requestAnimationFrame(animate);
    angle += 0.01;
    camera.position.x = 3 * Math.sin(angle);
    camera.position.z = 3 * Math.cos(angle);
    camera.lookAt(mesh.position);
    mesh.rotation.y += 0.01;
    renderer.render(scene, camera);
}
animate();

Also, handle window resizing:

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

Putting all this into the script tag.

Potential issues:

- The starfield uses a large number of points. If performance is a problem, reduce starCount.

- The Icosahedron might be too detailed; the second parameter in IcosahedronGeometry is the detail level. Setting it to 0 for lower poly count.

- Lighting positions: need to ensure they are placed to illuminate the object effectively.

Testing the code in the headless environment. Since I can't test it here, I'll proceed to write the code accordingly.

Now, the final index.html will have all these parts combined.

Now, I need to write this into the index.html file using the write function.

Okay, I've successfully created the index.html file with all the required elements. Let me just make sure everything is covered.

The user wanted a full-screen scene with a rotating icosahedron. The code includes the icosahedron geometry with a MeshStandardMaterial for a nice look. Two colored point lights are added—one red and one blue—at different positions to create interesting lighting effects. 

For the orbit-style auto-rotation, since the user's provided three.min.js doesn't include OrbitControls, I manually updated the camera's position in the animation loop to orbit around the object. This gives that continuous rotation effect without needing additional libraries.

The starfield background is generated using a Points system with randomly placed points in a sphere around the scene. This should create a subtle, space-like background. The stars are white points with a small size to keep them subtle.

I also included the necessary CSS to make sure the canvas fills the entire screen and handles resizing properly. The JavaScript handles window resizing by updating the camera and renderer dimensions accordingly.

Testing this in a browser should show a rotating icosahedron with the camera orbiting around it, two colored lights, and a starfield background. All resources are inline or from the provided three.min.js, so no external dependencies are needed. Looks like everything the user asked for is there!