@monoes/monomindcli 1.8.0 → 1.9.1

package/.claude/helpers/graphify-freshen.cjs

@@ -1,29 +1,60 @@
 'use strict';
-// Runs at SessionStart — rebuilds the knowledge graph using graphify (Python) in the background.
+// Runs at SessionStart — rebuilds the knowledge graph using @monoes/monograph in the background.
 // Fire-and-forget: spawns detached child, logs start, exits immediately without blocking session.
 const path = require('path');
 const fs = require('fs');
-const { spawn, execSync } = require('child_process');
+const { spawn } = require('child_process');
 
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const graphDir = path.join(projectDir, '.monomind', 'graph');
-
-// Check if graphify CLI is available
-try {
-  execSync('graphify --help', { encoding: 'utf-8', stdio: 'ignore' });
-} catch {
-  console.log('[graph] skip: graphify not installed (run: uv tool install graphifyy)');
-  process.exit(0);
-}
-
 fs.mkdirSync(graphDir, { recursive: true });
 
 const logPath = path.join(graphDir, 'build.log');
 let logFd;
 try { logFd = fs.openSync(logPath, 'a'); } catch { logFd = 'ignore'; }
 
-// graphify update <path> — re-extracts code files and rebuilds graph.json
-const child = spawn('graphify', ['update', projectDir], {
+// Resolve the monograph entry point — searches several common layouts
+function resolveMonographEntry(dir) {
+  // pnpm virtual store — the reliable pre-built copy not affected by workspace symlinks
+  const pnpmStore = (() => {
+    try {
+      const storeBase = path.join(dir, 'node_modules', '.pnpm');
+      if (!fs.existsSync(storeBase)) return null;
+      const entries = fs.readdirSync(storeBase).filter(e => e.startsWith('@monoes+monograph@'));
+      for (const e of entries.sort().reverse()) { // newest version first
+        const p = path.join(storeBase, e, 'node_modules', '@monoes', 'monograph', 'dist', 'src', 'index.js');
+        if (fs.existsSync(p)) return p;
+      }
+    } catch {}
+    return null;
+  })();
+
+  const candidates = [
+    // pnpm store version (most reliable — pre-built, isolated from workspace source changes)
+    pnpmStore,
+    // Monorepo: monobrain root is the monograph package
+    path.join(dir, 'dist', 'src', 'index.js'),
+    // Monorepo: monograph lives under packages/@monomind/monograph (pnpm workspace)
+    path.join(dir, 'packages', '@monomind', 'monograph', 'dist', 'src', 'index.js'),
+    // Installed as a flat dependency
+    path.join(dir, 'node_modules', '@monoes', 'monograph', 'dist', 'src', 'index.js'),
+    path.join(dir, 'node_modules', '@monomind', 'monograph', 'dist', 'src', 'index.js'),
+  ].filter(Boolean);
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+const entryPoint = resolveMonographEntry(projectDir);
+if (!entryPoint) {
+  console.error('[graph] @monoes/monograph not found — skipping build');
+  process.exit(0);
+}
+
+// Spawn a detached node process to run buildAsync from @monoes/monograph (ESM)
+const script = `import { buildAsync } from ${JSON.stringify('file://' + entryPoint)}; await buildAsync(${JSON.stringify(projectDir)});`;
+const child = spawn(process.execPath, ['--input-type=module', '--eval', script], {
   detached: true,
   stdio: ['ignore', logFd, logFd],
   cwd: projectDir,

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

@@ -10,6 +10,21 @@ const fs = require('fs');
 const helpersDir = __dirname;
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
+// Resolve @monoes/monograph — it lives in pnpm's virtual store, not a named symlink.
+// Try common locations; fall back gracefully so all hooks remain non-fatal.
+function _requireMonograph() {
+  var candidates = [
+    path.join(CWD, 'node_modules/.pnpm/node_modules/@monoes/monograph'),
+    path.join(CWD, 'packages/node_modules/.pnpm/node_modules/@monoes/monograph'),
+    path.join(CWD, 'node_modules/@monoes/monograph'),
+  ];
+  for (var i = 0; i < candidates.length; i++) {
+    try { if (fs.existsSync(candidates[i])) return require(candidates[i]); } catch(e) {}
+  }
+  try { return require('@monoes/monograph'); } catch(e) {}
+  return null;
+}
+
 function safeRequire(modulePath) {
   try {
     if (fs.existsSync(modulePath)) {
@@ -240,6 +255,12 @@ function _autoIndexKnowledge(knowledgeDir) {
       }
     } catch (e) {}
   }
+  // Include monograph graph build time in hash so re-index happens after graph rebuild
+  try {
+    var statsForHash = JSON.parse(fs.readFileSync(path.join(CWD, '.monomind', 'graph', 'stats.json'), 'utf-8'));
+    hashInput += 'monograph:' + (statsForHash.builtAt || 0) + ';';
+  } catch(e) {}
+
   var contentHash = crypto.createHash('md5').update(hashInput).digest('hex');
 
   var chunksFile = path.join(knowledgeDir, 'chunks.jsonl');
@@ -275,6 +296,60 @@ function _autoIndexKnowledge(knowledgeDir) {
     } catch (e) {}
   }
 
+  // Inject monograph graph summary as a knowledge chunk
+  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 }
+        }));
+      }
+    }
+  } catch (e) { /* graph not available yet, skip */ }
+
   try {
     fs.mkdirSync(knowledgeDir, { recursive: true });
     fs.writeFileSync(chunksFile, newLines.length > 0 ? newLines.join('\n') + '\n' : '', 'utf-8');
@@ -564,6 +639,17 @@ const handlers = {
 
       console.log(output.join('\n'));
 
+      // Inject monograph hint for complex tasks
+      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.');
+          }
+        }
+      } catch(e) {}
+
       // Swarm mode selection is available on-demand via /mastermind slash command.
     } else {
       console.log('[INFO] Router not available, using default routing');
@@ -657,7 +743,7 @@ const handlers = {
     console.log('[OK] Command validated');
   },
 
-  'post-edit': () => {
+  'post-edit': async () => {
     if (session && session.metric) {
       try { session.metric('edits'); } catch (e) { /* no active session */ }
     }
@@ -695,6 +781,70 @@ const handlers = {
       }
     } catch (e) { /* non-fatal */ }
 
+    // ── Monograph Incremental Rebuild ─────────────────────────────────────
+    // After every code file edit, trigger a background monograph rebuild so
+    // the knowledge graph stays current. Debounced via a lock file (5s cooldown).
+    try {
+      var editedFile = (hookInput.file_path || toolInput.file_path
+        || process.env.TOOL_INPUT_file_path || args[0] || '');
+      var codeExts = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|cs|cpp|c|rb|swift|php)$/i;
+      if (editedFile && codeExts.test(editedFile)) {
+        var lockFile = path.join(CWD, '.monomind', 'graph', '.rebuild-lock');
+        var now = Date.now();
+        var lastBuild = 0;
+        try { lastBuild = parseInt(fs.readFileSync(lockFile, 'utf-8').trim(), 10) || 0; } catch (e) {}
+        var COOLDOWN_MS = 5000; // 5-second debounce
+        if (now - lastBuild > COOLDOWN_MS) {
+          fs.writeFileSync(lockFile, String(now), 'utf-8');
+          var { spawn: spawnRebuild } = require('child_process');
+          var rebuildScript = "import { buildAsync } from '@monoes/monograph'; await buildAsync(" + JSON.stringify(CWD) + ");";
+          var graphDir = path.join(CWD, '.monomind', 'graph');
+          var logPath = path.join(graphDir, 'build.log');
+          var logFd;
+          try { logFd = fs.openSync(logPath, 'a'); } catch(e) { logFd = 'ignore'; }
+          var child = spawnRebuild(process.execPath, ['--input-type=module', '--eval', rebuildScript], {
+            detached: true, stdio: ['ignore', logFd, logFd], cwd: CWD,
+          });
+          child.unref();
+          console.log('[MONOGRAPH] Incremental rebuild triggered for ' + path.basename(editedFile));
+
+          // Option C: fire ua-enrich.mjs in background after monograph rebuild
+          var uaEnrichScript = path.join(CWD, 'scripts', 'ua-enrich.mjs');
+          if (fs.existsSync(uaEnrichScript)) {
+            var uaChild = spawnRebuild(process.execPath, [uaEnrichScript, '--dir', CWD, '--file', editedFile, '--db', path.join(CWD, '.monomind', 'monograph.db')], {
+              detached: true, stdio: 'ignore', cwd: CWD,
+            });
+            uaChild.unref();
+          }
+        }
+        // Show importers of the edited file so Claude sees blast radius
+        try {
+          var mgDbPath4 = path.join(CWD, '.monomind', 'monograph.db');
+          if (fs.existsSync(mgDbPath4)) {
+            var mgMod4 = null;
+            mgMod4 = _requireMonograph();
+            if (mgMod4 && mgMod4.openDb) {
+              var db4 = mgMod4.openDb(mgDbPath4);
+              try {
+                var editedBase4 = path.basename(editedFile).replace(/\.[^.]+$/, '');
+                var editNode4 = db4.prepare("SELECT id, name, label FROM nodes WHERE file_path LIKE ? OR name = ? LIMIT 1")
+                  .get('%' + path.sep + path.basename(editedFile), editedBase4);
+                if (editNode4) {
+                  var editImporters4 = db4.prepare(
+                    'SELECT n2.name FROM edges e JOIN nodes n2 ON n2.id = e.source_id WHERE e.target_id = ? LIMIT 8'
+                  ).all(editNode4.id);
+                  if (editImporters4.length > 0) {
+                    console.log('[MONOGRAPH_IMPACT] ' + editNode4.name + ' (' + editNode4.label + ') is depended on by: ' +
+                      editImporters4.map(function(i) { return i.name; }).join(', '));
+                  }
+                }
+              } finally { if (mgMod4.closeDb) mgMod4.closeDb(db4); }
+            }
+          }
+        } catch(e) { /* non-fatal */ }
+      }
+    } catch (e) { /* non-fatal */ }
+
     console.log('[OK] Edit recorded');
   },
 
