monomind 1.18.15 → 2.0.0

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

@@ -22,29 +22,18 @@ module.exports = {
       console.log('[SESSION] Skipping consolidation — daemon holds lock');
     }
 
-    // Consolidate intelligence (with timeout — #1530)
-    if (!daemonHoldsLock && intelligence && intelligence.consolidate) {
-      var consResult = await hCtx.runWithTimeout(function() { return intelligence.consolidate(); }, 'intelligence.consolidate()');
-      if (consResult && consResult.entries > 0) {
-        var msg = '[INTELLIGENCE] Consolidated: ' + consResult.entries + ' entries, ' + consResult.edges + ' edges';
-        if (consResult.newEntries > 0) msg += ', ' + consResult.newEntries + ' new';
-        msg += ', PageRank recomputed';
-        console.log(msg);
-      }
-    }
-    try {
-      if (session && session.end) {
-        session.end();
-      } else {
-        console.log('[OK] Session ended');
-      }
-    } catch (e) { console.log('[WARN] Session end failed: ' + e.message); }
+    // ── Session-end feedback BEFORE consolidation ──────────────────────────
+    // IMPORTANT: feedback() must run BEFORE consolidate() so that the session-end
+    // outcome record captures recentEdits from disk. consolidate() clears
+    // recent-edits.jsonl, so calling it first leaves the outcome empty.
+    // (Fixed: all outcomes previously had recentEdits: [].)
 
     // ── Routing Feedback Loop (SE-001) ────────────────────────────────────
     // Persist routing accuracy feedback so the router improves over sessions.
     // 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 = 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');
