@monoes/monomindcli 2.16.3 → 2.16.5

package/.claude/helpers/hook-handler.cjs

@@ -313,8 +313,10 @@ async function main() {
   function isSimpleCommand(p) {
     if (typeof p !== 'string') return false;
     var s = p.trim();
-    // Slash commands: /ts, /list-agents, /commit, /help, /use-agent etc.
-    if (/^\/[a-z0-9_-]+(\s|$)/i.test(s)) return true;
+    // Slash commands: /ts, /list-agents, /commit, /help, and namespaced ones
+    // (/mastermind:plan). A path (/var/log/app.log …) has a second '/' and is
+    // not a command.
+    if (/^\/[a-z0-9_-]+(:[a-z0-9_-]+)*(\s|$)/i.test(s)) return true;
     // Short single-word operator tokens (toggle, list, status)
     if (/^(ts|ls|ps|pwd|help|clear|exit|quit|status|toggle|refresh)$/i.test(s)) return true;
     // Already-resolved command messages (Claude Code sends hook with command-name context)

package/.claude/helpers/jev-catalog.cjs

@@ -4,7 +4,8 @@
  * prompt hook (via jev-picker.cjs) and the CLI (`monomind pick`, MCP pick via
  * src/decision/catalogs.ts), so both rank exactly the same agents and skills.
  *
- *   agents  .monomind/registry.json            (src/agents/registry-builder.ts)
+ *   agents  .monomind/registry.json            (agent-registry.cjs: project,
+ *           ~/.claude/agents and extra roots)
  *   skills  .claude/helpers/skill-registry.json (build-skill-registry.cjs):
  *           `skills` = platform commands/skills, `orgSkills` = Org library
  */
@@ -48,7 +49,9 @@ function norm(s) {
 
 /** Agents from .monomind/registry.json (built by registry-builder.ts), or from
  *  opts.registry (an in-memory build outside a project). The description leads
- *  with the one-line `when_to_use`; deprecated agents drop. */
+ *  with the one-line `when_to_use`; deprecated agents drop. The `vibe`
+ *  personality line is not ranked: its words ("crashes", "segfault") name no
+ *  capability and pulled unrelated tasks to the agent. */
 function loadAgentCatalog(root, opts) {
   var reg = (opts && opts.registry) || readJsonFile(path.join(root, '.monomind', 'registry.json'));
   var list = reg && Array.isArray(reg.agents) ? reg.agents : [];
@@ -60,16 +63,19 @@ function loadAgentCatalog(root, opts) {
     var category = typeof a.category === 'string' ? a.category : '';
     var description = typeof a.description === 'string' ? a.description : '';
     var when = typeof a.whenToUse === 'string' ? a.whenToUse.trim() : '';
-    out.push({
+    var item = {
       id: a.slug,
       name: typeof a.name === 'string' ? a.name : a.slug,
       category: category,
       description: when ? when + (description ? ' — ' + description : '') : description,
       text: [category]
-        .concat(strings(a.tags), strings(a.capabilities), strings(a.taskTypes), typeof a.vibe === 'string' ? [a.vibe] : [])
+        .concat(strings(a.tags), strings(a.capabilities), strings(a.taskTypes))
         .filter(Boolean)
         .join(' '),
-    });
+    };
+    // 'project' | 'user' (~/.claude/agents) | 'extra'; shown by `pick --json`, never sent to the model.
+    if (typeof a.origin === 'string') item.origin = a.origin;
+    out.push(item);
   });
   return out;
 }
@@ -139,11 +145,13 @@ function jevAllowed(gate, s, root) {
 }
 
 /** Platform commands/skills. Command/skill mirrors of one capability collapse,
- *  preferring the slash form. */
+ *  preferring the slash form. An entry whose source file is gone (the index
+ *  predates its removal) is dropped: naming it would fail at invoke time. */
 function platformSkills(root, list, gate) {
   var byKey = new Map();
   list.forEach(function (s) {
     if (!s || typeof s.skill !== 'string' || typeof s.invoke !== 'string') return;
+    if (typeof s.source === 'string' && !fs.existsSync(sourceFile(root, s.source))) return;
     // A catalog projection reaches the decision model only when approved with
     // the jev target; ordinary skills carry no catalog field and are unaffected.
     if (s.catalog && s.catalog.jev !== true) return;

package/.claude/helpers/jev-picker.cjs

@@ -12,7 +12,8 @@
  */
 var redaction = require('./redact-secrets.cjs');
 // Keyword ranking builds the candidate shortlist (and is every caller's fallback).
-var shortlist = require('./pick-rank.cjs').shortlist;
+var pickRank = require('./pick-rank.cjs');
+var shortlist = pickRank.shortlist;
 
 var TYPESAFE_BASE_URL = 'https://api.typesafe.ai';
 var DEFAULT_MODEL = 'jev-latest';
@@ -37,7 +38,10 @@ var NONE_ID = '__none__';
 var OFF_VALUES = ['0', 'off', 'false', 'no'];
 var ON_VALUES = ['1', 'on', 'true', 'yes'];
 var DEFAULT_HOOK_TIMEOUT_MS = 1500;
-var MAX_HOOK_TIMEOUT_MS = 10000;
+// Every prompt waits on the hook window, so a larger value is capped here
+// whatever MONOMIND_JEV_HOOK_TIMEOUT_MS asks: a dead endpoint once held each
+// prompt 10 s. Hosted Jev answers well inside it.
+var MAX_HOOK_TIMEOUT_MS = 3000;
 
 class JevError extends Error {
   constructor(message, provider, status) {
@@ -82,10 +86,11 @@ function resolveTimeoutMs(env) {
   return Number.isInteger(n) && n >= MIN_TIMEOUT_MS && n <= MAX_TIMEOUT_MS ? n : DEFAULT_TIMEOUT_MS;
 }
 
-/** The per-prompt hook's window: short, because every prompt waits on it. */
+/** The per-prompt hook's window: short, because every prompt waits on it.
+ *  Values above MAX_HOOK_TIMEOUT_MS are capped to it. */
 function resolveHookTimeoutMs(env) {
   var n = Number((env || process.env).MONOMIND_JEV_HOOK_TIMEOUT_MS);
-  return Number.isInteger(n) && n >= MIN_TIMEOUT_MS && n <= MAX_HOOK_TIMEOUT_MS ? n : DEFAULT_HOOK_TIMEOUT_MS;
+  return Number.isInteger(n) && n >= MIN_TIMEOUT_MS ? Math.min(n, MAX_HOOK_TIMEOUT_MS) : DEFAULT_HOOK_TIMEOUT_MS;
 }
 
 function resolveMinConfidence(env) {
@@ -281,6 +286,39 @@ function toAnswer(answer, criteria) {
   return { choice: answer.choice, confidence: answer.confidence, ranked: rankedFrom(answer, criteria) };
 }
 
+/** The options sent for one question: the keyword-ranked items that share a
+ *  word with the task (forced `include` ids first), then the rest round-robin
+ *  across categories (an agent's category, else an id's first segment) — so
+ *  a task that matches few or no words (a non-English prompt) is not judged
+ *  over the first `max` entries of one category. */
+function candidatesFor(text, items, max, include) {
+  var forced = new Set(include || []);
+  var out = shortlist(text, items, max, include).filter(function (item) {
+    return item.score > 0 || forced.has(item.id);
+  });
+  if (out.length >= max) return out;
+  var taken = new Set(out.map(function (item) { return item.id; }));
+  var groups = new Map();
+  items.forEach(function (item) {
+    if (taken.has(item.id)) return;
+    var key = item.category || String(item.id).toLowerCase().split(/[-:_/]/)[0];
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(item);
+  });
+  var lists = Array.from(groups.values());
+  for (var round = 0; out.length < max; round++) {
+    var added = false;
+    for (var g = 0; g < lists.length && out.length < max; g++) {
+      if (round < lists[g].length) {
+        out.push(lists[g][round]);
+        added = true;
+      }
+    }
+    if (!added) break;
+  }
+  return out;
+}
+
 /** Pick an agent and/or a skill for `task` in ONE request. null = no decision. */
 async function pick(task, catalogs, opts) {
   opts = opts || {};
@@ -295,14 +333,16 @@ async function pick(task, catalogs, opts) {
   var skills = catalogs && Array.isArray(catalogs.skills) ? catalogs.skills : [];
   var questions = {};
   if (agents.length >= 2) {
+    var agentCriteria = criteriaFor(candidatesFor(text, agents, max, include.agents));
+    agentCriteria[NONE_ID] = 'None of these agents fits the task';
     questions.agent = {
       type: 'choice',
       instructions: opts.agentInstructions || 'Which specialist agent should handle this task?',
-      criteria: criteriaFor(shortlist(text, agents, max, include.agents)),
+      criteria: agentCriteria,
     };
   }
   if (skills.length >= 1) {
-    var skillCriteria = criteriaFor(shortlist(text, skills, max, include.skills));
+    var skillCriteria = criteriaFor(candidatesFor(text, skills, max, include.skills));
     skillCriteria[NONE_ID] = 'None of these skills fits the task';
     questions.skill = {
       type: 'choice',
@@ -325,9 +365,10 @@ async function pick(task, catalogs, opts) {
   return out;
 }
 
-/** `minConfidence` overrides the automatic-decision floor for this call. */
+/** `minConfidence` overrides the automatic-decision floor for this call.
+ *  "None fits" is never an agent. */
 function acceptAgent(answer, env, minConfidence) {
-  if (!answer) return null;
+  if (!answer || answer.choice === NONE_ID) return null;
   return answer.confidence >= floorFor(env, minConfidence) ? answer.choice : null;
 }
 
@@ -380,6 +421,9 @@ module.exports = {
   ask: ask,
   probe: probe,
   shortlist: shortlist,
+  withoutExclusions: pickRank.withoutExclusions,
+  KEYWORD_GATE: pickRank.KEYWORD_GATE,
+  leads: pickRank.leads,
   pick: pick,
   acceptAgent: acceptAgent,
   acceptSkills: acceptSkills,

package/.claude/helpers/pick-rank.cjs

@@ -13,6 +13,26 @@
  * the item matches. An item marked `pick: 'low'` (admin/meta skills, from
  * `pick: low` frontmatter) keeps LOW_PICK_FACTOR of its score, so it surfaces
  * only when the task names it. Equal scores keep catalog order.
+ *
+ * Exclusions in the task (English only): words the task explicitly
+ * rules out do not count ("anything pending rather than release" must not
+ * pick release-manager). withoutExclusions() drops each cue and the words in
+ * its scope before tokenizing. Cues: "rather than", "other than", "instead
+ * of", "apart from", "aside from", "except", "besides", "excluding",
+ * "without", "not", "no", "nor", "don't"/"dont". The scope ends at clause
+ * punctuation (. , ; : ! ? brackets, dashes), at "but"/"then"/"so", at
+ * "and" once a word was dropped ("or"/"nor" keep excluding: "without CI or
+ * staging"), or after SCOPE_WORDS content words. Problem descriptions are not
+ * exclusions: "not"/"no" after a copula or auxiliary ("is not loading",
+ * "are no tests", "does not"), "not only", and "don't know/see/get/..." stay.
+ *
+ * Exclusions on the document side (English only): a description's own
+ * "not for X" / "never for X" / "do not use for X" clause names work the item
+ * is NOT for. Its words leave the item's index unless the rest of the
+ * description uses them too, so "Not for pull requests" no longer matches
+ * "pull request". A task that names what a "not for" clause rules out (more
+ * than half the words of one of its alternatives, at least one of them a word
+ * the item does not otherwise carry) keeps EXCLUDED_FACTOR of its score.
  */
 
 var K1 = 1.2;
@@ -23,13 +43,15 @@ var STRONG_WEIGHT = 2;
 var PREFIX_MIN_SHARED = 3;
 // Share of its score a `pick: 'low'` item keeps.
 var LOW_PICK_FACTOR = 0.35;
+// Share of its score an item keeps when the task names what it is not for.
+var EXCLUDED_FACTOR = 0.2;
 
 var STOPWORDS = new Set(
   (
-    'a about above after again against all also am an and any are as at be because been before being below ' +
-    'between both but by can could did do does doing down during each etc every few for from further had has ' +
+    'a about above after again against all also am an and any anything are as at be because been before being below ' +
+    'between both but by can could did do does doing down during each else etc every everything few for from further had has ' +
     'have having he her here hers him his how i if in into is it its itself just me more most must my no nor ' +
-    'not now of off on once only or other our ours out over own per please same she should so some such than ' +
+    'not nothing now of off on once only or other our ours out over own per please same she should so some something such than ' +
     'that the their theirs them then there these they this those through to too under until up upon us very ' +
     'via was we were what when where which while who whom why will with within without would you your yours'
   ).split(' '),
@@ -111,6 +133,111 @@ function tokens(text) {
   return words(text).filter(isContent).map(stem);
 }
 
+// Content words an exclusion cue rules out at most.
+var SCOPE_WORDS = 4;
+var CLAUSE_SPLIT = /[.,;:!?()[\]{}<>|\n\r\u2013\u2014]+|\s-+\s/;
+var SINGLE_CUES = new Set('except besides excluding without not no nor dont'.split(' '));
+var PAIR_CUES = { rather: 'than', other: 'than', instead: 'of', apart: 'from', aside: 'from', don: 't' };
+// "is not loading", "are no tests", "does not work": a description, not an exclusion.
+var DESCRIBES = new Set(
+  ('am is are was were be been being does did has have had can could will would get gets got ' +
+    'isn aren wasn weren doesn didn hasn haven hadn won wouldn couldn there').split(' '),
+);
+// "don't know why the build fails" describes a problem too.
+var DONT_DESCRIBES = new Set('know understand see get think remember why how'.split(' '));
+var SCOPE_ENDS = new Set('but then so'.split(' '));
+
+/** Words the cue at ws[i] spans (0: no cue there). */
+function cueAt(ws, i) {
+  var w = ws[i];
+  var next = ws[i + 1];
+  if (PAIR_CUES[w] && next === PAIR_CUES[w]) {
+    if (w === 'don' && DONT_DESCRIBES.has(ws[i + 2])) return 0;
+    return 2;
+  }
+  if (!SINGLE_CUES.has(w)) return 0;
+  if ((w === 'dont' || (w === 'not' && ws[i - 1] === 'do')) && DONT_DESCRIBES.has(next)) return 0;
+  if ((w === 'not' || w === 'no') && (DESCRIBES.has(ws[i - 1]) || next === 'only')) return 0;
+  return 1;
+}
+
+/** `text` minus the exclusion cues and the words they rule out (see the file
+ *  header), clause breaks kept as ". ". Lowercased; a text without cues keeps
+ *  every word. */
+function withoutExclusions(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/\u2019/g, "'")
+    .split(CLAUSE_SPLIT)
+    .map(function (clause) {
+      var ws = clause.match(/[\p{L}\p{N}]+/gu) || [];
+      var out = [];
+      var left = 0;
+      var dropped = 0;
+      for (var i = 0; i < ws.length; i++) {
+        var n = cueAt(ws, i);
+        if (n) {
+          i += n - 1;
+          left = SCOPE_WORDS;
+          dropped = 0;
+          continue;
+        }
+        var w = ws[i];
+        if (left > 0) {
+          if (SCOPE_ENDS.has(w) || (w === 'and' && dropped > 0)) left = 0;
+          else {
+            if (isContent(w)) {
+              left--;
+              dropped++;
+            }
+            continue;
+          }
+        }
+        out.push(w);
+      }
+      return out.join(' ');
+    })
+    .join('. ');
+}
+
+/** tokens() of a task: the words it rules out dropped first. */
+function queryTokens(text) {
+  return tokens(withoutExclusions(text));
+}
+
+// A description clause: sentence punctuation, brackets or dashes end it.
+var DOC_CLAUSE_SPLIT = /[.;:!?()[\]{}<>|\n\r\u2013\u2014]+|\s-+\s/;
+var DOC_NOT_FOR = /\b(?:not|never)\s+(?:intended\s+|meant\s+)?for\s+(.+)$|\b(?:do\s+not|don't|dont|never)\s+use\s+(?:it\s+|this\s+)?for\s+(.+)$/;
+var DOC_ALTERNATIVES = /,|\s(?:or|and|nor)\s/;
+
+/** A description's own exclusions (see the file header): `kept` is the text
+ *  without its "not for" clauses, `ruledOut` the word lists of each
+ *  alternative a "not for" clause names, `dropped` every word those clauses
+ *  hold. */
+function docExclusions(description) {
+  var kept = [];
+  var ruledOut = [];
+  var dropped = [];
+  String(description || '')
+    .toLowerCase()
+    .replace(/\u2019/g, "'")
+    .split(DOC_CLAUSE_SPLIT)
+    .forEach(function (clause) {
+      var m = DOC_NOT_FOR.exec(clause);
+      if (m) {
+        kept.push(clause.slice(0, m.index));
+        (m[1] || m[2]).split(DOC_ALTERNATIVES).forEach(function (alt) {
+          var t = tokens(alt);
+          if (t.length) ruledOut.push(t);
+        });
+        dropped.push(m[1] || m[2]);
+        return;
+      }
+      kept.push(clause);
+    });
+  return { kept: kept.join(' . '), ruledOut: ruledOut, dropped: new Set(tokens(dropped.join(' '))) };
+}
+
 /** Leading id segments ("engineering-", "mastermind:", "analysis:") that are
  *  shared by >= PREFIX_MIN_SHARED ids or equal the item's category. */
 function categoryPrefixes(items) {
@@ -150,13 +277,26 @@ function indexFor(items) {
   var total = 0;
   var docs = items.map(function (item) {
     var strong = strongTerms(item, isPrefix);
-    var weakList = tokens((item.description || '') + ' ' + (item.text || ''));
+    var ex = docExclusions(item.description);
+    var keptList = tokens(ex.kept);
+    var own = new Set(keptList);
+    // `text` repeats description words (derived keywords): a word only an
+    // exclusion clause holds leaves it too.
+    var weakList = keptList.concat(tokens(item.text || '').filter(function (t) {
+      return own.has(t) || !ex.dropped.has(t);
+    }));
     var weak = termCounts(weakList);
     new Set(Array.from(strong).concat(Array.from(weak.keys()))).forEach(function (t) {
       df.set(t, (df.get(t) || 0) + 1);
     });
     total += weakList.length;
-    return { strong: strong, weak: weak, len: weakList.length, low: item.pick === 'low' };
+    // Each "not for" alternative, with the words it names beyond the item's own.
+    var ruledOut = ex.ruledOut
+      .map(function (alt) {
+        return { all: alt, own: alt.filter(function (t) { return strong.has(t) || weak.has(t); }) };
+      })
+      .filter(function (alt) { return alt.own.length < alt.all.length; });
+    return { strong: strong, weak: weak, len: weakList.length, low: item.pick === 'low', ruledOut: ruledOut };
   });
   return { size: items.length, docs: docs, df: df, avg: total / items.length || 1 };
 }
@@ -166,6 +306,16 @@ function idf(index, term) {
   return Math.log(1 + (index.size - n + 0.5) / (n + 0.5));
 }
 
+/** True when the task names more than half of the words of one of the
+ *  item's "not for" alternatives, one of them a word the item does not
+ *  otherwise carry. */
+function namesRuledOut(doc, query) {
+  return doc.ruledOut.some(function (alt) {
+    var hits = alt.all.filter(function (t) { return query.indexOf(t) !== -1; });
+    return hits.length * 2 > alt.all.length && hits.some(function (t) { return alt.own.indexOf(t) === -1; });
+  });
+}
+
 function scoreDoc(index, doc, query) {
   var score = 0;
   var matched = 0;
@@ -182,6 +332,7 @@ function scoreDoc(index, doc, query) {
   // Coordination: an item matching more of the task's words ranks higher.
   if (query.length) score *= matched / query.length;
   if (doc.low) score *= LOW_PICK_FACTOR;
+  if (namesRuledOut(doc, query)) score *= EXCLUDED_FACTOR;
   return Math.round(score * 1000) / 1000;
 }
 
@@ -190,7 +341,7 @@ function scoreDoc(index, doc, query) {
  *  overlap). Equal scores keep catalog order. */
 function shortlist(query, items, limit, include) {
   var index = indexFor(items);
-  var q = Array.from(new Set(tokens(query)));
+  var q = Array.from(new Set(queryTokens(query)));
   var scored = items.map(function (item, i) {
     return { item: item, index: i, score: scoreDoc(index, index.docs[i], q) };
   });
@@ -214,8 +365,35 @@ function shortlist(query, items, limit, include) {
   return out;
 }
 
+// The bar a keyword pick must clear before anything acts on it (the prompt
+// hook's [PICK] line, `pick`'s summary and `confident` flag): a minimum
+// relevance AND a lead over the runner-up. Ties and weak overlap are no
+// decision — a wrong pick in Claude's context costs more than none. Agents
+// were tuned on the 40-task pick benchmark (25/40 shown, 23 correct), skills
+// on tests/pick-eval (59 tasks, 514 skills: 34 shown, 31 correct).
+var KEYWORD_GATE = {
+  agents: { min: 2, lead: 1.5 },
+  skills: { min: 3, lead: 1.25 },
+};
+
+/** The top of a ranked list when it clears `min` and leads the runner-up by
+ *  `ratio`, else null. The floor is on keyword relevance alone (`baseScore`
+ *  when an outcome prior re-ranked). */
+function leads(list, min, ratio) {
+  var top = list && list[0];
+  if (!top || !((top.baseScore !== undefined ? top.baseScore : top.score) >= min)) return null;
+  var second = list[1];
+  if (!second || !(second.score > 0)) return top;
+  return top.score >= second.score * (ratio || 1) && top.score > second.score ? top : null;
+}
+
 module.exports = {
+  KEYWORD_GATE: KEYWORD_GATE,
+  leads: leads,
   stem: stem,
   tokens: tokens,
+  queryTokens: queryTokens,
+  withoutExclusions: withoutExclusions,
+  docExclusions: docExclusions,
   shortlist: shortlist,
 };

package/.claude/helpers/pick-stats.cjs

@@ -17,6 +17,13 @@
  * watermark beyond the ones already counted there. Nothing here
  * throws to a hook: update() returns null on any failure.
  *
+ * Adherence is a route's, not a spawn's: a route counts as followed once, at
+ * its first spawn of the picked agent (an override counted for an earlier
+ * spawn of that route is taken back), and as overridden once otherwise.
+ * Slash-command routes are not picks. When .monomind/registry.json is
+ * readable only its agents are tracked (other subagent_types, e.g. "issue-337",
+ * never enter the stats, and stored ones are dropped).
+ *
  * The prior: an agent with >= MIN_OBS observations gets a factor in
  * [1 - SPAN, 1 + SPAN] from Beta(1,1)-smoothed success and adoption rates. It
  * multiplies a keyword score, so a zero-overlap item stays at zero, and the
@@ -41,6 +48,10 @@ var MAX_ENTRIES = 300;
 var MAX_EDGE_KEYS = 50;
 var MIN_OBS = 5;
 var SPAN = 0.15;
+// Routes whose adherence is remembered (followed / overridden / a command).
+var MAX_ROUTE_STATES = 500;
+// A prompt that is a slash command (the route hook's rule): not a pick.
+var COMMAND_PROMPT = /^\/[a-z0-9_-]+(:[a-z0-9_-]+)*(\s|$)/i;
 
 function emptyStats() {
   return {
@@ -61,6 +72,7 @@ function emptyStats() {
     },
     agents: {},
     skills: {},
+    routeStates: {},
   };
 }
 
@@ -109,6 +121,17 @@ function load(root) {
         if (isObject(s.skills[k])) out.skills[k] = { recommended: count(s.skills[k].recommended) };
       });
     }
+    if (isObject(s.routeStates)) {
+      Object.keys(s.routeStates).slice(-MAX_ROUTE_STATES).forEach(function (k) {
+        var r = s.routeStates[k];
+        if (!isObject(r)) return;
+        var st = {};
+        if (r.c === 1) st.c = 1;
+        if (r.f === 1) st.f = 1;
+        if (typeof r.o === 'string') st.o = r.o.slice(0, 128);
+        out.routeStates[String(k).slice(0, 128)] = st;
+      });
+    }
     return out;
   } catch (e) {
     return emptyStats();
@@ -230,9 +253,30 @@ function readNew(file, cursor) {
 
 // ── Aggregation ─────────────────────────────────────────────────────────────
 
+/** normName()s of every agent name and slug in .monomind/registry.json, or
+ *  null when it cannot be read (then nothing is filtered). */
+function registryNames(root) {
+  try {
+    var file = path.join(root, '.monomind', 'registry.json');
+    if (fs.statSync(file).size > 5 * 1024 * 1024) return null;
+    var reg = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    if (!reg || !Array.isArray(reg.agents)) return null;
+    var names = new Set();
+    reg.agents.forEach(function (a) {
+      if (!a) return;
+      if (typeof a.name === 'string') names.add(normName(a.name));
+      if (typeof a.slug === 'string') names.add(normName(a.slug));
+    });
+    return names;
+  } catch (e) {
+    return null;
+  }
+}
+
 function agentEntry(stats, name) {
   var key = normName(name);
   if (!key) return null;
+  if (stats._known && !stats._known.has(key)) return null;
   if (!stats.agents[key]) {
     stats.agents[key] = { name: String(name).slice(0, 128), recommended: 0, followed: 0, overridden: 0, chosen: 0, success: 0, failure: 0 };
   }
@@ -246,7 +290,26 @@ function skillEntry(stats, invoke) {
   return stats.skills[key];
 }
 
+/** This route's remembered adherence (created on demand; oldest dropped). */
+function routeState(stats, routeId) {
+  var id = String(routeId).slice(0, 128);
+  var st = stats.routeStates[id];
+  if (st) return st;
+  st = stats.routeStates[id] = {};
+  var ids = Object.keys(stats.routeStates);
+  for (var i = 0; i < ids.length - MAX_ROUTE_STATES; i++) delete stats.routeStates[ids[i]];
+  return st;
+}
+
+function dec(obj, key) {
+  if (obj && obj[key] > 0) obj[key]--;
+}
+
 function addRoute(stats, rec) {
+  if (COMMAND_PROMPT.test(String(rec.promptPreview || rec.task || '').trim())) {
+    if (rec.routeId) routeState(stats, rec.routeId).c = 1;
+    return;
+  }
   stats.totals.routes++;
   if (!rec.shown) return;
   stats.totals.shown++;
@@ -258,16 +321,30 @@ function addRoute(stats, rec) {
 
 function addAdherence(stats, rec) {
   stats.totals.spawns++;
-  if (!rec.recommended) { stats.totals.unpicked++; return; }
+  var st = rec.routeId ? routeState(stats, rec.routeId) : null;
+  if (!rec.recommended || (st && st.c)) { stats.totals.unpicked++; return; }
   var rec1 = agentEntry(stats, rec.recommended);
   if (rec.followed === true) {
+    if (st && st.f) return;
+    if (st && st.o !== undefined) {
+      // An earlier spawn of this route was counted as an override: the
+      // route was followed after all.
+      dec(stats.totals, 'overridden');
+      dec(rec1, 'overridden');
+      if (st.o) dec(stats.agents[st.o], 'chosen');
+      delete st.o;
+    }
     stats.totals.followed++;
     if (rec1) rec1.followed++;
+    if (st) st.f = 1;
   } else if (rec.followed === false) {
+    if (st && (st.f || st.o !== undefined)) return;
     stats.totals.overridden++;
     if (rec1) rec1.overridden++;
     var actual = rec.actual ? agentEntry(stats, rec.actual) : null;
-    if (actual && actual !== rec1) actual.chosen++;
+    var chosen = actual && actual !== rec1;
+    if (chosen) actual.chosen++;
+    if (st) st.o = chosen ? normName(rec.actual) : '';
   }
 }
 
@@ -303,6 +380,13 @@ function update(root, opts) {
     var persist = !opts || opts.persist !== false;
     var stats = load(root);
     var dir = path.join(root, '.monomind');
+    var known = registryNames(root);
+    Object.defineProperty(stats, '_known', { value: known, enumerable: false });
+    if (known) {
+      Object.keys(stats.agents).forEach(function (k) {
+        if (!known.has(k)) delete stats.agents[k];
+      });
+    }
     var adders = { routes: addRoute, adherence: addAdherence, feedback: addFeedback };
     Object.keys(SOURCES).forEach(function (src) {
       var got = readNew(path.join(dir, SOURCES[src]), stats.cursors[src]);

package/.claude/skills/agentic-jujutsu/SKILL.md

@@ -165,7 +165,7 @@ const key = crypto.randomBytes(32).toString('base64');
 jj.enableEncryption(key);
 ```
 
-### 6. Operation Tracking with LanceDB
+### 6. Operation Tracking
 
 Automatic tracking of all operations:
 
@@ -396,7 +396,7 @@ for (let i = 1; i <= 10; i++) {
 | `queryTrajectories(task, limit)` | Find similar trajectories | JSON: Trajectory[] |
 | `resetLearning()` | Clear learned data | void |
 
-### LanceDB Methods
+### Operation Log Methods
 
 | Method | Description | Returns |
 |--------|-------------|---------|
@@ -630,7 +630,6 @@ async function agentSwarm(taskList) {
 - **GitHub**: https://github.com/monoes/monomind
 - **Full README**: See package README.md
 - **Validation Guide**: docs/VALIDATION_FIXES_v2.3.1.md
-- **LanceDB Guide**: docs/LANCEDB_GUIDE.md
 
 ## Version History
 

package/.claude/skills/github-toolkit/SKILL.md

@@ -5,7 +5,7 @@ description: >
   repo structure, and multi-package sync. Trigger on "open a PR", "manage
   issues", "cut a release", "sync packages", or any GitHub Actions/repo
   automation request. All GitHub operations use the `gh` CLI plus monomind's
-  MCP GitHub tools — there is no `monomind github` CLI command group.
+  MCP GitHub tools — the `monomind` CLI has no `github` command group.
 ---
 
 # GitHub Toolkit