monomind 2.1.3 → 2.1.5

package/packages/@monomind/cli/.claude/helpers/handlers/route-handler.cjs

@@ -18,6 +18,38 @@
 const path = require('path');
 const fs = require('fs');
 
+// ── Intelligence read-path bridge ───────────────────────────────────────────
+// route-handler.cjs runs as a fresh node subprocess per invocation, but a
+// single process may call handle() more than once (e.g. tests, or a daemon
+// wrapper) — cache the dynamic import of the CLI's compiled intelligence
+// bridge (hooks-embedding.js -> suggestAgentsFromIntelligence) so repeat
+// calls within the same process don't re-resolve/re-import the module.
+// suggestAgentsFromIntelligence() reads the SONA/ReasoningBank embedding
+// store populated by recordMemoryDecision() on every post-task — this is
+// the module that makes stored embedding patterns affect live routing.
+var _intelligenceModPromise = null;
+function _loadIntelligenceModule(CWD) {
+  if (!_intelligenceModPromise) {
+    _intelligenceModPromise = (async function() {
+      var candidates = [
+        path.resolve(CWD, 'packages', '@monomind', 'cli', 'dist', 'src', 'mcp-tools', 'hooks-embedding.js'),
+        path.resolve(CWD, 'packages', '@monomind', 'cli', 'node_modules', '@monomind', 'cli', 'dist', 'src', 'mcp-tools', 'hooks-embedding.js'),
+      ];
+      for (var i = 0; i < candidates.length; i++) {
+        if (fs.existsSync(candidates[i])) {
+          try {
+            return await import(candidates[i]);
+          } catch (e) {
+            return null;
+          }
+        }
+      }
+      return null;
+    })();
+  }
+  return _intelligenceModPromise;
+}
+
 module.exports = {
   handle: async function(hCtx) {
     var prompt = hCtx.prompt;
@@ -104,7 +136,7 @@ module.exports = {
                 if (erRule.pattern && erRule.pattern.test(prompt)) {
                   result.agent = erRule.routeName || erRule.agentSlug;
                   result.agentSlug = erRule.agentSlug;
-                  result.confidence = 0.90;
+                  result.confidence = erRule.score != null ? Math.min(0.98, Math.max(0.70, erRule.score)) : 0.85;
                   result.reason = 'Enriched: ' + (erRule.description || erRule.routeName);
                   result.enrichedFrom = 'routing-keyword-pre-filter';
                   break;
@@ -115,6 +147,47 @@ module.exports = {
         } catch (e) { /* non-fatal — routing package may not be available */ }
       }
 
+      // ── Intelligence embedding suggestion (SONA/ReasoningBank read path) ──
+      // Wires the previously-write-only intelligence system into live routing:
+      // suggestAgentsFromIntelligence() runs an embedding similarity search
+      // over patterns stored by recordMemoryDecision() on every post-task.
+      // 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 {
+        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); })
+        ]);
+        if (intelResult && intelResult.agents && intelResult.agents.length > 0) {
+          var topIntelAgent = intelResult.agents[0];
+          var intelConf = intelResult.confidence != null ? intelResult.confidence : 0;
+          result.intelligenceSuggestion = { agents: intelResult.agents, confidence: intelConf };
+
+          var curAgent = result.agentSlug || result.agent;
+          var curConf = result.confidence != null ? result.confidence : 0;
+          if (topIntelAgent !== curAgent) {
+            // Only override when the embedding match clearly beats the keyword
+            // route (0.1 margin) — otherwise just surface it as a signal.
+            if (intelConf > curConf + 0.1) {
+              console.log('[INTELLIGENCE] Embedding suggestion overrides keyword routing: ' + topIntelAgent + ' (confidence ' + intelConf.toFixed(2) + ') vs keyword ' + curAgent + ' (' + curConf.toFixed(2) + ')');
+              result.keywordAgent = curAgent;
+              result.agent = topIntelAgent;
+              result.agentSlug = topIntelAgent;
+              result.confidence = intelConf;
+              result.reason = 'Intelligence embedding match (SONA/ReasoningBank)' + (result.reason ? '; keyword route was: ' + result.reason : '');
+              result.enrichedFrom = 'intelligence-embedding';
+            } else {
+              console.log('[INTELLIGENCE] Embedding suggestion: ' + topIntelAgent + ' (confidence ' + intelConf.toFixed(2) + ') — kept keyword route ' + curAgent);
+            }
+          }
+        }
+      } catch (e) { /* non-fatal — intelligence system unavailable or timed out */ }
+
       // ── Agent success pattern lookup ──────────────────────────
       try {
         var patternDb = hCtx._openMonographDb();

package/packages/@monomind/cli/.claude/helpers/hook-handler.cjs

@@ -393,15 +393,16 @@ const handlers = {
   },
 
   'pre-bash': async () => {
-    // SECURITY GATE FIRST — destructive-ops enforcement must never be
-    // starved by the slower enrichment work below (monograph hint lookups).
-    // Previously this ran LAST, after up to 10 monograph SQLite strategies,
-    // AND was fired without awaiting its promise — meaning the block
-    // decision (process.exitCode) could still be unset when the process
-    // exited under the global 5s safety timer (see main()'s
-    // `process.exit(0)`), i.e. the gate could fail OPEN under time
-    // pressure. Awaiting it first guarantees the block/allow decision is
-    // computed and set before any enrichment work even starts.
+    // SECURITY GATE FIRST — destructive-ops + secrets enforcement must never
+    // be starved by the slower enrichment work below (monograph hint lookups,
+    // monofence-ai scan). Previously this ran LAST, after up to 10 monograph
+    // SQLite strategies and a 1.5s monofence budget; under load/slow disk the
+    // global 5s safety timer (see main()'s `process.exit(0)`) could fire
+    // before the gate ever printed its block decision — i.e. the gate could
+    // fail OPEN under time pressure. Computing it first guarantees the
+    // block/allow decision (process.exitCode) is set before any enrichment
+    // work even starts; enrichment output is still attached afterward if
+    // there's time left in the process's lifetime.
     var gates = require('./handlers/gates-handler.cjs');
     await gates.handlePreBash(hCtx);
     if (process.exitCode === 2) return; // blocked — skip enrichment entirely
@@ -661,10 +662,11 @@ const handlers = {
     }
   },
 
-  'pre-write': () => {
-    // Enforcement gate: secrets detection before Write/Edit/MultiEdit lands on disk
+  'pre-write': async () => {
+    // Enforcement gate: secrets detection + monofence-ai threat scan before
+    // Write/Edit/MultiEdit content lands on disk
     var gates = require('./handlers/gates-handler.cjs');
-    gates.handlePreWrite(hCtx);
+    await gates.handlePreWrite(hCtx);
   },
 
   'pre-search': () => {

package/packages/@monomind/cli/.claude/helpers/router.cjs

@@ -310,12 +310,22 @@ function routeTask(prompt) {
     if (slug === 'coder' && hasStrongSkill) continue;
     var pattern = _ROUTING_PATTERNS[slug];
     if (pattern && pattern.test(safePrompt)) {
-      var confidence = applyFeedbackWeight(slug, TASK_CONFIDENCES[slug] || 0.75);
+      // Count how many distinct keywords from the pattern actually matched
+      // so confidence reflects real match quality, not just a static constant.
+      var caps = AGENT_CAPABILITIES[slug] || [];
+      var promptLower = safePrompt.toLowerCase();
+      var matchedKw = 0;
+      for (var ki = 0; ki < caps.length; ki++) {
+        if (promptLower.indexOf(caps[ki].toLowerCase()) !== -1) matchedKw++;
+      }
+      var baseConf = TASK_CONFIDENCES[slug] || 0.75;
+      var matchBonus = Math.min(0.10, matchedKw * 0.02);
+      var confidence = Math.min(0.98, applyFeedbackWeight(slug, baseConf + matchBonus));
       return {
         agent: TASK_AGENTS[slug],
         agentSlug: slug,
         confidence: confidence,
-        reason: ('Keyword match: ' + slug).slice(0, 80),
+        reason: ('Keyword match: ' + slug + ' (' + matchedKw + ' kw)').slice(0, 80),
         semanticRouting: false,
         specificAgents: [{ slug: slug, name: TASK_AGENTS[slug], confidence: confidence }],
         skillMatches: skills,