monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/.claude/helpers/handlers/route-handler.cjs

@@ -52,6 +52,14 @@ module.exports = {
 
     if (intelligence && intelligence.getContext) {
       try {
+        // Each hook event runs as a fresh node process, so the module-level
+        // _entries cache is always empty here — without init() getContext()
+        // returns null on every prompt and stored patterns are never recalled.
+        // init() reads one small JSON file (auto-memory-store.json), so the
+        // per-prompt cost is negligible.
+        if (intelligence.init) {
+          try { intelligence.init(); } catch (e) { /* non-fatal */ }
+        }
         // Bootstrap intelligence from monograph on first prompt if store is sparse
         if (intelligence.bootstrapFromDb) {
           try {
@@ -70,6 +78,43 @@ module.exports = {
       const routeFn = router.routeTaskSemantic || router.routeTask;
       var result = await Promise.resolve(routeFn(prompt));
 
+      // ── Enrichment: when router.cjs falls to the broad "coder" catch-all,
+      //    try @monomind/routing's richer keyword pre-filter (30+ specialized
+      //    rules for Solidity, game engines, DevOps, embedded, etc.) for a
+      //    more specific agent match. This bridges the hooks layer (router.cjs)
+      //    with the CLI routing package without requiring ESM imports. ─────────
+      if (result && result.agentSlug === 'coder' && result.confidence <= 0.8) {
+        try {
+          var routingPkgPath = path.resolve(
+            CWD, 'packages', '@monomind', 'routing', 'dist', 'keyword-pre-filter.js'
+          );
+          // Also check CLI's node_modules (symlinked workspace)
+          if (!fs.existsSync(routingPkgPath)) {
+            routingPkgPath = path.resolve(
+              CWD, 'packages', '@monomind', 'cli', 'node_modules',
+              '@monomind', 'routing', 'dist', 'keyword-pre-filter.js'
+            );
+          }
+          if (fs.existsSync(routingPkgPath)) {
+            var routingMod = await import(routingPkgPath);
+            var enrichRules = routingMod.DEFAULT_KEYWORD_ROUTES;
+            if (enrichRules && enrichRules.length > 0) {
+              for (var eri = 0; eri < enrichRules.length; eri++) {
+                var erRule = enrichRules[eri];
+                if (erRule.pattern && erRule.pattern.test(prompt)) {
+                  result.agent = erRule.routeName || erRule.agentSlug;
+                  result.agentSlug = erRule.agentSlug;
+                  result.confidence = 0.90;
+                  result.reason = 'Enriched: ' + (erRule.description || erRule.routeName);
+                  result.enrichedFrom = 'routing-keyword-pre-filter';
+                  break;
+                }
+              }
+            }
+          }
+        } catch (e) { /* non-fatal — routing package may not be available */ }
+      }
+
       // ── Agent success pattern lookup ──────────────────────────
       try {
         var patternDb = hCtx._openMonographDb();
@@ -113,7 +158,7 @@ module.exports = {
           for (var ri = 0; ri < recentRf.length; ri++) {
             try {
               var rfEntry = JSON.parse(recentRf[ri]);
-              if (rfEntry.suggestedAgent === routedAgent) {
+              if (rfEntry.suggestedAgent === routedAgent && typeof rfEntry.intelligenceFeedback === 'boolean') {
                 agentFeedback.push(rfEntry.intelligenceFeedback);
               }
             } catch (e) {}
@@ -133,6 +178,23 @@ module.exports = {
       // recommendations that are no longer injected into context. The statusline
       // just shows the keyword router's pick; no need for 50 lines of overrides.
 
+      // ── Dispatch dedup: suppress re-recommending the same agent just dispatched ──
+      // agent-start-handler writes last-dispatch.json on SubagentStart.
+      // If the router picks the same agent within 60s, it's likely the parent re-routing
+      // the same prompt — log a note so the LLM can vary its approach.
+      try {
+        var dispatchPath = path.join(CWD, '.monomind', 'last-dispatch.json');
+        var MAX_DISPATCH = 4096;
+        if (fs.existsSync(dispatchPath) && fs.statSync(dispatchPath).size <= MAX_DISPATCH) {
+          var lastDispatch = JSON.parse(fs.readFileSync(dispatchPath, 'utf-8'));
+          var dispatchAge = Date.now() - new Date(lastDispatch.dispatchedAt || 0).getTime();
+          if (dispatchAge < 60000 && lastDispatch.agentType === (result.agentSlug || result.agent)) {
+            result.recentlyDispatched = true;
+            console.log('[DISPATCH_DEDUP] ' + lastDispatch.agentType + ' was dispatched ' + Math.round(dispatchAge / 1000) + 's ago — consider a different specialist or direct implementation');
+          }
+        }
+      } catch (e) { /* non-fatal */ }
+
       var output = [];
       var conf = result.confidence != null ? result.confidence : 0;
 
@@ -226,12 +288,74 @@ module.exports = {
             console.log('[SECURITY] ' + secData.findings.length + ' findings from background scan. Review .monomind/metrics/security-audit.json');
           }
         }
-        // Codebase map hotspots
+        // Codebase map top files (high-centrality god nodes from monograph)
         var mapFile = path.join(metricsDir, 'codebase-map.json');
         if (fs.existsSync(mapFile) && fs.statSync(mapFile).size < 32768) {
           var mapData = JSON.parse(fs.readFileSync(mapFile, 'utf-8'));
-          if (mapData && mapData.hotspots && mapData.hotspots.length > 0) {
-            console.log('[CODEBASE] ' + mapData.hotspots.length + ' hotspots detected. Top: ' + (mapData.hotspots[0].file || mapData.hotspots[0].name || 'unknown'));
+          if (mapData && mapData.topFiles && mapData.topFiles.length > 0) {
+            console.log('[CODEBASE] ' + mapData.topFiles.length + ' high-centrality files. Top: ' + (mapData.topFiles[0].ref || 'unknown') + ' (degree ' + (mapData.topFiles[0].degree || '?') + ')');
+          }
+          if (mapData && mapData.graphStaleness && mapData.graphStaleness.commitsBehind > 10) {
+            console.log('[CODEBASE] Graph index ' + mapData.graphStaleness.commitsBehind + ' commits behind HEAD — run monograph build');
+          }
+        }
+        // Deep dive findings (god nodes, high-degree files from background analysis)
+        var deepdiveFile = path.join(metricsDir, 'deepdive.json');
+        if (fs.existsSync(deepdiveFile) && fs.statSync(deepdiveFile).size < 32768) {
+          var ddData = JSON.parse(fs.readFileSync(deepdiveFile, 'utf-8'));
+          if (ddData && ddData.findings && ddData.findings.length > 0) {
+            for (var di = 0; di < ddData.findings.length; di++) {
+              var finding = ddData.findings[di];
+              if (finding.category === 'god_nodes' && finding.items && finding.items.length > 0) {
+                var topGod = finding.items[0];
+                console.log('[DEEPDIVE] ' + finding.items.length + ' god nodes. Top: ' + (topGod.name || 'unknown') + ' (degree ' + (topGod.degree || '?') + ') in ' + (topGod.file || 'unknown'));
+              }
+            }
+          }
+        }
+        // Ultralearn insights (bridge nodes crossing community boundaries)
+        var ultralearnFile = path.join(metricsDir, 'ultralearn.json');
+        if (fs.existsSync(ultralearnFile) && fs.statSync(ultralearnFile).size < 32768) {
+          var ulData = JSON.parse(fs.readFileSync(ultralearnFile, 'utf-8'));
+          if (ulData && ulData.insightsGained && ulData.insightsGained.length > 0) {
+            for (var ui = 0; ui < ulData.insightsGained.length; ui++) {
+              var insight = ulData.insightsGained[ui];
+              if (insight.category === 'bridge_nodes' && insight.items && insight.items.length > 0) {
+                var topBridge = insight.items[0];
+                console.log('[ARCHITECTURE] ' + insight.items.length + ' bridge nodes crossing community boundaries. Top: ' + (topBridge.name || 'unknown') + ' (' + (topBridge.crossCommunityEdges || '?') + ' cross-edges) in ' + (topBridge.location || 'unknown'));
+              }
+            }
+          }
+        }
+        // Performance metrics (daemon optimize worker)
+        var perfFile = path.join(metricsDir, 'performance.json');
+        if (fs.existsSync(perfFile) && fs.statSync(perfFile).size < 32768) {
+          var perfData = JSON.parse(fs.readFileSync(perfFile, 'utf-8'));
+          if (perfData && perfData.memoryUsage) {
+            var rssBytes = perfData.memoryUsage.rss || 0;
+            var rssMB = Math.round(rssBytes / (1024 * 1024));
+            if (rssMB > 512) {
+              console.log('[PERF] Daemon RSS ' + rssMB + 'MB (>512MB threshold). Consider restarting daemon or reducing worker concurrency');
+            }
+          }
+        }
+        // Memory consolidation health
+        var consolFile = path.join(metricsDir, 'consolidation.json');
+        if (fs.existsSync(consolFile) && fs.statSync(consolFile).size < 32768) {
+          var consolData = JSON.parse(fs.readFileSync(consolFile, 'utf-8'));
+          if (consolData && consolData.patternsConsolidated > 0) {
+            console.log('[MEMORY] ' + consolData.patternsConsolidated + ' patterns consolidated into ' + consolData.clustersCreated + ' RAPTOR clusters');
+          }
+        }
+        // Benchmark worker RSS (manual-trigger `daemon trigger -w benchmark`)
+        var benchFile = path.join(metricsDir, 'benchmark.json');
+        if (fs.existsSync(benchFile) && fs.statSync(benchFile).size < 32768) {
+          var benchData = JSON.parse(fs.readFileSync(benchFile, 'utf-8'));
+          if (benchData && benchData.benchmarks && benchData.benchmarks.memoryUsage) {
+            var benchRssMB = Math.round((benchData.benchmarks.memoryUsage.rss || 0) / (1024 * 1024));
+            if (benchRssMB > 512) {
+              console.log('[PERF] Benchmark snapshot RSS ' + benchRssMB + 'MB (>512MB threshold) at last `daemon trigger -w benchmark` run');
+            }
           }
         }
       } catch (e) { /* non-fatal */ }
@@ -248,6 +372,15 @@ module.exports = {
             var promptTokens = promptLower.match(/[a-z][a-z0-9_-]{2,}/g) || [];
             if (promptTokens.length > 0) {
               var matches = [];
+              // Truncate at the last space before maxLen so fragments never
+              // end mid-word (falls back to a hard cut for space-less text).
+              var truncAtWord = function(s, maxLen) {
+                s = String(s || '');
+                if (s.length <= maxLen) return s;
+                var cut = s.slice(0, maxLen);
+                var sp = cut.lastIndexOf(' ');
+                return sp > 40 ? cut.slice(0, sp) : cut;
+              };
               // Only search last 200 episodes
               var searchEps = epRaw.slice(-200);
               for (var ei = 0; ei < searchEps.length; ei++) {
@@ -264,14 +397,23 @@ module.exports = {
                   }
                   var relevance = promptTokens.length > 0 ? hits / promptTokens.length : 0;
                   if (relevance >= 0.3 && hits >= 2) {
-                    matches.push({ summary: (ep.summary || '').slice(0, 120), relevance: relevance, ts: ep.endedAt || 0 });
+                    matches.push({ summary: truncAtWord(ep.summary || '', 120), relevance: relevance, ts: ep.endedAt || 0 });
                   }
                 } catch (e) {}
               }
-              // Show top 2 most relevant matches
+              // Show top 2 most relevant matches — dedupe by fragment text so
+              // two episodes from the same conversation don't inject the same
+              // truncated snippet twice.
               if (matches.length > 0) {
                 matches.sort(function(a, b) { return b.relevance - a.relevance; });
-                var topMatches = matches.slice(0, 2);
+                var topMatches = [];
+                var seenFrags = {};
+                for (var tmi = 0; tmi < matches.length && topMatches.length < 2; tmi++) {
+                  var frag = matches[tmi].summary.replace(/\n/g, ' ').trim();
+                  if (seenFrags[frag]) continue;
+                  seenFrags[frag] = true;
+                  topMatches.push(matches[tmi]);
+                }
                 var memLines = ['[MEMORY] Relevant past sessions:'];
                 for (var mi = 0; mi < topMatches.length; mi++) {
                   var ago = topMatches[mi].ts ? Math.round((Date.now() - topMatches[mi].ts) / 3600000) + 'h ago' : '';

package/packages/@monomind/cli/.claude/helpers/handlers/session-handler.cjs

@@ -33,7 +33,7 @@ module.exports = {
     // sessionSuccess is derived from intelligence-outcomes.jsonl entries written
     // during this session (last 30 minutes). A session is marked failed when the
     // majority of feedback() calls carried success=false in that window.
-    var sessionSuccess = true; // optimistic default when no signal exists
+    var sessionSuccess = null; // null = no evidence; only set to a boolean from real signals
     try {
       var feedbackPath = path.join(CWD, '.monomind', 'routing-feedback.jsonl');
       var lastRoutePath = path.join(CWD, '.monomind', 'last-route.json');
@@ -68,35 +68,41 @@ module.exports = {
                 }
               }
             }
-            // else: modified files exist, keep optimistic default (true)
+            // else: modified files exist — work in progress, not evidence either way (leave null)
           }
-        } catch (e) { /* non-critical — keep optimistic default */ }
+        } catch (e) { /* non-critical — leave null (no evidence) */ }
 
         // Record session-end feedback WITH recentEdits (before consolidate clears them)
-        if (intelligence && intelligence.feedback) {
+        if (intelligence && intelligence.feedback && typeof sessionSuccess === 'boolean') {
           try { intelligence.feedback(sessionSuccess); } catch (e) { /* non-fatal */ }
         }
-        var feedbackEntry = {
-          timestamp: new Date().toISOString(),
-          suggestedAgent: lastRoute.agent,
-          confidence: lastRoute.confidence,
-          sessionId: String(hookInput.sessionId || hookInput.session_id || '').slice(0, 128),
-          intelligenceFeedback: sessionSuccess,
-        };
-        fs.appendFileSync(feedbackPath, JSON.stringify(feedbackEntry) + '\n', 'utf-8');
-        // Rotate: keep last 1000 lines to prevent unbounded growth
-        try {
-          var MAX_FEEDBACK = 512 * 1024; // 512 KiB
-          if (fs.existsSync(feedbackPath) && fs.statSync(feedbackPath).size > MAX_FEEDBACK) {
-            // File too large — emergency trim without full read
-            throw new Error('skip-rotation');
-          }
-          var raw = fs.readFileSync(feedbackPath, 'utf-8');
-          var lines = raw.split('\n').filter(Boolean);
-          if (lines.length > 1000) {
-            fs.writeFileSync(feedbackPath, lines.slice(-1000).join('\n') + '\n', 'utf-8');
-          }
-        } catch (e2) { /* rotation is best-effort */ }
+        // Normalize agent label to a lowercase slug ("Coder" → "coder", "backend dev" → "backend-dev")
+        var agentSlug = String(lastRoute.agent || '').trim().toLowerCase().replace(/\s+/g, '-');
+        // Skip non-agent placeholders — "AI selecting" etc. carry no routing signal
+        if (agentSlug && agentSlug !== 'ai-selecting' && agentSlug !== 'unknown') {
+          var feedbackEntry = {
+            timestamp: new Date().toISOString(),
+            suggestedAgent: agentSlug,
+            confidence: lastRoute.confidence,
+            sessionId: String(hookInput.sessionId || hookInput.session_id || '').slice(0, 128),
+          };
+          // Only write the success flag when derived from actual evidence (commits, outcomes)
+          if (typeof sessionSuccess === 'boolean') feedbackEntry.intelligenceFeedback = sessionSuccess;
+          fs.appendFileSync(feedbackPath, JSON.stringify(feedbackEntry) + '\n', 'utf-8');
+          // Rotate: keep last 1000 lines to prevent unbounded growth
+          try {
+            var MAX_FEEDBACK = 512 * 1024; // 512 KiB
+            if (fs.existsSync(feedbackPath) && fs.statSync(feedbackPath).size > MAX_FEEDBACK) {
+              // File too large — emergency trim without full read
+              throw new Error('skip-rotation');
+            }
+            var raw = fs.readFileSync(feedbackPath, 'utf-8');
+            var lines = raw.split('\n').filter(Boolean);
+            if (lines.length > 1000) {
+              fs.writeFileSync(feedbackPath, lines.slice(-1000).join('\n') + '\n', 'utf-8');
+            }
+          } catch (e2) { /* rotation is best-effort */ }
+        }
       }
     } catch (e) { /* non-fatal */ }
 
@@ -117,6 +123,22 @@ module.exports = {
       }
     } catch (e) { console.log('[WARN] Session end failed: ' + e.message); }
 
+    // Bridge to @monomind/hooks registry — fires SessionEnd hooks (episode-binner closeEpisode, observability bus).
+    // 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.SessionEnd, {
+          session: {
+            id: String(hookInput.sessionId || hookInput.session_id || ''),
+            startedAt: new Date(),
+          },
+          success: sessionSuccess !== false, // null (no evidence) still counts as non-failure here
+        }, { continueOnError: true, timeout: 2000 });
+      } catch (e) { /* non-fatal */ }
+    }
+
     // Memory Palace tombstone writes removed — redundant with raw session JSONL
 
     // ── Context Persistence Auto-Archive ─────────────────────────────────

package/packages/@monomind/cli/.claude/helpers/handlers/session-restore-handler.cjs

@@ -120,15 +120,92 @@ module.exports = {
     }
 
     // Bridge to @monomind/hooks compiled workers (GAP-001).
+    // Uses the shared hCtx._ensureHooksModule() (defined in hook-handler.cjs) so worker
+    // registration happens exactly once per process instead of being duplicated here —
+    // every other bridging handler (agent-start, pre-task, post-task, post-edit,
+    // session-end) calls the same lazy loader since each hook event is its own process.
     try {
-      var hooksModule = await import('@monomind/hooks');
-      if (hooksModule && hooksModule.initDefaultWorkers) {
-        await runWithTimeout(function() { return hooksModule.initDefaultWorkers(); }, '@monomind/hooks.initDefaultWorkers()');
+      var hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : await import('@monomind/hooks');
+      if (hooksModule) {
         hCtx._hooksModule = hooksModule;
         console.log('[INFO] @monomind/hooks workers initialized');
+
+        // Gate enforcement lives entirely in gates-handler.cjs (its own regex
+        // table, run on every PreToolUse). The @monomind/guidance package that
+        // used to compile gate configs here was removed.
+
+        // Fire SessionStart event so observability bus and other SessionStart hooks activate
+        if (hooksModule.executeHooks && hooksModule.HookEvent) {
+          try {
+            await runWithTimeout(function() {
+              return hooksModule.executeHooks(hooksModule.HookEvent.SessionStart, {
+                session: {
+                  id: String(hookInput.sessionId || hookInput.session_id || ''),
+                  startedAt: new Date(),
+                },
+              }, { continueOnError: true, timeout: 1500 });
+            }, '@monomind/hooks.SessionStart');
+          } catch (e2) { /* non-fatal */ }
+        }
       }
     } catch (e) { /* @monomind/hooks not compiled yet — skip */ }
 
+    // Refresh worker metrics once per session start — the statusline
+    // (.claude/helpers/statusline.cjs) reads .monomind/metrics/ddd-progress.json,
+    // route-handler.cjs and doctor read codebase-map/security-audit/performance/
+    // consolidation.json; the @monomind/hooks workers are never otherwise
+    // scheduled on the live hook path (the worker daemon that used to produce
+    // these files was deleted).
+    //
+    // Staleness gating keeps session start fast: the metrics-producing workers
+    // only run when their output file is missing or older than 6 hours (ddd is
+    // refreshed every session, as before). Each run is capped by runWithTimeout
+    // (1.5s) — on timeout the awaiting stops but the worker keeps running and
+    // flushes atomically via tmp+rename, so a slow worker never blocks session
+    // start and never leaves a partial file.
+    try {
+      var _metricsDir = path.join(CWD, '.monomind', 'metrics');
+      fs.mkdirSync(_metricsDir, { recursive: true });
+      var STALE_MS = 6 * 60 * 60 * 1000; // 6 hours
+      var _isStale = function(outFile) {
+        try {
+          var st = fs.statSync(path.join(_metricsDir, outFile));
+          return (Date.now() - st.mtimeMs) > STALE_MS;
+        } catch (e) { return true; } // missing → run
+      };
+      var _hooksWorkers = [
+        { factory: 'createDDDWorker',         file: 'worker-ddd.js',         out: 'ddd-progress.json',    always: true },
+        { factory: 'createMapWorker',         file: 'worker-map.js',         out: 'codebase-map.json' },
+        { factory: 'createAuditWorker',       file: 'worker-audit.js',       out: 'security-audit.json' },
+        { factory: 'createOptimizeWorker',    file: 'worker-optimize.js',    out: 'performance.json' },
+        { factory: 'createConsolidateWorker', file: 'worker-consolidate.js', out: 'consolidation.json' },
+      ];
+      var _hooksDistDir = path.join(CWD, 'packages', '@monomind', 'hooks', 'dist', 'workers');
+      for (var wi = 0; wi < _hooksWorkers.length; wi++) {
+        var _w = _hooksWorkers[wi];
+        if (!_w.always && !_isStale(_w.out)) continue;
+        try {
+          var _create = (hooksModule && typeof hooksModule[_w.factory] === 'function')
+            ? hooksModule[_w.factory] : null;
+          if (!_create) {
+            // Dev-repo fallback: bare '@monomind/hooks' does not resolve from .claude/helpers
+            // in the monorepo (pnpm workspace link lives under packages/@monomind/cli), so
+            // import the compiled worker directly by path.
+            var _wDist = path.join(_hooksDistDir, _w.file);
+            if (fs.existsSync(_wDist)) {
+              var _wMod = await import('file://' + _wDist);
+              if (_wMod && typeof _wMod[_w.factory] === 'function') _create = _wMod[_w.factory];
+            }
+          }
+          if (_create) {
+            var _wRun = _create(CWD);
+            // runWithTimeout caps each at 1.5s so a slow worker can never block session start.
+            await runWithTimeout(function() { return _wRun(); }, '@monomind/hooks.' + _w.factory);
+          }
+        } catch (e) { /* non-fatal — worker unavailable */ }
+      }
+    } catch (e) { /* non-fatal — hooks workers unavailable */ }
+
     // Context Persistence Auto-Restore
     try {
       var cpHook = await import('file://' + path.join(helpersDir, 'context-persistence-hook.mjs'));
@@ -275,46 +352,6 @@ module.exports = {
       } catch (e) {}
     } catch (e) { /* non-fatal */ }
 
-    // Daemon Auto-Start Check.
-    try {
-      var daemonPid = path.join(CWD, '.monomind', 'daemon.pid');
-      var daemonRunning = false;
-      if (fs.existsSync(daemonPid)) {
-        try {
-          var MAX_PID = 32; // 32 bytes — enough for any pid
-          if (fs.statSync(daemonPid).size <= MAX_PID) {
-            var pid = parseInt(fs.readFileSync(daemonPid, 'utf-8').trim(), 10);
-            if (Number.isInteger(pid) && pid > 0 && pid < 4194304) {
-              process.kill(pid, 0);
-              daemonRunning = true;
-            }
-          }
-        } catch (e) { /* pid stale */ }
-      }
-      if (!daemonRunning) {
-        var daemonCfg = {};
-        try {
-          var cfgPath = path.join(CWD, 'monomind.config.json');
-          var MAX_CFG = 256 * 1024; // 256 KiB
-          if (fs.existsSync(cfgPath) && fs.statSync(cfgPath).size <= MAX_CFG) daemonCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8')).daemon || {};
-        } catch (e) {}
-        if (daemonCfg.autoStart) {
-          var spawn = require('child_process').spawn;
-          var daemonChild = spawn('npx', ['monomind', 'daemon', 'start'], {
-            cwd: CWD, detached: true, stdio: 'ignore'
-          });
-          daemonChild.on('error', function() {});
-          daemonChild.unref();
-          console.log('[DAEMON_AUTOSTART] Background daemon started (pid ' + daemonChild.pid + ')');
-        }
-        // Daemon not running + no autoStart: emit only if this project has a config
-        // (i.e. daemon was intentionally set up). Avoids noisy output in daemon-less projects.
-        else if (fs.existsSync(path.join(CWD, 'monomind.config.json'))) {
-          console.log('[DAEMON_STOPPED] Run `npx monomind daemon start` to enable background workers');
-        }
-      }
-    } catch (e) { /* non-fatal */ }
-
     // Token Usage — inject daily/monthly cost summary.
     try {
       var tokenTracker = require(path.join(helpersDir, 'token-tracker.cjs'));

package/packages/@monomind/cli/.claude/helpers/handlers/task-handler.cjs

@@ -24,8 +24,10 @@ module.exports = {
     // - 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
-    var _hooksModule = hCtx._hooksModule;
+    // 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, {
@@ -81,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, {

package/packages/@monomind/cli/.claude/helpers/hook-handler.cjs

@@ -15,11 +15,24 @@
  * 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 — currently at session-restore (to bridge pre-task /
- *    post-task into the hook registry) and at session-restore for a
- *    non-blocking security scan. The CJS handlers in system (1) are
- *    the authoritative dispatch path; system (2) provides optional
- *    enrichment when the package is installed and built.
+ *    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');
@@ -88,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;
@@ -212,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,
@@ -292,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': () => {
@@ -757,9 +806,13 @@ if (command && handlers[command]) {
   }
 }
 
-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);
+  });
+}