helixmind 0.2.25 → 0.2.27

package/dist/cli/brain/template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../../src/cli/brain/template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAwlE3D"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../../src/cli/brain/template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAimE3D"}

package/dist/cli/brain/template.js

@@ -593,18 +593,144 @@ const EDGE_COLORS = {
   belongs_to: '#ff6600', part_of: '#ff6600', supersedes: '#ff4444',
   default: '#334466',
 };
-// V4: Living Brain Nebula — uniform cloud sizes, spiral helix arrangement
-// Activity-based: L1 (Focus) glows brightest/fastest, L5 (Deep) dimmest/slowest
-// cx/cz: center offsets creating a DNA-helix spiral when viewed from above
-const SPATIAL = {
-  1: { iR: 20, oR: 240, yBase: 300,  yS: 100, size: 44, pulse: 2.5, activity: 1.0,  cx: 50,  cz: 0 },
-  2: { iR: 20, oR: 240, yBase: 150,  yS: 100, size: 38, pulse: 1.8, activity: 0.85, cx: 25,  cz: 43 },
-  3: { iR: 15, oR: 235, yBase: 0,    yS: 95,  size: 32, pulse: 1.2, activity: 0.65, cx: -25, cz: 43 },
-  4: { iR: 15, oR: 230, yBase: -150, yS: 90,  size: 28, pulse: 0.7, activity: 0.45, cx: -50, cz: 0 },
-  5: { iR: 10, oR: 220, yBase: -300, yS: 85,  size: 22, pulse: 0.3, activity: 0.25, cx: -25, cz: -43 },
-  6: { iR: 20, oR: 240, yBase: -450, yS: 100, size: 36, pulse: 0.8, activity: 0.7,  cx: 25,  cz: -43 },
+// V6: Galaxy Brain — Force-directed 3D graph like a neural galaxy
+// Nodes positioned by connections (force layout), not by layer planes
+// Render style per level (size, pulse, activity) but NO spatial separation
+const LEVEL_STYLE = {
+  1: { size: 14, pulse: 2.0, activity: 1.0 },
+  2: { size: 13, pulse: 1.5, activity: 0.85 },
+  3: { size: 11, pulse: 1.0, activity: 0.7 },
+  4: { size: 10, pulse: 0.6, activity: 0.5 },
+  5: { size: 9,  pulse: 0.3, activity: 0.3 },
+  6: { size: 12, pulse: 0.8, activity: 0.7 },
 };
-const MAX_RENDERED_EDGES = 8000; // cap for performance + clarity
+const MAX_RENDERED_EDGES = 12000; // more edges visible in galaxy layout
+
+// Force-directed layout: positions nodes based on their connections
+function computeForceLayout(nodeList, edgeList, nodeIdxMapLocal) {
+  const N = nodeList.length;
+  if (N === 0) return [];
+
+  const pos = new Array(N);
+  // Initialize positions in a sphere with level-based shells
+  for (let i = 0; i < N; i++) {
+    const lv = nodeList[i].level || 3;
+    // L1-L5: inner to outer, L6: outer orbit
+    const shell = lv === 6 ? 1.1 : (lv * 0.18 + 0.1);
+    const R = 200 * shell;
+    // Golden angle spiral for even distribution
+    const golden = 2.399963; // Math.PI * (3 - Math.sqrt(5))
+    const theta = golden * i;
+    const phi = Math.acos(1 - 2 * (i + 0.5) / N);
+    pos[i] = {
+      x: R * Math.sin(phi) * Math.cos(theta) + (srand(i * 7) - 0.5) * 30,
+      y: R * Math.cos(phi) + (srand(i * 13) - 0.5) * 30,
+      z: R * Math.sin(phi) * Math.sin(theta) + (srand(i * 19) - 0.5) * 30
+    };
+  }
+
+  // Build adjacency for force computation
+  const adjList = new Array(N);
+  for (let i = 0; i < N; i++) adjList[i] = [];
+  for (const e of edgeList) {
+    const si = nodeIdxMapLocal[e.source];
+    const ti = nodeIdxMapLocal[e.target];
+    if (si !== undefined && ti !== undefined) {
+      adjList[si].push(ti);
+      adjList[ti].push(si);
+    }
+  }
+
+  // Force simulation: 50 iterations
+  const ITERATIONS = 50;
+  const REPULSION = 8000;
+  const ATTRACTION = 0.008;
+  const CENTERING = 0.002;
+  const DAMPING = 0.85;
+  const K_SAMPLES = Math.min(N, 25); // random sample for repulsion
+
+  const vel = new Array(N);
+  for (let i = 0; i < N; i++) vel[i] = { x: 0, y: 0, z: 0 };
+
+  for (let iter = 0; iter < ITERATIONS; iter++) {
+    const temp = 1.0 - iter / ITERATIONS; // cooling
+    const repScale = REPULSION * temp;
+
+    for (let i = 0; i < N; i++) {
+      let fx = 0, fy = 0, fz = 0;
+
+      // Repulsion: random sample K nodes
+      for (let k = 0; k < K_SAMPLES; k++) {
+        const j = Math.floor(srand(iter * 10007 + i * 997 + k * 31) * N);
+        if (j === i) continue;
+        const dx = pos[i].x - pos[j].x;
+        const dy = pos[i].y - pos[j].y;
+        const dz = pos[i].z - pos[j].z;
+        const distSq = dx * dx + dy * dy + dz * dz + 1;
+        const f = repScale / distSq;
+        const dist = Math.sqrt(distSq);
+        fx += (dx / dist) * f;
+        fy += (dy / dist) * f;
+        fz += (dz / dist) * f;
+      }
+      // Scale repulsion by N/K_SAMPLES for unbiased estimate
+      const repBias = N / K_SAMPLES;
+      fx *= repBias; fy *= repBias; fz *= repBias;
+
+      // Attraction: pull toward connected nodes
+      for (const j of adjList[i]) {
+        const dx = pos[j].x - pos[i].x;
+        const dy = pos[j].y - pos[i].y;
+        const dz = pos[j].z - pos[i].z;
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz + 1);
+        const f = ATTRACTION * dist;
+        fx += (dx / dist) * f;
+        fy += (dy / dist) * f;
+        fz += (dz / dist) * f;
+      }
+
+      // Centering force
+      fx -= pos[i].x * CENTERING;
+      fy -= pos[i].y * CENTERING;
+      fz -= pos[i].z * CENTERING;
+
+      vel[i].x = (vel[i].x + fx) * DAMPING;
+      vel[i].y = (vel[i].y + fy) * DAMPING;
+      vel[i].z = (vel[i].z + fz) * DAMPING;
+
+      // Cap velocity
+      const maxV = 30 * temp + 2;
+      const vLen = Math.sqrt(vel[i].x * vel[i].x + vel[i].y * vel[i].y + vel[i].z * vel[i].z);
+      if (vLen > maxV) {
+        vel[i].x = vel[i].x / vLen * maxV;
+        vel[i].y = vel[i].y / vLen * maxV;
+        vel[i].z = vel[i].z / vLen * maxV;
+      }
+    }
+
+    // Apply velocities
+    for (let i = 0; i < N; i++) {
+      pos[i].x += vel[i].x;
+      pos[i].y += vel[i].y;
+      pos[i].z += vel[i].z;
+    }
+  }
+
+  // Scale to fit nicely (target radius ~400)
+  let maxDist = 0;
+  for (let i = 0; i < N; i++) {
+    const d = Math.sqrt(pos[i].x * pos[i].x + pos[i].y * pos[i].y + pos[i].z * pos[i].z);
+    if (d > maxDist) maxDist = d;
+  }
+  const scale = maxDist > 0 ? 400 / maxDist : 1;
+  for (let i = 0; i < N; i++) {
+    pos[i].x *= scale;
+    pos[i].y *= scale;
+    pos[i].z *= scale;
+  }
+
+  return pos;
+}
 
 function srand(s) { const x = Math.sin(s * 9301 + 49297) * 49297; return x - Math.floor(x); }
 function escapeHtml(s) { return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;'); }
@@ -617,21 +743,19 @@ document.body.prepend(renderer.domElement);
 
 const scene = new THREE.Scene();
 scene.background = new THREE.Color('#030308');
-scene.fog = new THREE.FogExp2('#030308', 0.00018);
+scene.fog = new THREE.FogExp2('#030308', 0.0003);
 
 const camera = new THREE.PerspectiveCamera(50, window.innerWidth / window.innerHeight, 1, 12000);
-camera.position.set(400, 250, 650);
+camera.position.set(600, 350, 600);
 
 const controls = new OrbitControls(camera, renderer.domElement);
 controls.target.set(0, 0, 0);
 controls.enableDamping = true;
 controls.dampingFactor = 0.06;
 controls.autoRotate = true;
-controls.autoRotateSpeed = 0.08;
+controls.autoRotateSpeed = 0.12;
 controls.minDistance = 80;
 controls.maxDistance = 4000;
-controls.maxPolarAngle = Math.PI * 0.85;
-controls.minPolarAngle = Math.PI * 0.15;
 controls.update();
 
 // =========== BACKGROUND STARS ===========
@@ -673,12 +797,11 @@ const nodeMat = new THREE.ShaderMaterial({
     void main(){
       vColor = aColor;
       vActivity = aActivity;
-      float breath = 1.0 + sin(uTime * aPulse + position.x * .008 + position.z * .006) * (.08 + aActivity * .18);
+      float breath = 1.0 + sin(uTime * aPulse + position.x * .008 + position.z * .006) * (.06 + aActivity * .10);
       vec3 pos = position;
-      // Organic breathing — active layers move more
-      pos.y += sin(uTime * (.2 + aActivity * .4) + position.x * .01 + position.z * .015) * (2.0 + aActivity * 5.0);
-      pos.x += sin(uTime * .1 + position.z * .004) * aActivity * 3.0;
-      pos.z += cos(uTime * .08 + position.x * .004) * aActivity * 3.0;
+      pos.y += sin(uTime * (.3 + aActivity * .2) + position.x * .01 + position.z * .015) * (2.0 + aActivity * 3.0);
+      pos.x += sin(uTime * .08 + position.z * .003) * aActivity * 2.0;
+      pos.z += cos(uTime * .06 + position.x * .003) * aActivity * 2.0;
       vAlpha = aHighlight;
       vec4 mv = modelViewMatrix * vec4(pos, 1.0);
       gl_PointSize = aSize * breath * aHighlight * (500.0 / -mv.z);
@@ -693,13 +816,13 @@ const nodeMat = new THREE.ShaderMaterial({
       vec2 c = gl_PointCoord - vec2(.5);
       float d = length(c);
       if(d > .5) discard;
-      float act = 0.3 + vActivity * 0.7;
-      float core = exp(-d*d*80.0) * act;
-      float g1 = exp(-d*d*12.0) * .55 * act;
-      float g2 = exp(-d*d*3.0) * .25 * act;
-      float g3 = exp(-d*d*0.6) * .12;
+      float act = 0.5 + vActivity * 0.5;
+      float core = exp(-d*d*120.0) * (0.6 + act * 0.4);
+      float g1 = exp(-d*d*20.0) * .4 * act;
+      float g2 = exp(-d*d*5.0) * .15 * act;
+      float g3 = exp(-d*d*1.5) * .05;
       float i = core + g1 + g2 + g3;
-      gl_FragColor = vec4(vColor * (1.0 + core * .6), i * vAlpha);
+      gl_FragColor = vec4(vColor * (1.0 + core * .4), i * vAlpha);
     }
   \`,
   transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
@@ -733,38 +856,6 @@ const particleMat = new THREE.PointsMaterial({
   blending: THREE.AdditiveBlending, depthWrite: false, sizeAttenuation: true
 });
 
-// Fog nebula material — very soft, large, dim particles for volumetric clouds
-const fogMat = new THREE.ShaderMaterial({
-  uniforms: { uTime: { value: 0 } },
-  vertexShader: \`
-    attribute float aSize;
-    attribute vec3 aColor;
-    varying vec3 vColor;
-    uniform float uTime;
-    void main(){
-      vColor = aColor;
-      vec3 pos = position;
-      pos.x += sin(uTime * 0.05 + position.y * 0.003 + position.z * 0.002) * 12.0;
-      pos.z += cos(uTime * 0.04 + position.y * 0.004 + position.x * 0.002) * 12.0;
-      pos.y += sin(uTime * 0.06 + position.x * 0.002) * 6.0;
-      vec4 mv = modelViewMatrix * vec4(pos, 1.0);
-      gl_PointSize = aSize * (400.0 / -mv.z);
-      gl_Position = projectionMatrix * mv;
-    }
-  \`,
-  fragmentShader: \`
-    varying vec3 vColor;
-    void main(){
-      vec2 c = gl_PointCoord - vec2(.5);
-      float d = length(c);
-      if(d > .5) discard;
-      float glow = exp(-d*d*2.0) * .35 + exp(-d*d*0.5) * .18;
-      gl_FragColor = vec4(vColor, glow);
-    }
-  \`,
-  transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
-});
-
 // =========== SCENE OBJECTS (rebuilt by rebuildScene) ===========
 let nodePoints = null;
 let nodeGeo = null;
@@ -772,8 +863,6 @@ let edgeLines = null;
 let edgeGeo = null;
 let particlePoints = null;
 let particleGeo = null;
-let fogPoints = null;
-let fogGeo = null;
 
 // Data arrays rebuilt per scene
 let nodes = [];
@@ -787,7 +876,6 @@ let pData = [];
 let nCount = 0;
 let eCount = 0;
 let pCount = 0;
-let orbitRings = [];
 
 const PARTICLES_PER_EDGE = 3;
 const tc = new THREE.Color();
@@ -798,9 +886,6 @@ function rebuildScene() {
   if (nodeGeo) { nodeGeo.dispose(); scene.remove(nodePoints); }
   if (edgeGeo) { edgeGeo.dispose(); scene.remove(edgeLines); }
   if (particleGeo) { particleGeo.dispose(); scene.remove(particlePoints); }
-  if (fogGeo) { fogGeo.dispose(); scene.remove(fogPoints); }
-  orbitRings.forEach(r => { r.geometry.dispose(); r.material.dispose(); scene.remove(r); });
-  orbitRings = [];
 
   nodes = BRAIN_DATA.nodes;
   nCount = nodes.length;
@@ -813,30 +898,17 @@ function rebuildScene() {
     byLevel[lv].push(i);
   });
 
-  // Compute radial spiral positions
-  positions = new Array(nCount);
-  for (const [lv, indices] of Object.entries(byLevel)) {
-    const s = SPATIAL[lv] || SPATIAL[3];
-    const c = indices.length;
-    indices.forEach((ni, j) => {
-      const angle = (j / Math.max(c, 1)) * Math.PI * 2 + (srand(ni * 19) - 0.5) * 1.2;
-      const r = s.iR + srand(ni * 7) * (s.oR - s.iR);
-      const spiral = angle + r * 0.005 + srand(ni * 23) * 0.8;
-      const y = (s.yBase || 0) + (srand(ni * 11) - 0.5) * s.yS;
-      // Heavy organic jitter — chaotic like a nebula/universe
-      const jitterX = (srand(ni * 29) - 0.5) * r * 0.3;
-      const jitterZ = (srand(ni * 37) - 0.5) * r * 0.3;
-      positions[ni] = new THREE.Vector3(
-        Math.cos(spiral) * r + jitterX + (s.cx || 0),
-        y,
-        Math.sin(spiral) * r + jitterZ + (s.cz || 0)
-      );
-    });
-  }
-
-  // Build adjacency + nodeIdxMap
+  // Build nodeIdxMap first (needed for force layout)
   nodeIdxMap = {};
   nodes.forEach((n, i) => { nodeIdxMap[n.id] = i; });
+
+  // Force-directed 3D layout
+  const forcePos = computeForceLayout(nodes, BRAIN_DATA.edges, nodeIdxMap);
+  positions = new Array(nCount);
+  for (let i = 0; i < nCount; i++) {
+    const fp = forcePos[i] || { x: 0, y: 0, z: 0 };
+    positions[i] = new THREE.Vector3(fp.x, fp.y, fp.z);
+  }
   adj = {};
   nodeEdgeMap = {};
   BRAIN_DATA.edges.forEach((e, ei) => {
@@ -864,7 +936,7 @@ function rebuildScene() {
   for (let i = 0; i < nCount; i++) {
     const p = positions[i];
     const n = nodes[i];
-    const s = SPATIAL[n.level] || SPATIAL[3];
+    const s = LEVEL_STYLE[n.level] || LEVEL_STYLE[3];
     nPos[i * 3] = p.x; nPos[i * 3 + 1] = p.y; nPos[i * 3 + 2] = p.z;
     tc.set(LEVEL_COLORS_HEX[n.level] || 0x00FFFF);
     nCol[i * 3] = tc.r; nCol[i * 3 + 1] = tc.g; nCol[i * 3 + 2] = tc.b;
@@ -882,64 +954,6 @@ function rebuildScene() {
   nodePoints = new THREE.Points(nodeGeo, nodeMat);
   scene.add(nodePoints);
 
-  // ---- ORBIT RINGS (one per layer, centered at layer's spiral offset) ----
-  for (let lv = 1; lv <= 6; lv++) {
-    const s = SPATIAL[lv];
-    if (!s || !(byLevel[lv] || []).length) continue;
-    const ringRadius = s.oR * 0.85;
-    const ringGeo = new THREE.RingGeometry(ringRadius - 0.3, ringRadius + 0.3, 96);
-    const ringColor = new THREE.Color(LEVEL_COLORS_HEX[lv] || 0x00FFFF);
-    const ringMat = new THREE.MeshBasicMaterial({
-      color: ringColor, transparent: true, opacity: 0.06 + (s.activity || 0.5) * 0.06, side: THREE.DoubleSide,
-      blending: THREE.AdditiveBlending, depthWrite: false,
-    });
-    const ring = new THREE.Mesh(ringGeo, ringMat);
-    ring.rotation.x = -Math.PI / 2;
-    ring.position.set(s.cx || 0, s.yBase, s.cz || 0);
-    ring.userData.level = lv;
-    scene.add(ring);
-    orbitRings.push(ring);
-  }
-
-  // ---- FOG NEBULA PARTICLES (volumetric cloud around each layer) ----
-  const FOG_PER_LAYER = 80;
-  const fogArr = [];
-  const ftc = new THREE.Color();
-  for (let lv = 1; lv <= 6; lv++) {
-    const s = SPATIAL[lv];
-    if (!s || !(byLevel[lv] || []).length) continue;
-    ftc.set(LEVEL_COLORS_HEX[lv] || 0x00FFFF);
-    const act = s.activity || 0.5;
-    for (let j = 0; j < FOG_PER_LAYER; j++) {
-      const seed = lv * 1000 + j;
-      const angle = srand(seed * 67) * Math.PI * 2;
-      const r = srand(seed * 73) * s.oR * 1.3;
-      fogArr.push({
-        x: Math.cos(angle) * r + (s.cx || 0),
-        y: s.yBase + (srand(seed * 79) - 0.5) * s.yS * 2.0,
-        z: Math.sin(angle) * r + (s.cz || 0),
-        cr: ftc.r * (0.15 + act * 0.15), cg: ftc.g * (0.15 + act * 0.15), cb: ftc.b * (0.15 + act * 0.15),
-        size: 50 + srand(seed * 83) * 100,
-      });
-    }
-  }
-  const fTotal = fogArr.length;
-  fogGeo = new THREE.BufferGeometry();
-  const fPos = new Float32Array(fTotal * 3);
-  const fCol = new Float32Array(fTotal * 3);
-  const fSz = new Float32Array(fTotal);
-  for (let i = 0; i < fTotal; i++) {
-    const f = fogArr[i];
-    fPos[i * 3] = f.x; fPos[i * 3 + 1] = f.y; fPos[i * 3 + 2] = f.z;
-    fCol[i * 3] = f.cr; fCol[i * 3 + 1] = f.cg; fCol[i * 3 + 2] = f.cb;
-    fSz[i] = f.size;
-  }
-  fogGeo.setAttribute('position', new THREE.BufferAttribute(fPos, 3));
-  fogGeo.setAttribute('aColor', new THREE.BufferAttribute(fCol, 3));
-  fogGeo.setAttribute('aSize', new THREE.BufferAttribute(fSz, 1));
-  fogPoints = new THREE.Points(fogGeo, fogMat);
-  scene.add(fogPoints);
-
   // ---- EDGES (LineSegments) ----
   // Prioritize cross-level edges (vertical) over intra-level (horizontal)
   const allEdges = [];
@@ -967,17 +981,18 @@ function rebuildScene() {
   const alphaScale = Math.min(1.0, 3000 / eCount);
 
   for (let i = 0; i < eCount; i++) {
-    const { si, ti, weight, crossLevel } = validEdges[i];
+    const { si, ti, weight, type, crossLevel } = validEdges[i];
     const s = positions[si], t = positions[ti];
     const o = i * 6;
     ePos[o] = s.x; ePos[o + 1] = s.y; ePos[o + 2] = s.z;
     ePos[o + 3] = t.x; ePos[o + 4] = t.y; ePos[o + 5] = t.z;
-    sc.set(LEVEL_COLORS_HEX[nodes[si].level] || 0x00FFFF);
-    dc.set(LEVEL_COLORS_HEX[nodes[ti].level] || 0x00FFFF);
+    // Color by edge type for galaxy look
+    const edgeColor = EDGE_COLORS[type] || EDGE_COLORS.default;
+    sc.set(edgeColor); dc.set(edgeColor);
     eCol[o] = sc.r; eCol[o + 1] = sc.g; eCol[o + 2] = sc.b;
     eCol[o + 3] = dc.r; eCol[o + 4] = dc.g; eCol[o + 5] = dc.b;
-    // Cross-level edges brighter, intra-level edges dimmer
-    const baseAlpha = crossLevel ? (0.08 + weight * 0.12) : (0.03 + weight * 0.04);
+    // Galaxy: all edges visible, weighted by importance
+    const baseAlpha = 0.06 + weight * 0.14;
     eAlpha[i * 2] = baseAlpha * alphaScale;
     eAlpha[i * 2 + 1] = baseAlpha * alphaScale;
   }
@@ -989,13 +1004,13 @@ function rebuildScene() {
   edgeLines = new THREE.LineSegments(edgeGeo, edgeMat);
   scene.add(edgeLines);
 
-  // ---- FLOWING PARTICLES (only on cross-level edges for clarity) ----
+  // ---- FLOWING PARTICLES (on stronger connections) ----
   pData = [];
   const maxParticleEdges = Math.min(eCount, 2000);
   for (let i = 0; i < maxParticleEdges; i++) {
-    const { si, ti, weight, crossLevel } = validEdges[i];
-    if (!crossLevel) continue; // only particles on vertical connections
-    const particleCount = weight > 0.6 ? 2 : 1;
+    const { si, ti, weight } = validEdges[i];
+    if (weight < 0.4) continue; // only on stronger connections
+    const particleCount = weight > 0.7 ? 2 : 1;
     for (let j = 0; j < particleCount; j++) {
       pData.push({
         edgeIdx: i, progress: srand(i * 100 + j * 31),
@@ -1145,8 +1160,8 @@ function updateHighlights() {
   const activeEdgeTypes = getActiveEdgeTypes();
   const alphaS = Math.min(1.0, 3000 / eCount);
   for (let i = 0; i < eCount; i++) {
-    const { si, ti, weight, type, crossLevel } = validEdges[i];
-    const baseA = crossLevel ? (0.08 + weight * 0.12) : (0.03 + weight * 0.04);
+    const { si, ti, weight, type } = validEdges[i];
+    const baseA = 0.06 + weight * 0.14;
     let a = baseA * alphaS;
 
     // Level toggle: hide edges connected to hidden levels
@@ -1174,11 +1189,6 @@ function updateHighlights() {
   }
   ea.needsUpdate = true;
 
-  // Update orbit ring visibility
-  orbitRings.forEach(ring => {
-    const lv = ring.userData.level;
-    ring.material.opacity = levelToggles[lv] === false ? 0 : 0.08;
-  });
 }
 
 function getActiveEdgeTypes() {
@@ -1241,7 +1251,7 @@ function closeSidebar(evt) {
     controls.autoRotate = true;
     camTween = {
       startPos: camera.position.clone(), startLookAt: controls.target.clone(),
-      targetPos: new THREE.Vector3(400, 250, 650), targetLookAt: new THREE.Vector3(0, -50, 0),
+      targetPos: new THREE.Vector3(600, 350, 600), targetLookAt: new THREE.Vector3(0, 0, 0),
       progress: 0
     };
   }
@@ -1341,7 +1351,6 @@ function animate() {
   // Update shader uniforms
   nodeMat.uniforms.uTime.value = t;
   edgeMat.uniforms.uTime.value = t;
-  fogMat.uniforms.uTime.value = t;
 
   // Camera tween
   if (camTween) {

package/dist/cli/brain/template.js.map

@@ -1 +1 @@
-{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../src/cli/brain/template.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,iBAAiB,CAAC,IAAiB;IACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAEtC,OAAO;;;;;;0CAMiC,IAAI,CAAC,IAAI,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA2ZxB,IAAI,CAAC,IAAI,CAAC,UAAU,iBAAiB,IAAI,CAAC,IAAI,CAAC,UAAU,eAAe,IAAI,CAAC,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,iBAAiB,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,CAAC,IAAI,CAAC,WAAW;;wCAE3L,IAAI,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;uCACpD,IAAI,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAkKvE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAu8BL,IAAI,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAukBvE,CAAC;AACT,CAAC"}
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../src/cli/brain/template.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,iBAAiB,CAAC,IAAiB;IACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAEtC,OAAO;;;;;;0CAMiC,IAAI,CAAC,IAAI,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA2ZxB,IAAI,CAAC,IAAI,CAAC,UAAU,iBAAiB,IAAI,CAAC,IAAI,CAAC,UAAU,eAAe,IAAI,CAAC,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,iBAAiB,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,CAAC,IAAI,CAAC,WAAW;;wCAE3L,IAAI,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;uCACpD,IAAI,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAkKvE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAg9BL,IAAI,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAukBvE,CAAC;AACT,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helixmind",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "HelixMind – AI Coding CLI with Persistent Spiral Memory",
   "type": "module",
   "main": "dist/index.js",