@monoes/monomindcli 1.10.30 → 1.10.32

package/.claude/commands/browse.md

@@ -1,32 +1,21 @@
 ---
 name: browse
-description: Launch agent-browser for web UI testing and automation — installs if missing, then runs the agent-browser-testing skill
+description: Launch monomind browse for web UI testing and automation — native TypeScript CDP client, no external binary needed
 ---
 
 Invoke the agent-browser-testing skill to test or automate a web UI.
 
-Run this shell command immediately without asking for confirmation:
-
-```bash
-if ! command -v agent-browser &>/dev/null; then
-  echo "Installing agent-browser..."
-  npm install -g agent-browser
-else
-  echo "agent-browser $(agent-browser --version) ready"
-fi
-```
-
-After confirming agent-browser is available, invoke the skill:
+`monomind browse` is built-in — no install needed. Invoke the skill:
 
 Skill("agent-browser-testing")
 
 Pass the user's argument (if any) as the URL or task description: $1
 
-Use the full agent-browser workflow:
-1. `agent-browser open <url>`
-2. `agent-browser snapshot -i`
+Use the full monomind browse workflow:
+1. `npx monomind browse open <url>`
+2. `npx monomind browse snapshot -i`
 3. Act using element refs (@e1, @e2, ...)
 4. Re-snapshot to verify
-5. Report results (✅ PASS / ❌ FAIL / ⚠️ WARN)
+5. Report results (PASS / FAIL / WARN)
 
 Examples: `/browse`, `/browse https://example.com`, `/browse test the login flow`

package/.claude/helpers/handlers/adr-draft-handler.cjs

@@ -0,0 +1,64 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'adr-draft' command.
+// Drafts an ADR from accumulated decision markers in .monomind/decisions.jsonl.
+// Receives hCtx from dispatcher. See route-handler.cjs for hCtx field docs.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handle: function(hCtx) {
+    var CWD = hCtx.CWD;
+
+    var jsonl = path.join(CWD, '.monomind', 'decisions.jsonl');
+    if (!fs.existsSync(jsonl)) {
+      console.log('[ADR] No decisions recorded yet. Type prompts containing markers like "let\'s go with X", "we chose Y", "decision: Z" to populate the log.');
+      return;
+    }
+    var lines = fs.readFileSync(jsonl, 'utf-8').trim().split('\n').filter(Boolean);
+    if (lines.length === 0) {
+      console.log('[ADR] decisions.jsonl is empty.');
+      return;
+    }
+    // Group decisions captured in the last 7 days.
+    var cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    var recent = lines
+      .map(function(l) { try { return JSON.parse(l); } catch (_) { return null; } })
+      .filter(function(d) { return d && d.ts >= cutoff; });
+    if (recent.length === 0) {
+      console.log('[ADR] No decisions in the last 7 days. Older entries: ' + lines.length + '.');
+      return;
+    }
+
+    var adrsDir = path.join(CWD, 'docs', 'adrs');
+    try { fs.mkdirSync(adrsDir, { recursive: true }); } catch (_) {}
+    var existing = [];
+    try { existing = fs.readdirSync(adrsDir).filter(function(f) { return /^ADR-\d{4}/.test(f); }); } catch (_) {}
+    var nextNum = existing.length + 1;
+    var num = String(nextNum).padStart(4, '0');
+    var stamp = new Date().toISOString().slice(0, 10);
+    var fname = 'ADR-' + num + '-' + stamp + '-session-decisions.md';
+    var outPath = path.join(adrsDir, fname);
+
+    var body = '# ADR-' + num + ': Session decisions (' + stamp + ')\n\n' +
+               '**Status:** Proposed\n**Date:** ' + stamp + '\n\n' +
+               '## Context\n\n' +
+               'During recent sessions, the following decision markers were captured ' +
+               'from user prompts. Each excerpt is the surrounding sentence at the time.\n\n' +
+               '## Decisions\n\n';
+    for (var i = 0; i < recent.length; i++) {
+      var d = recent[i];
+      var date = new Date(d.ts).toISOString().slice(0, 16).replace('T', ' ');
+      body += '### ' + (i + 1) + '. ' + date + '\n\n';
+      for (var j = 0; j < d.excerpts.length; j++) {
+        body += '> ' + d.excerpts[j].trim() + '\n\n';
+      }
+      if (d.prompt) body += '_Prompt:_ ' + d.prompt.slice(0, 200) + (d.prompt.length > 200 ? '…' : '') + '\n\n';
+    }
+    body += '## Consequences\n\n_(fill in after review)_\n\n' +
+            '## Status\n\nProposed — awaiting human review and refinement.\n';
+    fs.writeFileSync(outPath, body);
+    console.log('[ADR_DRAFT] Wrote ' + recent.length + ' decision(s) to ' + outPath);
+    console.log('  Edit the file to fill in Context and Consequences, then change Status to Accepted/Rejected.');
+  },
+};

