monomind 1.18.15 → 1.19.0

package/.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 = true; // optimistic default when no signal exists
     try {
       var feedbackPath = path.join(CWD, '.monomind', 'routing-feedback.jsonl');
       var lastRoutePath = path.join(CWD, '.monomind', 'last-route.json');
@@ -52,26 +41,38 @@ 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, keep optimistic default (true)
           }
         } catch (e) { /* non-critical — keep optimistic default */ }
 
+        // Record session-end feedback WITH recentEdits (before consolidate clears them)
         if (intelligence && intelligence.feedback) {
           try { intelligence.feedback(sessionSuccess); } catch (e) { /* non-fatal */ }
         }
@@ -99,32 +100,24 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Memory Palace tombstone writes removed — redundant with raw session JSONL
-
-    // ── 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) {
-      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 */ }
+    // 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); }
+
+    // Memory Palace tombstone writes removed — redundant with raw session JSONL
 
     // ── Context Persistence Auto-Archive ─────────────────────────────────
     // Archive conversation context so it survives compaction and new sessions
@@ -139,99 +132,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/.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.
@@ -356,15 +371,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 */ }
   },
 };

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

@@ -18,114 +18,11 @@ module.exports = {
       try { session.metric('tasks'); } catch (e) { /* no active session */ }
     }
 
-    // Task 06: AutoRetry — signal retry policy only if coordinator path is active
-    if (hookInput.swarmCoordinator || hookInput.coordinator || hookInput.useRetry) {
-      console.log('[AUTO_RETRY_ENABLED] maxAttempts=3 strategy=exponential-backoff backoffMs=1000');
-    }
-
-    if (router && prompt) {
-      var routeFn = router.routeTaskSemantic || router.routeTask;
-      var result = await Promise.resolve(routeFn(prompt));
-      console.log('[INFO] Task routed to: ' + result.agent + ' (confidence: ' + result.confidence + ')');
-    } else {
-      console.log('[OK] Task started');
-    }
-
-    // AutoMem Phase 1: PLAN routine — consult memory before acting (arXiv:2607.01224)
-    if (prompt && typeof prompt === 'string' && prompt.length > 20) {
-      try {
-        var intelligence = hCtx.intelligence;
-        if (intelligence && intelligence.findSimilarPatterns) {
-          var memPatterns = await Promise.resolve(intelligence.findSimilarPatterns(prompt, { k: 3, type: 'memory-proficiency' }));
-          if (memPatterns && memPatterns.length > 0) {
-            console.log('[AUTOMEM_PLAN] Recalled ' + memPatterns.length + ' memory pattern(s): ' + memPatterns.map(function(p) { return p.content.substring(0, 80); }).join(' | '));
-          }
-          // Also check general patterns for task-relevant memory
-          var taskPatterns = await Promise.resolve(intelligence.findSimilarPatterns(prompt, { k: 2 }));
-          if (taskPatterns && taskPatterns.length > 0) {
-            console.log('[AUTOMEM_CONTEXT] ' + taskPatterns.length + ' relevant pattern(s) from prior sessions');
-          }
-        }
-      } catch (e) { /* non-fatal — PLAN is advisory */ }
-    }
-
-    // Task 24: PromptVersioning — resolve prompt variant before agent spawn
-    try {
-      var memMod = await import('@monomind/memory');
-      if (memMod && memMod.PromptVersionStore) {
-        var pvStore = new memMod.PromptVersionStore(path.join(CWD, '.monomind', 'prompt-versions'));
-        var pvMod = await import('file://' + path.join(CWD, 'packages/@monomind/cli/dist/src/agents/prompt-experiment.js'));
-        if (pvMod && pvMod.PromptExperimentRouter) {
-          var pvRouter = new pvMod.PromptExperimentRouter(pvStore);
-          var agentSlug24 = hookInput.agentSlug || hookInput.agentType || hookInput.agent_type || 'unknown';
-          if (agentSlug24 !== 'unknown') {
-            var resolved = pvRouter.resolvePromptForSpawn(agentSlug24);
-            if (resolved.version) {
-              console.log('[PROMPT_VERSION] ' + agentSlug24 + ' v' + resolved.version + (resolved.isCandidate ? ' (experiment candidate)' : ''));
-            }
-          }
-        }
-      }
-    } catch (e) { /* not available or no experiment */ }
-
-    // Monograph impact — detect changed files and surface their dependents
-    try {
-      var mgDbPath1 = path.join(CWD, '.monomind', 'monograph.db');
-      if (fs.existsSync(mgDbPath1)) {
-        var changedFiles1 = await new Promise(function(resolve) {
-          require('child_process').exec(
-            'git diff --name-only HEAD 2>/dev/null || git diff --name-only 2>/dev/null',
-            { cwd: CWD, timeout: 3000 },
-            function(err, stdout) { resolve(err ? '' : (stdout || '').trim()); }
-          );
-        });
-        if (changedFiles1) {
-          var mgMod1 = null;
-          mgMod1 = hCtx._requireMonograph();
-          if (mgMod1 && mgMod1.openDb) {
-            var db1 = mgMod1.openDb(mgDbPath1);
-            try {
-              var fileList1 = changedFiles1.split('\n').filter(Boolean).slice(0, 8);
-              var impacted1 = [];
-              for (var fi = 0; fi < fileList1.length; fi++) {
-                var fBase = path.basename(fileList1[fi]);
-                var fNode = db1.prepare("SELECT id, name, label FROM nodes WHERE file_path LIKE ? LIMIT 1").get('%' + fBase);
-                if (fNode) {
-                  var fImporters = db1.prepare(
-                    'SELECT n2.name FROM edges e JOIN nodes n2 ON n2.id = e.source_id WHERE e.target_id = ? LIMIT 5'
-                  ).all(fNode.id);
-                  var entry = fNode.name + ' (' + fNode.label + ')';
-                  if (fImporters.length) entry += ' ← ' + fImporters.map(function(i){ return i.name; }).join(', ');
-                  impacted1.push(entry);
-                }
-              }
-              if (impacted1.length > 0) {
-                console.log('[MONOGRAPH_IMPACT] Changed files and their dependents: ' + impacted1.join(' | '));
-              }
-
-              // Effective blast radius — second pass using first impacted node
-              try {
-                if (fileList1.length > 0 && mgMod1.effectiveBlastRadius) {
-                  var firstFile1 = path.basename(fileList1[0]);
-                  var firstNode1 = db1.prepare("SELECT id, name, label FROM nodes WHERE file_path LIKE ? LIMIT 1").get('%' + firstFile1);
-                  if (firstNode1) {
-                    var blastResults1 = mgMod1.effectiveBlastRadius(db1, firstNode1.id, { maxDepth: 4 });
-                    if (blastResults1 && blastResults1.length > 0) {
-                      var bwdCount1 = blastResults1.filter(function(r){ return r.direction === 'backward' || r.direction === 'both'; }).length;
-                      var fwdCount1 = blastResults1.filter(function(r){ return r.direction === 'forward' || r.direction === 'both'; }).length;
-                      var topBlast1 = blastResults1.slice(0, 8).map(function(r){
-                        return '[' + r.direction + ':' + r.hops + '] ' + r.nodeName + ' (' + r.nodeLabel + ')';
-                      });
-                      console.log('[MONOGRAPH_BLAST_RADIUS] Node: ' + firstNode1.name + ' | forward=' + fwdCount1 + ' backward=' + bwdCount1 + ' | ' + topBlast1.join(', '));
-                    }
-                  }
-                }
-              } catch(blastErr) { /* non-fatal */ }
-            } finally { if (mgMod1.closeDb) mgMod1.closeDb(db1); }
-          }
-        }
-      }
-    } catch(e) { /* non-fatal */ }
+    // monolean: removed per-subagent redundancies:
+    // - Re-routing (already done by route handler on parent prompt)
+    // - AUTOMEM pattern recall (marginal value, 2 similarity searches per spawn)
+    // - PromptVersioning experiments (unused feature)
+    // - Monograph blast radius (already shown by post-edit hook on actual changes)
 
     // Bridge to @monomind/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks
     var _hooksModule = hCtx._hooksModule;
