@monoes/monomindcli 2.16.2 → 2.16.3

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

@@ -0,0 +1,225 @@
+'use strict';
+/**
+ * Candidate catalogs for the Jev picker — ONE implementation shared by the
+ * 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)
+ *   skills  .claude/helpers/skill-registry.json (build-skill-registry.cjs):
+ *           `skills` = platform commands/skills, `orgSkills` = Org library
+ */
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+
+var MAX_CATALOG_BYTES = 5 * 1024 * 1024;
+
+/** Org skills that duplicate a platform skill under another name: the
+ *  platform one (directly invokable) is kept. Keys and values are norm()ed. */
+var ORG_ALIASES = {
+  'architecture-decision-records': 'mastermind-adr',
+  'release-manager': 'mastermind-release',
+  'using-git-worktrees': 'mastermind-worktree',
+  'systematic-debugging': 'mastermind-debug',
+  'writing-plans': 'mastermind-plan',
+  'receiving-code-review': 'mastermind-receive-review',
+};
+
+function readJsonFile(file) {
+  try {
+    if (!fs.existsSync(file) || fs.statSync(file).size > MAX_CATALOG_BYTES) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function strings(list) {
+  return (Array.isArray(list) ? list : []).filter(function (s) {
+    return typeof s === 'string';
+  });
+}
+
+/** Lowercase, every non-alphanumeric run a single '-': "mastermind:plan",
+ *  "mastermind_plan" and "Mastermind Plan" all meet. */
+function norm(s) {
+  return String(s || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+
+/** 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. */
+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 : [];
+  var out = [];
+  var seen = new Set();
+  list.forEach(function (a) {
+    if (!a || typeof a.slug !== 'string' || a.deprecated === true || seen.has(a.slug)) return;
+    seen.add(a.slug);
+    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({
+      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] : [])
+        .filter(Boolean)
+        .join(' '),
+    });
+  });
+  return out;
+}
+
+/** .monomind/catalog/state.json as { ok, entries } (entries maps a catalog id
+ *  to its state entry); null without a state file. */
+function catalogJevGate(root) {
+  var file = path.join(root, '.monomind', 'catalog', 'state.json');
+  if (!fs.existsSync(file)) return null;
+  var state = readJsonFile(file);
+  var gate = { ok: !!state && Array.isArray(state.entries), entries: new Map() };
+  (gate.ok ? state.entries : []).forEach(function (e) {
+    if (e && typeof e.id === 'string') gate.entries.set(e.id, e);
+  });
+  return gate;
+}
+
+/** A registry `source` as a file path: `~/…` (user skills) under the home
+ *  directory, anything else under the project root. */
+function sourceFile(root, source) {
+  if (typeof source !== 'string') return '';
+  if (source === '~' || source.indexOf('~/') === 0) return path.join(os.homedir(), source.slice(1));
+  return path.resolve(root, source);
+}
+
+/** True when the indexed file carries a catalog projection block. Only files
+ *  inside the project or ~/.claude/skills are read. */
+function isProjectedCopy(root, source) {
+  var file = sourceFile(root, source);
+  var inside = [path.resolve(root), path.join(os.homedir(), '.claude', 'skills')].some(function (dir) {
+    return file.indexOf(dir + path.sep) === 0;
+  });
+  if (!inside) return false;
+  try {
+    if (fs.statSync(file).size > MAX_CATALOG_BYTES) return false;
+    return fs.readFileSync(file, 'utf-8').indexOf('monomind:start catalog:skill:') !== -1;
+  } catch (e) {
+    return false;
+  }
+}
+
+function activeForJev(e) {
+  return !!e && e.status === 'active' && Array.isArray(e.targets) && e.targets.indexOf('jev') !== -1;
+}
+
+/** The package a state entry names still hashes to its recorded digest (the
+ *  same egress check as catalogs.ts jevVisible). */
+function packageVerifies(root, e) {
+  try {
+    return !!require('./org-skill-index.cjs').verifyCatalogPackage(root, e);
+  } catch (err) {
+    return false;
+  }
+}
+
+/** The catalog state decides, never the forgeable projection marker: a skill
+ *  that is a catalog projection (a `catalog` field, or a projection block in
+ *  its file for an index from an old builder) is sent only while this
+ *  project's state.json parses, lists it active with the `jev` target, and its
+ *  package verifies. Missing or unreadable state drops every such skill (fail
+ *  closed). Skills that are not projections are unaffected. */
+function jevAllowed(gate, s, root) {
+  if (!s.catalog && !isProjectedCopy(root, s.source)) return true;
+  var id = s.catalog ? String(s.catalog.id) : 'skill:' + s.skill;
+  var e = gate && gate.ok ? gate.entries.get(id) : null;
+  return activeForJev(e) && packageVerifies(root, e);
+}
+
+/** Platform commands/skills. Command/skill mirrors of one capability collapse,
+ *  preferring the slash form. */
+function platformSkills(root, list, gate) {
+  var byKey = new Map();
+  list.forEach(function (s) {
+    if (!s || typeof s.skill !== 'string' || typeof s.invoke !== 'string') 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;
+    if (!jevAllowed(gate, s, root)) return;
+    var key = s.skill.toLowerCase().replace(/[:_]/g, '-');
+    var prev = byKey.get(key);
+    if (prev && !(s.invoke.charAt(0) === '/' && prev.invoke.charAt(0) !== '/')) return;
+    var item = {
+      id: s.skill,
+      invoke: s.invoke,
+      description: typeof s.description === 'string' ? s.description : '',
+      text: strings(s.nameTerms).concat(strings(s.keywords)).join(' '),
+      source: 'platform',
+    };
+    // Admin/meta entries (frontmatter `pick: low`) rank below equal matches.
+    if (s.pick === 'low') item.pick = 'low';
+    byKey.set(key, item);
+  });
+  return Array.from(byKey.values());
+}
+
+/** A catalog Org skill leaves the machine only while its state entry is active
+ *  with the jev target, names the indexed package, and that package verifies
+ *  now (the same egress check as catalogs.ts jevVisible). */
+function catalogOrgAllowed(root, gate, s) {
+  var e = gate && gate.ok ? gate.entries.get(s.catalogId) : null;
+  return activeForJev(e) && e.sha256 === s.sha256 && packageVerifies(root, e);
+}
+
+/** Org-library skills that are not a platform skill by name or known alias,
+ *  and not an agent (an Org skill named after an agent duplicates it). */
+function orgSkills(root, list, taken, gate) {
+  var out = [];
+  var seen = new Set();
+  list.forEach(function (s) {
+    if (!s || typeof s.name !== 'string' || seen.has(s.name)) return;
+    var key = norm(s.name);
+    if (taken.has(key) || (ORG_ALIASES[key] && taken.has(ORG_ALIASES[key]))) return;
+    if (s.origin === 'catalog' && !catalogOrgAllowed(root, gate, s)) return;
+    seen.add(s.name);
+    out.push({
+      id: s.name,
+      description: typeof s.description === 'string' ? s.description : '',
+      text: strings(s.tags).join(' '),
+      source: 'org',
+      invoke: 'mcp__monomind__org_skill_show ' + JSON.stringify({ name: s.name }),
+    });
+  });
+  return out;
+}
+
+/**
+ * Every skill a task can use, as one list: platform skills (directly
+ * invokable) first, then Org-library skills (read with the org_skill_show MCP
+ * tool, or `npx -y monomind org skills show <name>`). opts.index: an
+ * already-built index object (the CLI passes the one it just refreshed);
+ * otherwise the file is read. opts.registry: the agent
+ * registry to dedupe against (see loadAgentCatalog).
+ */
+function loadSkillCatalog(root, opts) {
+  var reg = (opts && opts.index) || readJsonFile(path.join(root, '.claude', 'helpers', 'skill-registry.json'));
+  var gate = catalogJevGate(root);
+  var platform = platformSkills(root, reg && Array.isArray(reg.skills) ? reg.skills : [], gate);
+  var taken = new Set();
+  platform.forEach(function (s) { taken.add(norm(s.id)); });
+  loadAgentCatalog(root, opts).forEach(function (a) {
+    taken.add(norm(a.id));
+    taken.add(norm(a.name));
+  });
+  return platform.concat(orgSkills(root, reg && Array.isArray(reg.orgSkills) ? reg.orgSkills : [], taken, gate));
+}
+
+module.exports = {
+  ORG_ALIASES: ORG_ALIASES,
+  norm: norm,
+  loadAgentCatalog: loadAgentCatalog,
+  loadSkillCatalog: loadSkillCatalog,
+  catalogJevGate: catalogJevGate,
+};

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

@@ -10,9 +10,9 @@
  * 3000). Nothing configured → no network, and pick() resolves null so every
  * caller keeps its existing routing.
  */
