We need to create index.html that loads three.min.js from current directory. Render a full-screen scene with rotating icosahedron lit by two colored point lights, orbit-style auto-rotation, subtle starfield background. Use only local resources, no external. We'll write HTML, CSS, JS.

We must ensure three.min.js exists in current directory; we can refer to it.

We need to create index.html in /tmp/ws.

We'll create a file with HTML boilerplate, include <script src="three.min.js"></script>. Then set up scene, camera, renderer with full-screen canvas. Add an IcosahedronGeometry, material (e.g., MeshStandardMaterial or MeshPhongMaterial). Add two point lights with different colors. Orbit-style auto-rotation: use camera controls? We cannot import OrbitControls from separate file? But we could implement simple auto rotation by rotating the object or camera manually. The instruction "orbit-style auto-rotation" likely refers to rotating camera around object automatically like OrbitControls but without interaction. We can just rotate camera around the object on its y-axis with a radius.

Subtle starfield background: we can create a particle system with many points randomly distributed on a sphere around the scene. Use Points and PointsMaterial with small size and white color.

Ensure full-screen: set renderer size to window.innerWidth/innerHeight, add resize listener.

Add animation loop to rotate icosahedron slowly. Also animate camera or use orbit controls? We'll do camera position moving around object.

Let's write code accordingly.

Also make CSS for body margin 0, overflow hidden, set background black (but stars will be visible). We'll use <style>.

Let's write content.

Check for three.min.js path. Use <script src="three.min.js"></script>.

Implementation details:

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);
renderer.setPixelRatio(window.devicePixelRatio);
document.body.appendChild(renderer.domElement);

Add icosahedron:

const geometry = new THREE.IcosahedronGeometry(1, 0);
const material = new THREE.MeshStandardMaterial({ color: 0x156289, metalness: 0.1, roughness: 0.7 });
const icosahedron = new THREE.Mesh(geometry, material);
scene.add(icosahedron);

Add lights: PointLight colors: maybe red and blue.

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

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

Starfield: create geometry with many points: use BufferGeometry, create random positions on sphere radius 200, maybe 2000 points.

const stars = new THREE.BufferGeometry();
const starCount = 2000;
const positions = new Float32Array(starCount * 3);
for (let i=0;i<starCount;i++){
   const phi = Math.random() * Math.PI * 2;
   const theta = Math.acos( Math.random() * 2 - 1);
   const r = 200;
   positions[i*3] = r * Math.sin(theta) * Math.cos(phi);
   positions[i*3+1] = r * Math.sin(theta) * Math.sin(phi);
   positions[i*3+2] = r * Math.cos(theta);
}
stars.setAttribute('position', new THREE.BufferAttribute(positions, 3));
const starMaterial = new THREE.PointsMaterial({ color: 0xffffff, size: 0.5, sizeAttenuation: true });
const starField = new THREE.Points(stars, starMaterial);
scene.add(starField);

Animation loop:

let angle = 0;

function animate() {
   requestAnimationFrame(animate);
   // rotate icosahedron
   icosahedron.rotation.x += 0.005;
   icosahedron.rotation.y += 0.01;
   // auto orbit camera
   angle += 0.002;
   camera.position.x = Math.cos(angle) * 5;
   camera.position.z = Math.sin(angle) * 5;
   camera.lookAt(0,0,0);
   renderer.render(scene, camera);
}

Window resize handler.

Let's write HTML file.

We'll use <script> with 'use strict'.

Let's craft final content.

Also set background black or starfield is black.

Let's write file content.

We'll use write function to create index.html.

Let's produce final answer.

We wrote index.html. Need to check if all requirements satisfied: full-screen scene, rotating icosahedron, lit by two colored point lights, orbit-style auto-rotation, subtle starfield background. We have that. Ensure starfield subtle: size small, starCount 2000, but could be fine.

Potential missing: icosahedron rotates automatically? We also orbit camera. Good. Use global THREE. The file uses three.min.js. Works.

But maybe we should ensure use of orbit-style auto-rotation: we implemented orbiting camera. Fine.

Also subtle starfield: we can reduce starSize maybe 0.5. Already small.

Edge: Need to include <meta name="viewport">? Not essential.

Ensure background color is black. We set body background. Good.

Thus final output is file written.

We should maybe confirm that three.min.js exists. Let's check.

The user: "Using the pre-provided three.min.js (global THREE), render a full-screen scene with a rotating icosahedron lit by two colored point lights, orbit-style auto-rotation, and a subtle starfield background."

We have written index.html accordingly. Need to ensure full-screen, starfield subtle, orbit-style auto rotation. Provided code seems fine. But maybe adjust star size. But should suffice. Let's output final.