tryassay 0.21.1 → 0.22.0

package/demo/js/orb.js

@@ -0,0 +1,634 @@
+// orb.js — Three.js orb with phase morphing, particles, effects + bloom
+import * as THREE from 'three';
+import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
+import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
+import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
+
+// ──────────────────────────────────────────────
+// Phase color mapping
+// ──────────────────────────────────────────────
+const PHASE_COLORS = {
+  idle:                  new THREE.Color(0x1e3a5f),
+  initializing:          new THREE.Color(0x1e3a5f),
+  planning:              new THREE.Color(0x06b6d4),
+  verifying_plan:        new THREE.Color(0xf59e0b),
+  requirements_refining: new THREE.Color(0xf59e0b),
+  scaffolding:           new THREE.Color(0x22c55e),
+  building_feature:      new THREE.Color(0x22c55e),
+  build_verifying:       new THREE.Color(0xf59e0b),
+  build_repairing:       new THREE.Color(0xef4444),
+  integration_verifying: new THREE.Color(0xf59e0b),
+  functional_testing:    new THREE.Color(0xf59e0b),
+  functional_repairing:  new THREE.Color(0xef4444),
+  cross_verifying:       new THREE.Color(0xf59e0b),
+  finalizing:            new THREE.Color(0x22c55e),
+  completed:             new THREE.Color(0xffffff),
+  failed:                new THREE.Color(0xef4444)
+};
+
+// ──────────────────────────────────────────────
+// Layer 1: Phase Behavior Config
+// ──────────────────────────────────────────────
+const PHASE_BEHAVIORS = {
+  idle: {
+    targetRadius: 1.2, noiseAmplitude: 0.02, noiseFrequency: 0.8, noiseSpeed: 0.3,
+    solidOpacity: 0.85, transmission: 0.6, metalness: 0.1,
+    wireframeOpacity: 0.15, emissiveIntensity: 0.3,
+    shellMin: 1.5, shellMax: 3.5, particleSpeedMult: 1.0, convergence: 0.0,
+    rotationSpeed: 0.003, wobbleAmplitude: 0.1, bloomStrength: 1.2,
+    scanRing: false, connectionArcs: false,
+  },
+  planning: {
+    targetRadius: 1.45, noiseAmplitude: 0.15, noiseFrequency: 1.2, noiseSpeed: 0.8,
+    solidOpacity: 0.6, transmission: 0.7, metalness: 0.05,
+    wireframeOpacity: 0.25, emissiveIntensity: 0.5,
+    shellMin: 2.0, shellMax: 4.5, particleSpeedMult: 1.8, convergence: 0.0,
+    rotationSpeed: 0.006, wobbleAmplitude: 0.2, bloomStrength: 1.4,
+    scanRing: false, connectionArcs: false,
+  },
+  verifying_plan: {
+    targetRadius: 1.05, noiseAmplitude: 0.03, noiseFrequency: 0.6, noiseSpeed: 0.2,
+    solidOpacity: 0.9, transmission: 0.3, metalness: 0.4,
+    wireframeOpacity: 0.1, emissiveIntensity: 0.4,
+    shellMin: 1.3, shellMax: 2.5, particleSpeedMult: 0.6, convergence: 0.0,
+    rotationSpeed: 0.002, wobbleAmplitude: 0.05, bloomStrength: 1.3,
+    scanRing: true, connectionArcs: false,
+  },
+  scaffolding: {
+    targetRadius: 1.2, noiseAmplitude: 0.01, noiseFrequency: 0.5, noiseSpeed: 0.2,
+    solidOpacity: 0.3, transmission: 0.2, metalness: 0.0,
+    wireframeOpacity: 1.0, emissiveIntensity: 0.4,
+    shellMin: 1.5, shellMax: 3.0, particleSpeedMult: 1.0, convergence: 0.0,
+    rotationSpeed: 0.004, wobbleAmplitude: 0.08, bloomStrength: 1.1,
+    scanRing: false, connectionArcs: false,
+  },
+  building_feature: {
+    targetRadius: 1.3, noiseAmplitude: 0.05, noiseFrequency: 0.7, noiseSpeed: 0.4,
+    solidOpacity: 0.8, transmission: 0.4, metalness: 0.15,
+    wireframeOpacity: 0.2, emissiveIntensity: 0.45,
+    shellMin: 1.4, shellMax: 3.0, particleSpeedMult: 1.2, convergence: 0.3,
+    rotationSpeed: 0.004, wobbleAmplitude: 0.12, bloomStrength: 1.3,
+    scanRing: false, connectionArcs: false,
+  },
+  build_verifying: {
+    targetRadius: 1.1, noiseAmplitude: 0.02, noiseFrequency: 0.5, noiseSpeed: 0.15,
+    solidOpacity: 0.9, transmission: 0.3, metalness: 0.4,
+    wireframeOpacity: 0.1, emissiveIntensity: 0.4,
+    shellMin: 1.3, shellMax: 2.5, particleSpeedMult: 0.5, convergence: 0.0,
+    rotationSpeed: 0.002, wobbleAmplitude: 0.04, bloomStrength: 1.3,
+    scanRing: true, connectionArcs: false,
+  },
+  build_repairing: {
+    targetRadius: 1.2, noiseAmplitude: 0.2, noiseFrequency: 1.5, noiseSpeed: 1.0,
+    solidOpacity: 0.7, transmission: 0.4, metalness: 0.1,
+    wireframeOpacity: 0.4, emissiveIntensity: 0.6,
+    shellMin: 1.5, shellMax: 3.5, particleSpeedMult: 2.0, convergence: 0.0,
+    rotationSpeed: 0.008, wobbleAmplitude: 0.25, bloomStrength: 1.5,
+    scanRing: false, connectionArcs: false,
+  },
+  cross_verifying: {
+    targetRadius: 1.1, noiseAmplitude: 0.03, noiseFrequency: 0.6, noiseSpeed: 0.2,
+    solidOpacity: 0.75, transmission: 0.5, metalness: 0.3,
+    wireframeOpacity: 0.15, emissiveIntensity: 0.4,
+    shellMin: 1.3, shellMax: 2.8, particleSpeedMult: 0.8, convergence: 0.0,
+    rotationSpeed: 0.003, wobbleAmplitude: 0.06, bloomStrength: 1.3,
+    scanRing: false, connectionArcs: true,
+  },
+  finalizing: {
+    targetRadius: 1.2, noiseAmplitude: 0.0, noiseFrequency: 0.5, noiseSpeed: 0.1,
+    solidOpacity: 0.95, transmission: 0.2, metalness: 0.7,
+    wireframeOpacity: 0.05, emissiveIntensity: 0.5,
+    shellMin: 1.3, shellMax: 2.0, particleSpeedMult: 0.3, convergence: 0.0,
+    rotationSpeed: 0.001, wobbleAmplitude: 0.02, bloomStrength: 1.5,
+    scanRing: false, connectionArcs: false,
+  },
+  completed: {
+    targetRadius: 1.2, noiseAmplitude: 0.0, noiseFrequency: 0.5, noiseSpeed: 0.1,
+    solidOpacity: 0.95, transmission: 0.1, metalness: 0.3,
+    wireframeOpacity: 0.0, emissiveIntensity: 1.0,
+    shellMin: 1.3, shellMax: 2.0, particleSpeedMult: 0.4, convergence: 0.0,
+    rotationSpeed: 0.001, wobbleAmplitude: 0.03, bloomStrength: 2.0,
+    scanRing: false, connectionArcs: false,
+  },
+  failed: {
+    targetRadius: 1.3, noiseAmplitude: 0.35, noiseFrequency: 2.0, noiseSpeed: 1.5,
+    solidOpacity: 0.5, transmission: 0.3, metalness: 0.0,
+    wireframeOpacity: 0.6, emissiveIntensity: 0.8,
+    shellMin: 2.5, shellMax: 5.0, particleSpeedMult: 3.0, convergence: -0.5,
+    rotationSpeed: 0.01, wobbleAmplitude: 0.4, bloomStrength: 1.8,
+    scanRing: false, connectionArcs: false,
+  },
+};
+
+// Phase aliases — map runtime phases to visual configs
+PHASE_BEHAVIORS.initializing = PHASE_BEHAVIORS.idle;
+PHASE_BEHAVIORS.plan_questioning = PHASE_BEHAVIORS.planning;
+PHASE_BEHAVIORS.plan_refining = PHASE_BEHAVIORS.verifying_plan;
+PHASE_BEHAVIORS.requirements_refining = PHASE_BEHAVIORS.verifying_plan;
+PHASE_BEHAVIORS.integration_verifying = PHASE_BEHAVIORS.build_verifying;
+PHASE_BEHAVIORS.functional_testing = PHASE_BEHAVIORS.build_verifying;
+PHASE_BEHAVIORS.functional_repairing = PHASE_BEHAVIORS.build_repairing;
+
+// ──────────────────────────────────────────────
+// Simplex 3D Noise (inline, no deps)
+// ──────────────────────────────────────────────
+const _PERM = [151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,74,165,71,134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,228,251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180];
+const _p = new Uint8Array(512);
+for (let i = 0; i < 512; i++) _p[i] = _PERM[i & 255];
+
+const _g3 = [[1,1,0],[-1,1,0],[1,-1,0],[-1,-1,0],[1,0,1],[-1,0,1],[1,0,-1],[-1,0,-1],[0,1,1],[0,-1,1],[0,1,-1],[0,-1,-1]];
+
+function simplex3(xin, yin, zin) {
+  const F3 = 1 / 3, G3 = 1 / 6;
+  const s = (xin + yin + zin) * F3;
+  const i = Math.floor(xin + s), j = Math.floor(yin + s), k = Math.floor(zin + s);
+  const t = (i + j + k) * G3;
+  const x0 = xin - (i - t), y0 = yin - (j - t), z0 = zin - (k - t);
+
+  let i1, j1, k1, i2, j2, k2;
+  if (x0 >= y0) {
+    if (y0 >= z0) { i1=1;j1=0;k1=0;i2=1;j2=1;k2=0; }
+    else if (x0 >= z0) { i1=1;j1=0;k1=0;i2=1;j2=0;k2=1; }
+    else { i1=0;j1=0;k1=1;i2=1;j2=0;k2=1; }
+  } else {
+    if (y0 < z0) { i1=0;j1=0;k1=1;i2=0;j2=1;k2=1; }
+    else if (x0 < z0) { i1=0;j1=1;k1=0;i2=0;j2=1;k2=1; }
+    else { i1=0;j1=1;k1=0;i2=1;j2=1;k2=0; }
+  }
+
+  const x1 = x0-i1+G3, y1 = y0-j1+G3, z1 = z0-k1+G3;
+  const x2 = x0-i2+2*G3, y2 = y0-j2+2*G3, z2 = z0-k2+2*G3;
+  const x3 = x0-1+3*G3, y3 = y0-1+3*G3, z3 = z0-1+3*G3;
+
+  const ii = i & 255, jj = j & 255, kk = k & 255;
+  let n = 0;
+
+  let t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
+  if (t0 > 0) { t0 *= t0; const g = _g3[_p[ii+_p[jj+_p[kk]]] % 12]; n += t0*t0*(g[0]*x0+g[1]*y0+g[2]*z0); }
+  let t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
+  if (t1 > 0) { t1 *= t1; const g = _g3[_p[ii+i1+_p[jj+j1+_p[kk+k1]]] % 12]; n += t1*t1*(g[0]*x1+g[1]*y1+g[2]*z1); }
+  let t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
+  if (t2 > 0) { t2 *= t2; const g = _g3[_p[ii+i2+_p[jj+j2+_p[kk+k2]]] % 12]; n += t2*t2*(g[0]*x2+g[1]*y2+g[2]*z2); }
+  let t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
+  if (t3 > 0) { t3 *= t3; const g = _g3[_p[ii+1+_p[jj+1+_p[kk+1]]] % 12]; n += t3*t3*(g[0]*x3+g[1]*y3+g[2]*z3); }
+
+  return 32 * n;
+}
+
+// ──────────────────────────────────────────────
+// Module state
+// ──────────────────────────────────────────────
+let scene, camera, renderer, composer, bloomPass;
+let orb, wireMat, particles, rings = [];
+let scanRingMesh, arcGroup;
+let targetColor = new THREE.Color(0x1e3a5f);
+let currentColor = new THREE.Color(0x1e3a5f);
+let time = 0;
+
+// Morph state
+let vertexDirections;
+let currentBehavior = { ...PHASE_BEHAVIORS.idle };
+let targetBehavior = PHASE_BEHAVIORS.idle;
+
+// Effects
+const microEffects = [];
+const arcs = [];
+let arcTimer = 0;
+const ARC_SPAWN_INTERVAL = 0.5;
+const ARC_LIFETIME = 2.0;
+
+// ──────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────
+function randomDirection() {
+  const theta = Math.random() * Math.PI * 2;
+  const phi = Math.acos(2 * Math.random() - 1);
+  return new THREE.Vector3(
+    Math.sin(phi) * Math.cos(theta),
+    Math.sin(phi) * Math.sin(theta),
+    Math.cos(phi)
+  );
+}
+
+function lerpBehavior(current, target, t) {
+  for (const key in target) {
+    if (typeof target[key] === 'number') {
+      current[key] += (target[key] - current[key]) * t;
+    } else if (typeof target[key] === 'boolean') {
+      current[key] = target[key];
+    }
+  }
+}
+
+function spawnArc() {
+  const pos = orb.geometry.attributes.position;
+  const i1 = Math.floor(Math.random() * pos.count);
+  let i2 = Math.floor(Math.random() * pos.count);
+  if (i2 === i1) i2 = (i2 + 1) % pos.count;
+
+  const points = [
+    new THREE.Vector3(pos.getX(i1), pos.getY(i1), pos.getZ(i1)),
+    new THREE.Vector3(pos.getX(i2), pos.getY(i2), pos.getZ(i2)),
+  ];
+  const geo = new THREE.BufferGeometry().setFromPoints(points);
+  const mat = new THREE.LineBasicMaterial({
+    color: currentColor.clone(),
+    transparent: true,
+    opacity: 0,
+    blending: THREE.AdditiveBlending,
+    depthWrite: false,
+  });
+  const line = new THREE.Line(geo, mat);
+  arcGroup.add(line);
+  arcs.push({ line, v1: i1, v2: i2, age: 0 });
+}
+
+// ──────────────────────────────────────────────
+// Init
+// ──────────────────────────────────────────────
+export function initOrb() {
+  const container = document.getElementById('orb-container');
+  if (!container) return;
+
+  const w = container.clientWidth;
+  const h = container.clientHeight;
+
+  scene = new THREE.Scene();
+
+  camera = new THREE.PerspectiveCamera(60, w / h, 0.1, 1000);
+  camera.position.z = 5;
+
+  renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+  renderer.setSize(w, h);
+  renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+  renderer.toneMapping = THREE.ACESFilmicToneMapping;
+  renderer.toneMappingExposure = 1.2;
+  container.appendChild(renderer.domElement);
+
+  // Post-processing
+  composer = new EffectComposer(renderer);
+  composer.addPass(new RenderPass(scene, camera));
+
+  bloomPass = new UnrealBloomPass(
+    new THREE.Vector2(w, h),
+    1.2, 0.5, 0.3
+  );
+  composer.addPass(bloomPass);
+
+  // Orb — translucent icosahedron
+  const orbGeo = new THREE.IcosahedronGeometry(1.2, 4);
+  const orbMat = new THREE.MeshPhysicalMaterial({
+    color: 0x1e3a5f,
+    metalness: 0.1,
+    roughness: 0.2,
+    transmission: 0.6,
+    thickness: 1.5,
+    clearcoat: 1.0,
+    clearcoatRoughness: 0.1,
+    emissive: 0x1e3a5f,
+    emissiveIntensity: 0.3,
+    transparent: true,
+    opacity: 0.85,
+    wireframe: false
+  });
+  orb = new THREE.Mesh(orbGeo, orbMat);
+  scene.add(orb);
+
+  // Snapshot vertex directions for morph engine
+  const posAttr = orbGeo.attributes.position;
+  const vCount = posAttr.count;
+  vertexDirections = new Float32Array(vCount * 3);
+  for (let vi = 0; vi < vCount; vi++) {
+    const vx = posAttr.getX(vi), vy = posAttr.getY(vi), vz = posAttr.getZ(vi);
+    const len = Math.sqrt(vx * vx + vy * vy + vz * vz);
+    vertexDirections[vi * 3] = vx / len;
+    vertexDirections[vi * 3 + 1] = vy / len;
+    vertexDirections[vi * 3 + 2] = vz / len;
+  }
+
+  // Wireframe overlay
+  const wireGeo = new THREE.IcosahedronGeometry(1.22, 2);
+  wireMat = new THREE.MeshBasicMaterial({
+    color: 0x1e3a5f,
+    wireframe: true,
+    transparent: true,
+    opacity: 0.15
+  });
+  orb.add(new THREE.Mesh(wireGeo, wireMat));
+
+  // Particle system — 200 orbiting particles
+  const particleCount = 200;
+  const particleGeo = new THREE.BufferGeometry();
+  const positions = new Float32Array(particleCount * 3);
+  const velocities = new Float32Array(particleCount * 3);
+
+  for (let i = 0; i < particleCount; i++) {
+    const theta = Math.random() * Math.PI * 2;
+    const phi = Math.acos(2 * Math.random() - 1);
+    const r = 1.8 + Math.random() * 1.2;
+    positions[i * 3]     = r * Math.sin(phi) * Math.cos(theta);
+    positions[i * 3 + 1] = r * Math.sin(phi) * Math.sin(theta);
+    positions[i * 3 + 2] = r * Math.cos(phi);
+    velocities[i * 3]     = (Math.random() - 0.5) * 0.01;
+    velocities[i * 3 + 1] = (Math.random() - 0.5) * 0.01;
+    velocities[i * 3 + 2] = (Math.random() - 0.5) * 0.01;
+  }
+
+  particleGeo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+  const particleMat = new THREE.PointsMaterial({
+    color: 0x06b6d4,
+    size: 0.03,
+    transparent: true,
+    opacity: 0.6,
+    blending: THREE.AdditiveBlending,
+    depthWrite: false
+  });
+  particles = new THREE.Points(particleGeo, particleMat);
+  scene.add(particles);
+  particles.__velocities = velocities;
+
+  // Scan ring (Layer 3) — horizontal ring that sweeps through orb during verification
+  const scanGeo = new THREE.RingGeometry(0.8, 1.5, 64);
+  const scanMat = new THREE.MeshBasicMaterial({
+    color: 0xf59e0b,
+    transparent: true,
+    opacity: 0.0,
+    side: THREE.DoubleSide,
+    blending: THREE.AdditiveBlending,
+    depthWrite: false,
+  });
+  scanRingMesh = new THREE.Mesh(scanGeo, scanMat);
+  scanRingMesh.rotation.x = Math.PI / 2;
+  scanRingMesh.visible = false;
+  scene.add(scanRingMesh);
+
+  // Arc group (Layer 3) — child of orb so arcs rotate with it
+  arcGroup = new THREE.Group();
+  orb.add(arcGroup);
+
+  // Lights
+  const ambient = new THREE.AmbientLight(0x111122, 0.5);
+  scene.add(ambient);
+
+  const point = new THREE.PointLight(0x06b6d4, 2, 20);
+  point.position.set(0, 0, 3);
+  scene.add(point);
+
+  // Subscribe to state
+  AppState.on('phase_change', ({ to }) => {
+    targetColor = PHASE_COLORS[to] || PHASE_COLORS.idle;
+    targetBehavior = PHASE_BEHAVIORS[to] || PHASE_BEHAVIORS.idle;
+    updateAgentRings();
+  });
+
+  AppState.on('verification', (v) => {
+    if (v && v.result === 'fail') {
+      microEffects.push({ type: 'ripple', origin: randomDirection(), strength: 0.2, decay: 0.92 });
+      microEffects.push({ type: 'emissive', strength: 1.0, decay: 0.9 });
+    } else if (v) {
+      microEffects.push({ type: 'ripple', origin: randomDirection(), strength: 0.08, decay: 0.94 });
+    }
+  });
+
+  AppState.on('code_generated', () => {
+    microEffects.push({ type: 'convergence', strength: 0.5, decay: 0.92 });
+    microEffects.push({ type: 'emissive', strength: 0.3, decay: 0.93 });
+  });
+
+  AppState.on('task_update', (task) => {
+    if (task && task.status === 'completed') {
+      microEffects.push({ type: 'emissive', strength: 0.5, decay: 0.91 });
+    }
+  });
+
+  AppState.on('agent_status', () => updateAgentRings());
+
+  // Resize
+  window.addEventListener('resize', () => {
+    const w2 = container.clientWidth;
+    const h2 = container.clientHeight;
+    camera.aspect = w2 / h2;
+    camera.updateProjectionMatrix();
+    renderer.setSize(w2, h2);
+    composer.setSize(w2, h2);
+  });
+
+  animate();
+}
+
+// ──────────────────────────────────────────────
+// Agent rings (unchanged)
+// ──────────────────────────────────────────────
+function updateAgentRings() {
+  const agents = AppState.get().agents.filter(a => a.status === 'active');
+
+  rings.forEach(r => scene.remove(r));
+  rings = [];
+
+  const ringColors = [0x06b6d4, 0x22c55e, 0xf59e0b, 0xa855f7];
+  agents.forEach((agent, i) => {
+    const ringGeo = new THREE.TorusGeometry(1.6 + i * 0.25, 0.008, 8, 64);
+    const ringMat = new THREE.MeshBasicMaterial({
+      color: ringColors[i % ringColors.length],
+      transparent: true,
+      opacity: 0.5
+    });
+    const ring = new THREE.Mesh(ringGeo, ringMat);
+
+    ring.rotation.x = Math.PI / 3 + i * 0.4;
+    ring.rotation.y = i * 0.7;
+    ring.__speed = 0.3 + i * 0.15;
+    ring.__axis = i % 2 === 0 ? 'y' : 'x';
+
+    scene.add(ring);
+    rings.push(ring);
+  });
+}
+
+// ──────────────────────────────────────────────
+// Animate — all 4 layers
+// ──────────────────────────────────────────────
+function animate() {
+  requestAnimationFrame(animate);
+  time += 0.016;
+
+  const b = currentBehavior;
+
+  // ── Layer 2: Behavior lerp ──
+  lerpBehavior(currentBehavior, targetBehavior, 0.02);
+
+  // ── Color lerp ──
+  currentColor.lerp(targetColor, 0.03);
+  orb.material.color.copy(currentColor);
+  orb.material.emissive.copy(currentColor);
+
+  // ── Layer 2: Material morphing ──
+  let emissiveBoost = 0;
+  for (const fx of microEffects) {
+    if (fx.type === 'emissive') emissiveBoost += fx.strength;
+  }
+
+  orb.material.opacity = b.solidOpacity;
+  orb.material.transmission = b.transmission;
+  orb.material.metalness = b.metalness;
+  orb.material.emissiveIntensity = b.emissiveIntensity + Math.sin(time * 2) * 0.1 + emissiveBoost;
+
+  // Wireframe
+  wireMat.color.copy(currentColor);
+  wireMat.opacity = b.wireframeOpacity;
+
+  // Bloom
+  bloomPass.strength = b.bloomStrength;
+
+  // ── Layer 2: Vertex morphing ──
+  const pos = orb.geometry.attributes.position;
+  const noiseT = time * b.noiseSpeed;
+
+  for (let i = 0; i < pos.count; i++) {
+    const dx = vertexDirections[i * 3];
+    const dy = vertexDirections[i * 3 + 1];
+    const dz = vertexDirections[i * 3 + 2];
+
+    const n = simplex3(
+      dx * b.noiseFrequency + noiseT,
+      dy * b.noiseFrequency + noiseT * 0.7,
+      dz * b.noiseFrequency + noiseT * 0.5
+    );
+
+    // Micro-effect displacement (ripples)
+    let microDisp = 0;
+    for (const fx of microEffects) {
+      if (fx.type === 'ripple') {
+        const dot = dx * fx.origin.x + dy * fx.origin.y + dz * fx.origin.z;
+        const prox = Math.max(0, dot);
+        microDisp += prox * prox * fx.strength;
+      }
+    }
+
+    const r = b.targetRadius + n * b.noiseAmplitude + microDisp;
+    const tx = dx * r;
+    const ty = dy * r;
+    const tz = dz * r;
+
+    pos.setX(i, pos.getX(i) + (tx - pos.getX(i)) * 0.04);
+    pos.setY(i, pos.getY(i) + (ty - pos.getY(i)) * 0.04);
+    pos.setZ(i, pos.getZ(i) + (tz - pos.getZ(i)) * 0.04);
+  }
+  pos.needsUpdate = true;
+  orb.geometry.computeVertexNormals();
+
+  // ── Layer 2: Rotation ──
+  orb.rotation.y += b.rotationSpeed;
+  orb.rotation.x = Math.sin(time * 0.5) * b.wobbleAmplitude;
+
+  // ── Layer 2: Particle behavior ──
+  const ppos = particles.geometry.attributes.position;
+  const vel = particles.__velocities;
+
+  let convergenceBoost = 0;
+  for (const fx of microEffects) {
+    if (fx.type === 'convergence') convergenceBoost += fx.strength;
+  }
+  const totalConvergence = b.convergence + convergenceBoost;
+
+  for (let i = 0; i < ppos.count; i++) {
+    const x = ppos.getX(i);
+    const y = ppos.getY(i);
+    const z = ppos.getZ(i);
+    const dist = Math.sqrt(x * x + y * y + z * z);
+
+    const speed = 0.005 * b.particleSpeedMult / Math.max(dist, 0.5);
+    let nx = x * Math.cos(speed) - z * Math.sin(speed) + vel[i * 3];
+    let ny = y + vel[i * 3 + 1];
+    let nz = x * Math.sin(speed) + z * Math.cos(speed) + vel[i * 3 + 2];
+
+    // Convergence/divergence
+    if (totalConvergence !== 0 && dist > 0.1) {
+      const invDist = 1 / dist;
+      nx -= x * invDist * totalConvergence * 0.01;
+      ny -= y * invDist * totalConvergence * 0.01;
+      nz -= z * invDist * totalConvergence * 0.01;
+    }
+
+    ppos.setX(i, nx);
+    ppos.setY(i, ny);
+    ppos.setZ(i, nz);
+
+    // Shell bounds
+    const newDist = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (newDist > b.shellMax || newDist < b.shellMin) {
+      const targetDist = (b.shellMin + b.shellMax) / 2;
+      const scale = targetDist / newDist;
+      ppos.setX(i, nx * scale);
+      ppos.setY(i, ny * scale);
+      ppos.setZ(i, nz * scale);
+    }
+  }
+  ppos.needsUpdate = true;
+  particles.material.color.copy(currentColor);
+
+  // ── Layer 3: Scan ring ──
+  if (b.scanRing) {
+    scanRingMesh.visible = true;
+    scanRingMesh.position.y = Math.sin(time * 2) * 1.3;
+    scanRingMesh.material.color.copy(currentColor);
+    scanRingMesh.material.opacity = 0.3 + Math.sin(time * 4) * 0.15;
+  } else {
+    if (scanRingMesh.material.opacity > 0.01) {
+      scanRingMesh.material.opacity *= 0.9;
+    } else {
+      scanRingMesh.visible = false;
+    }
+  }
+
+  // ── Layer 3: Connection arcs ──
+  if (b.connectionArcs) {
+    arcTimer += 0.016;
+    if (arcTimer >= ARC_SPAWN_INTERVAL) {
+      arcTimer -= ARC_SPAWN_INTERVAL;
+      spawnArc();
+    }
+  }
+
+  for (let i = arcs.length - 1; i >= 0; i--) {
+    arcs[i].age += 0.016;
+    const at = arcs[i].age / ARC_LIFETIME;
+    if (at >= 1.0) {
+      arcGroup.remove(arcs[i].line);
+      arcs[i].line.geometry.dispose();
+      arcs[i].line.material.dispose();
+      arcs.splice(i, 1);
+    } else {
+      // Update endpoints from current vertex positions
+      const lp = arcs[i].line.geometry.attributes.position;
+      lp.setXYZ(0, pos.getX(arcs[i].v1), pos.getY(arcs[i].v1), pos.getZ(arcs[i].v1));
+      lp.setXYZ(1, pos.getX(arcs[i].v2), pos.getY(arcs[i].v2), pos.getZ(arcs[i].v2));
+      lp.needsUpdate = true;
+      arcs[i].line.material.opacity = Math.sin(at * Math.PI) * 0.6;
+      arcs[i].line.material.color.copy(currentColor);
+    }
+  }
+
+  if (!b.connectionArcs && arcs.length === 0) {
+    arcTimer = 0;
+  }
+
+  // ── Layer 4: Micro-effect decay ──
+  for (let i = microEffects.length - 1; i >= 0; i--) {
+    microEffects[i].strength *= microEffects[i].decay;
+    if (microEffects[i].strength < 0.005) {
+      microEffects.splice(i, 1);
+    }
+  }
+
+  // ── Agent ring rotation ──
+  rings.forEach(ring => {
+    if (ring.__axis === 'y') {
+      ring.rotation.y += ring.__speed * 0.016;
+    } else {
+      ring.rotation.x += ring.__speed * 0.016;
+    }
+  });
+
+  composer.render();
+}