monomind 1.11.14 → 1.13.0

package/.claude/helpers/statusline.cjs

@@ -16,7 +16,7 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
+const { execSync, spawnSync } = require('child_process');
 const os = require('os');
 
 // Configuration
@@ -204,6 +204,8 @@ function getModelFromSessionJSONL() {
     if (files.length === 0) return null;
 
     const sessionFile = path.join(projectsDir, files[0].f);
+    // Guard against OOM: skip session files larger than 10 MB
+    try { if (fs.statSync(sessionFile).size > 10 * 1024 * 1024) return null; } catch { return null; }
     const raw = fs.readFileSync(sessionFile, 'utf-8');
     const lines = raw.split('\n').filter(Boolean);
 
@@ -905,6 +907,60 @@ function getHILPending() {
   return { pending };
 }
 
+// Active org runs — scan .monomind/orgs/*/runs/*.jsonl for recent activity
+// Also checks .git/monomind/orgs/ (git-safe path used by mastermind orgs).
+// An org is "active" if it has an events file modified within the last 10 minutes.
+function getActiveOrgs() {
+  // Try git-common-dir path first (mastermind orgs store run files there)
+  let orgsDir = path.join(CWD, '.monomind', 'orgs');
+  try {
+    const gitCommon = safeExec('git rev-parse --git-common-dir 2>/dev/null', 1000);
+    if (gitCommon) {
+      const candidate = path.isAbsolute(gitCommon)
+        ? path.join(gitCommon, 'monomind', 'orgs')
+        : path.join(CWD, gitCommon, 'monomind', 'orgs');
+      if (fs.existsSync(candidate)) orgsDir = candidate;
+    }
+  } catch { /* use default */ }
+  if (!fs.existsSync(orgsDir)) return { count: 0, orgs: [] };
+  const STALE_MS = 10 * 60 * 1000; // 10 min
+  const now = Date.now();
+  const active = [];
+  try {
+    const orgNames = fs.readdirSync(orgsDir).filter(f => !f.startsWith('.'));
+    for (const orgName of orgNames.slice(0, 20)) {
+      const runsDir = path.join(orgsDir, orgName, 'runs');
+      if (!fs.existsSync(runsDir)) continue;
+      try {
+        const files = fs.readdirSync(runsDir).filter(f => f.endsWith('.jsonl'));
+        if (!files.length) continue;
+        files.sort();
+        const latest = files[files.length - 1];
+        const stat = safeStat(path.join(runsDir, latest));
+        if (!stat) continue;
+        const age = now - stat.mtimeMs;
+        if (age < STALE_MS) {
+          // Check last event type to determine if still running
+          let isRunning = true;
+          try {
+            const MAX_RUN = 512 * 1024; // 512 KiB
+            if (stat.size <= MAX_RUN) {
+              const raw = fs.readFileSync(path.join(runsDir, latest), 'utf-8');
+              const lines = raw.trim().split('\n').filter(Boolean);
+              if (lines.length) {
+                const lastEv = JSON.parse(lines[lines.length - 1]);
+                if (lastEv.type === 'run:complete' || lastEv.type === 'org:complete') isRunning = false;
+              }
+            }
+          } catch { /* treat as running */ }
+          active.push({ name: orgName, runId: latest.replace('.jsonl', ''), ageMs: age, running: isRunning });
+        }
+      } catch { /* skip */ }
+    }
+  } catch { /* ignore */ }
+  return { count: active.length, orgs: active };
+}
+
 // Monograph knowledge graph stats
 // Sources, in priority order:
 //   1. .monomind/graph/stats.json     — explicit cached stats
@@ -922,7 +978,13 @@ function getGraphifyStats() {
 
   try {
     if (fs.existsSync(dbPath)) {
-      const out = safeExec(`sqlite3 "${dbPath}" "SELECT (SELECT COUNT(*) FROM nodes), (SELECT COUNT(*) FROM edges);"`, 1000);
+      // Use spawnSync array args to prevent shell injection via dbPath (CWD-derived)
+      const result = spawnSync(
+        'sqlite3',
+        [dbPath, 'SELECT (SELECT COUNT(*) FROM nodes), (SELECT COUNT(*) FROM edges);'],
+        { encoding: 'utf-8', timeout: 1000 }
+      );
+      const out = (result.stdout || '').trim();
       if (out) {
         const [n, e] = out.split('|').map(v => parseInt(v, 10) || 0);
         if (n > 0) return { nodes: n, edges: e, exists: true };
@@ -952,6 +1014,36 @@ function getSIBudget() {
   } catch { return null; }
 }
 
+// Token cost summary — reads cached .monomind/metrics/token-summary.json (no JSONL scanning).
+// Returns null if file absent, stale (cachedAt is not today in UTC), or cost is zero.
+// All costs are aggregated across ALL Claude Code projects, not just this repo.
+function getTokenCostSummary() {
+  const summaryPath = path.join(CWD, '.monomind', 'metrics', 'token-summary.json');
+  const d = readJSON(summaryPath);
+  if (!d) return null;
+
+  // Staleness guard: only show "today" figures when cachedAt is today (UTC)
+  const todayUtc = new Date().toISOString().slice(0, 10); // "YYYY-MM-DD"
+  const cachedDate = (d.cachedAt || '').slice(0, 10);
+  const isFresh = cachedDate === todayUtc;
+
+  const todayCost  = isFresh ? (d.todayCost  || 0) : 0;
+  const monthCost  = d.monthCost  || 0;
+  const todayCalls = isFresh ? (d.todayCalls || 0) : 0;
+
+  if (monthCost === 0 && todayCost === 0) return null;
+
+  return { todayCost, monthCost, todayCalls, isFresh };
+}
+
+// Format a dollar amount compactly: $0.0023, $1.23, $228.87
+function fmtCost(n) {
+  if (n >= 100)  return '$' + n.toFixed(0);
+  if (n >= 1)    return '$' + n.toFixed(2);
+  if (n >= 0.01) return '$' + n.toFixed(3);
+  return '$' + n.toFixed(4);
+}
+
 // ── Single-line statusline (compact) ─────────────────────────────
 function generateStatusline() {
   const git       = getGitInfo();
@@ -987,9 +1079,24 @@ function generateStatusline() {
     parts.push(`${col}${icon} ${x.bold}${activeAgent.name}${x.reset}`);
   }
 
-  // Intelligence
+  // Active org runs — high signal for users tracking autonomous orgs
+  const orgStatus = getActiveOrgs();
+  if (orgStatus.count > 0) {
+    const runningOrgs = orgStatus.orgs.filter(o => o.running);
+    const doneOrgs = orgStatus.orgs.filter(o => !o.running);
+    if (runningOrgs.length > 0) {
+      const names = runningOrgs.slice(0, 2).map(o => o.name).join(', ');
+      parts.push(`${x.green}🏛 ${x.bold}${names}${x.reset}${runningOrgs.length > 2 ? ` +${runningOrgs.length - 2}` : ''}`);
+    } else if (doneOrgs.length > 0) {
+      parts.push(`${x.slate}🏛 ${doneOrgs[0].name} done${x.reset}`);
+    }
+  }
+
+  // Intelligence — only show when non-trivial (>15%) to avoid misleading 0%/noise
   const ic = pctColor(system.intelligencePct);
-  parts.push(`${ic}💡 ${system.intelligencePct}%${x.reset}`);
+  if (system.intelligencePct > 15) {
+    parts.push(`${ic}💡 ${system.intelligencePct}%${x.reset}`);
+  }
 
   // Knowledge chunks (Task 28) — show when populated
   if (knowledge.chunks > 0) {
@@ -1011,6 +1118,17 @@ function generateStatusline() {
     parts.push(`${x.mint}⚡ ${hooks.enabled}h${x.reset}`);
   }
 
+  // Token cost — today's spend across all projects (from cached summary)
+  const tokenCost = getTokenCostSummary();
+  if (tokenCost) {
+    if (tokenCost.isFresh && tokenCost.todayCost > 0) {
+      const col = tokenCost.todayCost > 50 ? x.coral : tokenCost.todayCost > 10 ? x.gold : x.mint;
+      parts.push(`${col}${fmtCost(tokenCost.todayCost)} today${x.reset}`);
+    } else if (tokenCost.monthCost > 0) {
+      parts.push(`${x.slate}${fmtCost(tokenCost.monthCost)} mo${x.reset}`);
+    }
+  }
+
   return parts.join(`  ${DIV}  `);
 }
 
@@ -1053,6 +1171,17 @@ function generateDashboard() {
   hdr += `  ${DIV}  🤖 ${x.violet}${x.bold}${modelName}${x.reset}`;
   if (session.duration) hdr += `  ${x.dim}⏱ ${session.duration}${x.reset}`;
 
+  // Token cost in dashboard header — today's spend (all projects)
+  const tokenCost = getTokenCostSummary();
+  if (tokenCost) {
+    if (tokenCost.isFresh && tokenCost.todayCost > 0) {
+      const col = tokenCost.todayCost > 50 ? x.coral : tokenCost.todayCost > 10 ? x.gold : x.mint;
+      hdr += `  ${DIV}  ${col}${fmtCost(tokenCost.todayCost)} today${x.reset}${x.dim} · ${fmtCost(tokenCost.monthCost)} mo${x.reset}`;
+    } else if (tokenCost.monthCost > 0) {
+      hdr += `  ${DIV}  ${x.slate}${fmtCost(tokenCost.monthCost)} mo${x.reset}`;
+    }
+  }
+
   lines.push(hdr);
   lines.push(SEP);
 
@@ -1131,6 +1260,20 @@ function generateDashboard() {
 
   lines.push(`${x.teal}🧠  CONTEXT${x.reset}  ${graphStr}   ${DIV}   ${hilStr}`);
 
+  // ── Row 3: Active org runs ───────────────────────────────────
+  const orgStatus = getActiveOrgs();
+  if (orgStatus.count > 0) {
+    lines.push(SEP);
+    const orgParts = orgStatus.orgs.slice(0, 5).map(o => {
+      const ageMin = Math.floor(o.ageMs / 60000);
+      const ageFmt = ageMin < 1 ? 'just now' : ageMin < 60 ? `${ageMin}m ago` : `${Math.floor(ageMin / 60)}h ago`;
+      const col = o.running ? x.green : x.slate;
+      const dot2 = o.running ? `${x.green}●${x.reset}` : `${x.slate}◌${x.reset}`;
+      return `${dot2} ${col}${x.bold}${o.name}${x.reset}  ${x.dim}${ageFmt}${x.reset}`;
+    });
+    lines.push(`${x.purple}🏛  ORGS${x.reset}     ${orgParts.join(`   ${DIV}   `)}`);
+  }
+
   return lines.join('\n');
 }
 
@@ -1148,6 +1291,7 @@ function generateJSON() {
     agentdb:    getAgentDBStats(),
     tests:      getTestStats(),
     git:        { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
+    tokenCost:  getTokenCostSummary(),
     lastUpdated: new Date().toISOString(),
   };
 }

package/.claude/helpers/toggle-statusline.cjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * toggle-statusline.cjs — Toggle or set the monomind statusline display mode.
+ *
+ * Modes:  full | compact
+ * Storage: $CLAUDE_PROJECT_DIR/.monomind/statusline-mode.txt
+ *
+ * Usage:
+ *   node toggle-statusline.cjs              # toggle current mode
+ *   node toggle-statusline.cjs --get        # print current mode
+ *   node toggle-statusline.cjs --set <mode> # set mode (full|compact)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const MODE_FILE = path.join(CWD, '.monomind', 'statusline-mode.txt');
+const VALID_MODES = ['full', 'compact'];
+
+function ensureDir() {
+  try { fs.mkdirSync(path.dirname(MODE_FILE), { recursive: true }); } catch (_) {}
+}
+
+function readMode() {
+  try {
+    if (!fs.existsSync(MODE_FILE)) return 'full';
+    var val = fs.readFileSync(MODE_FILE, 'utf-8').trim();
+    return VALID_MODES.includes(val) ? val : 'full';
+  } catch (_) {
+    return 'full';
+  }
+}
+
+function writeMode(mode) {
+  ensureDir();
+  fs.writeFileSync(MODE_FILE, mode, 'utf-8');
+}
+
+function printUsage() {
+  process.stderr.write(
+    'Usage: toggle-statusline.cjs [--get | --set <full|compact>]\n' +
+    '  (no args)        toggle between full and compact\n' +
+    '  --get            print current mode\n' +
+    '  --set <mode>     set mode to full or compact\n'
+  );
+}
+
+var args = process.argv.slice(2);
+
+if (args[0] === '--get') {
+  process.stdout.write(readMode() + '\n');
+  process.exit(0);
+}
+
+if (args[0] === '--set') {
+  var newMode = args[1];
+  if (!newMode || !VALID_MODES.includes(newMode)) {
+    printUsage();
+    process.exit(1);
+  }
+  writeMode(newMode);
+  process.stdout.write('statusline mode → ' + newMode + '\n');
+  process.exit(0);
+}
+
+// No args: toggle
+var current = readMode();
+var toggled = current === 'full' ? 'compact' : 'full';
+writeMode(toggled);
+process.stdout.write('statusline mode → ' + toggled + '  (was: ' + current + ')\n');
+process.exit(0);