We are building a single-page web app (index.html) that uses the provided three.min.js.
 We have to include the script tag for three.min.js (which is already present in the current directory).
 Since the app is self-contained, we'll write the HTML, CSS, and JS in one file.

 Steps:
 1. Create the basic HTML structure.
 2. Include the three.min.js script.
 3. Write CSS for full-screen canvas and remove margins.
 4. Write JavaScript to:
    a. Initialize the scene, camera, and renderer (full-screen, WebGL).
    b. Create an icosahedron (using THREE.IcosahedronGeometry) with a material (e.g., MeshStandardMaterial).
    c. Add two colored point lights (with different colors) and position them appropriately.
    d. Add an OrbitControls for auto-rotation and user control.
    e. Create a subtle starfield background (using a large number of small points scattered in the scene).
    f. Set up an animation loop to rotate the icosahedron and update the controls.
    g. Handle window resize.

 Note: We are not allowed to use external resources, so everything is inline.

 Let's break down the JS:

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

  - Renderer:
      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); // radius, detail
      const material = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: 0.5, metalness: 0.5 });
      const icosahedron = new THREE.Mesh(geometry, material);
      scene.add(icosahedron);

  - Point Lights:
      const light1 = new THREE.PointLight(0xff0000, 1, 100); // color, intensity, distance
      light1.position.set(2, 2, 2);
      scene.add(light1);

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

  - OrbitControls (from THREE's controls):
      After including three.min.js, OrbitControls is available as THREE.OrbitControls.
      const controls = new THREE.OrbitControls(camera, renderer.domElement);
      controls.autoRotate = true;
      controls.autoRotateSpeed = 2.0;

  - Starfield Background:
      We can create a particle system with many small points (THREE.Points) spread in a sphere or cube.
      We'll create a large number of stars (e.g., 5000) at random positions within a large radius.

      const starGeometry = new THREE.BufferGeometry();
      const starMaterial = new THREE.PointsMaterial({ color: 0xffffff, size: 0.02 });

      // Generate 5000 stars
      const stars = [];
      for (let i = 0; i < 5000; i++) {
          // Position each star in a sphere of radius 100
          const x = (Math.random() - 0.5) * 200;
          const y = (Math.random() - 0.5) * 200;
          const z = (Math.random() - 0.5) * 200;
          stars.push(x, y, z);
      }

      starGeometry.setAttribute('position', new THREE.Float32BufferAttribute(stars, 3));
      const starField = new THREE.Points(starGeometry, starMaterial);
      scene.add(starField);

  - Animation loop:
      function animate() {
          requestAnimationFrame(animate);
          icosahedron.rotation.x += 0.01;
          icosahedron.rotation.y += 0.01;
          controls.update(); // required if controls.enableDamping = true, but we are auto rotating so update is needed
          renderer.render(scene, camera);
      }
      animate();

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

 However, note: We are using OrbitControls which also needs to handle resize? Actually, the controls don't require resize handling, but we are updating the camera and renderer.

  Also, note: We are adding auto-rotation to the controls and also rotating the icosahedron. Let's decide: either the scene (icosahedron) rotates on its own (without controls) but we also have an auto-rotating camera. The requirements say "orbit-style auto-rotation", meaning the camera orbits the object. So we can set:
      controls.autoRotate = true;
  and remove the manual rotation of the icosahedron? Or do both? The requirement says "rotating icosahedron", so we can have the icosahedron rotating on its own axis and the camera orbiting? Or just the camera? The problem is ambiguous.

  Since it says "orbit-style auto-rotation", I think the camera orbits the object (so the object itself doesn't rotate locally, but the camera moves around it). Also, the controls allow the user to rotate the view.

  But the requirement also says "rotating icosahedron". So perhaps we want the icosahedron to rotate on its own axis and then also the camera orbits? That might be too much. Let me re-read: "render a full-screen scene with a rotating icosahedron lit by two colored point lights, orbit-style auto-rotation"

  Interpretation:
    - Rotating icosahedron: the object itself rotates (so we update its rotation)
    - Orbit-style auto-rotation: the camera automatically orbits (which is provided by OrbitControls.autoRotate)

  Then we do both:
    In the animation loop:
      icosahedron.rotation.x += 0.005;
      icosahedron.rotation.y += 0.005;
      controls.update(); // because autoRotate is on

  Also, we have two point lights.

  We'll write the entire HTML in one string and write it to index.html.

 Let me write the entire index.html content:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Three.js Icosahedron</title>
    <style>
        body { 
            margin: 0; 
            overflow: hidden; /* Prevent scrollbars */
        }
        canvas { 
            display: block; 
        }
    </style>
</head>
<body>
    <script src="three.min.js"></script>
    <script>
        // Wait for the script to be executed after the page loads
        document.addEventListener('DOMContentLoaded', function() {
            // Scene setup
            const scene = new THREE.Scene();
            const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
            camera.position.z = 5;

            // Renderer
            const renderer = new THREE.WebGLRenderer({ antialias: true });
            renderer.setSize(window.innerWidth, window.innerHeight);
            renderer.setClearColor(0x000000); // black background, but we are adding stars so it should be black
            document.body.appendChild(renderer.domElement);

            // Icosahedron
            const geometry = new THREE.IcosahedronGeometry(1, 0); // radius=1, detail=0
            const material = new THREE.MeshStandardMaterial({ 
                color: 0xffffff, 
                roughness: 0.5, 
                metalness: 0.5 
            });
            const icosahedron = new THREE.Mesh(geometry, material);
            scene.add(icosahedron);

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

            const light2 = new THREE.PointLight(0x0040ff, 1, 100); // blueish
            light2.position.set(-2, -2, -2);
            scene.add(light2);

            // Add ambient light to soften the shadows
            const ambientLight = new THREE.AmbientLight(0x404040); // soft white light
            scene.add(ambientLight);

            // Orbit Controls
            const controls = new THREE.OrbitControls(camera, renderer.domElement);
            controls.autoRotate = true;
            controls.autoRotateSpeed = 2.0;

            // Starfield
            const starGeometry = new THREE.BufferGeometry();
            const starMaterial = new THREE.PointsMaterial({
                color: 0xffffff,
                size: 0.02,
            });

            // Generate 5000 stars in a cube of 200 units
            const stars = [];
            for (let i = 0; i < 5000; i++) {
                const x = (Math.random() - 0.5) * 200;
                const y = (Math.random() - 0.5) * 200;
                const z = (Math.random() - 0.5) * 200;
                stars.push(x, y, z);
            }
            starGeometry.setAttribute('position', new THREE.Float32BufferAttribute(stars, 3));
            const starField = new THREE.Points(starGeometry, starMaterial);
            scene.add(starField);

            // Animation loop
            function animate() {
                requestAnimationFrame(animate);
                // Rotate the icosahedron
                icosahedron.rotation.x += 0.005;
                icosahedron.rotation.y += 0.005;
                // Update controls (for auto rotation)
                controls.update();
                renderer.render(scene, camera);
            }
            animate();

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

 Note: 
   - We set the renderer's clear color to black (0x000000) for the background. The stars will appear as white points.
   - We added a soft ambient light to make the icosahedron more visible.
   - The icosahedron rotates at a fixed rate and the camera also orbits.

 But note: the starfield is static and will not move with the camera because it's in the scene and the camera moves. This will give a parallax effect? Actually, the stars are fixed in space and the camera moves so they will appear to move a little. That is acceptable.

 We are using THREE.BufferGeometry and THREE.Points for the stars. We also note that we are using THREE.Float32BufferAttribute to set the positions.

 However, note that the OrbitControls might cause the starfield to appear to move relative to the icosahedron, which is the desired effect.

 We have to write this entire content to index.html.

 Let's write the file.

We are building a single-page web app that uses Three.js (via the provided three.min.js) to render a scene with:
 - A rotating icosahedron
 - Two colored point lights
 - Orbit-style auto-rotation (using OrbitControls)
 - A subtle starfield background

The entire app must be in one file: index.html.

We have the three.min.js in the current directory, so we load it with: <script src="three.min.js"></script>

Plan:
1. Create a full-screen Three.js scene.
2. Add an icosahedron (using IcosahedronGeometry) with a material that looks nice (e.g., MeshStandardMaterial with some metalness and roughness).
3. Add two point lights at different positions and with different colors.
4. Add OrbitControls for orbit-style interaction and enable auto-rotation.
5. Create a starfield in the background using a particle system (Points with BufferGeometry and PointsMaterial).
6. Handle window resizing and set up the animation loop.

Important: We must not use any external resources; everything (including the Three.js library) must be loaded from the current directory.

We'll write the entire HTML structure with CSS and JS in one file.

Let's create the index.html file with:
- A <style> section to make the canvas full-screen and remove margins.
- A <script> section for our Three.js code after loading three.min.js.

We must remember:
- To initialize the scene, camera, and renderer.
- To set the camera position and aspect ratio.
- To append the renderer's domElement to the body.

For the starfield:
- We'll create a large number of points (e.g., 5000) distributed randomly in a 3D space (but far enough so they don't interfere with the main object).
- We'll use a PointsMaterial with a small size and set `sizeAttenuation` to false or adjust as needed.

We'll use OrbitControls from three.min.js. Since three.min.js includes all the core and controls, we can use OrbitControls.

However, note: in some versions of Three.js, OrbitControls might be in an examples directory. But since we are using a minified version that includes controls (as per common minified builds that bundle controls), I assume we can use it.

But to be safe, let me note: if the provided three.min.js does not include OrbitControls, we need to adjust. But the problem states that the library is pre-provided and named three.min.js, so we rely on it including OrbitControls.

We'll write the code accordingly.

We'll also add a fog effect to give the starfield some depth? Or use depth test in the particle system.

Alternatively, we can just create the starfield as a background without depth interaction, but by placing the stars far away and then moving the camera? Actually, we are moving the camera with OrbitControls, so we want the stars to appear fixed (or very distant) so they don't move much.

We'll create the stars as a point cloud that spans a large space (from -100 to 100 in x, y, z) and then set the camera to see within that space. We set the camera far plane to 1000? Actually, we set the near and far of the camera to 0.1 and 1000 respectively.

We'll also enable auto-rotation of the controls.

Code structure:

HTML:
<!DOCTYPE html>
<html>
<head>
    <title>Rotating Icosahedron</title>
    <style>
        body { margin: 0; }
        canvas { display: block; }
    </style>
</head>
<body>
    <script src="three.min.js"></script>
    <script>
        // ... our code
    </script>
</body>
</html>

The JavaScript code:

1. Set up scene, camera, renderer.
2. Create the icosahedron.
3. Create the two point lights and add them to the scene.
4. Create the starfield with a particle system.
5. Set up OrbitControls and enable auto-rotation.
6. Handle window resize.
7. Animation loop to rotate the icosahedron and update the controls.

Let me write the code accordingly.

Note: We are using THREE as a global variable, so we can access THREE.OrbitControls.

But note: In the minified version, the controls might be available as THREE.OrbitControls or not. We assume it is.

We create the starfield using a BufferGeometry and Points.

Also, we'll set the scene background color to black and the stars to white.

We'll make the icosahedron a bit shiny to reflect the colored lights.

We'll also add an ambient light to provide base illumination.

Let's code accordingly.

I will now write the entire content of index.html to the file.