@@ -789,6 +939,56 @@ const handlers = {
       }
     } catch (e) { /* non-fatal */ }
 
+    // ── Monograph Context Injection ──────────────────────────────────────────
+    // On session start, query monograph DB for god nodes, inject as context,
+    // and write them into knowledge/chunks.jsonl for semantic search recall.
+    try {
+      var mgDbPath = path.join(CWD, '.monomind', 'monograph.db');
+      if (fs.existsSync(mgDbPath)) {
+        var mgMod = null;
+        mgMod = _requireMonograph();
+        if (mgMod && mgMod.openDb) {
+          var mgDb = mgMod.openDb(mgDbPath);
+          try {
+            var mgNodeCount = mgDb.prepare('SELECT COUNT(*) AS c FROM nodes').get().c;
+            var mgEdgeCount = mgDb.prepare('SELECT COUNT(*) AS c FROM edges').get().c;
+            var mgGodNodes = mgDb.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 ORDER BY deg DESC LIMIT 12'
+            ).all();
+            if (mgGodNodes.length > 0) {
+              var mgGodStr = mgGodNodes.slice(0, 8).map(function(n) {
+                return n.name + ' (' + n.label + ', ' + n.deg + ' links)';
+              }).join(', ');
+              console.log('[MONOGRAPH_CONTEXT] ' + mgNodeCount + ' nodes · ' + mgEdgeCount + ' edges. Key nodes: ' + mgGodStr);
+              // Write god nodes into knowledge chunks so semantic search finds them
+              var mgKnowledgeDir = path.join(CWD, '.monomind', 'knowledge');
+              var mgChunksFile = path.join(mgKnowledgeDir, 'chunks.jsonl');
+              try {
+                fs.mkdirSync(mgKnowledgeDir, { recursive: true });
+                var mgGodChunk = JSON.stringify({
+                  id: 'monograph-god-nodes',
+                  text: 'Codebase architecture — high-centrality nodes (most depended-on): ' + mgGodNodes.map(function(n) {
+                    return n.name + ' [' + n.label + '] at ' + (n.file_path || '') + ' (' + n.deg + ' connections)';
+                  }).join('; '),
+                  namespace: 'knowledge:monograph',
+                  metadata: { label: 'monograph-god-nodes', nodes: mgNodeCount, edges: mgEdgeCount }
+                });
+                var mgExisting = [];
+                try { mgExisting = fs.readFileSync(mgChunksFile, 'utf-8').trim().split('\n').filter(Boolean); } catch(e) {}
+                mgExisting = mgExisting.filter(function(line) {
+                  try { return JSON.parse(line).id !== 'monograph-god-nodes'; } catch(e) { return true; }
+                });
+                mgExisting.push(mgGodChunk);
+                fs.writeFileSync(mgChunksFile, mgExisting.join('\n') + '\n');
+              } catch(e) {}
+            }
+          } finally { if (mgMod.closeDb) mgMod.closeDb(mgDb); }
+        }
+      }
+    } catch(e) { /* non-fatal */ }
+
     // Task 23: SharedInstructions — auto-load .agents/shared_instructions.md on session restore
     // Hard limit: 1500 chars (~375 tokens). Content beyond this is truncated and flagged.
     var SI_CHAR_LIMIT = 1500;
