@monoes/monomindcli 2.15.7 → 2.16.0

package/.claude/helpers/build-skill-registry.cjs

@@ -202,6 +202,23 @@ function scanCommands(root) {
   return out;
 }
 
+/** A catalog projection's marker (monomind catalog project) is the line right
+ *  after `# monomind:start catalog:skill:<dir>`:
+ *  `<!-- catalog skill:<dir> sha256:<hex> jev:yes|no -->`. Returns { id, jev },
+ *  or null for a file with no catalog block at all. A file that has a catalog
+ *  block but no valid marker in that position, or one naming another directory,
+ *  is a catalog projection that is not Jev-approved (jev: false).
+ *  jev-picker.cjs sends a catalog skill to the decision model only when jev is
+ *  true. */
+function readCatalogMarker(text, dir) {
+  if (text.indexOf('monomind:start catalog:skill:') === -1) return null;
+  var id = 'skill:' + dir;
+  var lines = text.split(/\r?\n/);
+  var at = lines.indexOf('# monomind:start catalog:' + id);
+  var m = at === -1 ? null : /^<!-- catalog (skill:[a-z0-9][a-z0-9-]*) sha256:[0-9a-f]{64} jev:(yes|no) -->$/.exec(lines[at + 1] || '');
+  return { id: id, jev: !!m && m[1] === id && m[2] === 'yes' };
+}
+
 /** Scan .claude/skills/<name>/SKILL.md -> Skill() entries. */
 function scanSkills(root) {
   var base = path.join(root, '.claude', 'skills');
@@ -227,7 +244,7 @@ function scanSkills(root) {
     var name = fm.name || d.name;
     var description = fm.description || readLeadingComment(text) || readFirstHeading(text);
     var nameTerms = deriveNameTerms(name, d.name);
-    out.push({
+    var entry = {
       skill: d.name,
       invoke: 'Skill("' + d.name + '")',
       kind: 'skill',
@@ -236,7 +253,10 @@ function scanSkills(root) {
       keywords: deriveKeywords(description, nameTerms),
       category: 'skill',
       source: '.claude/skills/' + d.name + '/SKILL.md',
-    });
+    };
+    var catalog = readCatalogMarker(text, d.name);
+    if (catalog) entry.catalog = catalog;
+    out.push(entry);
   }
   return out;
 }
@@ -320,4 +340,5 @@ module.exports = {
   readFrontmatter: readFrontmatter,
   deriveNameTerms: deriveNameTerms,
   deriveKeywords: deriveKeywords,
+  readCatalogMarker: readCatalogMarker,
 };

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

@@ -61,8 +61,83 @@ function _loadIntelligenceModule(CWD) {
   return _intelligenceModPromise;
 }
 
+// ── Jev decision-model bridge ───────────────────────────────────────────────
+// jev-picker.cjs (a sibling helper) asks the configured decision model to pick
+// the agent AND the skill in one request, within MONOMIND_JEV_TIMEOUT_MS.
+// Not configured / failed / not confident → null, and keyword routing stands.
+var _jevPicker;
+function _loadJevPicker() {
+  if (_jevPicker === undefined) {
+    try {
+      _jevPicker = require(path.join(__dirname, '..', 'jev-picker.cjs'));
+    } catch (e) {
+      _jevPicker = null;
+    }
+  }
+  return _jevPicker;
+}
+
+var JEV_BREAKER_MS = 5 * 60 * 1000;
+function _jevBreakerPath(CWD) { return path.join(CWD, '.monomind', 'jev-breaker.json'); }
+function _jevBreakerOpen(CWD) {
+  try { return JSON.parse(fs.readFileSync(_jevBreakerPath(CWD), 'utf-8')).until > Date.now(); } catch (e) { return false; }
+}
+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) {
+  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] : [] },
+    timeoutMs: jp.resolveHookTimeoutMs(process.env),
+    onError: function (err) { failures.push(err.provider + ': ' + err.message); },
+  });
+  if (failures.length) advisoryLog('[JEV] ' + failures.join('; ') + (picked ? '' : ' — using keyword routing'));
+  if (!picked) {
+    if (failures.length) _tripJevBreaker(CWD);
+    return null;
+  }
+  var skillById = {};
+  skills.forEach(function (s) { skillById[s.id] = s; });
+  return {
+    provider: picked.provider,
+    agent: jp.acceptAgent(picked.agent),
+    agentConfidence: picked.agent ? picked.agent.confidence : 0,
+    // 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';
+  }
+  // Jev's skill answer replaces keyword skill matches, including "none fits".
+  if (jev.skillAnswered) {
+    result.skillMatches = jev.skills.map(function (s, i) {
+      return { skill: s.id, invoke: s.invoke, description: s.description || '', score: i === 0 ? 2 : 1, source: 'jev' };
+    });
+  }
+}
+
+
 module.exports = {
   handle: async function(hCtx) {
+    var hookStart = Date.now();
     var prompt = hCtx.prompt;
     var hookInput = hCtx.hookInput;
     var router = hCtx.router;
@@ -120,6 +195,14 @@ module.exports = {
     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
@@ -161,7 +244,7 @@ module.exports = {
       //    rules for Solidity, game engines, DevOps, embedded, etc.) for a
       //    more specific agent match. This bridges the hooks layer (router.cjs)
       //    with the CLI routing package without requiring ESM imports. ─────────
-      if (result && result.agentSlug === 'coder' && result.confidence <= 0.8) {
+      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'
@@ -200,14 +283,17 @@ module.exports = {
       // 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).
-      try {
+      // A slow or failed Jev attempt may already have spent most of the 5 s
+      // hook exit, so the budget shrinks to keep the route persist below in time.
+      var intelBudgetMs = Math.min(2000, Math.max(0, 4500 - (Date.now() - hookStart)));
+      if (result.routingMethod !== 'jev' && intelBudgetMs > 0) try {
         var intelResult = await Promise.race([
           (async function() {
             var mod = await _loadIntelligenceModule(CWD);
             if (!mod || !mod.suggestAgentsFromIntelligence) return null;
             return await mod.suggestAgentsFromIntelligence(prompt);
           })(),
-          new Promise(function(resolve) { setTimeout(function() { resolve(null); }, 2000); })
+          new Promise(function(resolve) { setTimeout(function() { resolve(null); }, intelBudgetMs); })
         ]);
         if (intelResult && intelResult.agents && intelResult.agents.length > 0) {
           var topIntelAgent = intelResult.agents[0];

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

@@ -131,7 +131,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'];
+          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'];
           for (var hi = 0; hi < helpersToCheck.length; hi++) {
             var hName = helpersToCheck[hi];
             var healedName = _healIfStale(

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

@@ -0,0 +1,499 @@
+'use strict';
+/**
+ * Jev decision-model picker. This is the ONE implementation, shared by the prompt
+ * hook (handlers/route-handler.cjs) and the CLI (src/decision/jev.ts requires
+ * this file from the package's .claude/helpers).
+ *
+ * Speaks POST /v1/systemone, which hosted Jev (api.typesafe.ai) and the OpenJev
+ * helper shim share. Providers are tried in order (MONOMIND_JEV_URL, then
+ * TYPESAFE_API_KEY) inside ONE total window (MONOMIND_JEV_TIMEOUT_MS, default
+ * 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');
+
+var TYPESAFE_BASE_URL = 'https://api.typesafe.ai';
+var DEFAULT_MODEL = 'jev-latest';
+var DEFAULT_TIMEOUT_MS = 3000;
+var MIN_TIMEOUT_MS = 100;
+var MAX_TIMEOUT_MS = 30000;
+var MIN_PROVIDER_WINDOW_MS = 50;
+var DEFAULT_MIN_CONFIDENCE = 0.6;
+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.
+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'];
+var DEFAULT_HOOK_TIMEOUT_MS = 1500;
+var MAX_HOOK_TIMEOUT_MS = 4000;
+
+class JevError extends Error {
+  constructor(message, provider, status) {
+    super(message);
+    this.name = 'JevError';
+    this.provider = provider;
+    this.status = status;
+  }
+}
+
+// ── Configuration ──────────────────────────────────────────────────────────
+
+function readEnvValue(env, name) {
+  var value = env[name];
+  if (typeof value !== 'string') return undefined;
+  value = value.trim();
+  return value ? value : undefined;
+}
+
+function isDisabled(env) {
+  var value = readEnvValue(env || process.env, 'MONOMIND_JEV');
+  return value !== undefined && OFF_VALUES.indexOf(value.toLowerCase()) !== -1;
+}
+
+/** http(s) origin + path, trailing slashes and a trailing /v1 removed; null if unusable. */
+function normalizeBaseUrl(value) {
+  var raw = typeof value === 'string' ? value.trim() : '';
+  if (!raw) return null;
+  var url;
+  try {
+    url = new URL(raw);
+  } catch (e) {
+    return null;
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') return null;
+  if (url.username || url.password) return null;
+  return url.origin + url.pathname.replace(/\/+$/, '').replace(/\/v1$/, '');
+}
+
+function resolveTimeoutMs(env) {
+  var n = Number((env || process.env).MONOMIND_JEV_TIMEOUT_MS);
+  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. */
+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;
+}
+
+function resolveMinConfidence(env) {
+  var n = Number((env || process.env).MONOMIND_JEV_MIN_CONFIDENCE);
+  return n > 0 && n <= 1 ? n : DEFAULT_MIN_CONFIDENCE;
+}
+
+/** 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) {
+  return { name: name, baseUrl: baseUrl, apiKey, model: model };
+}
+
+function resolveProviders(env) {
+  env = env || process.env;
+  if (isDisabled(env)) return [];
+  var model = readEnvValue(env, 'MONOMIND_JEV_MODEL') || DEFAULT_MODEL;
+  var providers = [];
+  var customUrl = normalizeBaseUrl(env.MONOMIND_JEV_URL);
+  if (customUrl) {
+    var customKey = readEnvValue(env, 'MONOMIND_JEV_API_KEY');
+    providers.push(makeProvider('custom', customUrl, customKey, model));
+  }
+  // TYPESAFE_API_KEY alone never sends anything: it may be set for unrelated
+  // TypeSafe use, and every prompt would silently leave the machine.
+  var typesafeKey = readEnvValue(env, 'TYPESAFE_API_KEY');
+  var hosted = (readEnvValue(env, 'MONOMIND_JEV_HOSTED') || '').toLowerCase();
+  if (typesafeKey && ON_VALUES.indexOf(hosted) !== -1) {
+    providers.push(makeProvider('typesafe', TYPESAFE_BASE_URL, typesafeKey, model));
+  }
+  return providers;
+}
+
+// ── Protocol ───────────────────────────────────────────────────────────────
+
+async function postSystemOne(provider, request, timeoutMs, fetchImpl) {
+  var doFetch = fetchImpl || globalThis.fetch;
+  var headers = { 'content-type': 'application/json' };
+  if (provider.apiKey) headers.authorization = 'Bearer ' + provider.apiKey;
+  var text;
+  try {
+    var res = await doFetch(provider.baseUrl + '/v1/systemone', {
+      method: 'POST',
+      headers: headers,
+      body: JSON.stringify(request),
+      // A redirect would re-send the bearer key to wherever it points.
+      redirect: 'error',
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) throw new JevError('HTTP ' + res.status, provider.name, res.status);
+    text = await res.text();
+  } catch (err) {
+    if (err instanceof JevError) throw err;
+    throw new JevError('request failed: ' + (err && err.message ? err.message : String(err)), provider.name);
+  }
+  if (text.length > MAX_RESPONSE_CHARS) throw new JevError('response too large', provider.name);
+  var body;
+  try {
+    body = JSON.parse(text);
+  } catch (e) {
+    throw new JevError('response is not JSON', provider.name);
+  }
+  if (!body || typeof body !== 'object' || !body.answers || typeof body.answers !== 'object') {
+    throw new JevError('response has no answers', provider.name);
+  }
+  return body;
+}
+
+function isValidAnswer(answer, question) {
+  if (!answer || typeof answer !== 'object' || answer.type !== question.type) return false;
+  if (question.type === 'noul') return Number.isFinite(answer.noul);
+  return (
+    typeof answer.choice === 'string' &&
+    Object.prototype.hasOwnProperty.call(question.criteria, answer.choice) &&
+    Number.isFinite(answer.confidence) &&
+    answer.confidence >= 0 &&
+    answer.confidence <= 1
+  );
+}
+
+function report(onError, err) {
+  if (typeof onError !== 'function') return;
+  try {
+    onError(err);
+  } catch (e) {
+    /* a logger must never break routing */
+  }
+}
+
+/** Ask every question in one request; first provider with a usable answer wins. */
+async function ask(state, questions, opts) {
+  opts = opts || {};
+  var env = opts.env || process.env;
+  var providers = opts.providers || resolveProviders(env);
+  var ids = Object.keys(questions);
+  if (providers.length === 0 || ids.length === 0) return null;
+  var deadline = Date.now() + (opts.timeoutMs || resolveTimeoutMs(env));
+  for (var i = 0; i < providers.length; i++) {
+    var provider = providers[i];
+    var remaining = deadline - Date.now();
+    if (remaining < MIN_PROVIDER_WINDOW_MS) break;
+    try {
+      var body = await postSystemOne(
+        provider,
+        { state: state, model: provider.model, questions: questions },
+        remaining,
+        opts.fetchImpl,
+      );
+      var answers = {};
+      var usable = 0;
+      for (var j = 0; j < ids.length; j++) {
+        var answer = body.answers[ids[j]];
+        if (isValidAnswer(answer, questions[ids[j]])) {
+          answers[ids[j]] = answer;
+          usable++;
+        }
+      }
+      if (usable > 0) return { provider: provider.name, answers: answers };
+      report(opts.onError, new JevError('no usable answer', provider.name));
+    } catch (err) {
+      report(opts.onError, err instanceof JevError ? err : new JevError(String(err), provider.name));
+    }
+  }
+  return null;
+}
+
+/** One tiny noul round-trip; resolves to elapsed ms or throws JevError. */
+async function probe(provider, opts) {
+  opts = opts || {};
+  var started = Date.now();
+  var body = await postSystemOne(
+    provider,
+    {
+      state: 'The sky is blue.',
+      model: provider.model,
+      questions: { probe: { type: 'noul', instructions: 'Does the text mention a colour?' } },
+    },
+    resolveTimeoutMs(opts.env || process.env),
+    opts.fetchImpl,
+  );
+  var answer = body.answers.probe;
+  if (!answer || answer.type !== 'noul' || !Number.isFinite(answer.noul)) {
+    throw new JevError('probe answer is malformed', provider.name);
+  }
+  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) {
+  var text = redaction.redactHead(item.description || item.name || item.id).replace(/\s+/g, ' ').trim();
+  return text.length > MAX_DESCRIPTION_CHARS ? text.slice(0, MAX_DESCRIPTION_CHARS - 1) + '…' : text;
+}
+
+function criteriaFor(items) {
+  var criteria = {};
+  items.forEach(function (item) {
+    criteria[item.id] = describeItem(item);
+  });
+  return criteria;
+}
+
+/** Only options that were sent, with probabilities in [0, 1]: an id the model
+ *  invents (or an injection payload) must never reach a caller. */
+function rankedFrom(answer, criteria) {
+  var probs = answer.probabilities;
+  if (!probs || typeof probs !== 'object') return [{ id: answer.choice, probability: answer.confidence }];
+  return Object.keys(probs)
+    .filter(function (id) {
+      var p = probs[id];
+      return Object.prototype.hasOwnProperty.call(criteria, id) && Number.isFinite(p) && p >= 0 && p <= 1;
+    })
+    .map(function (id) {
+      return { id: id, probability: probs[id] };
+    })
+    .sort(function (a, b) {
+      return b.probability - a.probability;
+    });
+}
+
+function toAnswer(answer, criteria) {
+  return { choice: answer.choice, confidence: answer.confidence, ranked: rankedFrom(answer, criteria) };
+}
+
+/** Pick an agent and/or a skill for `task` in ONE request. null = no decision. */
+async function pick(task, catalogs, opts) {
+  opts = opts || {};
+  var env = opts.env || process.env;
+  var providers = resolveProviders(env);
+  if (providers.length === 0) return null;
+  var text = redaction.redactHead(task).slice(0, MAX_STATE_CHARS);
+  if (!text.trim()) return null;
+  var max = opts.maxCandidates || DEFAULT_MAX_CANDIDATES;
+  var include = opts.include || {};
+  var agents = catalogs && Array.isArray(catalogs.agents) ? catalogs.agents : [];
+  var skills = catalogs && Array.isArray(catalogs.skills) ? catalogs.skills : [];
+  var questions = {};
+  if (agents.length >= 2) {
+    questions.agent = {
+      type: 'choice',
+      instructions: opts.agentInstructions || 'Which specialist agent should handle this task?',
+      criteria: criteriaFor(shortlist(text, agents, max, include.agents)),
+    };
+  }
+  if (skills.length >= 1) {
+    var skillCriteria = criteriaFor(shortlist(text, skills, max, include.skills));
+    skillCriteria[NONE_ID] = 'None of these skills fits the task';
+    questions.skill = {
+      type: 'choice',
+      instructions: opts.skillInstructions || 'Which skill best fits this task?',
+      criteria: skillCriteria,
+    };
+  }
+  if (!questions.agent && !questions.skill) return null;
+  var res = await ask(text, questions, {
+    env: env,
+    providers: providers,
+    fetchImpl: opts.fetchImpl,
+    onError: opts.onError,
+    timeoutMs: opts.timeoutMs,
+  });
+  if (!res) return null;
+  var out = { provider: res.provider };
+  if (res.answers.agent) out.agent = toAnswer(res.answers.agent, questions.agent.criteria);
+  if (res.answers.skill) out.skill = toAnswer(res.answers.skill, questions.skill.criteria);
+  return out;
+}
+
+function acceptAgent(answer, env) {
+  if (!answer) return null;
+  return answer.confidence >= resolveMinConfidence(env) ? answer.choice : null;
+}
+
+function acceptSkills(answer, env, max) {
+  if (!answer || answer.choice === NONE_ID || answer.confidence < resolveMinConfidence(env)) return [];
+  var limit = max || DEFAULT_MAX_SKILLS;
+  var out = [answer.choice];
+  for (var i = 0; i < answer.ranked.length && out.length < limit; i++) {
+    var r = answer.ranked[i];
+    if (r.id !== NONE_ID && out.indexOf(r.id) === -1 && r.probability >= MIN_EXTRA_SKILL_PROBABILITY) {
+      out.push(r.id);
+    }
+  }
+  return out.slice(0, limit);
+}
+
+// ── 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;
+  }
+}
+
+function strings(list) {
+  return (Array.isArray(list) ? list : []).filter(function (s) {
+    return typeof s === 'string';
+  });
+}
+
+/** 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());
+}
+
+module.exports = {
+  JevError: JevError,
+  NONE_ID: NONE_ID,
+  TYPESAFE_BASE_URL: TYPESAFE_BASE_URL,
+  isDisabled: isDisabled,
+  normalizeBaseUrl: normalizeBaseUrl,
+  resolveTimeoutMs: resolveTimeoutMs,
+  resolveMinConfidence: resolveMinConfidence,
+  resolveHookTimeoutMs: resolveHookTimeoutMs,
+  redactSecrets: redaction.redactSecrets,
+  SECRET_PATTERNS: redaction.SECRET_PATTERNS,
+  resolveProviders: resolveProviders,
+  postSystemOne: postSystemOne,
+  ask: ask,
+  probe: probe,
+  shortlist: shortlist,
+  pick: pick,
+  acceptAgent: acceptAgent,
+  acceptSkills: acceptSkills,
+  loadAgentCatalog: loadAgentCatalog,
+  loadSkillCatalog: loadSkillCatalog,
+};