package/.claude/helpers/handlers/agent-start-handler.cjs

@@ -0,0 +1,99 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'agent-start' (SubagentStart) hook event.
+// Receives hCtx from dispatcher. See route-handler.cjs for hCtx field docs.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handle: function(hCtx) {
+    var hookInput = hCtx.hookInput;
+    var CWD = hCtx.CWD;
+    var _openMonographDb = hCtx._openMonographDb;
+    var getMonographSuggestions = hCtx.getMonographSuggestions;
+
+    // Register this agent so the statusline can count active agents.
+    const regDir = path.join(CWD, '.monomind', 'agents', 'registrations');
+    try {
+      fs.mkdirSync(regDir, { recursive: true });
+      const id = Date.now() + '-' + Math.random().toString(36).slice(2, 6);
+      const regFile = path.join(regDir, 'agent-' + id + '.json');
+      fs.writeFileSync(regFile, JSON.stringify({
+        agentId: id,
+        startedAt: new Date().toISOString(),
+        pid: process.pid,
+      }));
+      // Refresh swarm-activity.json within the 5-min staleness window.
+      const activityDir = path.join(CWD, '.monomind', 'metrics');
+      fs.mkdirSync(activityDir, { recursive: true });
+      const activityPath = path.join(activityDir, 'swarm-activity.json');
+      const active = fs.readdirSync(regDir).filter(f => f.endsWith('.json')).length;
+      // Preserve lastActive (peak) so statusline shows non-zero after completion.
+      let prevLastActive = 0;
+      try { prevLastActive = (JSON.parse(fs.readFileSync(activityPath, 'utf-8'))?.swarm?.lastActive) || 0; } catch { /* ignore */ }
+      fs.writeFileSync(activityPath, JSON.stringify({
+        timestamp: new Date().toISOString(),
+        swarm: {
+          active: active > 0,
+          agent_count: active,
+          coordination_active: active > 0,
+          lastActive: Math.max(active, prevLastActive),
+        },
+      }));
+
+      // Write last-dispatch.json so the route handler can suppress redundant
+      // suggestions on the next turn when the same agent type is recommended.
+      const agentType = hookInput.subagent_type || hookInput.agentType || hookInput.agent_type || hookInput.agentSlug || 'unknown';
+      const agentDesc = hookInput.description || hookInput.prompt_description || '';
+      fs.writeFileSync(
+        path.join(CWD, '.monomind', 'last-dispatch.json'),
+        JSON.stringify({
+          agentType: agentType,
+          description: agentDesc.substring(0, 120),
+          dispatchedAt: new Date().toISOString(),
+        }),
+        'utf-8'
+      );
+    } catch (e) { /* non-fatal — never block a subagent from starting */ }
+
+    // Subagent context inheritance — inject graph god nodes + parent's last
+    // pre-resolved suggestions so the spawned agent inherits spatial map.
+    try {
+      var subDb = _openMonographDb();
+      if (subDb) {
+        try {
+          var godRows = subDb.prepare(
+            "SELECT n.name, n.label, n.file_path AS file, " +
+            "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
+            "FROM nodes n " +
+            "WHERE n.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
+            "ORDER BY deg DESC LIMIT 5"
+          ).all();
+          if (godRows.length > 0) {
+            console.log('[MONOGRAPH_SUBAGENT_CTX] Graph map inherited from parent:');
+            for (var gi = 0; gi < godRows.length; gi++) {
+              var gr = godRows[gi];
+              console.log('  · ' + gr.name + ' [' + gr.label + '] — ' + (gr.file || '') + ' (deg ' + gr.deg + ')');
+            }
+            try {
+              var subAgentDesc = hookInput.description || hookInput.prompt_description || '';
+              if (subAgentDesc && subAgentDesc.length > 8) {
+                var subHints = getMonographSuggestions(subAgentDesc, 3);
+                if (subHints.length > 0) {
+                  console.log('  Top files for this subagent task:');
+                  for (var si2 = 0; si2 < subHints.length; si2++) {
+                    var sh = subHints[si2];
+                    console.log('    · ' + sh.name + ' [' + sh.label + '] — ' + (sh.file || ''));
+                  }
+                }
+              }
+            } catch (_) {}
+            console.log('  Use mcp__monomind__monograph_suggest / monograph_query in this subagent before grepping.');
+          }
+        } catch (e) { /* non-fatal */ }
+      }
+    } catch (e) { /* non-fatal */ }
+
+    console.log('[OK] Agent registered');
+  },
+};