@@ -148,7 +45,7 @@ module.exports = {
     var taskSuccess = hookInput.success !== false && hookInput.status !== 'failed';
     if (intelligence && intelligence.feedback) {
       try {
-        intelligence.feedback(true);
+        intelligence.feedback(taskSuccess);
       } catch (e) { /* non-fatal */ }
     }
     // Each TeammateIdle/TaskCompleted = one agent done → remove oldest registration (FIFO)
@@ -244,7 +141,8 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // AutoMem Phase 1: LOG routine — record memory proficiency metrics (arXiv:2607.01224)
+    // Record whether this task's outcome matched a recalled memory pattern,
+    // so future pattern recall can be scored for usefulness.
     try {
       var intelligence = hCtx.intelligence;
       if (intelligence && intelligence.recordMemoryDecision) {
@@ -259,51 +157,6 @@ module.exports = {
       }
     } catch (e) { /* non-fatal — LOG is advisory */ }
 
-    // ── Worker Auto-Dispatch ──────────────────────────────────────────────
-    // Auto-dispatch background workers based on task outcome
-    try {
-      var taskDesc = (typeof prompt === 'string' ? prompt : hookInput.description || '').toLowerCase();
-      var workersToDispatch = [];
-
-      // Always consolidate memory after any task
-      workersToDispatch.push('consolidate');
-
-      // Security-related task → dispatch audit worker
-      if (/\b(security|auth|vuln|cve|threat|token|permission|crypto)\b/.test(taskDesc)) {
-        workersToDispatch.push('audit');
-      }
-      // Performance-related → dispatch benchmark worker
-      if (/\b(performance|optimiz|benchmark|latency|throughput)\b/.test(taskDesc)) {
-        workersToDispatch.push('benchmark');
-      }
-      // Code changes → dispatch testgaps worker
-      if (/\b(implement|feature|refactor|fix|build|add|create|modify)\b/.test(taskDesc)) {
-        workersToDispatch.push('testgaps');
-      }
-      // Any significant task → dispatch map worker for codebase indexing
-      if (taskDesc.length > 50) {
-        workersToDispatch.push('map');
-      }
-
-      // Dispatch via @monomind/hooks if available, otherwise write dispatch file
-      if (workersToDispatch.length > 0) {
-        var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');
-        fs.mkdirSync(dispatchDir, { recursive: true });
-        var dispatchPayload = {
-          workers: workersToDispatch,
-          trigger: 'post-task',
-          taskDesc: taskDesc.substring(0, 100),
-          success: taskSuccess,
-          timestamp: new Date().toISOString(),
-        };
-        fs.writeFileSync(
-          path.join(dispatchDir, 'pending-' + Date.now() + '-' + Math.random().toString(36).slice(2, 7) + '.json'),
-          JSON.stringify(dispatchPayload), 'utf-8'
-        );
-        console.log('[WORKER_DISPATCH] Queued: ' + workersToDispatch.join(', '));
-      }
-    } catch (e) { /* non-fatal */ }
-
     // ── ADR Auto-Generation ────────────────────────────────────────────────
     // When adr.autoGenerate is true and task involved architect-level work,
     // create an ADR stub in the configured directory