@monoes/monomindcli 2.16.4 → 2.16.5

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

@@ -38,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) {
@@ -83,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) {
@@ -282,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 || {};
@@ -296,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',
@@ -326,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;
 }
 
@@ -382,6 +422,8 @@ module.exports = {
   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

@@ -14,7 +14,7 @@
  * `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 (English only, query side only): words the task explicitly
+ * 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
@@ -25,6 +25,14 @@
  * 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;
@@ -35,6 +43,8 @@ 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(
   (
@@ -195,6 +205,39 @@ 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) {
@@ -234,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 };
 }
@@ -250,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;
@@ -266,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;
 }
 
@@ -298,10 +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