@@ -52,80 +41,106 @@ module.exports = {
       if (fs.existsSync(lastRoutePath) && (function() { try { return fs.statSync(lastRoutePath).size <= MAX_ROUTE; } catch(_) { return false; } }())) {
         var lastRoute = JSON.parse(fs.readFileSync(lastRoutePath, 'utf-8'));
 
-        // Derive sessionSuccess from intelligence-outcomes.jsonl
-        var sessionSuccess = true; // optimistic default when no signal exists
+        // Derive sessionSuccess from git commits (strongest signal: user committed = success)
         try {
-          var outcomesPath = path.join(CWD, '.monomind', 'intelligence-outcomes.jsonl');
-          var MAX_OUTCOMES = 512 * 1024; // 512 KiB
-          if (fs.existsSync(outcomesPath) && (function() { try { return fs.statSync(outcomesPath).size <= MAX_OUTCOMES; } catch(_) { return false; } }())) {
-            var windowMs = 30 * 60 * 1000; // 30-minute session window
-            var cutoff = Date.now() - windowMs;
-            var outcomeLines = fs.readFileSync(outcomesPath, 'utf-8').trim().split('\n').filter(Boolean);
-            var recent = outcomeLines.map(function(l) {
-              try { return JSON.parse(l); } catch { return null; }
-            }).filter(function(e) { return e && e.ts && e.ts >= cutoff; });
-            if (recent.length > 0) {
-              var failures = recent.filter(function(e) { return e.success === false; }).length;
-              // Majority-vote: session fails only if more than half the recent signals are failures
-              sessionSuccess = failures / recent.length < 0.5;
+          var execSync = require('child_process').execSync;
+          var recentCommits = execSync('git log --oneline --since="30 minutes ago" 2>/dev/null || true', { cwd: CWD, timeout: 3000, encoding: 'utf-8' }).trim();
+          if (recentCommits.length > 0) {
+            sessionSuccess = true;
+          } else {
+            // No commits — check if files were modified (work in progress, not failure)
+            var gitStatus = execSync('git diff --name-only 2>/dev/null || true', { cwd: CWD, timeout: 3000, encoding: 'utf-8' }).trim();
+            // Modified files = probably still working; no changes at all = exploration or failure
+            if (gitStatus.length === 0) {
+              // Fall back to intelligence-outcomes as a weak signal
+              var outcomesPath = path.join(CWD, '.monomind', 'data', 'intelligence-outcomes.jsonl');
+              var MAX_OUTCOMES = 512 * 1024;
+              if (fs.existsSync(outcomesPath) && (function() { try { return fs.statSync(outcomesPath).size <= MAX_OUTCOMES; } catch(_) { return false; } }())) {
+                var windowMs = 30 * 60 * 1000;
+                var cutoff = Date.now() - windowMs;
+                var outcomeLines = fs.readFileSync(outcomesPath, 'utf-8').trim().split('\n').filter(Boolean);
+                var recent = outcomeLines.map(function(l) {
+                  try { return JSON.parse(l); } catch { return null; }
+                }).filter(function(e) { return e && e.ts && e.ts >= cutoff; });
+                if (recent.length > 0) {
+                  var failures = recent.filter(function(e) { return e.success === false; }).length;
+                  sessionSuccess = failures / recent.length < 0.5;
+                }
+              }
             }
+            // 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) */ }
 
-        if (intelligence && intelligence.feedback) {
+        // Record session-end feedback WITH recentEdits (before consolidate clears them)
+        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 */ }
 
-    // Memory Palace tombstone writes removed — redundant with raw session JSONL
+    // Now consolidate AFTER feedback has been recorded (so the outcome has recentEdits)
+    if (!daemonHoldsLock && intelligence && intelligence.consolidate) {
+      var consResult = await hCtx.runWithTimeout(function() { return intelligence.consolidate(); }, 'intelligence.consolidate()');
+      if (consResult && consResult.entries > 0) {
+        var msg = '[INTELLIGENCE] Consolidated: ' + consResult.entries + ' entries';
+        if (consResult.newEntries > 0) msg += ', ' + consResult.newEntries + ' new patterns learned';
+        console.log(msg);
+      }
+    }
+    try {
+      if (session && session.end) {
+        session.end();
+      } else {
+        console.log('[OK] Session ended');
+      }
+    } catch (e) { console.log('[WARN] Session end failed: ' + e.message); }
 
-    // ── Learning Service Auto-Consolidation ─────────────────────────────
-    // Consolidate learned patterns from short-term to long-term storage.
-    // Uses module-level singleton (getLearningService) so the DB is not
-    // reopened on every session-end — state accumulated during the session
-    // is preserved and consolidated in a single pass.
-    if (!daemonHoldsLock) {
+    // 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 {
-        var ls = await hCtx.getLearningService();
-        if (ls && ls.consolidate) {
-          var lResult = await hCtx.runWithTimeout(function() { return ls.consolidate(); }, 'learning.consolidate()');
-          if (lResult && lResult.promoted > 0) {
-            console.log('[LEARNING] Consolidated: ' + lResult.promoted + ' patterns promoted to long-term');
-          }
-        }
-        if (ls && ls.promoteEpisodic) {
-          try {
-            var promResult = await hCtx.runWithTimeout(function() { return ls.promoteEpisodic(); }, 'learning.promoteEpisodic()');
-            if (promResult && promResult.promoted > 0) {
-              console.log('[LEARNING] Promoted ' + promResult.promoted + ' episodic patterns to semantic memory');
-            }
-          } catch (e) { /* non-fatal */ }
-        }
-      } catch (e) { /* non-fatal — learning-service may need better-sqlite3 */ }
+        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 ─────────────────────────────────
     // Archive conversation context so it survives compaction and new sessions
     try {
@@ -139,99 +154,103 @@ module.exports = {
       }
     } catch (e) { /* non-fatal — context-persistence may not export archive() */ }
 
-    // ── AutoMem Outer Loops (arXiv:2607.01224) ────────────────────────────
-    // Run scaffold optimization and decision curation on session-end
-    // to close the learning loop.
-    if (!daemonHoldsLock) {
+    // ── Auto-populate: write session episode for every session ─────
+    // Even solo sessions (no subagents) produce an episode so the
+    // route handler can surface relevant past sessions.
+    try {
+      var episodicDir = path.join(CWD, '.monomind', 'episodic');
+      fs.mkdirSync(episodicDir, { recursive: true });
+      var epPath = path.join(episodicDir, 'episodes.jsonl');
+
+      // Collect session context
+      var sessId = String(hookInput.sessionId || hookInput.session_id || process.env.CLAUDE_SESSION_ID || '');
+      var lastRouteFile = path.join(CWD, '.monomind', 'last-route.json');
+      var routeAgent = 'unknown';
+      var routePrompt = '';
       try {
-        var memMod = await import('@monomind/memory');
-        if (memMod && memMod.ScaffoldOptimizer && memMod.MemoryDecisionCurator && memMod.EpisodicStore) {
-          var episodicPath = path.join(CWD, '.monomind', 'episodic', 'episodes.jsonl');
-          if (fs.existsSync(episodicPath)) {
-            var epStore = new memMod.EpisodicStore({ filePath: episodicPath, maxRunsPerEpisode: 20 });
-            var episodes = epStore.readAll();
-            if (episodes.length >= 5) {
-              // Get learning service for scaffold optimizer metrics
-              var ls2 = await hCtx.getLearningService();
-
-              // Phase 2a: Scaffold optimization (gated revision)
-              if (ls2 && ls2.getLearningBridge) {
-                try {
-                  var bridge = ls2.getLearningBridge();
-                  if (bridge) {
-                    // Load tunable thresholds from .monomind/automem-config.json
-                    var scaffoldConfig = {};
-                    try {
-                      var amcPath = path.join(CWD, '.monomind', 'automem-config.json');
-                      if (fs.existsSync(amcPath) && fs.statSync(amcPath).size < 64 * 1024) {
-                        var amc = JSON.parse(fs.readFileSync(amcPath, 'utf-8'));
-                        if (amc.scaffold) scaffoldConfig = amc.scaffold;
-                      }
-                    } catch (e5) { /* non-fatal */ }
-                    var optimizer = new memMod.ScaffoldOptimizer(scaffoldConfig);
-                    var optResult = await hCtx.runWithTimeout(function() { return optimizer.optimize(epStore, bridge); }, 'scaffold.optimize()');
-                    if (optResult && optResult.accepted.length > 0) {
-                      console.log('[AUTOMEM_SCAFFOLD] Accepted ' + optResult.accepted.length + ' revision(s): ' + optResult.accepted.map(function(r) { return r.description; }).join(', '));
-                      // Persist revisions for diagnostics
-                      try {
-                        var revPath = path.join(CWD, '.monomind', 'data', 'scaffold-revisions.jsonl');
-                        fs.mkdirSync(path.dirname(revPath), { recursive: true });
-                        optResult.accepted.forEach(function(r) {
-                          fs.appendFileSync(revPath, JSON.stringify(r) + '\n', 'utf-8');
-                        });
-                      } catch (e6) { /* non-fatal */ }
-                    }
-                  }
-                } catch (e3) { /* non-fatal */ }
-              }
+        if (fs.existsSync(lastRouteFile) && fs.statSync(lastRouteFile).size < 16384) {
+          var lr = JSON.parse(fs.readFileSync(lastRouteFile, 'utf-8'));
+          routeAgent = lr.agent || 'unknown';
+          routePrompt = lr.prompt || '';
+        }
+      } catch (e) {}
 
-              // Phase 2b: Decision curation
-              try {
-                var backend = ls2 && ls2.getBackend ? ls2.getBackend() : null;
-                if (backend) {
-                  var curator = new memMod.MemoryDecisionCurator(backend);
-                  var curResult = await hCtx.runWithTimeout(function() { return curator.curateFromEpisodes(epStore); }, 'curator.curate()');
-                  if (curResult && curResult.curated > 0) {
-                    console.log('[AUTOMEM_CURATE] Curated ' + curResult.curated + '/' + curResult.total + ' memory decisions for training');
-                  }
-                }
-              } catch (e4) { /* non-fatal */ }
-            }
+      // Strip system noise (task notifications, XML tags) from prompt
+      if (routePrompt && (routePrompt.includes('<task-notification>') || routePrompt.includes('<system-reminder>'))) {
+        routePrompt = '';
+      }
+
+      // Determine session success from git commits (strongest signal)
+      var sessionOutcome = 'unknown';
+      var commitMessages = [];
+      var editedFiles = [];
+      try {
+        var execSync = require('child_process').execSync;
+        // Get recent commits as success signal
+        var commitLog = execSync('git log --oneline --since="30 minutes ago" 2>/dev/null || true', { cwd: CWD, timeout: 3000, encoding: 'utf-8' }).trim();
+        if (commitLog.length > 0) {
+          sessionOutcome = 'success';
+          commitMessages = commitLog.split('\n').filter(Boolean).map(function(l) {
+            return l.replace(/^[a-f0-9]+ /, '');
+          }).slice(0, 5);
+        }
+        // Get modified files from working tree
+        var diffOut = execSync('git diff --name-only HEAD 2>/dev/null || true', { cwd: CWD, timeout: 3000, encoding: 'utf-8' });
+        editedFiles = diffOut.trim().split('\n').filter(Boolean).map(function(f) { return path.basename(f); }).slice(0, 15);
+        if (sessionOutcome === 'unknown' && editedFiles.length > 0) {
+          sessionOutcome = 'in-progress';
+        }
+      } catch (e) {}
+
+      // Write episode with rich searchable content (commit messages are the user's own words)
+      var summaryParts = [];
+      if (routePrompt) summaryParts.push(routePrompt.slice(0, 300));
+      if (commitMessages.length > 0) summaryParts.push('Commits: ' + commitMessages.join('; '));
+      if (editedFiles.length > 0) summaryParts.push('Modified: ' + editedFiles.join(', '));
+      if (sessionOutcome !== 'unknown') summaryParts.push('Outcome: ' + sessionOutcome);
+      if (summaryParts.length === 0) summaryParts.push('Session with ' + routeAgent);
+
+      var soloEpisode = {
+        episodeId: require('crypto').randomUUID(),
+        sessionId: sessId,
+        runIds: [sessId],
+        summary: summaryParts.join('\n'),
+        startedAt: Date.now() - 300000,
+        endedAt: Date.now(),
+        agentSlugs: [routeAgent],
+        taskTypes: [routeAgent],
+        tokenEstimate: 0
+      };
+      fs.appendFileSync(epPath, JSON.stringify(soloEpisode) + '\n', 'utf-8');
+
+      // Rotate: keep last 500 episodes
+      try {
+        var epStat = fs.statSync(epPath);
+        if (epStat.size > 256 * 1024) {
+          var epLines = fs.readFileSync(epPath, 'utf-8').trim().split('\n').filter(Boolean);
+          if (epLines.length > 500) {
+            fs.writeFileSync(epPath, epLines.slice(-500).join('\n') + '\n', 'utf-8');
           }
         }
-      } catch (e2) { /* @monomind/memory not available or missing exports */ }
-    }
+      } catch (e) {}
+    } catch (e) { /* non-fatal */ }
 
-    // ── Worker Queue Cleanup ─────────────────────────────────────────────
-    // Process and clean up any pending worker dispatch files
+    // ── Memory ops summary ──────────────────────────────────────
     try {
-      var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');
-      if (fs.existsSync(dispatchDir)) {
-        var pending = fs.readdirSync(dispatchDir).filter(function(f) { return f.startsWith('pending-'); }).slice(0, 500);
-        if (pending.length > 0) {
-          console.log('[WORKER_CLEANUP] ' + pending.length + ' worker dispatch(es) pending from this session');
+      var memOpsSessionId = String(hookInput.sessionId || hookInput.session_id || process.env.CLAUDE_SESSION_ID || '');
+      var memOpsPath = path.join(CWD, '.monomind', 'memory-ops-' + memOpsSessionId.slice(0, 16) + '.json');
+      if (fs.existsSync(memOpsPath)) {
+        var memOps = JSON.parse(fs.readFileSync(memOpsPath, 'utf-8'));
+        if (memOps.writes > 0 || memOps.searches > 0) {
+          var parts = [];
+          if (memOps.writes > 0) parts.push(memOps.writes + ' writes' + (memOps.redundantWrites > 0 ? ' (' + memOps.redundantWrites + ' redundant)' : ''));
+          if (memOps.searches > 0) parts.push(memOps.searches + ' searches' + (memOps.emptySearches > 0 ? ' (' + memOps.emptySearches + ' empty)' : ''));
+          console.log('[MEMORY_OPS] Session: ' + parts.join(', '));
         }
-        // Move to processed
-        var processedDir = path.join(dispatchDir, 'processed');
-        fs.mkdirSync(processedDir, { recursive: true });
-        pending.forEach(function(f) {
-          try {
-            fs.renameSync(path.join(dispatchDir, f), path.join(processedDir, f));
-          } catch (e) { /* ignore */ }
-        });
-        // Trim processed/ to last 200 files to prevent unbounded growth
-        try {
-          var processedFiles = fs.readdirSync(processedDir)
-            .filter(function(f) { return f.startsWith('pending-'); })
-            .map(function(f) { var fp = path.join(processedDir, f); var mt = 0; try { mt = fs.statSync(fp).mtimeMs; } catch(e2){} return { f: f, mt: mt }; })
-            .sort(function(a, b) { return a.mt - b.mt; });
-          if (processedFiles.length > 200) {
-            processedFiles.slice(0, processedFiles.length - 200).forEach(function(item) {
-              try { fs.unlinkSync(path.join(processedDir, item.f)); } catch (e2) { /* ignore */ }
-            });
-          }
-        } catch (e2) { /* non-fatal */ }
+        // Clean up session stats file
+        try { fs.unlinkSync(memOpsPath); } catch (e) {}
       }
     } catch (e) { /* non-fatal */ }
+
   }
 };

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

@@ -30,6 +30,21 @@ module.exports = {
       }
     } catch (e) { console.log('[WARN] Session restore failed: ' + e.message); }
 
+    // ── Non-blocking security scan via @monomind/hooks worker ─────────────
+    // The hooks package ships a security worker (worker-security.ts) that scans
+    // for hardcoded secrets and vulnerability patterns. We run it at session
+    // start as a fire-and-forget check — failures are silently ignored since
+    // the package may not be installed or built.
+    try {
+      var hooksWorkersMod = require('@monomind/hooks/dist/workers/worker-security.js');
+      var _createSecurityWorker = hooksWorkersMod.createSecurityWorker;
+      if (typeof _createSecurityWorker === 'function') {
+        var _securityScan = _createSecurityWorker(CWD);
+        // Fire-and-forget: do not await — must not delay session restore
+        Promise.resolve(_securityScan()).catch(function() {});
+      }
+    } catch (e) { /* @monomind/hooks not available or not built — skip */ }
+
     // 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.
@@ -105,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'));
@@ -260,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'));
@@ -356,15 +408,5 @@ module.exports = {
       } catch (e) { /* non-fatal */ }
     }
 
-    // Worker Queue Resume (SR-003).
-    try {
-      var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');
-      if (fs.existsSync(dispatchDir)) {
-        var pendingFiles = fs.readdirSync(dispatchDir).filter(function(f) { return f.startsWith('pending-'); }).slice(0, 500);
-        if (pendingFiles.length > 0) {
-          console.log('[WORKER_RESUME] ' + pendingFiles.length + ' worker dispatch(es) pending from prior session');
-        }
-      }
-    } catch (e) { /* non-fatal */ }
   },
 };