@monoes/monomindcli 2.15.7 → 2.16.1

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,95 @@ 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;
+}
+
+// hook-handler.cjs force-exits every hook at this deadline. A configured Jev
+// may hold the route hook for its whole window, so that hook gets the window
+// plus 1.5 s to persist its route; without Jev it keeps the 5 s exit.
+var HOOK_EXIT_MS = 5000;
+function routeDeadlineMs(env) {
+  env = env || process.env;
+  var jp = _loadJevPicker();
+  if (!jp || jp.resolveProviders(env).length === 0) return HOOK_EXIT_MS;
+  return Math.max(HOOK_EXIT_MS, jp.resolveHookTimeoutMs(env) + 1500);
+}
+
+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 = {
+  routeDeadlineMs: routeDeadlineMs,
   handle: async function(hCtx) {
+    var hookStart = Date.now();
     var prompt = hCtx.prompt;
     var hookInput = hCtx.hookInput;
     var router = hCtx.router;
@@ -120,6 +207,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 +256,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 +295,18 @@ 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 time
+      // before the hook exit, so the budget shrinks to keep the route persist
+      // below in time (500 ms before routeDeadlineMs).
+      var intelBudgetMs = Math.min(2000, Math.max(0, routeDeadlineMs(process.env) - 500 - (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/hook-handler.cjs

@@ -239,10 +239,23 @@ async function readStdin() {
   });
 }
 
+// Every hook force-exits after 5 s, except the route hook while a Jev decision
+// model is configured: it may wait out the Jev window (route-handler.cjs
+// routeDeadlineMs). The security gates never load the route handler.
+function safetyTimeoutMs(cmd, env) {
+  if (cmd !== 'route') return 5000;
+  try {
+    return require('./handlers/route-handler.cjs').routeDeadlineMs(env || process.env);
+  } catch (e) {
+    return 5000;
+  }
+}
+
 async function main() {
   // Global safety timeout: hooks must NEVER hang (#1530, #1531)
+  var safetyMs = safetyTimeoutMs(command);
   var safetyTimer = setTimeout(function() {
-    process.stderr.write("[WARN] Hook handler global timeout (5s), forcing exit\n");
+    process.stderr.write("[WARN] Hook handler global timeout (" + (safetyMs / 1000) + "s), forcing exit\n");
     // If a security gate was still pending when the timer fired, the operation
     // was never evaluated — fail CLOSED rather than letting a hang act as an
     // allow. (`_securityGateCompleted` is `var`-hoisted, so it reads as
@@ -256,7 +269,7 @@ async function main() {
       process.exit(2);
     }
     process.exit(0);
-  }, 5000);
+  }, safetyMs);
   safetyTimer.unref();
 
   let stdinData = '';
@@ -940,6 +953,8 @@ if (command && handlers[command]) {
   }
 }
 
+module.exports = { safetyTimeoutMs: safetyTimeoutMs };
+
 // Only run when executed directly (every real hook event spawns this file as a
 // process). A require() — e.g. from tests verifying it loads — must not exit.
 if (require.main === module) {