-var fs = require('fs');
-var path = require('path');
 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 TYPESAFE_BASE_URL = 'https://api.typesafe.ai';
 var DEFAULT_MODEL = 'jev-latest';
@@ -20,7 +20,12 @@ var DEFAULT_TIMEOUT_MS = 3000;
 var MIN_TIMEOUT_MS = 100;
 var MAX_TIMEOUT_MS = 30000;
 var MIN_PROVIDER_WINDOW_MS = 50;
+// Automatic decisions (hook injection, org auto-assign) act only above this.
 var DEFAULT_MIN_CONFIDENCE = 0.6;
+// A ranking shown to a person (`monomind pick`) keeps Jev's answer down to
+// this, flagged low-confidence below DEFAULT_MIN_CONFIDENCE. On the 60-task
+// pick benchmark every answer at >= 0.35 was right and the one under 0.2 wrong.
+var DEFAULT_PICK_MIN_CONFIDENCE = 0.25;
 var MIN_EXTRA_SKILL_PROBABILITY = 0.2;
 var DEFAULT_MAX_SKILLS = 3;
 // OpenJev scores up to 52 options per pass; 30 (+ "none") keeps one pass.
@@ -28,7 +33,6 @@ var DEFAULT_MAX_CANDIDATES = 30;
 var MAX_DESCRIPTION_CHARS = 160;
 var MAX_STATE_CHARS = 8000;
 var MAX_RESPONSE_CHARS = 1024 * 1024;
