monomind 2.0.3 → 2.1.3

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

@@ -4,6 +4,8 @@
 
 const path = require('path');
 const fs = require('fs');
+const { purgeStaleRegistrations } = require('../utils/agent-registrations.cjs');
+const { cleanEntries, atomicWriteFileSync, withLock } = require('../utils/fs-helpers.cjs');
 
 module.exports = {
   handle: async function(hCtx) {
@@ -18,41 +20,65 @@ module.exports = {
       fs.mkdirSync(regDir, { recursive: true });
       const id = Date.now() + '-' + Math.random().toString(36).slice(2, 6);
       const regFile = path.join(regDir, 'agent-' + id + '.json');
+      // P3-15: also stamp the agent's type/slug so handlePostTask (task-handler.cjs)
+      // can correlate a completion event back to THIS registration instead of
+      // blindly popping the oldest file — the registration previously carried no
+      // identity beyond a random id, so post-task had nothing to match against.
+      // Same field precedence as the last-dispatch.json write below, computed
+      // early so both writers agree on the agent's identity.
+      const MAX_TYPE_LEN = 128;
+      const agentType = String(hookInput.subagent_type || hookInput.agentType || hookInput.agent_type || hookInput.agentSlug || 'unknown').slice(0, MAX_TYPE_LEN);
       fs.writeFileSync(regFile, JSON.stringify({
         agentId: id,
+        agentType: agentType,
         startedAt: new Date().toISOString(),
         pid: process.pid,
       }));
+      // Purge stragglers older than 30 min on every agent-start too — not just
+      // on TeammateIdle/TaskCompleted (task-handler.cjs) — since sessions that
+      // never emit those events would otherwise leak registrations forever.
+      const activeAfterPurge = purgeStaleRegistrations(regDir);
       // Refresh swarm-activity.json within the 5-min staleness window.
       const activityDir = path.join(CWD, '.monomind', 'metrics');
       fs.mkdirSync(activityDir, { recursive: true });
       const activityPath = path.join(activityDir, 'swarm-activity.json');
       const MAX_AGENTS = 1000;
-      const active = Math.min(fs.readdirSync(regDir).filter(f => f.endsWith('.json')).length, MAX_AGENTS);
-      // Preserve lastActive (peak) so statusline shows non-zero after completion.
-      let prevLastActive = 0;
-      try {
-        const MAX_ACTIVITY = 64 * 1024; // 64 KiB
-        var actStat = fs.statSync(activityPath);
-        if (actStat.size <= MAX_ACTIVITY) {
-          prevLastActive = (JSON.parse(fs.readFileSync(activityPath, 'utf-8'))?.swarm?.lastActive) || 0;
-        }
-      } catch { /* ignore */ }
-      fs.writeFileSync(activityPath, JSON.stringify({
-        timestamp: new Date().toISOString(),
-        swarm: {
-          active: active > 0,
-          agent_count: active,
-          coordination_active: active > 0,
-          lastActive: Math.max(active, prevLastActive),
-        },
-      }));
+      const active = Math.min(
+        activeAfterPurge != null ? activeAfterPurge : cleanEntries(regDir, f => f.endsWith('.json')).length,
+        MAX_AGENTS
+      );
+      // P2-21: swarm-activity.json is written by both this handler and
+      // task-handler.cjs's handlePostTask, concurrently (Claude Code fires
+      // hook events for parallel tool calls in one message). The old
+      // read-prevLastActive-then-write was a lost-update race — two
+      // processes could both read the same prevLastActive before either
+      // wrote, so whichever wrote last silently erased the other's peak.
+      // Share one lock file with task-handler.cjs so the read-merge-write
+      // cycle is a single critical section across both writers.
+      withLock(activityPath + '.lock', function() {
+        // Preserve lastActive (peak) so statusline shows non-zero after completion.
+        let prevLastActive = 0;
+        try {
+          const MAX_ACTIVITY = 64 * 1024; // 64 KiB
+          var actStat = fs.statSync(activityPath);
+          if (actStat.size <= MAX_ACTIVITY) {
+            prevLastActive = (JSON.parse(fs.readFileSync(activityPath, 'utf-8'))?.swarm?.lastActive) || 0;
+          }
+        } catch { /* ignore */ }
+        atomicWriteFileSync(activityPath, JSON.stringify({
+          timestamp: new Date().toISOString(),
+          swarm: {
+            active: active > 0,
+            agent_count: active,
+            coordination_active: active > 0,
+            lastActive: Math.max(active, prevLastActive),
+          },
+        }));
+      }, 5000);
 
       // Write last-dispatch.json so the route handler can suppress redundant
       // suggestions on the next turn when the same agent type is recommended.
-      const MAX_TYPE_LEN = 128;
       const MAX_DESC_LEN = 500;
-      const agentType = String(hookInput.subagent_type || hookInput.agentType || hookInput.agent_type || hookInput.agentSlug || 'unknown').slice(0, MAX_TYPE_LEN);
       const agentDesc = String(hookInput.description || hookInput.prompt_description || '').slice(0, MAX_DESC_LEN);
       fs.writeFileSync(
         path.join(CWD, '.monomind', 'last-dispatch.json'),
@@ -87,13 +113,19 @@ module.exports = {
       if (_hooksModule && _hooksModule.executeHooks && _hooksModule.HookEvent) {
         var agentTypeBridge = String(hookInput.subagent_type || hookInput.agentType || hookInput.agent_type || hookInput.agentSlug || 'unknown');
         var agentDescBridge = String(hookInput.description || hookInput.prompt_description || '');
-        _hooksModule.executeHooks(_hooksModule.HookEvent.AgentSpawn, {
-          agent: {
-            id: hookInput.agentId || hookInput.agent_id || (agentTypeBridge + '-' + Date.now()),
-            type: agentTypeBridge,
-            description: agentDescBridge.slice(0, 500),
-          },
-        }, { continueOnError: true, timeout: 1500 }).catch(function() {});
+        // Must be awaited (bounded by runWithTimeout, 1500ms) — hook-handler.cjs's
+        // main().finally(() => process.exit(...)) reaps any unawaited fire-and-forget
+        // promise before it does real I/O. See session-restore-handler.cjs's
+        // SessionStart bridge for the reference pattern this mirrors.
+        await hCtx.runWithTimeout(function() {
+          return _hooksModule.executeHooks(_hooksModule.HookEvent.AgentSpawn, {
+            agent: {
+              id: hookInput.agentId || hookInput.agent_id || (agentTypeBridge + '-' + Date.now()),
+              type: agentTypeBridge,
+              description: agentDescBridge.slice(0, 500),
+            },
+          }, { continueOnError: true, timeout: 1500 });
+        }, '@monomind/hooks.AgentSpawn');
       }
     } catch (e) { /* non-fatal */ }
   },

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

@@ -21,9 +21,51 @@ const fs = require('fs');
 const path = require('path');
 const http = require('http');
 const os = require('os');
+const crypto = require('crypto');
+const { appendJsonlWithRotation } = require('../utils/fs-helpers.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const CAPTURE_DIR = path.join(CWD, '.monomind', 'capture');
+const SNAP_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour — orphaned snapshots are cleaned up this old
+
+// P2-23: derive a stable key for a subagent invocation from whatever
+// identifying info Claude Code actually gives us in the hook payload.
+// `transcript_path` is the one field that's both present on SubagentStart
+// and SubagentStop AND unique per-subagent (each subagent gets its own
+// transcript file, distinct from the parent session's) — session_id alone
+// is shared by every concurrently-running subagent in the same team, so it
+// can't disambiguate which stop event belongs to which start.
+function subagentKey(hookInput) {
+  var raw = hookInput && (hookInput.transcript_path || hookInput.transcriptPath);
+  if (!raw) return null;
+  return crypto.createHash('md5').update(String(raw)).digest('hex').slice(0, 16);
+}
+
+// Determine subagent success from its result summary — errors/failures/
+// exceptions indicate failure. Shared by the Monograph `success` column and
+// the intelligence.feedback() call below, so both use one definition.
+function deriveSubagentSuccess(summary) {
+  if (!summary) return true;
+  var sumLower = summary.toLowerCase();
+  if (sumLower.includes('error') || sumLower.includes('failed') || sumLower.includes('exception') || sumLower.includes('fatal')) {
+    return false;
+  }
+  return true;
+}
+
+// Delete snap-*.json files older than SNAP_MAX_AGE_MS — orphaned when a
+// SubagentStop never arrived (crash, forced-stop) or was matched to a
+// different snapshot before keyed matching existed.
+function cleanupStaleSnaps() {
+  try {
+    var files = fs.readdirSync(CAPTURE_DIR).filter(f => f.startsWith('snap-') && f.endsWith('.json') && !f.startsWith('._'));
+    var now = Date.now();
+    for (var i = 0; i < files.length; i++) {
+      var p = path.join(CAPTURE_DIR, files[i]);
+      try { if (now - fs.statSync(p).mtimeMs > SNAP_MAX_AGE_MS) fs.unlinkSync(p); } catch { /* ignore */ }
+    }
+  } catch { /* CAPTURE_DIR may not exist yet */ }
+}
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
@@ -46,7 +88,7 @@ function snapshotJSONLFiles() {
   if (!fs.existsSync(claudeDir)) return [];
   try {
     return fs.readdirSync(claudeDir)
-      .filter(f => f.endsWith('.jsonl'))
+      .filter(f => f.endsWith('.jsonl') && !f.startsWith('._'))
       .map(f => {
         try { return { name: f, size: fs.statSync(path.join(claudeDir, f)).size }; }
         catch { return { name: f, size: 0 }; }
@@ -170,6 +212,7 @@ function emitEvent(event) {
 
 async function handleSubagentStart(hookInput) {
   fs.mkdirSync(CAPTURE_DIR, { recursive: true });
+  cleanupStaleSnaps();
 
   const snapshot = snapshotJSONLFiles();
   const agentType = String(
@@ -190,10 +233,19 @@ async function handleSubagentStart(hookInput) {
   }
   const activeSess = getActiveSession(activeRun);
 
-  // Write snapshot to FIFO queue — subagent-stop pops the oldest
+  // P2-23: key the snapshot filename by transcript_path when available so
+  // SubagentStop can look up the EXACT matching snapshot instead of
+  // FIFO-popping the lexicographically-oldest one — under real concurrency
+  // (multiple subagents stopping in close succession) FIFO pop can match a
+  // stop event to the wrong subagent's snapshot. Falls back to the old
+  // timestamp+random naming when transcript_path isn't present in the
+  // payload, so SubagentStop's FIFO fallback path still has something to
+  // match against.
+  const subKey = subagentKey(hookInput);
   const snapFile = path.join(
     CAPTURE_DIR,
-    'snap-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6) + '.json'
+    subKey ? 'snap-' + subKey + '.json'
+           : 'snap-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6) + '.json'
   );
   const leanModePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.monomind/state/monolean-mode');
   let leanMode = null;
@@ -235,18 +287,31 @@ async function handleSubagentStart(hookInput) {
 
 async function handleSubagentStop(hookInput) {
   fs.mkdirSync(CAPTURE_DIR, { recursive: true });
-
-  // Pop oldest snapshot (FIFO — matches the agent that just finished)
-  const snapFiles = fs.readdirSync(CAPTURE_DIR)
-    .filter(f => f.startsWith('snap-') && f.endsWith('.json'))
-    .sort(); // lexicographic = timestamp order
-
-  if (snapFiles.length === 0) {
-    console.log('[CAPTURE:stop] No snapshot to diff — skipping');
-    return;
+  cleanupStaleSnaps();
+
+  // P2-23: prefer the exact keyed snapshot (see subagentKey/handleSubagentStart)
+  // over FIFO-popping the oldest snap-*.json — FIFO misattributes the stop
+  // event to the wrong subagent whenever multiple subagents stop in close
+  // succession. Fall back to FIFO only when this event's payload carries no
+  // transcript_path (older Claude Code versions / unexpected payload shape).
+  const subKey = subagentKey(hookInput);
+  let snapPath = null;
+  if (subKey) {
+    const keyedPath = path.join(CAPTURE_DIR, 'snap-' + subKey + '.json');
+    if (fs.existsSync(keyedPath)) snapPath = keyedPath;
+  }
+  if (!snapPath) {
+    const snapFiles = fs.readdirSync(CAPTURE_DIR)
+      .filter(f => f.startsWith('snap-') && f.endsWith('.json') && !f.startsWith('._'))
+      .sort(); // lexicographic = timestamp order (FIFO fallback)
+    if (snapFiles.length === 0) {
+      console.log('[CAPTURE:stop] No snapshot to diff — skipping');
+      return;
+    }
+    snapPath = path.join(CAPTURE_DIR, snapFiles[0]);
+    console.log('[CAPTURE:stop] no transcript_path/keyed snapshot — falling back to FIFO match');
   }
 
-  const snapPath = path.join(CAPTURE_DIR, snapFiles[0]);
   let snap;
   try { snap = JSON.parse(fs.readFileSync(snapPath, 'utf8')); } catch {
     try { fs.unlinkSync(snapPath); } catch {}
@@ -292,13 +357,26 @@ async function handleSubagentStop(hookInput) {
     + (session ? ' · sess=' + session : '')
     + (org ? ' · ' + org + '/' + runId : ''));
 
+  // Feed the real per-subagent success/failure signal into the same
+  // intelligence-outcomes.jsonl that session-handler.cjs's SessionEnd
+  // heuristic reads (via outcomesSignal) to veto a commit-based "success".
+  // Without this, that veto path never fires — SubagentStop is the only
+  // remaining event that carries a genuine failure signal, since post-task
+  // (TeammateIdle/TaskCompleted) is dead code (those aren't valid Claude
+  // Code hook events and are stripped from settings.json on init).
+  try {
+    require('../intelligence.cjs').feedback(deriveSubagentSuccess(summary));
+  } catch (e) { /* non-fatal — feedback recording must never block subagent-stop */ }
+
   if (!org && !session) {
     // No active org or session — log to general capture file only
+    // P2-26: rotate — was a pure appendFileSync with no cap, unlike
+    // intelligence-outcomes.jsonl (500-line cap).
     const genLog = path.join(CAPTURE_DIR, 'unattributed.jsonl');
-    fs.appendFileSync(genLog, JSON.stringify({
+    appendJsonlWithRotation(genLog, JSON.stringify({
       ts: Date.now(), agentType, tokens_in: totalTin, tokens_out: totalTout,
       cost_usd: costUsd, capturedFiles, summary: summary.slice(0, 200),
-    }) + '\n');
+    }), 500);
     return;
   }
 
@@ -355,9 +433,11 @@ async function handleSubagentStop(hookInput) {
   // ── Persist transcript reference to run directory ─────────────────────────
   if (capturedFiles.length > 0 && org && runId) {
     const runDir = path.join(CWD, '.monomind', 'orgs', org, 'runs');
-    fs.mkdirSync(runDir, { recursive: true });
     const capLog = path.join(runDir, runId + '-captures.jsonl');
-    fs.appendFileSync(capLog, JSON.stringify({
+    // P2-26: rotate — was a pure appendFileSync with no cap. A long-running
+    // org loop can spawn far more than 500 agents over its lifetime, so
+    // this uses the same 500-line cap convention as the other JSONL logs.
+    appendJsonlWithRotation(capLog, JSON.stringify({
       type: 'agent:capture',
       org, runId, session,
       agentType,
@@ -368,7 +448,7 @@ async function handleSubagentStop(hookInput) {
       capturedFiles,
       claudeProjectDir: claudeDir,
       ts: Date.now(),
-    }) + '\n');
+    }), 500);
   }
 
   // ── Wire captured interaction into EpisodicStore ────
@@ -429,16 +509,7 @@ async function handleSubagentStop(hookInput) {
             tokens_in: totalTin || 0,
             tokens_out: totalTout || 0,
             cost_usd: costUsd || 0,
-            success: (function() {
-              // Determine success from result summary — errors/failures/exceptions indicate failure
-              if (summary) {
-                var sumLower = summary.toLowerCase();
-                if (sumLower.includes('error') || sumLower.includes('failed') || sumLower.includes('exception') || sumLower.includes('fatal')) {
-                  return 0;
-                }
-              }
-              return 1;
-            })(),
+            success: deriveSubagentSuccess(summary) ? 1 : 0,
             duration_ms: snap.ts ? (Date.now() - snap.ts) : 0,
             timestamp: Date.now(),
           });

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

@@ -5,6 +5,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const { claimLock } = require('../utils/fs-helpers.cjs');
 
 module.exports = {
   handle: async function(hCtx) {
@@ -84,12 +85,23 @@ module.exports = {
       var codeExts = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|cs|cpp|c|rb|swift|php)$/i;
       if (editedFile2 && codeExts.test(editedFile2)) {
         var lockFile = path.join(CWD, '.monomind', 'graph', '.rebuild-lock');
-        var now = Date.now();
-        var lastBuild = 0;
-        try { var _lkSt = fs.statSync(lockFile); if (_lkSt.size <= 32) { 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');
+        // P3-17: on a fresh project (no full `monograph build` has ever run),
+        // .monomind/graph/ doesn't exist yet, and claimLock's writeFileSync
+        // below throws ENOENT — caught by this try/catch and silently
+        // swallowed, so the incremental rebuild (and blast-radius display)
+        // never fires until some other code path happens to create the dir.
+        try { fs.mkdirSync(path.dirname(lockFile), { recursive: true }); } catch (e) { /* non-fatal */ }
+        // P2-22: claim the cooldown lock atomically (wx-create) instead of
+        // statSync-then-writeFileSync — under real Claude Code concurrency a
+        // multi-file Edit in one message fires several PostToolUse hook
+        // processes near-simultaneously, and a plain read-check-write lets
+        // ALL of them read the same stale lastBuild timestamp before any of
+        // them writes a fresh one, so every one of them passes the cooldown
+        // check and spawns its own rebuild + ua-enrich child (see the
+        // 896-orphan-process incident fixed in control-start.cjs). claimLock
+        // mirrors that same TOCTOU-safe stale-lock-breaking pattern.
+        if (claimLock(lockFile, COOLDOWN_MS)) {
           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');
@@ -148,10 +160,16 @@ module.exports = {
       try {
         var editFileBridge = hookInput.file_path || toolInput.file_path
           || process.env.TOOL_INPUT_file_path || args[0] || '';
-        _hooksModule.executeHooks(_hooksModule.HookEvent.PostEdit, {
-          file: { path: editFileBridge, operation: 'modify' },
-          duration: 0,
-        }, { continueOnError: true, timeout: 1500 }).catch(function() {});
+        // Must be awaited (bounded by runWithTimeout, 1500ms) — hook-handler.cjs's
+        // main().finally(() => process.exit(...)) reaps any unawaited fire-and-forget
+        // promise before it does real I/O. See session-restore-handler.cjs's
+        // SessionStart bridge for the reference pattern this mirrors.
+        await hCtx.runWithTimeout(function() {
+          return _hooksModule.executeHooks(_hooksModule.HookEvent.PostEdit, {
+            file: { path: editFileBridge, operation: 'modify' },
+            duration: 0,
+          }, { continueOnError: true, timeout: 1500 });
+        }, '@monomind/hooks.PostEdit');
       } catch (e) { /* non-fatal */ }
     }
 

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

@@ -6,7 +6,7 @@
  * @monomind/guidance package it mirrored has been removed.
  *
  * Gates enforced at runtime:
- *   pre-bash  → destructive-ops  (require-confirmation → block)
+ *   pre-bash  → destructive-ops  (hard block; no confirm-and-proceed path exists)
  *   pre-write → secrets          (block)
  */
 
@@ -32,8 +32,13 @@ const SECRET_PATTERNS = [
   /(?:api[_-]?key|apikey)\s*[:=]\s*['"][^'"]{8,}['"]/gi,
   /(?:secret|password|passwd|pwd)\s*[:=]\s*['"][^'"]{8,}['"]/gi,
   /(?:token|bearer)\s*[:=]\s*['"][^'"]{10,}['"]/gi,
+  // Unquoted variants — env-style KEY equals value with no surrounding
+  // quotes (the single most common real leak pattern; the quoted patterns
+  // above never match a bare assignment in a shell export or .env file).
+  /(?:api[_-]?key|apikey|token|secret|password|passwd|pwd)\s*[:=]\s*[^\s'"]{8,}/gi,
   /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----/g,
-  /sk-[a-zA-Z0-9]{20,}/g,
+  /sk-ant-[a-zA-Z0-9_-]{20,}/g,
+  /sk-[a-zA-Z0-9_-]{20,}/g,
   /ghp_[a-zA-Z0-9]{36}/g,
   /npm_[a-zA-Z0-9]{36}/g,
   /AKIA[0-9A-Z]{16}/g,
@@ -55,7 +60,7 @@ function checkDestructive(command) {
       return {
         triggered: true,
         matched: match[0],
-        reason: `Destructive operation detected: "${match[0]}". Confirm this is intentional and document a rollback plan before proceeding.`,
+        reason: `Destructive operation blocked: "${match[0]}". This hook always blocks (Claude Code's PreToolUse protocol has no confirm-and-proceed path) — there is no way to run this exact command after confirming. If it's genuinely intended, use a non-destructive equivalent instead (e.g. move the target aside, or scope the operation more narrowly).`,
       };
     }
   }
@@ -92,11 +97,14 @@ function handlePreBash(hCtx) {
 
   var result = checkDestructive(cmd);
   if (result.triggered) {
-    // Output block decision and set exit code 2 — both required by Claude Code PreToolUse protocol
-    console.log(JSON.stringify({
+    // Set exit code 2 to block, and write the reason to STDERR — per Claude
+    // Code's PreToolUse hook protocol, stdout JSON is only parsed when exit
+    // code is 0; at exit code 2 the caller reads the block reason from
+    // stderr instead, so putting it on stdout here would make it invisible.
+    process.stderr.write(JSON.stringify({
       decision: 'block',
       reason: '[gates] ' + result.reason,
-    }));
+    }) + '\n');
     process.exitCode = 2;
   }
 }
@@ -120,11 +128,12 @@ function handlePreWrite(hCtx) {
 
   var result = checkSecrets(content);
   if (result.triggered) {
-    // Output block decision and set exit code 2 — both required by Claude Code PreToolUse protocol
-    console.log(JSON.stringify({
+    // Set exit code 2 to block, and write the reason to STDERR — see the
+    // matching comment in handlePreBash for why stdout is the wrong stream.
+    process.stderr.write(JSON.stringify({
       decision: 'block',
       reason: '[gates] ' + result.reason,
-    }));
+    }) + '\n');
     process.exitCode = 2;
   }
 }

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

@@ -10,7 +10,7 @@ module.exports = {
     var loopsDir = path.join(CWD, '.monomind', 'loops');
     if (!fs.existsSync(loopsDir)) { console.log('No loops directory.'); return; }
     var files = fs.readdirSync(loopsDir).filter(function(f) {
-      return f.endsWith('.json') && !f.includes('-hil') && !f.endsWith('.stop');
+      return f.endsWith('.json') && !f.includes('-hil') && !f.endsWith('.stop') && !f.startsWith('._');
     }).slice(0, 200); // cap to prevent DoS via many files
     var STALE_MS = 6 * 60 * 60 * 1000;
     var now = Date.now();

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

@@ -299,6 +299,35 @@ module.exports = {
             console.log('[CODEBASE] Graph index ' + mapData.graphStaleness.commitsBehind + ' commits behind HEAD — run monograph build');
           }
         }
+        // Graph gate connectivity nudge — the pre-search/pre-bash gate
+        // (utils/monograph.cjs _graphGateShouldBlock) hard-blocks the first
+        // Grep/Glob/bash-grep-or-find call each session until a real
+        // monograph_query/monograph_suggest call fires. If that block was
+        // never followed by a real graph call, the monomind MCP server is
+        // most likely not connected this session (config present but
+        // unapproved/not started) — surface it once so the user can fix the
+        // actual cause instead of the gate silently degrading to a no-op.
+        var graphGateFile = path.join(CWD, '.monomind', 'graph-gate-state.json');
+        var mcpWarnFile = path.join(CWD, '.monomind', 'mcp-not-connected-warned.json');
+        if (fs.existsSync(graphGateFile) && fs.statSync(graphGateFile).size < 4096) {
+          var gateState = JSON.parse(fs.readFileSync(graphGateFile, 'utf-8'));
+          var gateSessId = String((hCtx.hookInput && (hCtx.hookInput.sessionId || hCtx.hookInput.session_id)) || '');
+          if (gateState && gateState.sessionId === gateSessId && gateState.blockedOnce && !gateState.queried) {
+            var alreadyWarnedMcp = false;
+            if (fs.existsSync(mcpWarnFile)) {
+              try {
+                var mcpWarnData = JSON.parse(fs.readFileSync(mcpWarnFile, 'utf-8'));
+                if (mcpWarnData && mcpWarnData.sessionId === gateSessId) alreadyWarnedMcp = true;
+              } catch (e) { /* corrupt — warn again to be safe */ }
+            }
+            if (!alreadyWarnedMcp) {
+              console.log('[MCP] The graph gate blocked a search but no monograph_query/monograph_suggest call followed — the monomind MCP server is likely not connected this session. Run `claude mcp add monomind -- npx monomind@latest mcp start` (then restart), or approve the .mcp.json trust prompt if one is pending.');
+              try {
+                fs.writeFileSync(mcpWarnFile, JSON.stringify({ sessionId: gateSessId, warnedAt: new Date().toISOString() }));
+              } catch (e) { /* non-fatal */ }
+            }
+          }
+        }
         // 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) {
@@ -327,15 +356,15 @@ module.exports = {
             }
           }
         }
-        // Performance metrics (daemon optimize worker)
+        // Performance metrics (optimize worker — a one-shot process, not a daemon)
         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;
+          if (perfData && perfData.workerProcessMemoryUsage) {
+            var rssBytes = perfData.workerProcessMemoryUsage.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');
+              console.log('[PERF] optimize worker RSS ' + rssMB + 'MB (>512MB threshold) at last run — reflects that one-shot process, not a persistent daemon');
             }
           }
         }