@monoes/monomindcli 2.16.1 → 2.16.3

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

@@ -17,6 +17,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const pickCore = require('./pick-core.cjs');
 
 // ── Advisory output gate ────────────────────────────────────────────────────
 // Set MONOMIND_HOOK_QUIET=1 to silence the per-prompt advisory blocks
@@ -97,17 +98,15 @@ function _tripJevBreaker(CWD) {
   try { fs.writeFileSync(_jevBreakerPath(CWD), JSON.stringify({ until: Date.now() + JEV_BREAKER_MS })); } catch (e) { /* best effort */ }
 }
 
-async function _pickWithJev(CWD, prompt, keywordResult) {
+async function _pickWithJev(CWD, prompt, agents, includeAgentId, skills) {
   var jp = _loadJevPicker();
   if (!jp || jp.resolveProviders(process.env).length === 0) return null;
   // A dead endpoint must not tax every prompt: after a failed pick, skip Jev for 5 min.
   if (_jevBreakerOpen(CWD)) return null;
-  var agents = jp.loadAgentCatalog(CWD);
-  var skills = jp.loadSkillCatalog(CWD);
   if (agents.length < 2 && skills.length === 0) return null;
   var failures = [];
   var picked = await jp.pick(prompt, { agents: agents, skills: skills }, {
-    include: { agents: keywordResult && keywordResult.agentSlug ? [keywordResult.agentSlug] : [] },
+    include: { agents: includeAgentId ? [includeAgentId] : [] },
     timeoutMs: jp.resolveHookTimeoutMs(process.env),
     onError: function (err) { failures.push(err.provider + ': ' + err.message); },
   });
@@ -122,27 +121,46 @@ async function _pickWithJev(CWD, prompt, keywordResult) {
     provider: picked.provider,
     agent: jp.acceptAgent(picked.agent),
     agentConfidence: picked.agent ? picked.agent.confidence : 0,
+    agentRanked: picked.agent ? picked.agent.ranked : [],
     // Only a confident skill answer (including a confident "none fits") replaces keyword matches.
     skillAnswered: !!picked.skill && picked.skill.confidence >= jp.resolveMinConfidence(process.env),
     skills: jp.acceptSkills(picked.skill).map(function (id) { return skillById[id]; }).filter(Boolean),
   };
 }
 
-function _applyJevPick(result, jev) {
-  if (jev.agent) {
-    result.keywordAgent = result.agentSlug || result.agent;
-    result.agent = jev.agent;
-    result.agentSlug = jev.agent;
-    result.confidence = jev.agentConfidence;
-    result.reason = 'Jev decision model (' + jev.provider + ')';
-    result.routingMethod = 'jev';
-  }
+// The prompt's pick, as the legacy result object the enrichment below reads.
+// Agents and skills both come from the shared catalogs (registry.json and the
+// skill index through jev-picker), the same the CLI pickers rank; router.cjs
+// is not a selector (its agent table and matchSkills predate the catalogs).
+async function _decidePick(CWD, prompt) {
+  var jp = _loadJevPicker();
+  var agents = jp ? jp.loadAgentCatalog(CWD) : [];
+  var skills = jp ? jp.loadSkillCatalog(CWD) : [];
+  var skillMatches = pickCore.rankSkills(jp, prompt, skills);
+  // Outcome prior (pick-stats.cjs): a bounded re-rank from past adherence and
+  // subagent success; the file is small and read once per prompt.
+  var stats = null;
+  try { stats = require(path.join(__dirname, '..', 'pick-stats.cjs')).load(CWD); } catch (e) { /* no prior */ }
+  var keywordCands = pickCore.rankAgents(jp, prompt, agents, stats);
+  var jev = await _pickWithJev(CWD, prompt, agents, keywordCands[0] && keywordCands[0].id, skills);
+  var pick = pickCore.decide({ agents: agents, keywordCands: keywordCands, skillMatches: skillMatches, jev: jev });
   // Jev's skill answer replaces keyword skill matches, including "none fits".
-  if (jev.skillAnswered) {
-    result.skillMatches = jev.skills.map(function (s, i) {
+  if (jev && jev.skillAnswered) {
+    skillMatches = jev.skills.map(function (s, i) {
       return { skill: s.id, invoke: s.invoke, description: s.description || '', score: i === 0 ? 2 : 1, source: 'jev' };
     });
   }
+  return {
+    pick: pick,
+    result: {
+      agent: pick.agent ? pick.agent.name : null,
+      agentSlug: pick.agent ? pick.agent.id : null,
+      confidence: pick.confidence,
+      reason: pick.method,
+      routingMethod: pick.method,
+      skillMatches: skillMatches,
+    },
+  };
 }
 
 
@@ -152,34 +170,29 @@ module.exports = {
     var hookStart = Date.now();
     var prompt = hCtx.prompt;
     var hookInput = hCtx.hookInput;
-    var router = hCtx.router;
     var intelligence = hCtx.intelligence;
     var CWD = hCtx.CWD;
 
-    // For slash commands and single-action invocations: skip routing panel output
-    // but still write last-route.json so the statusline reflects the current action.
+    // For slash commands and single-action invocations: no pick. The command
+    // becomes the session's route (agent null, skill = the command) so later
+    // spawns are not scored against an earlier prompt's pick.
     if (hCtx.isSimpleCommand(prompt)) {
       try {
         var cmdLabel = (typeof prompt === 'string' && prompt.trim().startsWith('/'))
           ? prompt.trim().split(/\s+/)[0]          // e.g. "/ts"
           : (hookInput.commandName || hookInput.command_name || 'command');
-        var routeDir = path.join(CWD, '.monomind');
-        fs.mkdirSync(routeDir, { recursive: true });
-        fs.writeFileSync(
-          path.join(routeDir, 'last-route.json'),
-          JSON.stringify({
-            agent: cmdLabel,
-            confidence: 1.0,
-            reason: 'predefined command — no routing needed',
-            semanticRouting: false,
-            updatedAt: new Date().toISOString(),
-          }),
-          'utf-8'
-        );
+        pickCore.persistCommandRoute(CWD, {
+          command: cmdLabel,
+          sessionId: hookInput.session_id || hookInput.sessionId,
+        });
       } catch (e) { /* non-fatal */ }
       return;
     }
 
+    // Claude Code's own turns (task notifications, reminder-only prompts,
+    // slash-command expansions) carry no user intent: no pick, no record.
+    if (pickCore.isSystemPrompt(prompt)) return;
+
     if (intelligence && intelligence.getContext) {
       try {
         // Each hook event runs as a fresh node process, so the module-level
@@ -204,102 +217,43 @@ module.exports = {
         if (ctx) advisoryLog(ctx);
       } catch (e) { /* non-fatal */ }
     }
-    if (router && (router.routeTaskSemantic || router.routeTask)) {
-      const routeFn = router.routeTaskSemantic || router.routeTask;
-      var result = await Promise.resolve(routeFn(prompt));
-      // ── Decision model first, in BOTH modes: this is the route decision,
-      //    not advisory enrichment. The quiet block below persists whatever
-      //    it chooses (statusline, compact/session context, outcomes).
-      //    Bounded by MONOMIND_JEV_HOOK_TIMEOUT_MS and the failure breaker.
-      var jevOutcome = await _pickWithJev(CWD, prompt, result);
-      if (jevOutcome) _applyJevPick(result, jevOutcome);
-
-
-
-      // When QUIET: the advisory output is suppressed anyway, so skip ALL the
-      // expensive enrichment below (embedding search, second-brain HTTP, monograph
-      // DB queries, metrics reads, episodes search). Persist the same outcome
-      // correlation identity as the full path before exiting: quiet changes
-      // advisory output and enrichment cost, never lifecycle side effects.
-      if (_HOOK_QUIET) {
+    {
+      // ── The pick, in BOTH modes: Jev over the agent registry, else a strong
+      //    keyword match over the same registry (bounded by
+      //    MONOMIND_JEV_HOOK_TIMEOUT_MS and the failure breaker). Its one
+      //    [PICK] line reaches Claude even under MONOMIND_HOOK_QUIET — it is
+      //    the hook's answer, not an advisory banner.
+      //    A trivial reply ("thanks", "ok") gets no pick and no record: the
+      //    session's earlier route still describes the work in progress.
+      var result;
+      if (pickCore.isTrivialPrompt(prompt)) {
+        result = { agent: null, agentSlug: null, confidence: null, reason: 'trivial prompt', routingMethod: 'none', skillMatches: [] };
+      } else {
+        var decided = await _decidePick(CWD, prompt);
+        result = decided.result;
+        var pickLine = pickCore.formatPickLine(decided.pick);
+        if (pickLine) console.log(pickLine);
         try {
-          var crypto = require('crypto');
-          var routeId = typeof crypto.randomUUID === 'function' ? crypto.randomUUID() : ('route-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8));
-          var routeDir = path.join(CWD, '.monomind');
-          fs.mkdirSync(routeDir, { recursive: true });
-          var agentName = result.agent || 'coder';
-          var promptSlice = (prompt || '').slice(0, 500);
-          fs.writeFileSync(path.join(routeDir, 'last-route.json'), JSON.stringify({
-            routeId: routeId,
-            agent: agentName,
-            agentSlug: result.agentSlug || null,
-            confidence: result.confidence,
-            reason: result.reason,
-            prompt: promptSlice,
-            updatedAt: new Date().toISOString(),
-          }), 'utf-8');
-          fs.appendFileSync(path.join(routeDir, 'route-outcomes.jsonl'), JSON.stringify({
-            routeId: routeId,
-            ts: Date.now(),
-            task: promptSlice,
-            recommendedAgent: agentName,
-            routingMethod: result.routingMethod || 'keyword',
-            confidence: typeof result.confidence === 'number' ? result.confidence : 0,
-            learningMode: 'js',
-          }) + '\n', 'utf-8');
+          pickCore.persistRoute(CWD, {
+            pick: decided.pick,
+            prompt: prompt,
+            sessionId: hookInput.session_id || hookInput.sessionId,
+            shown: !!pickLine,
+          });
         } catch (e) { /* non-fatal */ }
-        return;
       }
 
-      // ── Enrichment: when router.cjs falls to the broad "coder" catch-all,
-      //    try @monoes/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.routingMethod !== 'jev' && 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 = erRule.score != null ? Math.min(0.98, Math.max(0.70, erRule.score)) : 0.85;
-                  result.reason = 'Enriched: ' + (erRule.description || erRule.routeName);
-                  result.enrichedFrom = 'routing-keyword-pre-filter';
-                  break;
-                }
-              }
-            }
-          }
-        } catch (e) { /* non-fatal — routing package may not be available */ }
-      }
+      // When QUIET: the advisory output is suppressed anyway, so skip ALL the
+      // expensive enrichment below (embedding search, second-brain HTTP, monograph
+      // DB queries, metrics reads, episodes search).
+      if (_HOOK_QUIET) return;
 
       // ── Intelligence embedding suggestion (SONA/ReasoningBank read path) ──
-      // Wires the previously-write-only intelligence system into live routing:
-      // suggestAgentsFromIntelligence() runs an embedding similarity search
-      // over patterns stored by recordMemoryDecision() on every post-task.
-      // This ENHANCES the keyword route — it only overrides when the
-      // embedding match is meaningfully more confident, and never blocks or
-      // delays routing beyond a 2s budget (fails silently otherwise).
-      // A slow or failed Jev attempt may already have spent most of the time
-      // before the hook exit, so the budget shrinks to keep the route persist
-      // below in time (500 ms before routeDeadlineMs).
+      // An advisory signal only: its agent labels come from post-task records,
+      // not the registry, so it never replaces the pick. Bounded by a 2 s budget
+      // that shrinks after a slow Jev attempt so the hook exits in time.
       var intelBudgetMs = Math.min(2000, Math.max(0, routeDeadlineMs(process.env) - 500 - (Date.now() - hookStart)));
-      if (result.routingMethod !== 'jev' && intelBudgetMs > 0) try {
+      if (intelBudgetMs > 0) try {
         var intelResult = await Promise.race([
           (async function() {
             var mod = await _loadIntelligenceModule(CWD);
@@ -312,23 +266,8 @@ module.exports = {
           var topIntelAgent = intelResult.agents[0];
           var intelConf = intelResult.confidence != null ? intelResult.confidence : 0;
           result.intelligenceSuggestion = { agents: intelResult.agents, confidence: intelConf };
-
-          var curAgent = result.agentSlug || result.agent;
-          var curConf = result.confidence != null ? result.confidence : 0;
-          if (topIntelAgent !== curAgent) {
-            // Only override when the embedding match clearly beats the keyword
-            // route (0.1 margin) — otherwise just surface it as a signal.
-            if (intelConf > curConf + 0.1) {
-              advisoryLog('[INTELLIGENCE] Embedding suggestion overrides keyword routing: ' + topIntelAgent + ' (confidence ' + intelConf.toFixed(2) + ') vs keyword ' + curAgent + ' (' + curConf.toFixed(2) + ')');
-              result.keywordAgent = curAgent;
-              result.agent = topIntelAgent;
-              result.agentSlug = topIntelAgent;
-              result.confidence = intelConf;
-              result.reason = 'Intelligence embedding match (SONA/ReasoningBank)' + (result.reason ? '; keyword route was: ' + result.reason : '');
-              result.enrichedFrom = 'intelligence-embedding';
-            } else {
-              advisoryLog('[INTELLIGENCE] Embedding suggestion: ' + topIntelAgent + ' (confidence ' + intelConf.toFixed(2) + ') — kept keyword route ' + curAgent);
-            }
+          if (topIntelAgent !== result.agent) {
+            advisoryLog('[INTELLIGENCE] Embedding suggestion: ' + topIntelAgent + ' (confidence ' + intelConf.toFixed(2) + ')');
           }
         }
       } catch (e) { /* non-fatal — intelligence system unavailable or timed out */ }
@@ -349,7 +288,7 @@ module.exports = {
                 successRate: Math.round(patterns[pi].wins / patterns[pi].total * 100)
               };
             }
-            var routedAgent = result.agent || 'coder';
+            var routedAgent = result.agent;
             var routedPattern = patternMap[routedAgent];
             // Find if there's a clearly better agent
             if (routedPattern && routedPattern.successRate < 50) {
@@ -370,7 +309,7 @@ module.exports = {
         if (fs.existsSync(rfPath) && fs.statSync(rfPath).size <= MAX_RF) {
           var rfLines = fs.readFileSync(rfPath, 'utf-8').trim().split('\n').filter(Boolean);
           // Check last 50 entries for this agent's feedback
-          var routedAgent = result.agent || 'coder';
+          var routedAgent = result.agent;
           var recentRf = rfLines.slice(-50);
           var agentFeedback = [];
           for (var ri = 0; ri < recentRf.length; ri++) {
@@ -406,7 +345,9 @@ module.exports = {
         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)) {
+          var dispatchSid = hookInput.session_id || hookInput.sessionId || null;
+          var sameSession = !lastDispatch.sessionId || !dispatchSid || lastDispatch.sessionId === dispatchSid;
+          if (dispatchAge < 60000 && sameSession && result.agent && (lastDispatch.agentType === result.agent || lastDispatch.agentType === result.agentSlug)) {
             result.recentlyDispatched = true;
             advisoryLog('[DISPATCH_DEDUP] ' + lastDispatch.agentType + ' was dispatched ' + Math.round(dispatchAge / 1000) + 's ago — consider a different specialist or direct implementation');
           }
@@ -416,44 +357,6 @@ module.exports = {
       var output = [];
       var conf = result.confidence != null ? result.confidence : 0;
 
-      // ── Persist routing result for statusline display & outcome correlation ─
-      try {
-        var crypto = require('crypto');
-        var routeId = typeof crypto.randomUUID === 'function' ? crypto.randomUUID() : ('route-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8));
-        var routeDir = path.join(CWD, '.monomind');
-        fs.mkdirSync(routeDir, { recursive: true });
-        var agentName = result.agent || 'coder';
-        var confVal = typeof result.confidence === 'number' ? result.confidence : 0;
-        var promptSlice = (prompt || '').slice(0, 500);
-        fs.writeFileSync(
-          path.join(routeDir, 'last-route.json'),
-          JSON.stringify({
-            routeId: routeId,
-            agent: agentName,
-            agentSlug: result.agentSlug || null,
-            confidence: result.confidence,
-            reason: result.reason,
-            prompt: promptSlice,
-            historicalPattern: result.historicalPattern || null,
-            updatedAt: new Date().toISOString(),
-          }),
-          'utf-8'
-        );
-
-        // Append initial route recommendation to route-outcomes.jsonl
-        var routeRec = {
-          routeId: routeId,
-          ts: Date.now(),
-          task: promptSlice,
-          recommendedAgent: agentName,
-          routingMethod: result.routingMethod || 'keyword',
-          confidence: confVal,
-          learningMode: 'js',
-        };
-        var outcomesPath = path.join(routeDir, 'route-outcomes.jsonl');
-        fs.appendFileSync(outcomesPath, JSON.stringify(routeRec) + '\n', 'utf-8');
-      } catch (e) { /* non-fatal */ }
-
       // ── Skill auto-activation (the one thing the hook does better than Claude) ──
       var matches = result.skillMatches || [];
       if (matches.length > 0) {
@@ -978,12 +881,16 @@ module.exports = {
             advisoryLog('[MONOGRAPH] ' + nodeCount + ' nodes. Call mcp__monomind__monograph_suggest to find relevant files.');
             hCtx._recordGraphTelemetry('preresolve_miss');
           }
+        } else if (!hintDb || nodeCount > 100) {
+          // #328: the gate and these hints switch off when the hooks can't
+          // open the graph or it is past the 50-commit limit. Say so once per
+          // cause (not per prompt), even under MONOMIND_HOOK_QUIET.
+          var offNotice = require('../utils/monograph-resolve.cjs').graphOffNoticeOnce(CWD, hintDb || null);
+          if (offNotice) console.log(offNotice);
         }
       } catch(e) {}
 
       // Swarm mode selection is available on-demand via /mastermind slash command.
-    } else {
-      advisoryLog('[INFO] Router not available, using default routing');
     }
 
     // Task 22: TeamRoutingModes — only log when an explicit swarm config is present

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

@@ -5,6 +5,27 @@
 
 const path = require('path');
 const fs = require('fs');
+const pickCore = require('./pick-core.cjs');
+
+// The last `bytes` of a JSONL file as parsed records (a partial first line is
+// dropped), so a large file still yields its recent entries instead of none.
+function readTailRecords(file, bytes) {
+  var fd;
+  try {
+    var size = fs.statSync(file).size;
+    var len = Math.min(bytes, size);
+    var buf = Buffer.alloc(len);
+    fd = fs.openSync(file, 'r');
+    fs.readSync(fd, buf, 0, len, size - len);
+    var lines = buf.toString('utf-8').split('\n');
+    if (size > len) lines.shift();
+    return lines.map(function(l) { try { return l ? JSON.parse(l) : null; } catch (e) { return null; } }).filter(Boolean);
+  } catch (e) {
+    return [];
+  } finally {
+    if (fd !== undefined) try { fs.closeSync(fd); } catch (e) { /* ignore */ }
+  }
+}
 
 module.exports = {
   handleEnd: async function(hCtx) {
@@ -36,10 +57,9 @@ module.exports = {
     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');
-      var MAX_ROUTE = 64 * 1024; // 64 KiB
-      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'));
+      var endSessionId = hookInput.sessionId || hookInput.session_id || '';
+      var lastRoute = pickCore.readSessionRoute(CWD, endSessionId);
+      if (lastRoute) {
 
         // Derive sessionSuccess. A commit alone is not proof of success — a
         // session can commit a partial fix and then hit repeated failures —
@@ -50,14 +70,13 @@ module.exports = {
 
           var outcomesSignal = null; // majority success/failure from intelligence-outcomes, if any
           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; } }())) {
+          // Only the tail is read: the 30-minute window lives at the end of the
+          // file, and a size cap used to drop the whole signal once it grew.
+          if (fs.existsSync(outcomesPath)) {
             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; });
+            var recent = readTailRecords(outcomesPath, 256 * 1024)
+              .filter(function(e) { return e.ts && e.ts >= cutoff; });
             if (recent.length > 0) {
               var failures = recent.filter(function(e) { return e.success === false; }).length;
               outcomesSignal = failures / recent.length < 0.5;
@@ -88,7 +107,13 @@ module.exports = {
         if (intelligence && intelligence.feedback && typeof sessionSuccess === 'boolean') {
           try { intelligence.feedback(sessionSuccess); } catch (e) { /* non-fatal */ }
         }
-        // Normalize agent label to a lowercase slug ("Coder" → "coder", "backend dev" → "backend-dev")
+        // The session's outcome joins its latest route by routeId. The agent
+        // actually used is never inferred here: pick-adherence (PreToolUse
+        // Task|Agent) records the real subagent_type on the route when one ran.
+        if (typeof sessionSuccess === 'boolean' && lastRoute.routeId) {
+          try { pickCore.joinOutcome(CWD, lastRoute.routeId, { measuredSuccess: sessionSuccess }); } catch (eRo) { /* non-fatal */ }
+        }
+        // routing-feedback.jsonl: the recommendation (skip when there was none).
         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') {
@@ -98,52 +123,10 @@ module.exports = {
             confidence: lastRoute.confidence,
             sessionId: String(hookInput.sessionId || hookInput.session_id || '').slice(0, 128),
           };
+          if (lastRoute.routeId) feedbackEntry.routeId = lastRoute.routeId;
           // 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');
-
-          // Also join/record into route-outcomes.jsonl if routeId exists or outcome measured
-          if (typeof sessionSuccess === 'boolean') {
-            try {
-              var routeOutcomesPath = path.join(CWD, '.monomind', 'route-outcomes.jsonl');
-              if (fs.existsSync(routeOutcomesPath)) {
-                var roLines = fs.readFileSync(routeOutcomesPath, 'utf-8').trim().split('\n').filter(Boolean);
-                var updated = false;
-                if (lastRoute.routeId) {
-                  for (var ri = roLines.length - 1; ri >= 0; ri--) {
-                    try {
-                      var roRec = JSON.parse(roLines[ri]);
-                      if (roRec.routeId === lastRoute.routeId) {
-                        roRec.agentActuallyUsed = agentSlug;
-                        roRec.measuredSuccess = sessionSuccess;
-                        roLines[ri] = JSON.stringify(roRec);
-                        updated = true;
-                        break;
-                      }
-                    } catch (_) {}
-                  }
-                }
-                if (!updated) {
-                  // If not found by routeId, join latest unresolved record
-                  for (var ri2 = roLines.length - 1; ri2 >= 0; ri2--) {
-                    try {
-                      var roRec2 = JSON.parse(roLines[ri2]);
-                      if (roRec2.measuredSuccess === undefined) {
-                        roRec2.agentActuallyUsed = agentSlug;
-                        roRec2.measuredSuccess = sessionSuccess;
-                        roLines[ri2] = JSON.stringify(roRec2);
-                        updated = true;
-                        break;
-                      }
-                    } catch (_) {}
-                  }
-                }
-                if (updated) {
-                  fs.writeFileSync(routeOutcomesPath, roLines.join('\n') + '\n', 'utf-8');
-                }
-              }
-            } catch (eRo) { /* non-fatal */ }
-          }
           // Rotate: keep last 1000 lines to prevent unbounded growth.
           try {
             var MAX_FEEDBACK = 512 * 1024; // 512 KiB
@@ -191,6 +174,8 @@ module.exports = {
         }
       }
     } catch (e) { /* non-fatal */ }
+    // Fold this session's adherence/outcome lines into pick-stats.json (the ranking prior).
+    try { require('../pick-stats.cjs').update(CWD); } catch (e) { /* non-fatal */ }
 
     // Now consolidate AFTER feedback has been recorded (so the outcome has recentEdits)
     if (!daemonHoldsLock && intelligence && intelligence.consolidate) {
@@ -237,16 +222,13 @@ module.exports = {
 
       // 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 {
-        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) {}
+      var lr = pickCore.readSessionRoute(CWD, sessId);
+      if (lr) {
+        routeAgent = lr.agent || 'unknown';
+        routePrompt = lr.prompt || '';
+      }
 
       // Strip system noise (task notifications, XML tags) from prompt
       if (routePrompt && (routePrompt.includes('<task-notification>') || routePrompt.includes('<system-reminder>'))) {

package/.claude/helpers/handlers/session-restore-handler.cjs

@@ -36,6 +36,10 @@ module.exports = {
       }
     } catch (e) { log('[WARN] Session restore failed: ' + e.message); }
 
+    // Keep skill-registry.json (the skill catalog routing and Jev read) in
+    // step with .claude/skills: rebuilt when missing or older than any skill.
+    try { require('./pick-core.cjs').ensureSkillRegistryFresh(CWD); } catch (e) { /* non-fatal */ }
+
     // ── Non-blocking security scan via @monoes/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
@@ -131,7 +135,7 @@ module.exports = {
         if (bundledDir) {
           var healed = [];
           // Top-level critical files — mirrors executor.ts's `criticalHelpers` list.
-          var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs', 'router.cjs', 'monograph-freshen.cjs', 'control-start.cjs', 'intelligence.cjs', 'auto-memory-hook.mjs', 'build-skill-registry.cjs', 'jev-picker.cjs', 'redact-secrets.cjs'];
+          var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs', 'router.cjs', 'monograph-freshen.cjs', 'control-start.cjs', 'intelligence.cjs', 'auto-memory-hook.mjs', 'build-skill-registry.cjs', 'org-skill-index.cjs', 'jev-picker.cjs', 'jev-catalog.cjs', 'redact-secrets.cjs', 'pick-rank.cjs', 'pick-stats.cjs'];
           for (var hi = 0; hi < helpersToCheck.length; hi++) {
             var hName = helpersToCheck[hi];
             var healedName = _healIfStale(

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

@@ -47,6 +47,10 @@ module.exports = {
     var CWD = hCtx.CWD;
 
     var taskSuccess = hookInput.success !== false && hookInput.status !== 'failed';
+    // SubagentStop carries the subagent as agent_type; the other names are
+    // older/other payload shapes.
+    var completedAgent = String(hookInput.agent_type || hookInput.subagent_type || hookInput.agentType
+      || hookInput.agentSlug || hookInput.agent_slug || '').slice(0, 128) || 'unknown';
     if (intelligence && intelligence.feedback) {
       try {
         intelligence.feedback(taskSuccess);
@@ -124,7 +128,7 @@ module.exports = {
           task: {
             id: hookInput.taskId || hookInput.task_id || '',
             status: taskSuccess ? 'completed' : 'failed',
-            agentSlug: hookInput.agentSlug || hookInput.agent_slug || 'unknown',
+            agentSlug: completedAgent,
             type: hookInput.taskType || hookInput.task_type || 'general',
           },
           success: taskSuccess,
@@ -166,9 +170,9 @@ module.exports = {
           var dlqWriter = new dlqMod.DLQWriter(dlqDir);
           dlqWriter.enqueue({
             toolName: 'post-task',
-            originalPayload: { taskId: hookInput.taskId || '', agentSlug: hookInput.agentSlug || 'unknown' },
+            originalPayload: { taskId: hookInput.taskId || '', agentSlug: completedAgent },
             deliveryAttempts: [{ attempt: 1, timestamp: new Date().toISOString(), error: hookInput.error || 'task failed' }],
-            agentId: hookInput.agentSlug || hookInput.agent_slug,
+            agentId: completedAgent,
             swarmId: hookInput.swarmId || hookInput.swarm_id,
           });
           console.log('[DLQ_ENQUEUED] Failed task ' + (hookInput.taskId || 'unknown') + ' sent to dead-letter queue');
@@ -181,7 +185,7 @@ module.exports = {
     try {
       var intelligence = hCtx.intelligence;
       if (intelligence && intelligence.recordMemoryDecision) {
-        var agentSlug = hookInput.agentSlug || hookInput.agent_slug || 'unknown';
+        var agentSlug = completedAgent;
         var taskDesc = typeof prompt === 'string' ? prompt : hookInput.description || '';
         await Promise.resolve(intelligence.recordMemoryDecision({
           taskDescription: taskDesc.substring(0, 200),
@@ -206,7 +210,7 @@ module.exports = {
         }
       }
       if (adrCfg.autoGenerate) {
-        var taskAgent = hookInput.agentSlug || hookInput.agent_slug || '';
+        var taskAgent = completedAgent === 'unknown' ? '' : completedAgent;
         var taskDescAdr = (typeof prompt === 'string' ? prompt : hookInput.description || '').toLowerCase();
         var isArchitectLevel = ['architect', 'system-architect', 'software-architect'].includes(taskAgent)
           || /\b(architecture|design decision|adr|trade-?off|migration strategy)\b/.test(taskDescAdr);
@@ -236,6 +240,7 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    console.log('[OK] Task completed');
+    // SubagentStop runs post-task: the acknowledgement is silent under QUIET.
+    if (String(process.env.MONOMIND_HOOK_QUIET || '') !== '1') console.log('[OK] Task completed');
   }
 };