helixmind 0.2.26 → 0.2.28

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,CAqrE3D"}

package/dist/cli/brain/template.js

@@ -593,19 +593,196 @@ 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 },
+// V7: Clustered Galaxy Brain — Force-directed with level clustering
+// Each level forms an organic morphed blob; blobs barely touch each other
+const LEVEL_STYLE = {
+  1: { size: 22, pulse: 2.0, activity: 1.0 },
+  2: { size: 20, pulse: 1.5, activity: 0.85 },
+  3: { size: 17, pulse: 1.0, activity: 0.7 },
+  4: { size: 15, pulse: 0.6, activity: 0.5 },
+  5: { size: 13, pulse: 0.3, activity: 0.3 },
+  6: { size: 18, 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
+
+// Clustered force-directed layout: each level forms an organic blob
+// Blobs are pushed apart so they barely touch — morphed spheres
+function computeForceLayout(nodeList, edgeList, nodeIdxMapLocal) {
+  const N = nodeList.length;
+  if (N === 0) return [];
+
+  // Group nodes by level
+  const levelGroups = {};
+  for (let i = 0; i < N; i++) {
+    const lv = nodeList[i].level || 3;
+    if (!levelGroups[lv]) levelGroups[lv] = [];
+    levelGroups[lv].push(i);
+  }
+
+  // Assign each level a seed centroid direction (icosahedron-like placement)
+  const levels = Object.keys(levelGroups).map(Number).sort();
+  const seedCentroids = {};
+  const CLUSTER_SPREAD = 320;
+  // Evenly space level centroids on a sphere
+  for (let li = 0; li < levels.length; li++) {
+    const lv = levels[li];
+    const golden = 2.399963;
+    const theta = golden * li * 2.5; // multiplied for wider spread
+    const phi = Math.acos(1 - 2 * (li + 0.5) / Math.max(levels.length, 2));
+    seedCentroids[lv] = {
+      x: CLUSTER_SPREAD * Math.sin(phi) * Math.cos(theta),
+      y: CLUSTER_SPREAD * Math.cos(phi),
+      z: CLUSTER_SPREAD * Math.sin(phi) * Math.sin(theta)
+    };
+  }
+
+  const pos = new Array(N);
+  // Initialize nodes near their level's seed centroid
+  for (let i = 0; i < N; i++) {
+    const lv = nodeList[i].level || 3;
+    const c = seedCentroids[lv] || { x: 0, y: 0, z: 0 };
+    const INIT_SPREAD = 100;
+    pos[i] = {
+      x: c.x + (srand(i * 7) - 0.5) * INIT_SPREAD,
+      y: c.y + (srand(i * 13) - 0.5) * INIT_SPREAD,
+      z: c.z + (srand(i * 19) - 0.5) * INIT_SPREAD
+    };
+  }
+
+  // Build adjacency
+  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);
+    }
+  }
+
+  const ITERATIONS = 60;
+  const REPULSION = 5000;
+  const ATTRACTION = 0.012;
+  const CLUSTER_PULL = 0.02;    // pull nodes toward their own level centroid
+  const INTER_REPEL = 18000;    // push different-level centroids apart
+  const CENTERING = 0.0005;
+  const DAMPING = 0.82;
+  const K_SAMPLES = Math.min(N, 25);
+
+  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;
+    const repScale = REPULSION * temp;
+
+    // Compute dynamic level centroids
+    const dynC = {};
+    const dynN = {};
+    for (let i = 0; i < N; i++) {
+      const lv = nodeList[i].level || 3;
+      if (!dynC[lv]) { dynC[lv] = { x: 0, y: 0, z: 0 }; dynN[lv] = 0; }
+      dynC[lv].x += pos[i].x; dynC[lv].y += pos[i].y; dynC[lv].z += pos[i].z;
+      dynN[lv]++;
+    }
+    for (const lv in dynC) {
+      dynC[lv].x /= dynN[lv]; dynC[lv].y /= dynN[lv]; dynC[lv].z /= dynN[lv];
+    }
+
+    for (let i = 0; i < N; i++) {
+      let fx = 0, fy = 0, fz = 0;
+      const myLevel = nodeList[i].level || 3;
+
+      // Node-node repulsion (sampled)
+      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;
+        // Stronger repulsion between different levels
+        const crossMult = (nodeList[j].level || 3) !== myLevel ? 2.5 : 1.0;
+        const f = repScale * crossMult / distSq;
+        const dist = Math.sqrt(distSq);
+        fx += (dx / dist) * f; fy += (dy / dist) * f; fz += (dz / dist) * f;
+      }
+      const repBias = N / K_SAMPLES;
+      fx *= repBias; fy *= repBias; fz *= repBias;
+
+      // Attraction: pull toward connected nodes (stronger for same level)
+      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 sameLvl = (nodeList[j].level || 3) === myLevel ? 2.5 : 0.3;
+        const f = ATTRACTION * dist * sameLvl;
+        fx += (dx / dist) * f; fy += (dy / dist) * f; fz += (dz / dist) * f;
+      }
+
+      // Cluster cohesion: pull toward own level centroid
+      const mc = dynC[myLevel];
+      if (mc) {
+        fx += (mc.x - pos[i].x) * CLUSTER_PULL * temp;
+        fy += (mc.y - pos[i].y) * CLUSTER_PULL * temp;
+        fz += (mc.z - pos[i].z) * CLUSTER_PULL * temp;
+      }
+
+      // Inter-cluster repulsion: push away from OTHER level centroids
+      for (const lv in dynC) {
+        if (parseInt(lv) === myLevel) continue;
+        const oc = dynC[lv];
+        const dx = pos[i].x - oc.x;
+        const dy = pos[i].y - oc.y;
+        const dz = pos[i].z - oc.z;
+        const distSq = dx * dx + dy * dy + dz * dz + 1;
+        const f = INTER_REPEL * temp / distSq;
+        const dist = Math.sqrt(distSq);
+        fx += (dx / dist) * f; fy += (dy / dist) * f; fz += (dz / dist) * f;
+      }
+
+      // Light centering
+      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;
+
+      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;
+      }
+    }
+
+    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 (target radius ~650 for spacious clusters)
+  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 ? 650 / 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 +795,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.00018);
 
 const camera = new THREE.PerspectiveCamera(50, window.innerWidth / window.innerHeight, 1, 12000);