@@ -1156,6 +1356,61 @@ const handlers = {
       }
     } catch (e) { /* not available or no experiment */ }
 
+    // Monograph impact — detect changed files and surface their dependents
+    try {
+      var mgDbPath1 = path.join(CWD, '.monomind', 'monograph.db');
+      if (fs.existsSync(mgDbPath1)) {
+        var execSync1 = require('child_process').execSync;
+        var changedFiles1 = '';
+        try { changedFiles1 = execSync1('git diff --name-only HEAD 2>/dev/null || git diff --name-only 2>/dev/null', { cwd: CWD, timeout: 3000, shell: true }).toString().trim(); } catch(e) {}
+        if (changedFiles1) {
+          var mgMod1 = null;
+          mgMod1 = _requireMonograph();
+          if (mgMod1 && mgMod1.openDb) {
+            var db1 = mgMod1.openDb(mgDbPath1);
+            try {
+              var fileList1 = changedFiles1.split('\n').filter(Boolean).slice(0, 8);
+              var impacted1 = [];
+              for (var fi = 0; fi < fileList1.length; fi++) {
+                var fBase = path.basename(fileList1[fi]);
+                var fNode = db1.prepare("SELECT id, name, label FROM nodes WHERE file_path LIKE ? LIMIT 1").get('%' + fBase);
+                if (fNode) {
+                  var fImporters = db1.prepare(
+                    'SELECT n2.name FROM edges e JOIN nodes n2 ON n2.id = e.source_id WHERE e.target_id = ? LIMIT 5'
+                  ).all(fNode.id);
+                  var entry = fNode.name + ' (' + fNode.label + ')';
+                  if (fImporters.length) entry += ' ← ' + fImporters.map(function(i){ return i.name; }).join(', ');
+                  impacted1.push(entry);
+                }
+              }
+              if (impacted1.length > 0) {
+                console.log('[MONOGRAPH_IMPACT] Changed files and their dependents: ' + impacted1.join(' | '));
+              }
+
+              // Effective blast radius — second pass using first impacted node
+              try {
+                if (fileList1.length > 0 && mgMod1.effectiveBlastRadius) {
+                  var firstFile1 = path.basename(fileList1[0]);
+                  var firstNode1 = db1.prepare("SELECT id, name, label FROM nodes WHERE file_path LIKE ? LIMIT 1").get('%' + firstFile1);
+                  if (firstNode1) {
+                    var blastResults1 = mgMod1.effectiveBlastRadius(db1, firstNode1.id, { maxDepth: 4 });
+                    if (blastResults1 && blastResults1.length > 0) {
+                      var bwdCount1 = blastResults1.filter(function(r){ return r.direction === 'backward' || r.direction === 'both'; }).length;
+                      var fwdCount1 = blastResults1.filter(function(r){ return r.direction === 'forward' || r.direction === 'both'; }).length;
+                      var topBlast1 = blastResults1.slice(0, 8).map(function(r){
+                        return '[' + r.direction + ':' + r.hops + '] ' + r.nodeName + ' (' + r.nodeLabel + ')';
+                      });
+                      console.log('[MONOGRAPH_BLAST_RADIUS] Node: ' + firstNode1.name + ' | forward=' + fwdCount1 + ' backward=' + bwdCount1 + ' | ' + topBlast1.join(', '));
+                    }
+                  }
+                }
+              } catch(blastErr) { /* non-fatal */ }
+            } finally { if (mgMod1.closeDb) mgMod1.closeDb(db1); }
+          }
+        }
+      }
+    } catch(e) { /* non-fatal */ }
+
     // Bridge to @monomind/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks
     if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
       try {

package/.claude/helpers/loop-tracker.cjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * Loop Tracker — PostToolUse hook for ScheduleWakeup
+ * Writes loop state to .monomind/loops/<sessionId>.json so the
+ * Monomind Control dashboard can display active loops.
+ *
+ * Claude Code sends hook data as JSON via stdin:
+ *   { tool_name, tool_input: { delaySeconds, prompt, reason }, session_id }
+ */
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require('fs');
+const path = require('path');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const LOOPS_DIR = path.join(CWD, '.monomind', 'loops');
+
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  return new Promise((resolve) => {
+    let data = '';
+    const timer = setTimeout(() => { process.stdin.removeAllListeners(); resolve(data); }, 3000);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => { clearTimeout(timer); resolve(data); });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(data); });
+    process.stdin.resume();
+  });
+}
+
+function parseRepInfo(prompt, reason) {
+  // Try reason first: "repeat run 2/10 of ..."
+  const reasonMatch = (reason || '').match(/(\d+)\s*\/\s*(\d+)/);
+  if (reasonMatch) {
+    return { currentRep: parseInt(reasonMatch[1]), maxReps: parseInt(reasonMatch[2]) };
+  }
+  // Try prompt flags: --rep 2, --times 10
+  const repMatch = (prompt || '').match(/--rep\s+(\d+)/);
+  const timesMatch = (prompt || '').match(/--times\s+(\d+)/);
+  if (repMatch || timesMatch) {
+    return {
+      currentRep: repMatch ? parseInt(repMatch[1]) : 1,
+      maxReps: timesMatch ? parseInt(timesMatch[1]) : 0,
+    };
+  }
+  return { currentRep: 1, maxReps: 0 };
+}
+
+function detectType(prompt, maxReps) {
+  if (maxReps > 0) return 'repeat';
+  if ((prompt || '').startsWith('/monomind-repeat') || (prompt || '').startsWith('/loop')) return 'repeat';
+  return 'do';
+}
+
+async function main() {
+  const raw = await readStdin();
+  if (!raw.trim()) { process.exit(0); }
+
+  let hookInput = {};
+  try { hookInput = JSON.parse(raw); } catch { process.exit(0); }
+
+  const toolInput = hookInput.tool_input || hookInput.toolInput || {};
+  const sessionId = hookInput.session_id || hookInput.sessionId || hookInput.id || '';
+
+  if (!sessionId) { process.exit(0); }
+
+  const delaySeconds = toolInput.delaySeconds || toolInput.delay_seconds || 60;
+  const prompt = toolInput.prompt || '';
+  const reason = toolInput.reason || '';
+
+  const { currentRep, maxReps } = parseRepInfo(prompt, reason);
+  const type = detectType(prompt, maxReps);
+
+  const loopFile = path.join(LOOPS_DIR, `${sessionId}.json`);
+  let existing = {};
+  try {
+    if (fs.existsSync(loopFile)) {
+      existing = JSON.parse(fs.readFileSync(loopFile, 'utf-8'));
+    }
+  } catch { /* start fresh */ }
+
+  const now = Date.now();
+  const entry = {
+    id: sessionId,
+    sessionId,
+    type,
+    status: 'waiting',
+    prompt: (prompt || '').slice(0, 300),
+    reason,
+    startedAt: existing.startedAt || now,
+    lastRunAt: now,
+    nextRunAt: now + delaySeconds * 1000,
+    currentRep,
+    maxReps,
+    interval: Math.round(delaySeconds / 60),
+    source: 'schedule_wakeup_hook',
+  };
+
+  try {
+    fs.mkdirSync(LOOPS_DIR, { recursive: true });
+    fs.writeFileSync(loopFile, JSON.stringify(entry, null, 2), 'utf-8');
+  } catch { /* ignore write errors */ }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/.claude/helpers/router.cjs

@@ -167,14 +167,10 @@ function isNonDevTask(taskLower) {
   return false;
 }
 
-// ─── Two-Stage LLM Router (for non-dev and ambiguous tasks) ─────────────────
-// Stage 1: LLM picks category from ~9 categories
-// Stage 2: LLM picks specific agent from agents in that category
-// Falls back to keyword scoring if API unavailable
-
-function getAnthropicKey() {
-  return process.env.ANTHROPIC_API_KEY || '';
-}
+// ─── Two-Stage Keyword Router (for non-dev and ambiguous tasks) ──────────────
+// Stage 1: pick best category by scoring task tokens against category keywords
+// Stage 2: pick best agent within that category by keyword overlap
+// Pure in-process — no external API calls, no API key required.
 
 function buildCategoryList() {
   const registry = loadExtrasRegistry();
@@ -197,76 +193,60 @@ function getAgentsInCategory(category) {
     .map(e => ({ slug: e.slug, name: e.name, description: (e.description || '').slice(0, 120) }));
 }
 
-async function llmPick(systemPrompt, userPrompt) {
-  const key = getAnthropicKey();
-  if (!key) return null;
-  try {
-    const ac = new AbortController();
-    const timer = setTimeout(() => ac.abort(), 2000);
-    const resp = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': key,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify({
-        model: 'claude-haiku-4-5-20251001',
-        max_tokens: 60,
-        system: systemPrompt,
-        messages: [{ role: 'user', content: userPrompt }],
-      }),
-      signal: ac.signal,
-    });
-    clearTimeout(timer);
-    if (!resp.ok) return null;
-    const data = await resp.json();
-    const text = (data.content && data.content[0] && data.content[0].text) || '';
-    return text.trim();
-  } catch { return null; }
+// Score a task string against an agent entry using keyword overlap
+function scoreAgainstEntry(taskTokens, entry) {
+  let score = 0;
+  const nameTokens = (entry.name || '').toLowerCase().split(/\W+/).filter(Boolean);
+  const descTokens = (entry.description || '').toLowerCase().split(/\W+/).filter(Boolean);
+  const kwTokens = Array.isArray(entry.keywords) ? entry.keywords.map(k => k.toLowerCase()) : [];
+  const allTokens = new Set([...nameTokens, ...descTokens, ...kwTokens]);
+  for (const t of taskTokens) {
+    if (allTokens.has(t)) score += 2;
+    else for (const s of allTokens) { if (s.includes(t) || t.includes(s)) { score += 1; break; } }
+  }
+  return score;
 }
 
