@monoes/monomindcli 1.19.0 → 2.0.0

package/.claude/agents/github/issue-tracker.md

@@ -281,8 +281,6 @@ Updates will be posted automatically by swarm agents during implementation.
 ### Seamless integration with:
 - `/github pr-manager` - Link issues to pull requests
 - `/github release-manager` - Coordinate release issues
-- `/sparc orchestrator` - Complex project coordination
-- `/sparc tester` - Automated testing workflows
 
 ## Metrics and Analytics
 

package/.claude/agents/github/pr-manager.md

@@ -145,8 +145,6 @@ mcp__monomind__memory_store {
 - `/github issue-tracker` - For project coordination
 - `/github branch-manager` - For branch strategy
 - `/github ci-orchestrator` - For CI/CD integration
-- `/sparc reviewer` - For detailed code analysis
-- `/sparc tester` - For comprehensive testing
 
 ## Error Handling
 

package/.claude/agents/github/repo-architect.md

@@ -72,8 +72,8 @@ mcp__github__push_files {
       content: "[GitHub modes template]"
     },
     {
-      path: ".claude/commands/sparc/sparc-modes.md",
-      content: "[SPARC modes template]"
+      path: ".claude/commands/mastermind/help.md",
+      content: "[Mastermind commands template]"
     },
     {
       path: ".claude/settings.json",
@@ -116,7 +116,6 @@ npx monomind@latest mcp start
 
 ## Features
 - Monomind swarm coordination
-- SPARC development modes
 - GitHub workflow automation
 - Knowledge graph integration
 
@@ -270,16 +269,11 @@ monomind/
 │   │   ├── pr-manager.md
 │   │   ├── issue-tracker.md
 │   │   └── sync-coordinator.md
-│   ├── sparc/
-│   │   ├── sparc-modes.md
-│   │   ├── coder.md
-│   │   └── tester.md
 │   └── swarm/
 │       ├── coordination.md
 │       └── orchestration.md
 ├── agents/
-│   ├── github/
-│   └── sparc/
+│   └── github/
 └── settings.json
 ```
 
@@ -355,5 +349,3 @@ const integrationPattern = {
 
 - `/github sync-coordinator` - For cross-repo synchronization
 - `/github release-manager` - For coordinated releases
-- `/sparc architect` - For detailed architecture design
-- `/sparc optimizer` - For performance optimization

package/.claude/agents/goal/goal-planner.md

@@ -140,7 +140,6 @@ When handling requests:
 Integration with Monomind:
 - Coordinate with other specialized agents for specific actions
 - Use swarm coordination for parallel action execution
-- Leverage SPARC methodology for structured development tasks
 - Apply concurrent execution patterns from CLAUDE.md
 
 Advanced swarm coordination patterns:

package/.claude/commands/github/issue-tracker.md

@@ -275,8 +275,6 @@ Generated with Claude Code
 ### Seamless integration with:
 - `/github pr-manager` - Link issues to pull requests
 - `/github release-manager` - Coordinate release issues
-- `/sparc orchestrator` - Complex project coordination
-- `/sparc tester` - Automated testing workflows
 
 ## Metrics and Analytics
 

package/.claude/commands/github/pr-manager.md

@@ -155,8 +155,6 @@ mcp__monomind__memory_store {
 - `/github issue-tracker` - For project coordination
 - `/github branch-manager` - For branch strategy
 - `/github ci-orchestrator` - For CI/CD integration
-- `/sparc reviewer` - For detailed code analysis
-- `/sparc tester` - For comprehensive testing
 
 ## Error Handling
 

package/.claude/commands/github/repo-architect.md

@@ -78,8 +78,8 @@ mcp__github__push_files {
       content: "[GitHub modes template]"
     },
     {
-      path: ".claude/commands/sparc/sparc-modes.md",
-      content: "[SPARC modes template]"
+      path: ".claude/commands/mastermind/help.md",
+      content: "[Mastermind commands template]"
     },
     {
       path: ".claude/config.json",
@@ -121,14 +121,13 @@ mcp__github__push_files {
 
 ## Quick Start
 \`\`\`bash
-npx monomind init --sparc
+npx monomind init
 npm install
 npx monomind start --ui
 \`\`\`
 
 ## Features
 - Monomind swarm integration
-- SPARC development modes
 - GitHub workflow automation
 - Advanced coordination capabilities
 
@@ -280,10 +279,6 @@ monomind/
 │   │   ├── pr-manager.md
 │   │   ├── issue-tracker.md
 │   │   └── sync-coordinator.md
-│   ├── sparc/
-│   │   ├── sparc-modes.md
-│   │   ├── coder.md
-│   │   └── tester.md
 │   └── swarm/
 │       ├── coordination.md
 │       └── orchestration.md
@@ -368,8 +363,6 @@ const integrationPattern = {
 
 - `/github sync-coordinator` - For cross-repo synchronization
 - `/github release-manager` - For coordinated releases
-- `/sparc architect` - For detailed architecture design
-- `/sparc optimizer` - For performance optimization
 
 ### Workflow Enhancement:
 

package/.claude/commands/mastermind/help.md

@@ -57,8 +57,8 @@ npx monomind monograph search -q "authentication"
 npx monomind monograph stats
 
 # Pattern logging
-npx monomind neural patterns --action list
-npx monomind neural status --verbose
+npx monomind hooks intelligence patterns --action list
+npx monomind hooks intelligence status --verbose
 
 # Hooks
 npx monomind hooks pre-task --description "task description"
@@ -78,7 +78,7 @@ npx monomind performance benchmark --suite all
 
 ## Built-in Workflow Templates
 
-`development`, `research`, `testing`, `security-audit`, `code-review`, `refactoring`, `sparc`, `custom`
+`development`, `research`, `testing`, `security-audit`, `code-review`, `refactoring`, `custom`
 
 ## Swarm Topologies
 

package/.claude/commands/workflows/README.md

@@ -51,7 +51,6 @@ npx monomind workflow template create --name "my-workflow"
 | `security-audit` | Threat Model → Static → Dynamic → Report | security-architect, auditor |
 | `code-review` | Initial → Security → Quality → Feedback | reviewer, auditor, analyst |
 | `refactoring` | Analysis → Planning → Refactor → Validation | architect, coder, reviewer |
-| `sparc` | Spec → Pseudocode → Architecture → Refinement → Completion | architect, coder, tester, reviewer |
 | `custom` | Define your own stages | configurable |
 
 ## MCP Tools

package/.claude/commands/workflows/workflow-create.md

@@ -29,7 +29,6 @@ npx monomind workflow template list
 
 # Show a specific template's stages and agents
 npx monomind workflow template show development
-npx monomind workflow template show sparc
 ```
 
 ## Template Create Flags

package/.claude/commands/workflows/workflow-execute.md

@@ -1,6 +1,6 @@
 ---
 name: workflows:workflow-execute
-description: Run multi-agent workflows using built-in templates (development, research, testing, sparc, security-audit, etc.) via real npx monomind workflow run CLI
+description: Run multi-agent workflows using built-in templates (development, research, testing, security-audit, etc.) via real npx monomind workflow run CLI
 ---
 
 # Workflow Execute
@@ -23,7 +23,6 @@ npx monomind workflow run -t development --task "Build REST API with auth"
 npx monomind workflow run -t research --task "Analyze performance bottlenecks"
 npx monomind workflow run -t testing
 npx monomind workflow run -t security-audit
-npx monomind workflow run -t sparc --task "New payment module"
 
 # Run from a workflow file
 npx monomind workflow run -f ./workflow.yaml
@@ -55,7 +54,6 @@ npx monomind workflow run -t development --dry-run
 | `security-audit` | Threat Model → Static → Dynamic → Report | security-architect, auditor |
 | `code-review` | Initial → Security → Quality → Feedback | reviewer, auditor, analyst |
 | `refactoring` | Analysis → Planning → Refactor → Validation | architect, coder, reviewer |
-| `sparc` | Spec → Pseudocode → Architecture → Refinement → Completion | architect, coder, tester, reviewer |
 | `custom` | Define your own | configurable |
 
 ## MCP Tools

package/.claude/commands/workflows/workflow-export.md

@@ -23,7 +23,6 @@ npx monomind workflow template list
 
 # Show details for a specific template (stages, agents, estimated duration)
 npx monomind workflow template show development
-npx monomind workflow template show sparc
 npx monomind workflow template show security-audit
 
 # Validate a custom workflow file
@@ -45,7 +44,6 @@ npx monomind workflow list --status all
 | `security-audit` | Threat Model → Static → Dynamic → Report | 20-40 min |
 | `code-review` | Initial → Security → Quality → Feedback | 10-25 min |
 | `refactoring` | Analysis → Planning → Refactor → Validation | 15-35 min |
-| `sparc` | Spec → Pseudocode → Architecture → Refinement → Completion | 25-45 min |
 | `custom` | Define your own stages | varies |
 
 ## MCP Tools

package/.claude/helpers/handlers/agent-start-handler.cjs

@@ -6,7 +6,7 @@ const path = require('path');
 const fs = require('fs');
 
 module.exports = {
-  handle: function(hCtx) {
+  handle: async function(hCtx) {
     var hookInput = hCtx.hookInput;
     var CWD = hCtx.CWD;
     var _openMonographDb = hCtx._openMonographDb;
@@ -79,5 +79,22 @@ module.exports = {
         }
       }
     } catch (e) { /* non-fatal */ }
+
+    // Bridge to @monomind/hooks registry — fires AgentSpawn hooks (was previously never
+    // wired: HookEvent.AgentSpawn existed but no CJS handler ever fired it).
+    try {
+      var _hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null;
+      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() {});
+      }
+    } catch (e) { /* non-fatal */ }
   },
 };

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

@@ -140,6 +140,21 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
+    // Bridge to @monomind/hooks registry — fires PostEdit hooks (observability bus, guidance provider).
+    // 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 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() {});
+      } catch (e) { /* non-fatal */ }
+    }
+
     console.log('[OK] Edit recorded');
   }
 };

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

@@ -2,14 +2,8 @@
  * Enforcement Gates Handler
  *
  * Inline gate logic for PreToolUse hooks — no ESM/package dependency.
- *
- * Patterns are an INTENTIONAL SUPERSET of @monomind/guidance/src/gates.ts defaults:
- *   - All categories from DEFAULT_GATE_CONFIG are covered here
- *   - Many patterns are enhanced (e.g. --force-with-lease, -fr reversed flags, broader kubectl)
- *   - Key thresholds MUST stay aligned: password/secret min length = 8 chars (both files)
- *
- * When updating patterns in gates.ts, check whether the corresponding pattern here
- * also needs updating — and vice versa.
+ * This regex table is the canonical (and only) gate definition; the former
+ * @monomind/guidance package it mirrored has been removed.
  *
  * Gates enforced at runtime:
  *   pre-bash  → destructive-ops  (require-confirmation → block)

package/.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/.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 ─────────────────────────────────