package/.claude/helpers/handlers/budget-status-handler.cjs

@@ -0,0 +1,14 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'budget-status' command.
+
+module.exports = {
+  handle: function(hCtx) {
+    var _getBudgetStatus = hCtx._getBudgetStatus;
+    var b = _getBudgetStatus();
+    if (!b) { console.log('No budget data yet — token tracking not initialized.'); return; }
+    console.log('Today:   $' + b.todayCost.toFixed(2) + ' / $' + b.dailyLimit  + ' (' + b.dailyPct  + '%)' + (b.autoTuned ? ' [auto-tuned]' : ''));
+    console.log('Month:   $' + b.monthCost.toFixed(2) + ' / $' + b.monthlyLimit + ' (' + b.monthlyPct + '%)');
+    console.log('Status:  ' + (b.breached ? 'BREACHED' : b.spike ? 'SPIKE' : b.alert ? 'ALERT' : 'OK'));
+    console.log('Edit .monomind/budget.json to adjust. Delete to re-tune.');
+  },
+};

package/.claude/helpers/handlers/compact-handler.cjs

@@ -0,0 +1,33 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'compact-manual' and 'compact-auto' events.
+// Receives hCtx and mode ('manual'|'auto') from dispatcher.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handle: async function(hCtx, mode) {
+    var intelligence = hCtx.intelligence;
+    var runWithTimeout = hCtx.runWithTimeout;
+    var _injectCompactGraphMap = hCtx._injectCompactGraphMap;
+    var CWD = hCtx.CWD;
+
+    if (intelligence && intelligence.consolidate) {
+      try { await runWithTimeout(function() { return intelligence.consolidate(); }, 'intelligence.consolidate()'); } catch (e) { /* non-fatal */ }
+    }
+    try {
+      var lastRoute = path.join(CWD, '.monomind', 'last-route.json');
+      if (fs.existsSync(lastRoute)) {
+        var route = JSON.parse(fs.readFileSync(lastRoute, 'utf-8'));
+        console.log('[COMPACT_CONTEXT] Last route: ' + route.agent + ' (' + (route.confidence != null ? (route.confidence * 100).toFixed(0) : '?') + '%)');
+      }
+    } catch (e) { /* non-fatal */ }
+    _injectCompactGraphMap();
+    if (mode === 'auto') {
+      console.log('[COMPACT] Auto compaction — intelligence consolidated, context preserved');
+      console.log('GOLDEN RULE: 1 message = all parallel operations');
+    } else {
+      console.log('[COMPACT] Manual compaction — intelligence consolidated, context preserved');
+    }
+  },
+};

package/.claude/helpers/handlers/graph-status-handler.cjs

@@ -0,0 +1,38 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'graph-status' command.
+// Shows monograph node/edge counts and graph-vs-grep usage ratio.
+// Receives hCtx from dispatcher. See route-handler.cjs for hCtx field docs.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handle: function(hCtx) {
+    var CWD = hCtx.CWD;
+    var _openMonographDb = hCtx._openMonographDb;
+
+    var db = _openMonographDb();
+    if (!db) {
+      console.log('No monograph.db found. Run /monomind:understand to build.');
+      return;
+    }
+    try {
+      var n = db.prepare("SELECT COUNT(*) AS c FROM nodes").get().c;
+      var e = db.prepare("SELECT COUNT(*) AS c FROM edges").get().c;
+      var usage = (function() {
+        try { return JSON.parse(fs.readFileSync(path.join(CWD, '.monomind', 'metrics', 'graph-usage.json'), 'utf-8')); }
+        catch (_) { return {}; }
+      })();
+      var wins = (usage.monograph_call || 0) + (usage.preresolve_hit || 0)
+               + (usage.graph_assist_search || 0) + (usage.graph_assist_neighbors || 0);
+      var search = (usage.grep_call || 0) + (usage.glob_call || 0)
+                 + (usage.bash_grep_call || 0) + (usage.bash_find_call || 0);
+      var pct = (wins + search) > 0 ? Math.round((wins / (wins + search)) * 100) : 0;
+      var saved = usage.dollars_saved || 0;
+      console.log('Monograph: ' + n.toLocaleString() + ' nodes · ' + e.toLocaleString() + ' edges');
+      console.log('Usage: ' + pct + '% graph · ' + (100 - pct) + '% grep · ' +
+                  'wins=' + wins + ' search=' + search +
+                  (saved > 0 ? ' · saved $' + saved.toFixed(2) : ''));
+    } catch (err) { console.log('Error: ' + err.message); }
+  },
+};