-async function routeTaskLLM(task) {
-  const categories = buildCategoryList();
-  if (!categories.length) return null;
-
-  // Stage 1: pick category
-  const catList = categories.map((c, i) => `${i + 1}. ${c.name} (${c.count} agents, e.g. ${c.examples})`).join('\n');
-  const stage1System = 'You route tasks to agent categories. Reply with ONLY the category name, nothing else.';
-  const stage1User = `Task: "${task}"\n\nCategories:\n${catList}\n\nWhich category best fits this task? Reply with the category name only.`;
+// Category-level score: sum agent scores within the category
+function scoreCategoryForTask(taskTokens, category, registry) {
+  const agents = registry.extras.filter(e => e.category === category);
+  return agents.reduce((sum, e) => sum + scoreAgainstEntry(taskTokens, e), 0);
+}
 
-  const pickedCat = await llmPick(stage1System, stage1User);
-  if (!pickedCat) return null;
+async function routeTaskLLM(task) {
+  const registry = loadExtrasRegistry();
+  if (!registry.extras.length) return null;
 
-  // Normalize — find closest category match
-  const catLower = pickedCat.toLowerCase().replace(/[^a-z-]/g, '');
-  const matchedCat = categories.find(c => c.name.toLowerCase().replace(/[^a-z-]/g, '') === catLower);
-  const categoryName = matchedCat ? matchedCat.name : categories.find(c => catLower.includes(c.name.toLowerCase().replace(/[^a-z-]/g, '')))?.name;
-  if (!categoryName) return null;
+  const taskLower = task.toLowerCase();
+  const STOP = new Set(['the','and','for','are','but','not','you','all','can','had','her','was','one','our','out','day','get','has','him','his','how','its','may','new','now','old','see','two','way','who','did','let','put','say','she','too','use','will','with','that','this','from','they','been','have','make','then','than','when','what','does','into','your']);
+  const taskTokens = taskLower.split(/\W+/).filter(w => w.length > 3 && !STOP.has(w));
 
-  // Stage 2: pick agent within category
-  const agents = getAgentsInCategory(categoryName);
-  if (!agents.length) return null;
+  // Stage 1: pick best category by aggregate keyword score
+  const categories = [...new Set(registry.extras.map(e => e.category))];
+  const catScores = categories.map(cat => ({
+    cat,
+    score: scoreCategoryForTask(taskTokens, cat, registry),
+  })).sort((a, b) => b.score - a.score);
 
-  const agentList = agents.map((a, i) => `${i + 1}. ${a.name} — ${a.description}`).join('\n');
-  const stage2System = 'You pick the best agent for a task. Reply with ONLY the agent name exactly as listed, nothing else.';
-  const stage2User = `Task: "${task}"\n\nAgents in ${categoryName}:\n${agentList}\n\nWhich agent is the best fit? Reply with the exact agent name only.`;
+  const bestCat = catScores[0];
+  if (!bestCat || bestCat.score === 0) return null;
 
-  const pickedAgent = await llmPick(stage2System, stage2User);
-  if (!pickedAgent) return null;
+  // Stage 2: pick best agent within the category
+  const candidates = registry.extras.filter(e => e.category === bestCat.cat);
+  const scored = candidates.map(e => ({ e, score: scoreAgainstEntry(taskTokens, e) }))
+    .sort((a, b) => b.score - a.score);
 
-  // Find the agent entry — exact match only, fall back to keyword routing
-  const agentLower = pickedAgent.toLowerCase().trim();
-  const matched = agents.find(a => a.name.toLowerCase() === agentLower);
-  if (!matched) return null;
+  const top = scored[0];
+  if (!top || top.score === 0) return null;
 
+  const allInCat = candidates.map(e => ({ slug: e.slug, label: e.name, note: e.category }));
   return {
-    agent: matched.name,
-    agentSlug: matched.slug,
-    confidence: 0.9,
-    reason: `LLM 2-stage: ${categoryName} → ${matched.name}`,
-    category: categoryName,
-    allInCategory: agents.map(a => ({ slug: a.slug, label: a.name, note: categoryName })),
+    agent: top.e.name,
+    agentSlug: top.e.slug,
+    confidence: Math.min(0.85, 0.5 + top.score * 0.05),
+    reason: `Keyword 2-stage: ${bestCat.cat} → ${top.e.name}`,
+    category: bestCat.cat,
+    allInCategory: allInCat,
   };
 }