@monoes/monomindcli 1.18.15 → 2.0.0

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

@@ -18,117 +18,16 @@ module.exports = {
       try { session.metric('tasks'); } catch (e) { /* no active session */ }
     }
 
-    // Task 06: AutoRetry — signal retry policy only if coordinator path is active
-    if (hookInput.swarmCoordinator || hookInput.coordinator || hookInput.useRetry) {
-      console.log('[AUTO_RETRY_ENABLED] maxAttempts=3 strategy=exponential-backoff backoffMs=1000');
-    }
-
-    if (router && prompt) {
-      var routeFn = router.routeTaskSemantic || router.routeTask;
-      var result = await Promise.resolve(routeFn(prompt));
-      console.log('[INFO] Task routed to: ' + result.agent + ' (confidence: ' + result.confidence + ')');
-    } else {
-      console.log('[OK] Task started');
-    }
-
-    // AutoMem Phase 1: PLAN routine — consult memory before acting (arXiv:2607.01224)
-    if (prompt && typeof prompt === 'string' && prompt.length > 20) {
-      try {
-        var intelligence = hCtx.intelligence;
-        if (intelligence && intelligence.findSimilarPatterns) {
-          var memPatterns = await Promise.resolve(intelligence.findSimilarPatterns(prompt, { k: 3, type: 'memory-proficiency' }));
-          if (memPatterns && memPatterns.length > 0) {
-            console.log('[AUTOMEM_PLAN] Recalled ' + memPatterns.length + ' memory pattern(s): ' + memPatterns.map(function(p) { return p.content.substring(0, 80); }).join(' | '));
-          }
-          // Also check general patterns for task-relevant memory
-          var taskPatterns = await Promise.resolve(intelligence.findSimilarPatterns(prompt, { k: 2 }));
-          if (taskPatterns && taskPatterns.length > 0) {
-            console.log('[AUTOMEM_CONTEXT] ' + taskPatterns.length + ' relevant pattern(s) from prior sessions');
-          }
-        }
-      } catch (e) { /* non-fatal — PLAN is advisory */ }
-    }
-
-    // Task 24: PromptVersioning — resolve prompt variant before agent spawn
-    try {
-      var memMod = await import('@monomind/memory');
-      if (memMod && memMod.PromptVersionStore) {
-        var pvStore = new memMod.PromptVersionStore(path.join(CWD, '.monomind', 'prompt-versions'));
-        var pvMod = await import('file://' + path.join(CWD, 'packages/@monomind/cli/dist/src/agents/prompt-experiment.js'));
-        if (pvMod && pvMod.PromptExperimentRouter) {
-          var pvRouter = new pvMod.PromptExperimentRouter(pvStore);
-          var agentSlug24 = hookInput.agentSlug || hookInput.agentType || hookInput.agent_type || 'unknown';
-          if (agentSlug24 !== 'unknown') {
-            var resolved = pvRouter.resolvePromptForSpawn(agentSlug24);
-            if (resolved.version) {
-              console.log('[PROMPT_VERSION] ' + agentSlug24 + ' v' + resolved.version + (resolved.isCandidate ? ' (experiment candidate)' : ''));
-            }
-          }
-        }
-      }
-    } 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 changedFiles1 = await new Promise(function(resolve) {
-          require('child_process').exec(
-            'git diff --name-only HEAD 2>/dev/null || git diff --name-only 2>/dev/null',
-            { cwd: CWD, timeout: 3000 },
-            function(err, stdout) { resolve(err ? '' : (stdout || '').trim()); }
-          );
-        });
-        if (changedFiles1) {
-          var mgMod1 = null;
-          mgMod1 = hCtx._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
-    var _hooksModule = hCtx._hooksModule;
+    // monolean: removed per-subagent redundancies:
+    // - Re-routing (already done by route handler on parent prompt)
+    // - AUTOMEM pattern recall (marginal value, 2 similarity searches per spawn)
+    // - PromptVersioning experiments (unused feature)
+    // - Monograph blast radius (already shown by post-edit hook on actual changes)
+
+    // Bridge to @monomind/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks.
+    // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
+    // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
+    var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);
     if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
       try {
         await _hooksModule.executeHooks(_hooksModule.HookEvent.PreTask, {
@@ -148,7 +47,7 @@ module.exports = {
     var taskSuccess = hookInput.success !== false && hookInput.status !== 'failed';
     if (intelligence && intelligence.feedback) {
       try {
-        intelligence.feedback(true);
+        intelligence.feedback(taskSuccess);
       } catch (e) { /* non-fatal */ }
     }
     // Each TeammateIdle/TaskCompleted = one agent done → remove oldest registration (FIFO)
@@ -184,8 +83,10 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Bridge to @monomind/hooks registry — fires Tasks 39 (SpecializationScorer) and any other PostTask hooks
-    var _hooksModule = hCtx._hooksModule;
+    // Bridge to @monomind/hooks registry — fires Tasks 39 (SpecializationScorer) and any other PostTask hooks.
+    // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
+    // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
+    var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);
     if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
       try {
         await _hooksModule.executeHooks(_hooksModule.HookEvent.PostTask, {
@@ -244,7 +145,8 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // AutoMem Phase 1: LOG routine — record memory proficiency metrics (arXiv:2607.01224)
+    // Record whether this task's outcome matched a recalled memory pattern,
+    // so future pattern recall can be scored for usefulness.
     try {
       var intelligence = hCtx.intelligence;
       if (intelligence && intelligence.recordMemoryDecision) {
@@ -259,51 +161,6 @@ module.exports = {
       }
     } catch (e) { /* non-fatal — LOG is advisory */ }
 
-    // ── Worker Auto-Dispatch ──────────────────────────────────────────────
-    // Auto-dispatch background workers based on task outcome
-    try {
-      var taskDesc = (typeof prompt === 'string' ? prompt : hookInput.description || '').toLowerCase();
-      var workersToDispatch = [];
-
-      // Always consolidate memory after any task
-      workersToDispatch.push('consolidate');
-
-      // Security-related task → dispatch audit worker
-      if (/\b(security|auth|vuln|cve|threat|token|permission|crypto)\b/.test(taskDesc)) {
-        workersToDispatch.push('audit');
-      }
-      // Performance-related → dispatch benchmark worker
-      if (/\b(performance|optimiz|benchmark|latency|throughput)\b/.test(taskDesc)) {
-        workersToDispatch.push('benchmark');
-      }
-      // Code changes → dispatch testgaps worker
-      if (/\b(implement|feature|refactor|fix|build|add|create|modify)\b/.test(taskDesc)) {
-        workersToDispatch.push('testgaps');
-      }
-      // Any significant task → dispatch map worker for codebase indexing
-      if (taskDesc.length > 50) {
-        workersToDispatch.push('map');
-      }
-
-      // Dispatch via @monomind/hooks if available, otherwise write dispatch file
-      if (workersToDispatch.length > 0) {
-        var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');
-        fs.mkdirSync(dispatchDir, { recursive: true });
-        var dispatchPayload = {
-          workers: workersToDispatch,
-          trigger: 'post-task',
-          taskDesc: taskDesc.substring(0, 100),
-          success: taskSuccess,
-          timestamp: new Date().toISOString(),
-        };
-        fs.writeFileSync(
-          path.join(dispatchDir, 'pending-' + Date.now() + '-' + Math.random().toString(36).slice(2, 7) + '.json'),
-          JSON.stringify(dispatchPayload), 'utf-8'
-        );
-        console.log('[WORKER_DISPATCH] Queued: ' + workersToDispatch.join(', '));
-      }
-    } catch (e) { /* non-fatal */ }
-
     // ── ADR Auto-Generation ────────────────────────────────────────────────
     // When adr.autoGenerate is true and task involved architect-level work,
     // create an ADR stub in the configured directory

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

@@ -2,6 +2,37 @@
 /**
  * Monomind Hook Handler (Cross-Platform)
  * Dispatches hook events to the appropriate helper modules.
+ *
+ * ARCHITECTURE NOTE — Two Hook Systems
+ * =====================================
+ * There are two independent hook systems in this project:
+ *
+ * 1. .claude/helpers/ CJS handlers (THIS FILE and ./handlers/*.cjs)
+ *    These are the handlers that actually run via settings.json hook
+ *    configuration. They are plain CommonJS scripts invoked directly
+ *    by Claude Code's hook runtime. This is the "live" system.
+ *
+ * 2. @monomind/hooks TypeScript package (packages/@monomind/hooks/)
+ *    A full TypeScript package with workers, learning services, and
+ *    a WorkerManager. It compiles to dist/ but is only loaded
+ *    optionally, bridged at six lifecycle events: SessionStart (restore),
+ *    PreTask, PostTask, PostEdit, SessionEnd, and AgentSpawn (agent-start).
+ *    The CJS handlers in system (1) are the authoritative dispatch path;
+ *    system (2) provides optional enrichment when the package is
+ *    installed and built.
+ *
+ *    IMPORTANT: each hook event is dispatched as its OWN fresh `node`
+ *    process (Claude Code spawns one invocation per event — this file
+ *    does not stay resident across events). So the @monomind/hooks
+ *    module, and anything it registers (trace collector spans, episode
+ *    binner, etc.), cannot be set up once and reused across events —
+ *    every bridging handler must call hCtx._ensureHooksModule() itself,
+ *    which lazily imports the package AND calls initDefaultWorkers() in
+ *    that process before firing executeHooks(). Cross-event state (e.g.
+ *    correlating a PreTask span to its matching PostTask) is NOT
+ *    possible via in-memory maps for this reason; only handlers/hooks
+ *    that persist state to disk (like the daemon workers under
+ *    .monomind/metrics/) can meaningfully bridge across separate events.
  */
 
 const path = require('path');
@@ -70,9 +101,43 @@ const session = safeRequire(path.join(helpersDir, 'session.cjs'));
 const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));
 const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));
 
-// Module-level reference to @monomind/hooks — populated at session-restore,
-// then used by pre-task / post-task to bridge into the hook registry (Tasks 26, 39).
+// Module-level reference to @monomind/hooks — populated lazily via
+// _ensureHooksModule(). NOTE: hook-handler.cjs runs as a fresh `node` process
+// per hook event (Claude Code spawns one invocation per event, it does not
+// keep the process alive across events), so a value set during one event
+// (e.g. session-restore) is NOT visible to a later event's process (e.g.
+// pre-task). Each handler that needs the bridge MUST call
+// hCtx._ensureHooksModule() itself rather than reading hCtx._hooksModule
+// directly, or the bridge silently no-ops.
 let _hooksModule = null;
+let _hooksModuleLoadAttempted = false;
+async function _ensureHooksModule() {
+  if (_hooksModule) return _hooksModule;
+  if (_hooksModuleLoadAttempted) return null; // already tried+failed this process
+  _hooksModuleLoadAttempted = true;
+  // 1) Bare specifier — works when @monomind/hooks is installed/linked in a
+  //    node_modules reachable from this file (e.g. an end-user install).
+  try {
+    _hooksModule = await import('@monomind/hooks');
+  } catch (e) {
+    _hooksModule = null;
+  }
+  // 2) Dev-repo fallback — in the monorepo the pnpm workspace link lives under
+  //    packages/@monomind/cli/node_modules, NOT at the repo root, so the bare
+  //    specifier never resolves from .claude/helpers. Import the compiled dist
+  //    entry directly by path (same pattern as session-restore-handler.cjs).
+  if (!_hooksModule) {
+    try {
+      const _distIndex = path.join(CWD, 'packages', '@monomind', 'hooks', 'dist', 'index.js');
+      if (fs.existsSync(_distIndex)) {
+        _hooksModule = await import('file://' + _distIndex);
+      }
+    } catch (e) {
+      _hooksModule = null; // not built — bridge stays a fail-soft no-op
+    }
+  }
+  return _hooksModule;
+}
 
 // ── Intelligence timeout protection (fixes #1530, #1531) ───────────────────
 var INTELLIGENCE_TIMEOUT_MS = 1500;
@@ -194,9 +259,11 @@ var hCtx = {
   intelligence: intelligence,
   getLearningService: getLearningService,
   isSimpleCommand: isSimpleCommand,
-  // Module-level singleton (populated by session-restore handler)
+  // Module-level singleton (populated by session-restore handler, or lazily
+  // via _ensureHooksModule() — required since each hook event is a fresh process).
   get _hooksModule() { return _hooksModule; },
   set _hooksModule(v) { _hooksModule = v; },
+  _ensureHooksModule: _ensureHooksModule,
   // Utility functions
   _recordRecentEdit: _recordRecentEdit,
   _getRecentEdits: _getRecentEdits,
@@ -274,9 +341,9 @@ const handlers = {
     await h.handle(hCtx, 'auto');
   },
 
-  'agent-start': () => {
+  'agent-start': async () => {
     const h = require('./handlers/agent-start-handler.cjs');
-    h.handle(hCtx);
+    await h.handle(hCtx);
   },
 
   'adr-draft': () => {
@@ -435,6 +502,44 @@ const handlers = {
                     }
                   }
                 }
+
+                // --- Strategy 9: alternation patterns (TODO\|FIXME, mock\|fake\|stub) ---
+                if (!graphAssisted && pattern.indexOf('|') !== -1) {
+                  var altParts = pattern.split(/\\?\|/).map(function(p) {
+                    return p.replace(/[^a-zA-Z0-9_$]/g, '');
+                  }).filter(function(p) {
+                    return p.length >= 4 && /^[a-zA-Z_$]/.test(p) && !_grepStop[p.toLowerCase()];
+                  });
+                  for (var ai = 0; ai < altParts.length && !graphAssisted; ai++) {
+                    var arow = db.prepare(
+                      'SELECT n.name, n.file_path, n.start_line FROM nodes n WHERE n.name = ? COLLATE NOCASE AND n.label NOT IN (\'Concept\',\'Community\',\'Folder\') AND n.file_path IS NOT NULL AND n.file_path NOT LIKE \'%.md\' LIMIT 1'
+                    ).get(altParts[ai]);
+                    if (arow) {
+                      graphAssisted = true;
+                      var ahint = arow.file_path + (arow.start_line != null ? ':' + arow.start_line : '');
+                      console.log('[MONOGRAPH_HINT] ' + arow.name + ' → ' + ahint);
+                    }
+                  }
+                }
+
+              }
+            }
+            // --- Strategy 10: grep targeting a known source directory ---
+            // Runs outside `if (pattern)` so it works even when pattern extraction fails
+            if (!graphAssisted) {
+              var db10 = _openMonographDb();
+              if (db10) {
+                var dirMatch10 = cmdAfterTool.match(/\b(src|packages(?:\/[a-zA-Z0-9_@/-]*)?)\//);
+                if (dirMatch10) {
+                  var dirPath10 = dirMatch10[1].replace(/\/$/, '');
+                  var drow10 = db10.prepare(
+                    'SELECT COUNT(*) AS c FROM nodes WHERE label = \'File\' AND file_path LIKE ? LIMIT 1'
+                  ).get('%' + dirPath10 + '/%');
+                  if (drow10 && drow10.c > 0) {
+                    graphAssisted = true;
+                    console.log('[MONOGRAPH_HINT] grep scope ' + dirPath10 + ' has ' + drow10.c + ' indexed files');
+                  }
+                }
               }
             }
           } else {
@@ -452,6 +557,38 @@ const handlers = {
                 }
               }
             }
+            // find -name "*worker*" — extract core word from wildcard patterns
+            if (!graphAssisted) {
+              var wm = cmd.match(/-name\s+["'][*]?([a-zA-Z][a-zA-Z0-9_-]{3,})[*]?(?:\.[a-z]+)?["']/);
+              if (wm && wm[1]) {
+                var db = _openMonographDb();
+                if (db) {
+                  var wrow = db.prepare(
+                    'SELECT n.name, n.file_path FROM nodes n WHERE n.name LIKE ? AND n.label = \'File\' AND n.file_path NOT LIKE \'%.md\' LIMIT 1'
+                  ).get('%' + wm[1] + '%');
+                  if (wrow) {
+                    graphAssisted = true;
+                    console.log('[MONOGRAPH_HINT] file *' + wm[1] + '* → ' + wrow.file_path);
+                  }
+                }
+              }
+            }
+            // find with -type f in a known directory scope
+            if (!graphAssisted) {
+              var fdm = cmd.match(/\bfind\s+(\S*(?:src|packages|lib|app)[a-zA-Z0-9_@/-]*)/);
+              if (fdm && fdm[1]) {
+                var db = _openMonographDb();
+                if (db) {
+                  var fdrow = db.prepare(
+                    'SELECT COUNT(*) AS c FROM nodes WHERE label = \'File\' AND file_path LIKE ? LIMIT 1'
+                  ).get(fdm[1].replace(/\/$/, '') + '/%');
+                  if (fdrow && fdrow.c > 0) {
+                    graphAssisted = true;
+                    console.log('[MONOGRAPH_HINT] find scope ' + fdm[1] + ' has ' + fdrow.c + ' indexed files');
+                  }
+                }
+              }
+            }
           }
         } catch (e) { /* non-fatal */ }
       }