package/.claude/helpers/handlers/loops-status-handler.cjs

@@ -0,0 +1,45 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'loops-status' command.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  handle: function(hCtx) {
+    var CWD = hCtx.CWD;
+    var loopsDir = path.join(CWD, '.monomind', 'loops');
+    if (!fs.existsSync(loopsDir)) { console.log('No loops directory.'); return; }
+    var files = fs.readdirSync(loopsDir).filter(function(f) {
+      return f.endsWith('.json') && !f.includes('-hil') && !f.endsWith('.stop');
+    });
+    var STALE_MS = 6 * 60 * 60 * 1000;
+    var now = Date.now();
+    var active = [], stale = [];
+    files.forEach(function(f) {
+      try {
+        var d = JSON.parse(fs.readFileSync(path.join(loopsDir, f), 'utf-8'));
+        var last = d.lastRunAt || d.startedAt || 0;
+        var ageMs = last ? (now - last) : Infinity;
+        if (ageMs > STALE_MS) stale.push({ d: d, ageH: Math.round(ageMs / 3600000) });
+        else active.push(d);
+      } catch (_) {}
+    });
+    if (active.length === 0 && stale.length === 0) {
+      console.log('No loops.'); return;
+    }
+    if (active.length > 0) {
+      console.log('Active (' + active.length + '):');
+      active.forEach(function(d) {
+        console.log('  · ' + (d.command || '?') + ' [' + (d.type || '?') + '] run ' + (d.currentRep || 0) +
+                    (d.maxReps ? '/' + d.maxReps : '') + ' · ' + (d.status || '?'));
+      });
+    }
+    if (stale.length > 0) {
+      console.log('Stale (' + stale.length + ' >6h):');
+      stale.forEach(function(s) {
+        console.log('  · ' + (s.d.command || '?') + ' run ' + (s.d.currentRep || 0) +
+                    ' · ' + s.ageH + 'h ago · ' + (s.d.status || '?'));
+      });
+    }
+  },
+};

package/.claude/helpers/handlers/session-restore-handler.cjs

@@ -31,50 +31,55 @@ module.exports = {
     } catch (e) { console.log('[WARN] Session restore failed: ' + e.message); }
 
     // Stale helper detection — warn when project helpers drift from the bundled npm copy.
