@monoes/monomindcli 1.10.6 → 1.10.8

package/.claude/helpers/hook-handler.cjs

@@ -296,57 +296,82 @@ function _autoIndexKnowledge(knowledgeDir) {
     } catch (e) {}
   }
 
-  // Inject monograph graph summary as a knowledge chunk
+  // Inject monograph graph summary as a knowledge chunk.
+  // Reads from .monomind/monograph.db (SQLite, source of truth) and falls
+  // back to the legacy .monomind/graph/{stats,graph}.json pair only when
+  // present (older installs).
   try {
-    var statsPath = path.join(CWD, '.monomind', 'graph', 'stats.json');
-    var graphPath = path.join(CWD, '.monomind', 'graph', 'graph.json');
-    if (fs.existsSync(statsPath) && fs.existsSync(graphPath)) {
-      var stats = JSON.parse(fs.readFileSync(statsPath, 'utf-8'));
-      var graphStat = fs.statSync(graphPath);
-      // Only read graph if under 10MB
-      if (graphStat.size < 10 * 1024 * 1024) {
-        var graph = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
-        var rawNodes = Array.isArray(graph.nodes) ? graph.nodes : [];
-        var rawEdges = Array.isArray(graph.edges) ? graph.edges : (Array.isArray(graph.links) ? graph.links : []);
-        // Top 15 nodes by degree (god nodes)
-        var degree = {};
-        rawNodes.forEach(function(n) { degree[n.id] = 0; });
-        rawEdges.forEach(function(e) {
-          if (degree[e.source] !== undefined) degree[e.source]++;
-          if (degree[e.target] !== undefined) degree[e.target]++;
-        });
-        var topNodes = rawNodes
-          .filter(function(n) { return n.sourceFile && n.sourceFile !== ''; })
-          .sort(function(a, b) { return (degree[b.id] || 0) - (degree[a.id] || 0); })
-          .slice(0, 15);
-        // Community summary — group by type
-        var typeCounts = {};
-        rawNodes.forEach(function(n) { var t = n.type || n.label || 'unknown'; typeCounts[t] = (typeCounts[t] || 0) + 1; });
-        var topTypes = Object.entries(typeCounts).sort(function(a,b){return b[1]-a[1];}).slice(0,8).map(function(e){return e[0]+':'+e[1];}).join(', ');
-        var builtDate = stats.builtAt ? new Date(stats.builtAt).toISOString().slice(0,10) : 'unknown';
-        var summaryText = [
-          'MONOGRAPH KNOWLEDGE GRAPH SUMMARY',
-          'Built: ' + builtDate + ' | Nodes: ' + (stats.nodes || rawNodes.length) + ' | Edges: ' + (stats.edges || rawEdges.length) + ' | Files: ' + (stats.files || 0),
-          '',
-          'TOP GOD NODES (highest connectivity):',
-          topNodes.map(function(n) {
-            return '  ' + (n.name || n.id) + ' [' + (n.type || n.label || '?') + '] — ' + (n.sourceFile || '') + ' (degree: ' + (degree[n.id] || 0) + ')';
-          }).join('\n'),
-          '',
-          'NODE TYPE DISTRIBUTION: ' + topTypes,
-          '',
-          'Use mcp__monomind__monograph_suggest to find files relevant to your task.',
-          'Use mcp__monomind__monograph_query to search for symbols.',
-          'Use mcp__monomind__monograph_god_nodes for architecture overview.',
-        ].join('\n');
-        var chunkId = crypto.createHash('md5').update('monograph-graph-summary').digest('hex').slice(0, 16);
-        newLines.push(JSON.stringify({
-          chunkId: chunkId,
-          namespace: 'knowledge:shared',
-          text: summaryText,
-          metadata: { label: 'monograph-graph-summary', builtAt: stats.builtAt }
-        }));
-      }
+    var mgDbPath2 = path.join(CWD, '.monomind', 'monograph.db');
+    var legacyStats2 = path.join(CWD, '.monomind', 'graph', 'stats.json');
+    var legacyGraph2 = path.join(CWD, '.monomind', 'graph', 'graph.json');
+
+    var summaryText = null;
+    var summaryMeta = {};
+
+    if (fs.existsSync(mgDbPath2)) {
+      try {
+        var mgMod2 = _requireMonograph();
+        if (mgMod2 && mgMod2.openDb) {
+          var sumDb = mgMod2.openDb(mgDbPath2);
+          try {
+            var nodeC = sumDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
+            var edgeC = sumDb.prepare('SELECT COUNT(*) AS c FROM edges').get().c;
+            var topNodes2 = sumDb.prepare(
+              'SELECT n.name, n.label, n.file_path, ' +
+              '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg ' +
+              'FROM nodes n WHERE n.file_path IS NOT NULL AND n.file_path != "" ORDER BY deg DESC LIMIT 15'
+            ).all();
+            var typeRows = sumDb.prepare(
+              'SELECT label, COUNT(*) AS c FROM nodes GROUP BY label ORDER BY c DESC LIMIT 8'
+            ).all();
+            var typeStr = typeRows.map(function(r) { return r.label + ':' + r.c; }).join(', ');
+            summaryText = [
+              'MONOGRAPH KNOWLEDGE GRAPH SUMMARY',
+              'Source: monograph.db | Nodes: ' + nodeC + ' | Edges: ' + edgeC,
+              '',
+              'TOP GOD NODES (highest connectivity — start exploration here):',
+              topNodes2.map(function(n) {
+                return '  ' + n.name + ' [' + n.label + '] — ' + (n.file_path || '') + ' (degree: ' + n.deg + ')';
+              }).join('\n'),
+              '',
+              'NODE TYPE DISTRIBUTION: ' + typeStr,
+              '',
+              'Before grepping or globbing, prefer:',
+              '  mcp__monomind__monograph_suggest({ task: "<your task>" }) — ranked relevant files',
+              '  mcp__monomind__monograph_query({ q: "<symbol|keyword>" }) — BM25 search with file:line',
+              '  mcp__monomind__monograph_impact({ name: "<file>" }) — upstream + downstream blast radius',
+            ].join('\n');
+            summaryMeta = { label: 'monograph-graph-summary', source: 'monograph.db', nodes: nodeC, edges: edgeC };
+          } finally {
+            try { sumDb.close(); } catch (_) {}
+          }
+        }
+      } catch (e) { /* fall through to legacy */ }
+    }
+
+    if (!summaryText && fs.existsSync(legacyStats2) && fs.existsSync(legacyGraph2)) {
+      try {
+        var lStats = JSON.parse(fs.readFileSync(legacyStats2, 'utf-8'));
+        var lGraphStat = fs.statSync(legacyGraph2);
+        if (lGraphStat.size < 10 * 1024 * 1024) {
+          var lGraph = JSON.parse(fs.readFileSync(legacyGraph2, 'utf-8'));
+          var lNodes = Array.isArray(lGraph.nodes) ? lGraph.nodes : [];
+          summaryText = 'MONOGRAPH KNOWLEDGE GRAPH SUMMARY (legacy JSON)\n' +
+            'Nodes: ' + (lStats.nodes || lNodes.length) + ' | Edges: ' + (lStats.edges || 0) + '\n' +
+            'Use mcp__monomind__monograph_suggest to find files relevant to your task.';
+          summaryMeta = { label: 'monograph-graph-summary', source: 'legacy-json', builtAt: lStats.builtAt };
+        }
+      } catch (e) { /* ignore */ }
+    }
+
+    if (summaryText) {
+      var chunkId = crypto.createHash('md5').update('monograph-graph-summary').digest('hex').slice(0, 16);
+      newLines.push(JSON.stringify({
+        chunkId: chunkId,
+        namespace: 'knowledge:shared',
+        text: summaryText,
+        metadata: summaryMeta
+      }));
     }
   } catch (e) { /* graph not available yet, skip */ }
 
@@ -639,14 +664,34 @@ const handlers = {
 
       console.log(output.join('\n'));
 
-      // Inject monograph hint for complex tasks
+      // Inject monograph hint for complex tasks.
+      // Source of truth is .monomind/monograph.db (SQLite). Legacy stats.json
+      // is no longer written by the build, so it is checked only as a fallback.
       try {
-        var graphStatsPath = path.join(CWD, '.monomind', 'graph', 'stats.json');
-        if (fs.existsSync(graphStatsPath)) {
-          var gStats = JSON.parse(fs.readFileSync(graphStatsPath, 'utf-8'));
-          if (gStats.nodes > 100) {
-            console.log('\n[MONOGRAPH] ' + gStats.nodes + ' nodes indexed. For this task, call mcp__monomind__monograph_suggest first.');
-          }
+        var monographDb = path.join(CWD, '.monomind', 'monograph.db');
+        var legacyStats = path.join(CWD, '.monomind', 'graph', 'stats.json');
+        var nodeCount = 0;
+        if (fs.existsSync(monographDb)) {
+          try {
+            var mgMod = _requireMonograph();
+            if (mgMod && mgMod.openDb) {
+              var hintDb = mgMod.openDb(monographDb);
+              try {
+                nodeCount = hintDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
+              } finally {
+                try { hintDb.close(); } catch (_) {}
+              }
+            }
+          } catch (e) { /* ignore — fall back to legacy */ }
+        }
+        if (nodeCount === 0 && fs.existsSync(legacyStats)) {
+          try {
+            var gStats = JSON.parse(fs.readFileSync(legacyStats, 'utf-8'));
+            nodeCount = gStats.nodes || 0;
+          } catch (e) { /* ignore */ }
+        }
+        if (nodeCount > 100) {
+          console.log('\n[MONOGRAPH] ' + nodeCount + ' nodes indexed. For this task, call mcp__monomind__monograph_suggest first to find the right files without grepping.');
         }
       } catch(e) {}
 

package/.claude/helpers/statusline.cjs

@@ -696,6 +696,78 @@ function getGraphifyStats() {
   return { nodes: 0, edges: 0, exists: false };
 }
 
+// Graph freshness — compare graph build time against most recent commit
+// Returns: { commitsBehind, stale } where stale = >5 commits or never built
+function getGraphFreshness() {
+  const lockPath = path.join(CWD, '.monomind', 'graph', '.rebuild-lock');
+  const dbPath   = path.join(CWD, '.monomind', 'monograph.db');
+
+  let buildMs = 0;
+  try {
+    const lockStat = safeStat(lockPath);
+    const dbStat   = safeStat(dbPath);
+    buildMs = Math.max(lockStat?.mtimeMs || 0, dbStat?.mtimeMs || 0);
+  } catch { /* ignore */ }
+  if (!buildMs) return { commitsBehind: -1, stale: true, fresh: false };
+
+  // Count commits since the graph was last built
+  const buildIso = new Date(buildMs).toISOString();
+  const out = safeExec(`git rev-list --count --since='${buildIso}' HEAD 2>/dev/null`, 1500);
+  const commitsBehind = parseInt(out, 10) || 0;
+  return {
+    commitsBehind,
+    stale: commitsBehind > 5,
+    fresh: commitsBehind === 0,
+  };
+}
+
+// Active loops — scan .monomind/loops/*.json
+// Filters: skip *-hil*.json, skip stale (>6h since lastRunAt)
+function getLoopStatus() {
+  const loopsDir = path.join(CWD, '.monomind', 'loops');
+  if (!fs.existsSync(loopsDir)) return { count: 0, loops: [] };
+  const STALE_MS = 6 * 60 * 60 * 1000;
+  const now = Date.now();
+  let loops = [];
+  try {
+    const files = fs.readdirSync(loopsDir).filter(f =>
+      f.endsWith('.json') && !f.includes('-hil') && !f.endsWith('.stop'));
+    for (const f of files) {
+      const d = readJSON(path.join(loopsDir, f));
+      if (!d || !d.command) continue;
+      const last = d.lastRunAt || d.nextRunAt || d.startedAt || 0;
+      if (last && (now - last) > STALE_MS) continue;
+      loops.push({
+        cmd: d.command.replace(/^\//,''),
+        type: d.type || 'repeat',
+        rep: d.currentRep || 0,
+        max: d.maxReps || 0,
+        status: d.status || 'running',
+      });
+    }
+  } catch { /* ignore */ }
+  return { count: loops.length, loops };
+}
+
+// HIL pending — count <id>-hil.md files with no human response yet
+function getHILPending() {
+  const loopsDir = path.join(CWD, '.monomind', 'loops');
+  if (!fs.existsSync(loopsDir)) return { pending: 0 };
+  let pending = 0;
+  try {
+    const files = fs.readdirSync(loopsDir).filter(f => f.endsWith('-hil.md'));
+    for (const f of files) {
+      try {
+        const txt = fs.readFileSync(path.join(loopsDir, f), 'utf-8');
+        // A response is a line starting with "> " followed by non-whitespace
+        const answered = /^[ \t]*>[ \t]+\S/m.test(txt);
+        if (!answered) pending++;
+      } catch { /* ignore */ }
+    }
+  } catch { /* ignore */ }
+  return { pending };
+}
+
 // Memory Palace stats — drawers.jsonl + kg.json (the real persistent memory)
 function getMemoryPalaceStats() {
   const palaceDir = path.join(CWD, '.monomind', 'palace');
@@ -1130,158 +1202,68 @@ function generateDashboard() {
   lines.push(hdr);
   lines.push(SEP);
 
-  // ── Row 1: Knowledge & Graphify ──────────────────────────────
-  const knowStr = knowledge.chunks > 0
-    ? `${x.teal}📚 ${x.bold}${knowledge.chunks}${x.reset}${x.slate} chunks${x.reset}`
-    : `${x.slate}📚 no chunks${x.reset}`;
-
-  const skillStr = knowledge.skills > 0
-    ? `  ${x.mint}✦ ${knowledge.skills} skills${x.reset}`
-    : '';
-
-  const patStr = progress.patternsLearned > 0
-    ? `${x.gold}${progress.patternsLearned >= 1000 ? (progress.patternsLearned / 1000).toFixed(1) + 'k' : progress.patternsLearned} patterns${x.reset}`
-    : `${x.slate}0 patterns${x.reset}`;
-
-  const gf = getGraphifyStats();
-  const gfStr = gf.exists
-    ? `${x.sky}🔗 ${x.bold}${gf.nodes}${x.reset}${x.slate} nodes · ${x.reset}${x.sky}${x.bold}${gf.edges}${x.reset}${x.slate} edges${x.reset}`
-    : `${x.slate}🔗 no graph${x.reset}`;
-
-  lines.push(
-    `${x.purple}💡  INTEL${x.reset}    ` +
-    `${knowStr}${skillStr}   ${DIV}   ` +
-    `${patStr}   ${DIV}   ` +
-    gfStr
-  );
-  lines.push(SEP);
-
-  // ── Row 2: Agents & Triggers ──────────────────────────────────
-  const agentCol  = swarm.activeAgents > 0 ? x.green : x.slate;
-  const hookCol   = hooks.enabled > 0      ? x.mint  : x.slate;
-
-  // Triggers (Task 32)
-  const trigStr = triggers.triggers > 0
-    ? `${x.mint}🎯 ${x.bold}${triggers.triggers}${x.reset}${x.slate} triggers · ${triggers.agents} agents${x.reset}`
-    : `${x.slate}🎯 no triggers${x.reset}`;
-
-  // Active agent badge
-  let agentBadge;
+  // ── Row 1: Active agent + Loop status ────────────────────────
+  let agentStr;
   if (activeAgent) {
     const isExtras = activeAgent.slug === 'extras' || activeAgent.name === 'Extras';
     if (isExtras && activeAgent.extrasMatches && activeAgent.extrasMatches.length > 0) {
-      // Show specific specialist names instead of generic "Extras"
-      const specialists = activeAgent.extrasMatches.slice(0, 3);
-      const badgeParts = specialists.map(s => `${x.sky}👤 ${x.bold}${s.name}${x.reset}`);
-      agentBadge = badgeParts.join(`${x.slate}  ${x.reset}`);
+      const specialists = activeAgent.extrasMatches.slice(0, 3).map(s => s.name).join(', ');
+      agentStr = `${x.sky}👤 ${x.bold}${specialists}${x.reset}`;
     } else if (isExtras) {
-      // "extras" with no specific matches — suppress
-      agentBadge = `${x.slate}👤 no agent routed${x.reset}`;
+      agentStr = `${x.slate}👤 no agent routed${x.reset}`;
     } else {
       const col  = activeAgent.activated ? x.green : x.sky;
-      const mark = activeAgent.activated ? '● ACTIVE' : '';
+      const mark = activeAgent.activated ? `${col}${x.bold}● ACTIVE${x.reset}  ` : '';
       const conf = activeAgent.activated ? '' : `  ${x.slate}${(activeAgent.confidence * 100).toFixed(0)}%${x.reset}`;
-      const cat  = activeAgent.category  ? `  ${x.slate}[${activeAgent.category}]${x.reset}` : '';
-      agentBadge = mark
-        ? `${col}${x.bold}${mark}${x.reset}  ${col}👤 ${x.bold}${activeAgent.name}${x.reset}${cat}${conf}`
-        : `${col}👤 ${x.bold}${activeAgent.name}${x.reset}${cat}${conf}`;
+      agentStr = `${mark}${col}👤 ${x.bold}${activeAgent.name}${x.reset}${conf}`;
     }
   } else {
-    agentBadge = `${x.slate}👤 no agent routed${x.reset}`;
+    agentStr = `${x.slate}👤 no agent routed${x.reset}`;
   }
 
-  // Swarm line: show active count, or "N ✓ idle" when recently used, or "idle" when never used
-  const swarmCountStr = swarm.activeAgents > 0
-    ? `${agentCol}${x.bold}${swarm.activeAgents}${x.reset}${x.slate}/${x.reset}${x.white}${swarm.maxAgents}${x.reset} agents`
-    : (swarm.lastActive || 0) > 0
-      ? `${x.slate}${swarm.lastActive}${x.reset}${x.slate}/${swarm.maxAgents} (${x.reset}${x.green}✓ done${x.slate})${x.reset}`
-      : `${x.slate}idle${x.reset}          `;
-  lines.push(
-    `${x.gold}🐝  SWARM${x.reset}    ` +
-    `${swarmCountStr}   ` +
-    `${hookCol}⚡ ${hooks.enabled}/${hooks.total} hooks${x.reset}   ${DIV}   ` +
-    `${trigStr}   ${DIV}   ` +
-    agentBadge
-  );
-  lines.push(SEP);
-
-  // ── Row 3: Security ──────────────────────────────────────────
-  const cveStatus = security.totalCves === 0
-    ? (security.status === 'NONE' ? `${x.slate}not scanned${x.reset}` : `${x.green}✔ clean${x.reset}`)
-    : `${x.coral}${security.cvesFixed}/${security.totalCves} fixed${x.reset}`;
-
-  lines.push(
-    `${x.purple}🛡️  SECURITY${x.reset}  ` +
-    `${sec.col}${sec.label}${x.reset}   ${DIV}   ` +
-    `CVE ${cveStatus}`
-  );
-  lines.push(SEP);
-
-  // ── Row 4: Memory & Tests ─────────────────────────────────────
-  const testCol  = tests.testFiles > 0 ? x.green : x.slate;
-  const memCol   = system.memoryMB > 200 ? x.orange : x.sky;
-
-  // Auto-memory files display
-  const memFileCol = autoMem.count > 0 ? x.purple : x.slate;
-  const memFileStr = autoMem.count > 0
-    ? `${memFileCol}${x.bold}${autoMem.count}${x.reset}${x.slate} memories${x.reset}`
-    : `${x.slate}no memories${x.reset}`;
-  const memTypeOrder = ['handoff', 'user', 'feedback', 'project', 'reference'];
-  const typeColors = { user: x.sky, feedback: x.gold, project: x.teal, reference: x.violet, handoff: x.coral };
-  const typeParts = memTypeOrder
-    .filter(t => autoMem.byType[t] > 0)
-    .map(t => `${typeColors[t] || x.slate}${autoMem.byType[t]}${t.slice(0,1)}${x.reset}`);
-  const kgStr = typeParts.length > 0 ? `  ${typeParts.join(' ')}` : '';
-
-  // Total memory size (palace + agentdb)
-  const totalSizeKB = agentdb.dbSizeKB + palace.palaceSizeKB;
-  const sizeDisp = totalSizeKB >= 1024
-    ? `${(totalSizeKB / 1024).toFixed(1)} MB` : `${totalSizeKB} KB`;
-
-  // HNSW tag only meaningful if vectors exist
-  const vecTotal = agentdb.vectorCount;
-  const hnswTag  = agentdb.hasHnsw ? `  ${x.green}⚡ HNSW${x.reset}` : '';
-
-  const chips = [];
-  if (integration.mcpServers.total > 0) {
-    const mc = integration.mcpServers.enabled === integration.mcpServers.total ? x.green
-             : integration.mcpServers.enabled > 0 ? x.gold : x.coral;
-    chips.push(`${mc}MCP ${integration.mcpServers.enabled}/${integration.mcpServers.total}${x.reset}`);
+  const loopState = getLoopStatus();
+  let loopStr;
+  if (loopState.count > 0) {
+    const parts = loopState.loops.slice(0, 2).map(l => {
+      const status = l.status === 'hil:pending'
+        ? `${x.coral}⏳ HIL${x.reset}`
+        : `${x.green}⟳${x.reset}`;
+      const tag = l.type === 'tillend'
+        ? `${x.bold}${l.cmd}${x.reset}${x.slate} run ${l.rep}${x.reset}`
+        : `${x.bold}${l.cmd}${x.reset}${x.slate} ${l.rep}/${l.max}${x.reset}`;
+      return `${status} ${tag}`;
+    });
+    loopStr = `${x.gold}🔄${x.reset} ${parts.join(`${x.slate}  ·  ${x.reset}`)}`;
+    if (loopState.count > 2) loopStr += `${x.slate}  +${loopState.count - 2} more${x.reset}`;
+  } else {
+    loopStr = `${x.slate}🔄 no active loops${x.reset}`;
   }
-  if (integration.hasDatabase) chips.push(`${x.green}DB ✔${x.reset}`);
-  if (integration.hasApi)      chips.push(`${x.green}API ✔${x.reset}`);
-  const integStr = chips.length ? chips.join('  ') : `${x.slate}none${x.reset}`;
-
-  lines.push(
-    `${x.teal}🗄️  MEMORY${x.reset}   ` +
-    `${memFileStr}${kgStr}${hnswTag}   ${DIV}   ` +
-    `${x.white}${sizeDisp}${x.reset}   ${DIV}   ` +
-    `${testCol}🧪 ${tests.testFiles} test files${x.reset}   ${DIV}   ` +
-    integStr
-  );
+
+  lines.push(`${x.purple}🤖  AGENT${x.reset}    ${agentStr}   ${DIV}   ${loopStr}`);
   lines.push(SEP);
 
-  // ── Row 5: Context budget ─────────────────────────────────────
-  // SI budget (Task 23 monitor)
-  let siStr;
-  if (si) {
-    const siCol = si.pct > 100 ? x.coral : si.pct > 80 ? x.gold : x.green;
-    siStr = `${siCol}📄 SI ${si.pct}% budget${x.reset} ${x.dim}(${si.len}/${si.limit} chars)${x.reset}`;
+  // ── Row 2: Graph freshness + Pending HIL ─────────────────────
+  const gf = getGraphifyStats();
+  const freshness = getGraphFreshness();
+  let graphStr;
+  if (gf.exists) {
+    const nodesFmt = gf.nodes >= 1000 ? `${(gf.nodes / 1000).toFixed(0)}k` : `${gf.nodes}`;
+    const freshTag = freshness.fresh
+      ? `${x.green}● fresh${x.reset}`
+      : freshness.stale
+        ? `${x.coral}● ${freshness.commitsBehind} commits stale${x.reset}`
+        : `${x.gold}● ${freshness.commitsBehind} behind${x.reset}`;
+    graphStr = `${x.sky}🔗 ${x.bold}${nodesFmt}${x.reset}${x.slate} nodes${x.reset}  ${freshTag}`;
   } else {
-    siStr = `${x.slate}📄 no shared instructions${x.reset}`;
+    graphStr = `${x.slate}🔗 no graph${x.reset}`;
   }
 
-  let monthStr = '';
-  if (tokens) {
-    const mFmt = tokens.monthCost >= 100 ? `$${tokens.monthCost.toFixed(2)}` : tokens.monthCost >= 1 ? `$${tokens.monthCost.toFixed(3)}` : `$${tokens.monthCost.toFixed(4)}`;
-    monthStr = `   ${DIV}   ${x.gold}📈 ${x.bold}${mFmt}${x.reset}${x.slate} month · ${tokens.monthCalls} calls${x.reset}`;
-  }
-  lines.push(
-    `${x.slate}📋  CONTEXT${x.reset}  ` +
-    `${siStr}   ${DIV}   ` +
-    `${x.dim}💾 ${system.memoryMB} MB RAM${x.reset}` +
-    monthStr
-  );
+  const hil = getHILPending();
+  const hilStr = hil.pending > 0
+    ? `${x.coral}✨ ${x.bold}${hil.pending}${x.reset}${x.coral} HIL pending${x.reset}`
+    : `${x.slate}✨ no pending HIL${x.reset}`;
+
+  lines.push(`${x.teal}🧠  CONTEXT${x.reset}  ${graphStr}   ${DIV}   ${hilStr}`);
 
   return lines.join('\n');
 }

package/dist/src/init/statusline-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statusline-generator.d.ts","sourceRoot":"","sources":["../../../src/init/statusline-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA0oCrE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA8BnE"}
+{"version":3,"file":"statusline-generator.d.ts","sourceRoot":"","sources":["../../../src/init/statusline-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAonCrE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA8BnE"}