-var MAX_CATALOG_BYTES = 5 * 1024 * 1024;
 var NONE_ID = '__none__';
 var OFF_VALUES = ['0', 'off', 'false', 'no'];
 var ON_VALUES = ['1', 'on', 'true', 'yes'];
@@ -89,6 +93,17 @@ function resolveMinConfidence(env) {
   return n > 0 && n <= 1 ? n : DEFAULT_MIN_CONFIDENCE;
 }
 
+/** The floor for rankings a person reads (MONOMIND_JEV_PICK_MIN_CONFIDENCE). */
+function resolvePickMinConfidence(env) {
+  var n = Number((env || process.env).MONOMIND_JEV_PICK_MIN_CONFIDENCE);
+  return n > 0 && n <= 1 ? n : DEFAULT_PICK_MIN_CONFIDENCE;
+}
+
+/** An explicit floor in (0, 1] wins; otherwise the automatic-decision floor. */
+function floorFor(env, minConfidence) {
+  return minConfidence > 0 && minConfidence <= 1 ? minConfidence : resolveMinConfidence(env);
+}
+
 /** Shorthand properties keep a key variable out of `apiKey: <expr>` shapes,
  *  which the repo's git pre-commit secret gate rejects. */
 function makeProvider(name, baseUrl, apiKey, model) {
@@ -229,52 +244,6 @@ async function probe(provider, opts) {
   return Date.now() - started;
 }
 
-// ── Candidate shortlist ────────────────────────────────────────────────────
-
-function stem(tok) {
-  if (tok.length > 4 && tok.slice(-3) === 'ies') return tok.slice(0, -3) + 'y';
-  if (tok.length > 3 && tok.slice(-1) === 's' && tok.slice(-2) !== 'ss') return tok.slice(0, -1);
-  return tok;
-}
-
-function tokens(text) {
-  return (String(text || '').toLowerCase().match(/[a-z0-9]+/g) || []).map(stem);
-}
-
-/** Items ranked by word overlap with the query (id/name words count 3, other
- *  text 1), forced ids first, capped at `limit`. Stable for equal scores. */
-function shortlist(query, items, limit, include) {
-  var q = Array.from(new Set(tokens(query)));
-  var scored = items.map(function (item, index) {
-    var strong = new Set(tokens(item.id + ' ' + (item.name || '')));
-    var weak = new Set(tokens((item.description || '') + ' ' + (item.text || '')));
-    var score = 0;
-    for (var i = 0; i < q.length; i++) {
-      if (strong.has(q[i])) score += 3;
-      else if (weak.has(q[i])) score += 1;
-    }
-    return { item: item, index: index, score: score };
-  });
-  scored.sort(function (a, b) {
-    return b.score - a.score || a.index - b.index;
-  });
-  var out = [];
-  var seen = new Set();
-  function take(entry) {
-    if (seen.has(entry.item.id) || out.length >= limit) return;
-    seen.add(entry.item.id);
-    out.push(Object.assign({}, entry.item, { score: entry.score }));
-  }
-  (include || []).forEach(function (id) {
-    var hit = scored.find(function (s) {
-      return s.item.id === id;
-    });
-    if (hit) take(hit);
-  });
-  scored.forEach(take);
-  return out;
-}
-
 // ── Picking ────────────────────────────────────────────────────────────────
 
 function describeItem(item) {
@@ -356,13 +325,14 @@ async function pick(task, catalogs, opts) {
   return out;
 }
 
-function acceptAgent(answer, env) {
+/** `minConfidence` overrides the automatic-decision floor for this call. */
+function acceptAgent(answer, env, minConfidence) {
   if (!answer) return null;
-  return answer.confidence >= resolveMinConfidence(env) ? answer.choice : null;
+  return answer.confidence >= floorFor(env, minConfidence) ? answer.choice : null;
 }
 
-function acceptSkills(answer, env, max) {
-  if (!answer || answer.choice === NONE_ID || answer.confidence < resolveMinConfidence(env)) return [];
+function acceptSkills(answer, env, max, minConfidence) {
+  if (!answer || answer.choice === NONE_ID || answer.confidence < floorFor(env, minConfidence)) return [];
   var limit = max || DEFAULT_MAX_SKILLS;
   var out = [answer.choice];
   for (var i = 0; i < answer.ranked.length && out.length < limit; i++) {
@@ -375,104 +345,22 @@ function acceptSkills(answer, env, max) {
 }
 
 // ── Catalogs ───────────────────────────────────────────────────────────────
-
-function readJsonFile(file) {
-  try {
-    if (!fs.existsSync(file) || fs.statSync(file).size > MAX_CATALOG_BYTES) return null;
-    return JSON.parse(fs.readFileSync(file, 'utf-8'));
-  } catch (e) {
-    return null;
-  }
+// The loaders live in jev-catalog.cjs, shared with the CLI. Without it (a
+// half-installed helpers dir) the catalogs are empty and routing stays keyword.
+
+var catalog = null;
+try {
+  catalog = require('./jev-catalog.cjs');
+} catch (e) {
+  catalog = null;
 }
 
-function strings(list) {
-  return (Array.isArray(list) ? list : []).filter(function (s) {
-    return typeof s === 'string';
-  });
+function loadAgentCatalog(root, opts) {
+  return catalog ? catalog.loadAgentCatalog(root, opts) : [];
 }
 
-/** Agents from .monomind/registry.json (built by registry-builder.ts). */
-function loadAgentCatalog(root) {
-  var reg = readJsonFile(path.join(root, '.monomind', 'registry.json'));
-  var list = reg && Array.isArray(reg.agents) ? reg.agents : [];
-  var out = [];
-  var seen = new Set();
-  list.forEach(function (a) {
-    if (!a || typeof a.slug !== 'string' || a.deprecated === true || seen.has(a.slug)) return;
-    seen.add(a.slug);
-    var category = typeof a.category === 'string' ? a.category : '';
-    out.push({
-      id: a.slug,
-      name: typeof a.name === 'string' ? a.name : a.slug,
-      category: category,
-      description: typeof a.description === 'string' ? a.description : '',
-      text: [category].concat(strings(a.capabilities), strings(a.taskTypes)).filter(Boolean).join(' '),
-    });
-  });
-  return out;
-}
-
-/** .monomind/catalog/state.json as { ok, known, allowed } skill-name sets, where
- *  allowed = active with the jev target; null when there is no state file. */
-function catalogJevGate(root) {
-  var file = path.join(root, '.monomind', 'catalog', 'state.json');
-  if (!fs.existsSync(file)) return null;
-  var state = readJsonFile(file);
-  var gate = { ok: !!state && Array.isArray(state.entries), known: new Set(), allowed: new Set() };
-  (gate.ok ? state.entries : []).forEach(function (e) {
-    if (!e || typeof e.id !== 'string' || e.id.indexOf('skill:') !== 0) return;
-    gate.known.add(e.id.slice(6));
-    if (e.status === 'active' && Array.isArray(e.targets) && e.targets.indexOf('jev') !== -1) {
-      gate.allowed.add(e.id.slice(6));
-    }
-  });
-  return gate;
-}
-
-function isProjectedCopy(root, source) {
-  var file = typeof source === 'string' ? path.resolve(root, source) : '';
-  if (file.indexOf(path.resolve(root) + path.sep) !== 0) return false;
-  try {
-    if (fs.statSync(file).size > MAX_CATALOG_BYTES) return false;
-    return fs.readFileSync(file, 'utf-8').indexOf('monomind:start catalog:skill:') !== -1;
-  } catch (e) {
-    return false;
-  }
-}
-
-/** The catalog state decides, not the (possibly stale) projection marker: a
- *  disabled, revoked or no-jev entry drops out before re-projection, and an
- *  unreadable state drops every marked skill (fail closed). A hand-written
- *  namesake passes; an unmarked projected copy (old builder) does not. */
-function jevAllowed(gate, s, root) {
-  if (s.catalog && (!gate.ok || !gate.allowed.has(String(s.catalog.id).replace(/^skill:/, '')))) return false;
-  return !gate.known.has(s.skill) || gate.allowed.has(s.skill) || (!s.catalog && !isProjectedCopy(root, s.source));
-}
-
-/** Skills/commands from .claude/helpers/skill-registry.json (build-skill-registry.cjs).
- *  Command/skill mirrors of one capability collapse, preferring the slash form. */
-function loadSkillCatalog(root) {
-  var reg = readJsonFile(path.join(root, '.claude', 'helpers', 'skill-registry.json'));
-  var list = reg && Array.isArray(reg.skills) ? reg.skills : [];
-  var gate = catalogJevGate(root);
-  var byKey = new Map();
-  list.forEach(function (s) {
-    if (!s || typeof s.skill !== 'string' || typeof s.invoke !== 'string') 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;
-    if (gate && !jevAllowed(gate, s, root)) return;
-    var key = s.skill.toLowerCase().replace(/[:_]/g, '-');
-    var prev = byKey.get(key);
-    if (prev && !(s.invoke.charAt(0) === '/' && prev.invoke.charAt(0) !== '/')) return;
-    byKey.set(key, {
-      id: s.skill,
-      invoke: s.invoke,
-      description: typeof s.description === 'string' ? s.description : '',
-      text: strings(s.nameTerms).concat(strings(s.keywords)).join(' '),
-    });
-  });
-  return Array.from(byKey.values());
+function loadSkillCatalog(root, opts) {
+  return catalog ? catalog.loadSkillCatalog(root, opts) : [];
 }
 
 module.exports = {
@@ -483,6 +371,7 @@ module.exports = {
   normalizeBaseUrl: normalizeBaseUrl,
   resolveTimeoutMs: resolveTimeoutMs,
   resolveMinConfidence: resolveMinConfidence,
+  resolvePickMinConfidence: resolvePickMinConfidence,
   resolveHookTimeoutMs: resolveHookTimeoutMs,
   redactSecrets: redaction.redactSecrets,
   SECRET_PATTERNS: redaction.SECRET_PATTERNS,