Okay, let's tackle this problem. The user wants a full-screen web app using three.min.js that displays a rotating icosahedron with two colored point lights, orbit-style auto-rotation, and a starfield background. All in one index.html file.

First, I need to structure the HTML. The basic setup includes the HTML5 doctype, html, head, and body tags. The head should have a title and link to the three.min.js script. Wait, the user mentioned that three.min.js is already present in the current directory, so I should use a local script tag instead of a CDN. So, in the head, I'll add <script src="three.min.js"></script>.

Next, the body. The scene needs to be full-screen, so I'll use a canvas element that covers the entire window. Maybe set the CSS for the body and canvas to take up 100% width and height. Also, handle resizing the canvas when the window resizes.

Now, the Three.js setup. Initialize the scene, camera, and renderer. The camera should be positioned to view the icosahedron. The renderer needs to be set to antialias and fill the window. Add the renderer's DOM element to the body.

For the starfield background, I'll create a lot of small points (particles) that simulate stars. Using a geometry with many vertices and a shader material might be efficient, but maybe for simplicity, I can create multiple Point objects. However, creating thousands of points might be resource-heavy. Alternatively, using a shader or a texture could be better, but since the user wants it all in one file, perhaps using a simple approach with particles.

Wait, the user said "subtle starfield background," so maybe a simple approach with a lot of small points. Let me think: create a group of points, each with a random position within a sphere, and assign them a color. Then, in the animation loop, move them slightly to create a parallax effect. But how to do that efficiently?

Alternatively, use a shader material with a noise texture, but that would require an image. Since the user wants no external resources, maybe generate the starfield using a particle system. Let me proceed with that.

So, create a particle system with a geometry that has many vertices. Each vertex will be a point, and the material will be a PointMaterial with a color. Then, add this to the scene.

Next, the icosahedron. Create a mesh with an IcosahedronGeometry, apply a material (maybe a MeshStandardMaterial with some color), and add it to the scene. Then, add two PointLight objects with different colors, positioned appropriately.

For lighting, two point lights: one white and one blue, maybe positioned at different locations to illuminate the icosahedron from different angles.

Auto-rotation: animate the icosahedron by rotating it around its axes. Maybe rotate on both x and y axes slowly.

The camera should orbit around the icosahedron. To achieve this, perhaps use a controls library like OrbitControls, but the user didn't mention including any additional libraries. Wait, the user specified to use three.min.js, which is the core library. So, I can't use OrbitControls unless it's included. But the user said to use only three.min.js, so I need to handle the orbit manually.

Alternatively, use a simple rotation of the camera around the icosahedron. For example, in the animation loop, adjust the camera's position based on time to create an orbit effect.

Wait, the user mentioned "orbit-style auto-rotation," which might mean that the camera orbits around the icosahedron. So, perhaps the camera moves in a circular path around the object. To do that, calculate the camera's position based on time, keeping it at a certain distance from the icosahedron.

Putting it all together:

1. Set up the scene, camera, renderer.
2. Create the starfield as a particle system.
3. Create the icosahedron mesh.
4. Add two point lights.
5. Animate the icosahedron and camera.

Let me outline the code steps.

In the script section:

- Initialize the scene, camera, renderer.
- Create the starfield: create a geometry with many points, assign them random positions, and a material with a color. Maybe use a PointCloud.
- Add the starfield to the scene.
- Create the icosahedron geometry, material, mesh. Apply the material.
- Add the mesh to the scene.
- Create two point lights, set their positions and colors, add to the scene.
- Handle window resize events to adjust the renderer size and camera aspect ratio.
- Animation loop: update the starfield positions (for movement), rotate the icosahedron, and render.

Wait, for the starfield, if I want a subtle effect, maybe moving the points slightly in opposite directions. Or just have them static but with varying sizes and colors.

But to make it dynamic, perhaps in the animation loop, move each star point in the opposite direction of the camera's movement. Alternatively, create a parallax effect by moving the stars based on the camera's position.

But given time constraints, maybe a simple approach: create a large number of points with random positions, and in the animation loop, slightly move them in the opposite direction of the camera's movement. However, without using OrbitControls, this might be complex.

Alternatively, just have the stars as static points. Maybe that's sufficient for a subtle effect.

Now, code steps:

- Create a geometry with 1000 points. For each vertex, set a random position within a sphere. Use a PointMaterial with a color (white or light gray). Add to the scene.

For the icosahedron:

- Use THREE.IcosahedronGeometry with a radius, detail, etc.
- Material could be MeshStandardMaterial with a color, maybe with some roughness or metalness.
- Add to the scene.

Lights:

- Two PointLight instances. One white, one blue. Position them at different locations, e.g., (10, 10, 10) and (-10, -10, -10).

Animation loop:

- Rotate the icosahedron around its Y-axis.
- Move the camera in a circular path around the icosahedron. For example, the camera's position is (radius * Math.cos(time), radius * Math.sin(time), height), and then look at the center of the icosahedron.

Wait, the camera's position should be adjusted over time to create an orbit. Let's say the camera orbits around the Y-axis. So, in the animation loop, calculate the camera's position based on time.

Also, ensure the renderer's size is updated on window resize.

Putting all this into code.

Now, considering all the elements, I'll write the code into the index.html file. Make sure all the scripts are included correctly, and the HTML structure is correct.

Potential issues:

- The three.min.js is already present, so the script tag is correct.
- The starfield may be too slow to render with many points. Maybe use a smaller number, like 1000 points.
- The icosahedron's material needs to be properly set up with lighting.
- The camera's orbit needs to be calculated correctly.

Testing the code in the browser would help, but since I can't do that here, I'll proceed with writing the code as per the plan.

Okay, let me check what the user asked for. They wanted a full-screen web app using three.min.js with a rotating icosahedron, two colored point lights, orbit-style auto-rotation, and a starfield background. All in one index.html file.

First, I created the HTML structure with the necessary tags. Included the three.min.js script from the local directory. Then, set up the scene, camera, and renderer. The starfield was made using a Points material with random positions. The icosahedron is created with IcosahedronGeometry and a standard material. Two point lights are added with different colors. 

For the orbit, I moved the camera in a circular path using trigonometric functions based on time. The animation loop handles rotation of the icosahedron and camera movement. Also, added resize handling to adjust the renderer size.

I think that covers all requirements. Let me make sure there are no external resources. The code uses only three.min.js locally, so it's self-contained. The starfield is subtle with many small points. The lights are positioned to illuminate the icosahedron. The camera orbits smoothly. Everything should work as intended.