-camera.position.set(500, 300, 750);
+camera.position.set(900, 500, 900);
 
 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 ===========
@@ -693,13 +868,13 @@ const nodeMat = new THREE.ShaderMaterial({
       vec2 c = gl_PointCoord - vec2(.5);
       float d = length(c);
       if(d > .5) discard;
-      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 * .4), i * vAlpha);
+      // Sharp saturated core with minimal glow — preserves level color
+      float core = exp(-d*d*180.0) * 0.95;
+      float halo = exp(-d*d*22.0) * 0.25;
+      float outer = exp(-d*d*6.0) * 0.06;
+      float intensity = core + halo + outer;
+      // Keep color saturated — minimal brightness boost on core
+      gl_FragColor = vec4(vColor * (0.85 + core * 0.15), intensity * vAlpha);
     }
   \`,
   transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
@@ -753,7 +928,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 +938,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 +950,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) => {
@@ -817,6 +976,33 @@ function rebuildScene() {
     nodeEdgeMap[ti].push(ei);
   });
 
+  // ---- NODE COLOR: blend level + dominant edge type ----
+  // Pre-compute dominant edge type per node
+  const nodeEdgeTypeCounts = {};
+  for (const e of BRAIN_DATA.edges) {
+    const si = nodeIdxMap[e.source], ti = nodeIdxMap[e.target];
+    if (si === undefined || ti === undefined) continue;
+    const type = e.type || 'related_to';
+    if (!nodeEdgeTypeCounts[si]) nodeEdgeTypeCounts[si] = {};
+    if (!nodeEdgeTypeCounts[ti]) nodeEdgeTypeCounts[ti] = {};
+    nodeEdgeTypeCounts[si][type] = (nodeEdgeTypeCounts[si][type] || 0) + 1;
+    nodeEdgeTypeCounts[ti][type] = (nodeEdgeTypeCounts[ti][type] || 0) + 1;
+  }
+  const nodeDomType = {};
+  for (const idx in nodeEdgeTypeCounts) {
+    let maxT = 'default', maxC = 0;
+    for (const [t, c] of Object.entries(nodeEdgeTypeCounts[idx])) {
+      if (c > maxC) { maxC = c; maxT = t; }
+    }
+    nodeDomType[idx] = maxT;
+  }
+  // Max degree for brightness scaling
+  let maxDegree = 1;
+  for (let i = 0; i < nCount; i++) {
+    const deg = adj[i] ? adj[i].size : 0;
+    if (deg > maxDegree) maxDegree = deg;
+  }
+
   // ---- NODE POINTS ----
   nodeGeo = new THREE.BufferGeometry();
   const nPos = new Float32Array(nCount * 3);
@@ -825,13 +1011,23 @@ function rebuildScene() {
   const nHighlight = new Float32Array(nCount);
   const nPulse = new Float32Array(nCount);
   const nActivity = new Float32Array(nCount);
+  const ec = new THREE.Color();
 
   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;
+    // Base level color
     tc.set(LEVEL_COLORS_HEX[n.level] || 0x00FFFF);
+    // Blend with dominant edge type color (35% influence) for color variety
+    const domType = nodeDomType[i] || 'default';
+    ec.set(EDGE_COLORS[domType] || EDGE_COLORS.default);
+    tc.lerp(ec, 0.35);
+    // Brightness by degree: low-degree dimmer, high-degree brighter
+    const deg = adj[i] ? adj[i].size : 0;
+    const bright = 0.6 + (deg / maxDegree) * 0.4;
+    tc.multiplyScalar(bright);
     nCol[i * 3] = tc.r; nCol[i * 3 + 1] = tc.g; nCol[i * 3 + 2] = tc.b;
     nSize[i] = s.size;
     nHighlight[i] = 1.0;
@@ -847,40 +1043,16 @@ 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 = [];
   BRAIN_DATA.edges.forEach((e, i) => {
     const si = nodeIdxMap[e.source], ti = nodeIdxMap[e.target];
     if (si !== undefined && ti !== undefined) {
-      const crossLevel = nodes[si].level !== nodes[ti].level;
-      allEdges.push({ si, ti, weight: e.weight, type: e.type, idx: i, crossLevel });
+      allEdges.push({ si, ti, weight: e.weight, type: e.type, idx: i });
     }
   });
-  // Sort: cross-level edges first (they create the beautiful vertical connections)
-  allEdges.sort((a, b) => {
-    if (a.crossLevel !== b.crossLevel) return b.crossLevel ? 1 : -1;
-    return b.weight - a.weight; // then by weight
-  });
+  // Sort by weight (strongest connections first)
+  allEdges.sort((a, b) => b.weight - a.weight);
   validEdges = allEdges.slice(0, MAX_RENDERED_EDGES);
 
   eCount = validEdges.length;
@@ -893,17 +1065,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 } = 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);
+    // Boosted edge alpha for colorful connections
+    const baseAlpha = 0.12 + weight * 0.28;
     eAlpha[i * 2] = baseAlpha * alphaScale;
     eAlpha[i * 2 + 1] = baseAlpha * alphaScale;
   }
@@ -915,13 +1088,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 +1244,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 +1273,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 +1335,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoiCL,IAAI,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAukBvE,CAAC;AACT,CAAC"}

package/dist/cli/checkpoints/keybinding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keybinding.d.ts","sourceRoot":"","sources":["../../../src/cli/checkpoints/keybinding.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEjG,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAMvD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,EACzD,KAAK,EAAE,eAAe,GACrB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CA0BvC"}
+{"version":3,"file":"keybinding.d.ts","sourceRoot":"","sources":["../../../src/cli/checkpoints/keybinding.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEjG,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAMvD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,EACzD,KAAK,EAAE,eAAe,GACrB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CA2BvC"}

package/dist/cli/checkpoints/keybinding.js

@@ -4,7 +4,7 @@
 export function createKeybindingState() {
     return {
         lastEscTime: 0,
-        doubleEscThreshold: 300,
+        doubleEscThreshold: 500,
         inBrowser: false,
     };
 }
@@ -38,6 +38,7 @@ export function processKeypress(key, state) {
         state.lastEscTime = now;
         return { action: 'ignore' };
     }
+    state.lastEscTime = 0;
     return { action: 'ignore' };
 }
 //# sourceMappingURL=keybinding.js.map

package/dist/cli/checkpoints/keybinding.js.map

@@ -1 +1 @@
-{"version":3,"file":"keybinding.js","sourceRoot":"","sources":["../../../src/cli/checkpoints/keybinding.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,WAAW,EAAE,CAAC;QACd,kBAAkB,EAAE,GAAG;QACvB,SAAS,EAAE,KAAK;KACjB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAyD,EACzD,KAAsB;IAEtB,0CAA0C;IAC1C,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACpB,IAAI,GAAG,CAAC,IAAI,KAAK,IAAI;YAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QAC/C,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QACnD,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;QACtD,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QACvD,kCAAkC;QAClC,IAAI,GAAG,CAAC,QAAQ,IAAI,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IAC9B,CAAC;IAED,oCAAoC;IACpC,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,GAAG,GAAG,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,kBAAkB,EAAE,CAAC;YACvD,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC;YACtB,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;QACpC,CAAC;QACD,KAAK,CAAC,WAAW,GAAG,GAAG,CAAC;QACxB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IAC9B,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AAC9B,CAAC"}
+{"version":3,"file":"keybinding.js","sourceRoot":"","sources":["../../../src/cli/checkpoints/keybinding.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,WAAW,EAAE,CAAC;QACd,kBAAkB,EAAE,GAAG;QACvB,SAAS,EAAE,KAAK;KACjB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAyD,EACzD,KAAsB;IAEtB,0CAA0C;IAC1C,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACpB,IAAI,GAAG,CAAC,IAAI,KAAK,IAAI;YAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QAC/C,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QACnD,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;QACtD,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QACvD,kCAAkC;QAClC,IAAI,GAAG,CAAC,QAAQ,IAAI,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IAC9B,CAAC;IAED,oCAAoC;IACpC,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,GAAG,GAAG,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,kBAAkB,EAAE,CAAC;YACvD,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC;YACtB,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;QACpC,CAAC;QACD,KAAK,CAAC,WAAW,GAAG,GAAG,CAAC;QACxB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AAC9B,CAAC"}

package/dist/cli/jarvis/queue.d.ts

@@ -0,0 +1,41 @@
+import type { JarvisTask, JarvisTaskStatus, JarvisTaskPriority, JarvisDaemonState, JarvisStatusInfo } from './types.js';
+export declare class JarvisQueue {
+    private data;
+    private filePath;
+    private onChange?;
+    private daemonStartTime;
+    constructor(projectRoot: string, onChange?: (event: string, task: JarvisTask) => void);
+    private load;
+    private save;
+    addTask(title: string, description: string, opts?: {
+        priority?: JarvisTaskPriority;
+        dependencies?: number[];
+        tags?: string[];
+        maxRetries?: number;
+    }): JarvisTask;
+    getTask(id: number): JarvisTask | undefined;
+    updateTask(id: number, updates: Partial<Pick<JarvisTask, 'status' | 'priority' | 'title' | 'description' | 'result' | 'error' | 'startedAt' | 'completedAt' | 'retries' | 'sessionId' | 'tags'>>): JarvisTask | undefined;
+    removeTask(id: number): boolean;
+    /**
+     * Returns the next task to execute: highest priority pending task
+     * whose dependencies (if any) are all completed.
+     */
+    getNextTask(): JarvisTask | undefined;
+    getByStatus(status: JarvisTaskStatus): JarvisTask[];
+    getAllTasks(): JarvisTask[];
+    clearCompleted(): number;
+    get count(): number;
+    get pendingCount(): number;
+    getDaemonState(): JarvisDaemonState;
+    setDaemonState(state: JarvisDaemonState): void;
+    getStatus(): JarvisStatusInfo;
+    /**
+     * Build a summary string for injection into the system prompt.
+     */
+    getSummaryForPrompt(): string | null;
+    /** Short status line for the status bar */
+    getStatusLine(): string;
+    /** Set or replace the onChange callback */
+    setOnChange(handler: (event: string, task: JarvisTask) => void): void;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/cli/jarvis/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/cli/jarvis/queue.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,kBAAkB,EAAmB,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAMzI,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAkB;IAC9B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,CAA4C;IAC7D,OAAO,CAAC,eAAe,CAAuB;gBAElC,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI;IAiBrF,OAAO,CAAC,IAAI;IAeZ,OAAO,CAAC,IAAI;IAQZ,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QACjD,QAAQ,CAAC,EAAE,kBAAkB,CAAC;QAC9B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,UAAU;IAoBd,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAI3C,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EACrD,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,aAAa,GAAG,QAAQ,GAAG,OAAO,GACpE,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,CAC/D,CAAC,GAAG,UAAU,GAAG,SAAS;IAsB3B,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAQ/B;;;OAGG;IACH,WAAW,IAAI,UAAU,GAAG,SAAS;IAqBrC,WAAW,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,EAAE;IAInD,WAAW,IAAI,UAAU,EAAE;IAI3B,cAAc,IAAI,MAAM;IAQxB,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAID,cAAc,IAAI,iBAAiB;IAInC,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAW9C,SAAS,IAAI,gBAAgB;IAa7B;;OAEG;IACH,mBAAmB,IAAI,MAAM,GAAG,IAAI;IAoCpC,2CAA2C;IAC3C,aAAa,IAAI,MAAM;IAgBvB,2CAA2C;IAC3C,WAAW,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI;CAGtE"}

package/dist/cli/jarvis/queue.js

@@ -0,0 +1,236 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+const EMPTY_DATA = { version: 1, nextId: 1, tasks: [], daemonState: 'stopped' };
+const PRIORITY_ORDER = { high: 0, medium: 1, low: 2 };
+export class JarvisQueue {
+    data;
+    filePath;
+    onChange;
+    daemonStartTime = null;
+    constructor(projectRoot, onChange) {
+        this.filePath = join(projectRoot, '.helixmind', 'jarvis', 'tasks.json');
+        this.onChange = onChange;
+        this.data = this.load();
+        // Crash recovery: reset any stale 'running' tasks back to 'pending'
+        for (const task of this.data.tasks) {
+            if (task.status === 'running') {
+                task.status = 'pending';
+                task.updatedAt = Date.now();
+            }
+        }
+        if (this.data.tasks.some(t => t.status === 'pending')) {
+            this.save();
+        }
+    }
+    load() {
+        try {
+            if (existsSync(this.filePath)) {
+                const raw = readFileSync(this.filePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed.version === 1 && Array.isArray(parsed.tasks)) {
+                    return parsed;
+                }
+            }
+        }
+        catch {
+            // Corrupted file — start fresh
+        }
+        return { ...EMPTY_DATA, tasks: [] };
+    }
+    save() {
+        const dir = dirname(this.filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), 'utf-8');
+    }
+    addTask(title, description, opts) {
+        const task = {
+            id: this.data.nextId++,
+            title,
+            description,
+            status: 'pending',
+            priority: opts?.priority ?? 'medium',
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            retries: 0,
+            maxRetries: opts?.maxRetries ?? 3,
+            dependencies: opts?.dependencies,
+            tags: opts?.tags,
+        };
+        this.data.tasks.push(task);
+        this.save();
+        this.onChange?.('task_created', task);
+        return task;
+    }
+    getTask(id) {
+        return this.data.tasks.find(t => t.id === id);
+    }
+    updateTask(id, updates) {
+        const task = this.data.tasks.find(t => t.id === id);
+        if (!task)
+            return undefined;
+        if (updates.status !== undefined)
+            task.status = updates.status;
+        if (updates.priority !== undefined)
+            task.priority = updates.priority;
+        if (updates.title !== undefined)
+            task.title = updates.title;
+        if (updates.description !== undefined)
+            task.description = updates.description;
+        if (updates.result !== undefined)
+            task.result = updates.result;
+        if (updates.error !== undefined)
+            task.error = updates.error;
+        if (updates.startedAt !== undefined)
+            task.startedAt = updates.startedAt;
+        if (updates.completedAt !== undefined)
+            task.completedAt = updates.completedAt;
+        if (updates.retries !== undefined)
+            task.retries = updates.retries;
+        if (updates.sessionId !== undefined)
+            task.sessionId = updates.sessionId;
+        if (updates.tags !== undefined)
+            task.tags = updates.tags;
+        task.updatedAt = Date.now();
+        this.save();
+        this.onChange?.('task_updated', task);
+        return task;
+    }
+    removeTask(id) {
+        const idx = this.data.tasks.findIndex(t => t.id === id);
+        if (idx === -1)
+            return false;
+        this.data.tasks.splice(idx, 1);
+        this.save();
+        return true;
+    }
+    /**
+     * Returns the next task to execute: highest priority pending task
+     * whose dependencies (if any) are all completed.
+     */
+    getNextTask() {
+        const pending = this.data.tasks
+            .filter(t => t.status === 'pending')
+            .filter(t => {
+            if (!t.dependencies || t.dependencies.length === 0)
+                return true;
+            return t.dependencies.every(depId => {
+                const dep = this.data.tasks.find(d => d.id === depId);
+                return dep?.status === 'completed';
+            });
+        });
+        pending.sort((a, b) => {
+            if (PRIORITY_ORDER[a.priority] !== PRIORITY_ORDER[b.priority]) {
+                return PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+            }
+            return a.createdAt - b.createdAt;
+        });
+        return pending[0];
+    }
+    getByStatus(status) {
+        return this.data.tasks.filter(t => t.status === status);
+    }
+    getAllTasks() {
+        return [...this.data.tasks];
+    }
+    clearCompleted() {
+        const before = this.data.tasks.length;
+        this.data.tasks = this.data.tasks.filter(t => t.status !== 'completed');
+        const removed = before - this.data.tasks.length;
+        if (removed > 0)
+            this.save();
+        return removed;
+    }
+    get count() {
+        return this.data.tasks.length;
+    }
+    get pendingCount() {
+        return this.getByStatus('pending').length;
+    }
+    // --- Daemon state (persisted) ---
+    getDaemonState() {
+        return this.data.daemonState;
+    }
+    setDaemonState(state) {
+        this.data.daemonState = state;
+        if (state === 'running') {
+            this.data.lastRunAt = Date.now();
+            this.daemonStartTime = Date.now();
+        }
+        else if (state === 'stopped') {
+            this.daemonStartTime = null;
+        }
+        this.save();
+    }
+    getStatus() {
+        const running = this.data.tasks.find(t => t.status === 'running');
+        return {
+            daemonState: this.data.daemonState,
+            currentTaskId: running?.id ?? null,
+            pendingCount: this.getByStatus('pending').length,
+            completedCount: this.getByStatus('completed').length,
+            failedCount: this.getByStatus('failed').length,
+            totalCount: this.data.tasks.length,
+            uptimeMs: this.daemonStartTime ? Date.now() - this.daemonStartTime : 0,
+        };
+    }
+    /**
+     * Build a summary string for injection into the system prompt.
+     */
+    getSummaryForPrompt() {
+        if (this.data.tasks.length === 0)
+            return null;
+        const pending = this.getByStatus('pending');
+        const running = this.getByStatus('running');
+        const failed = this.getByStatus('failed');
+        if (pending.length === 0 && running.length === 0 && failed.length === 0)
+            return null;
+        const lines = ['## Jarvis Task Queue'];
+        if (running.length > 0) {
+            lines.push(`\nRunning:`);
+            for (const t of running) {
+                lines.push(`- #${t.id}: ${t.title} [${t.priority}]`);
+            }
+        }
+        if (pending.length > 0) {
+            lines.push(`\nPending (${pending.length}):`);
+            for (const t of pending.slice(0, 5)) {
+                lines.push(`- #${t.id}: ${t.title} [${t.priority}]`);
+            }
+            if (pending.length > 5)
+                lines.push(`  ... and ${pending.length - 5} more`);
+        }
+        if (failed.length > 0) {
+            lines.push(`\nFailed (${failed.length}):`);
+            for (const t of failed.slice(0, 3)) {
+                lines.push(`- #${t.id}: ${t.title} — ${t.error || 'unknown error'}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /** Short status line for the status bar */
+    getStatusLine() {
+        const pending = this.getByStatus('pending').length;
+        const running = this.getByStatus('running').length;
+        const completed = this.getByStatus('completed').length;
+        const failed = this.getByStatus('failed').length;
+        if (pending + running + completed + failed === 0)
+            return '';
+        const parts = [];
+        if (running > 0)
+            parts.push(`${running} running`);
+        if (pending > 0)
+            parts.push(`${pending} pending`);
+        if (completed > 0)
+            parts.push(`${completed} done`);
+        if (failed > 0)
+            parts.push(`${failed} failed`);
+        return parts.join(', ');
+    }
+    /** Set or replace the onChange callback */
+    setOnChange(handler) {
+        this.onChange = handler;
+    }
+}
+//# sourceMappingURL=queue.js.map

package/dist/cli/jarvis/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../src/cli/jarvis/queue.ts"],"names":[],"mappings":"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"}

package/dist/cli/jarvis/types.d.ts

@@ -0,0 +1,38 @@
+export type JarvisTaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'paused';
+export type JarvisTaskPriority = 'high' | 'medium' | 'low';
+export type JarvisDaemonState = 'stopped' | 'running' | 'paused';
+export interface JarvisTask {
+    id: number;
+    title: string;
+    description: string;
+    status: JarvisTaskStatus;
+    priority: JarvisTaskPriority;
+    createdAt: number;
+    updatedAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    result?: string;
+    error?: string;
+    retries: number;
+    maxRetries: number;
+    sessionId?: string;
+    dependencies?: number[];
+    tags?: string[];
+}
+export interface JarvisQueueData {
+    version: 1;
+    nextId: number;
+    tasks: JarvisTask[];
+    daemonState: JarvisDaemonState;
+    lastRunAt?: number;
+}
+export interface JarvisStatusInfo {
+    daemonState: JarvisDaemonState;
+    currentTaskId: number | null;
+    pendingCount: number;
+    completedCount: number;
+    failedCount: number;
+    totalCount: number;
+    uptimeMs: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cli/jarvis/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/jarvis/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;AACzF,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAC3D,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEjE,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,iBAAiB,CAAC;IAC/B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/dist/cli/jarvis/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/jarvis/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/cli/jarvis/types.ts"],"names":[],"mappings":""}

package/package.json

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