@@ -647,10 +784,6 @@ const handlers = {
     h.handle(hCtx);
   },
 
-  'status': () => {
-    console.log('[OK] Status check');
-  },
-
   'stats': async () => {
     const h = require('./handlers/stats-handler.cjs');
     await h.handle(hCtx);
@@ -669,13 +802,17 @@ if (command && handlers[command]) {
   } else if (command) {
     console.log('[OK] Hook: ' + command);
   } else {
-    console.log('Usage: hook-handler.cjs <route|pre-bash|pre-search|post-edit|post-read|post-graph-tool|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|status|stats>');
+    console.log('Usage: hook-handler.cjs <route|pre-bash|pre-search|post-edit|post-graph-tool|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|stats>');
   }
 }
 
-main().catch(function(e) {
-  console.log('[WARN] Hook handler error: ' + e.message);
-}).finally(function() {
-  // Use process.exitCode if a gate set it (exit 2 = block), otherwise clean exit
-  process.exit(process.exitCode || 0);
-});
+// Only run when executed directly (every real hook event spawns this file as a
+// process). A require() — e.g. from tests verifying it loads — must not exit.
+if (require.main === module) {
+  main().catch(function(e) {
+    console.log('[WARN] Hook handler error: ' + e.message);
+  }).finally(function() {
+    // Use process.exitCode if a gate set it (exit 2 = block), otherwise clean exit
+    process.exit(process.exitCode || 0);
+  });
+}