helixmind 0.2.26 → 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,CA6gE3D"}
+{"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,19 +593,144 @@ const EDGE_COLORS = {
   belongs_to: '#ff6600', part_of: '#ff6600', supersedes: '#ff4444',
   default: '#334466',
 };
-// V5: OG Chandelier Brain — iconic shape + modern rendering + 3D spiral spread
-// Shape: small/dim at top (deep archive) → large/bright at bottom (focus)
-// Activity BOOSTS brightness (active = brighter, not dimmer)
-// cx/cz: spiral center offsets for 3D depth
-const SPATIAL = {
-  5: { iR: 8,  oR: 110,  yBase: 420,  yS: 70,  size: 18, pulse: 0.3, activity: 0.3,  cx: 0,   cz: 0 },
-  4: { iR: 12, oR: 180,  yBase: 250,  yS: 80,  size: 24, pulse: 0.6, activity: 0.5,  cx: 30,  cz: 20 },
-  3: { iR: 18, oR: 260,  yBase: 60,   yS: 90,  size: 30, pulse: 1.0, activity: 0.7,  cx: -25, cz: 40 },
-  2: { iR: 25, oR: 340,  yBase: -140, yS: 100, size: 34, pulse: 1.5, activity: 0.85, cx: -45, cz: -15 },
-  1: { iR: 35, oR: 430,  yBase: -360, yS: 110, size: 40, pulse: 2.2, activity: 1.0,  cx: -15, cz: -40 },
-  6: { iR: 40, oR: 470,  yBase: -560, yS: 110, size: 34, pulse: 0.8, activity: 0.75, cx: 40,  cz: -30 },
+// 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;'); }
@@ -618,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.00015);
+scene.fog = new THREE.FogExp2('#030308', 0.0003);
 
 const camera = new THREE.PerspectiveCamera(50, window.innerWidth / window.innerHeight, 1, 12000);
-camera.position.set(500, 300, 750);
+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 ===========
@@ -753,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();
@@ -764,8 +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); }
-  orbitRings.forEach(r => { r.geometry.dispose(); r.material.dispose(); scene.remove(r); });
-  orbitRings = [];
 
   nodes = BRAIN_DATA.nodes;
   nCount = nodes.length;
@@ -778,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;
-      // Organic jitter for 3D spread
-      const jitterX = (srand(ni * 29) - 0.5) * r * 0.2;
-      const jitterZ = (srand(ni * 37) - 0.5) * r * 0.2;
-      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) => {
@@ -829,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;
@@ -847,25 +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);
-  }
-
   // ---- EDGES (LineSegments) ----
   // Prioritize cross-level edges (vertical) over intra-level (horizontal)
   const allEdges = [];
@@ -893,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;
   }
@@ -915,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),
@@ -1071,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
@@ -1100,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() {
@@ -1167,7 +1251,7 @@ function closeSidebar(evt) {
     controls.autoRotate = true;
     camTween = {
       startPos: camera.position.clone(), startLookAt: controls.target.clone(),
-      targetPos: new THREE.Vector3(500, 300, 750), targetLookAt: new THREE.Vector3(0, -50, 0),
+      targetPos: new THREE.Vector3(600, 350, 600), targetLookAt: new THREE.Vector3(0, 0, 0),
       progress: 0
     };
   }

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA43BL,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.26",
+  "version": "0.2.27",
   "description": "HelixMind – AI Coding CLI with Persistent Spiral Memory",
   "type": "module",
   "main": "dist/index.js",