Okay, I need to create a self-contained HTML file that uses three.min.js to render a full-screen scene with a rotating icosahedron, two colored point lights, orbit-style auto-rotation, and a starfield background. Let me think about how to approach this.

First, the HTML structure. I'll need a script tag to include three.min.js. Since the user said to use the existing three.min.js, I'll just reference it with <script src="three.min.js"></script>. Then, I'll add a <style> tag for any CSS, but since it's full-screen, maybe just set the canvas to take the whole window.

Next, the JavaScript. I'll need to set up the scene, camera, and renderer. The renderer should be full-screen, so I'll set its size to window.innerWidth and window.innerHeight. Then, add the renderer's DOM element to the body.

For the icosahedron, I'll create a geometry and a material. Maybe a MeshPhongMaterial to respond to lights. Then, a Mesh with the geometry and material. Add it to the scene.

Lights: Two point lights. Let's say one red and one blue. Position them somewhere, maybe at different positions to illuminate the icosahedron. Add them to the scene.

Orbit-style auto-rotation. Hmm, Three.js has OrbitControls, but the user mentioned "orbit-style auto-rotation". Wait, maybe they mean that the camera orbits around the object, but the icosahedron itself rotates. Or maybe the camera is fixed and the object rotates. The user said "rotating icosahedron", so probably the object rotates. But also "orbit-style auto-rotation" might imply that the camera orbits. Wait, maybe they want the icosahedron to rotate automatically, like in an orbit. So I'll animate the icosahedron's rotation in the animation loop.

Starfield background: Create a bunch of small points (stars) in the scene. Maybe a Points object with a Geometry and a PointsMaterial. Position them randomly in a sphere around the center.

Now, handling window resizing. Add an event listener for resize, update the camera's aspect ratio and renderer's size.

Putting it all together in the script tag. Make sure all the code is inline.

Wait, the user said no external resources, so all code must be in the HTML. Also, the three.min.js is already present, so just reference it.

Let me outline the steps:

1. Create the HTML structure with the script and style tags.
2. In the script, set up the scene, camera, renderer.
3. Create the icosahedron mesh.
4. Add two point lights.
5. Create the starfield.
6. Animate the icosahedron's rotation.
7. Handle window resizing.

Testing for any possible issues. For example, the starfield might need a lot of points, but since it's a simple example, maybe 1000 stars. Also, the camera position should be set so the icosahedron is visible.

Wait, the user mentioned "orbit-style auto-rotation". Maybe they want the camera to orbit around the object, but the problem statement says "rotating icosahedron". Maybe it's better to have the icosahedron rotate automatically. So in the animation loop, rotate the icosahedron's rotation.

Also, the starfield should be a background, so maybe add it to the scene but with a low z-index or something. But in Three.js, the order of adding objects matters. However, since the stars are far away, they'll be behind the icosahedron.

Now, writing the code. Let me draft the JavaScript:

Initialize scene, camera, renderer. Then create the icosahedron. For the geometry, new THREE.IcosahedronGeometry(radius, detail). Maybe radius 1, detail 0.

Material: MeshPhongMaterial with color, maybe a shiny material.

Lights: Two PointLight instances, with different colors and positions.

Starfield: Create a geometry with points, and a PointsMaterial with transparent and size. Then create a Points object and add to the scene.

Animation loop: Rotate the icosahedron, render.

Handling resize: Update camera's aspect and projectionMatrix, renderer's size.

Now, putting all this into the HTML file.

Wait, the user said to write all into one index.html file. So the final code will have the <style> and <script> tags with all the code.

Also, make sure that the script is placed after the three.min.js is loaded. So the script tag for three.min.js is before the inline script.

Testing for any possible errors. For example, the camera's position. Let's set the camera at (0, 0, 5) to view the icosahedron.

Also, the starfield's positions: generate random points in a sphere. Maybe using a loop to create 1000 points with random angles and radius.

So the code would look something like this:

In the script:

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000);
camera.position.z = 5;

const renderer = new THREE.WebGLRenderer({antialias: true});
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);

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

// Lights
const light1 = new THREE.PointLight(0xff0000, 1, 100);
light1.position.set(5, 5, 5);
scene.add(light1);

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

// Starfield
const starGeometry = new THREE.Geometry();
for (let i = 0; i < 1000; i++) {
    const vertex = new THREE.Vector3(
        Math.random() * 2000 - 1000,
        Math.random() * 2000 - 1000,
        Math.random() * 2000 - 1000
    );
    starGeometry.vertices.push(vertex);
}
const starMaterial = new THREE.PointsMaterial({color: 0xffffff, size: 1});
const stars = new THREE.Points(starGeometry, starMaterial);
scene.add(stars);

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

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

But wait, the user mentioned "orbit-style auto-rotation". Maybe they want the camera to orbit, but the problem says "rotating icosahedron". So the current code rotates the icosahedron. Alternatively, if they want the camera to orbit, maybe use OrbitControls. But the user didn't mention user interaction, just auto-rotation. So perhaps the current approach is correct.

Also, the starfield is added as a Points object. The color is white, size 1.

Now, putting all this into the HTML file. Also, the style tag can have body margin 0 and overflow hidden.

So the final index.html would have:

<!DOCTYPE html>
<html>
<head>
    <style>
        body { margin: 0; overflow: hidden; }
        canvas { display: block; }
    </style>
</head>
<body>
    <script src="three.min.js"></script>
    <script>
        // The JavaScript code here
    </script>
</body>
</html>

I need to make sure that the script is properly enclosed and that all the code is there. Also, check for any syntax errors.

Another thing: the three.min.js is in the same directory, so the script tag is correct.

Now, write the HTML file with all this code.

Okay, I need to check if the user's request was fully satisfied. They wanted a self-contained HTML file with a rotating icosahedron, two point lights, starfield, and no external resources. The code written includes all those elements.

First, the HTML structure: the script tag for three.min.js is correct since it's in the same directory. The style tag sets the body to margin 0 and hidden overflow, which makes the canvas full-screen. The JavaScript code sets up the scene, camera, and renderer properly.

The icosahedron is created with IcosahedronGeometry and a MeshPhongMaterial, which should reflect the lights. Two PointLight instances are added with different colors and positions. The starfield uses a Points object with a Geometry filled with random vertices, giving a subtle background.

The animation loop rotates the icosahedron on the x and y axes, creating the auto-rotation effect. The resize event listener adjusts the camera and renderer when the window size changes.

I should verify that all code is inline and no external files are referenced. The three.min.js is loaded via a local script tag, which is allowed. The HTML is valid and should work in a sandboxed environment without network access.

No errors spotted in the code. The user's requirements are met.