+    // Skip when running inside the monomind dev repo itself: local helpers ARE the
+    // source of truth there, so any diff vs. the npm global install is expected.
     try {
-      var crypto = require('crypto');
-      function _findBundledHelpers() {
-        var helperPaths = [
-          path.join(helpersDir),
-          path.join(CWD, 'node_modules', 'monomind', '.claude', 'helpers'),
-          path.join(CWD, 'node_modules', '@monoes', 'monomindcli', '.claude', 'helpers'),
-        ];
-        try {
-          var globalRoot = require('child_process')
-            .execSync('npm root -g 2>/dev/null', { encoding: 'utf-8', timeout: 2000 })
-            .trim();
-          if (globalRoot) {
-            helperPaths.push(path.join(globalRoot, 'monomind', '.claude', 'helpers'));
-            helperPaths.push(path.join(globalRoot, '@monoes', 'monomindcli', '.claude', 'helpers'));
-          }
-        } catch (_) {}
-        for (var i = 0; i < helperPaths.length; i++) {
-          if (fs.existsSync(path.join(helperPaths[i], 'hook-handler.cjs')) &&
-              helperPaths[i] !== path.join(CWD, '.claude', 'helpers')) {
-            return helperPaths[i];
-          }
-        }
-        return null;
-      }
-
-      var bundledDir = _findBundledHelpers();
-      if (bundledDir) {
-        var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs'];
-        var stale = [];
-        for (var hi = 0; hi < helpersToCheck.length; hi++) {
-          var hName = helpersToCheck[hi];
-          var localF   = path.join(CWD, '.claude', 'helpers', hName);
-          var bundledF = path.join(bundledDir, hName);
-          if (!fs.existsSync(localF) || !fs.existsSync(bundledF)) continue;
+      var _isDevRepo = fs.existsSync(path.join(CWD, 'packages', '@monomind', 'cli', 'package.json'));
+      if (!_isDevRepo) {
+        var crypto = require('crypto');
+        function _findBundledHelpers() {
+          var helperPaths = [
+            path.join(helpersDir),
+            path.join(CWD, 'node_modules', 'monomind', '.claude', 'helpers'),
+            path.join(CWD, 'node_modules', '@monoes', 'monomindcli', '.claude', 'helpers'),
+          ];
           try {
-            var hashL = crypto.createHash('sha256').update(fs.readFileSync(localF)).digest('hex');
-            var hashB = crypto.createHash('sha256').update(fs.readFileSync(bundledF)).digest('hex');
-            if (hashL !== hashB) stale.push(hName);
+            var globalRoot = require('child_process')
+              .execSync('npm root -g 2>/dev/null', { encoding: 'utf-8', timeout: 2000 })
+              .trim();
+            if (globalRoot) {
+              helperPaths.push(path.join(globalRoot, 'monomind', '.claude', 'helpers'));
+              helperPaths.push(path.join(globalRoot, '@monoes', 'monomindcli', '.claude', 'helpers'));
+            }
           } catch (_) {}
+          for (var i = 0; i < helperPaths.length; i++) {
+            if (fs.existsSync(path.join(helperPaths[i], 'hook-handler.cjs')) &&
+                helperPaths[i] !== path.join(CWD, '.claude', 'helpers')) {
+              return helperPaths[i];
+            }
+          }
+          return null;
         }
-        if (stale.length > 0) {
-          console.log('[STALE_HELPERS] Project helpers differ from bundled version: ' + stale.join(', '));
-          console.log('  Run `npx monomind@latest init upgrade` to refresh and pick up the latest features.');
+
+        var bundledDir = _findBundledHelpers();
+        if (bundledDir) {
+          var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs'];
+          var stale = [];
+          for (var hi = 0; hi < helpersToCheck.length; hi++) {
+            var hName = helpersToCheck[hi];
+            var localF   = path.join(CWD, '.claude', 'helpers', hName);
+            var bundledF = path.join(bundledDir, hName);
+            if (!fs.existsSync(localF) || !fs.existsSync(bundledF)) continue;
+            try {
+              var hashL = crypto.createHash('sha256').update(fs.readFileSync(localF)).digest('hex');
+              var hashB = crypto.createHash('sha256').update(fs.readFileSync(bundledF)).digest('hex');
+              if (hashL !== hashB) stale.push(hName);
+            } catch (_) {}
+          }
+          if (stale.length > 0) {
+            console.log('[STALE_HELPERS] Project helpers differ from bundled version: ' + stale.join(', '));
+            console.log('  Run `npx monomind@latest init upgrade` to refresh and pick up the latest features.');
+          }
         }
       }
     } catch (e) { /* non-fatal */ }
@@ -313,21 +318,27 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Monomind Control UI Status.
-    try {
-      var http = require('http');
-      var controlPort = 4242;
-      var req = http.get('http://localhost:' + controlPort + '/', function(res) {
-        if (res.statusCode === 200) {
-          console.log('[CONTROL_UI] UP — http://localhost:' + controlPort);
-        }
-        res.resume();
-      });
-      req.on('error', function() {
-        console.log('[CONTROL_UI] offline — run: npx monomind mcp start');
-      });
-      req.setTimeout(800, function() { req.destroy(); });
-    } catch (e) { /* non-fatal */ }
+    // Monomind Control UI Status — only probe when a daemon has previously run
+    // (indicated by daemon.pid or monomind.config.json). Skips silently in fresh
+    // environments and test fixtures that have no daemon history.
+    var _controlUiShouldProbe = fs.existsSync(path.join(CWD, '.monomind', 'daemon.pid'))
+      || fs.existsSync(path.join(CWD, 'monomind.config.json'));
+    if (_controlUiShouldProbe) {
+      try {
+        var http = require('http');
+        var controlPort = 4242;
+        var req = http.get('http://localhost:' + controlPort + '/', function(res) {
+          if (res.statusCode === 200) {
+            console.log('[CONTROL_UI] UP — http://localhost:' + controlPort);
+          }
+          res.resume();
+        });
+        req.on('error', function() {
+          console.log('[CONTROL_UI] offline — run: npx monomind mcp start');
+        });
+        req.setTimeout(800, function() { req.destroy(); });
+      } catch (e) { /* non-fatal */ }
+    }
 
     // Worker Queue Resume (SR-003).
     try {

package/.claude/helpers/handlers/stats-handler.cjs

@@ -0,0 +1,14 @@
+'use strict';
+// Extracted from hook-handler.cjs — handles 'stats' command.
+
+module.exports = {
+  handle: async function(hCtx) {
+    var intelligence = hCtx.intelligence;
+    var args = hCtx.args;
+    if (intelligence && intelligence.stats) {
+      await Promise.resolve(intelligence.stats(args.includes('--json')));
+    } else {
+      console.log('[WARN] Intelligence module not available. Run session-restore first.');
+    }
+  },
+};