@monoes/monomindcli 1.12.0 → 1.13.0

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

@@ -118,8 +118,8 @@ module.exports = {
       } catch (e) {}
 
       var output = [];
-      output.push('[INFO] Routing task: ' + (prompt.substring(0, 80) || '(no prompt)'));
-      output.push('');
+      // Skip the noisy "[INFO] Routing task: ..." prefix — it repeats the user's
+      // own words back and adds token overhead without helping Claude.
       // Routing panel strategy:
       //   conf >= 0.90 → show primary recommendation (router is confident, trust it)
       //   conf  < 0.90 → show category picker so Claude uses its own context to
@@ -185,13 +185,17 @@ module.exports = {
         var devAgentsForPersist = /^(coder|tester|reviewer|planner|researcher|system-architect|backend-dev|backend-architect|mobile-dev|ml-developer|cicd-engineer|api-docs|code-analyzer|production-validator|Technical Writer|Software Architect|Frontend Developer|AI Engineer|Data Engineer|Security Engineer|DevOps Automator|SRE)$/i;
         var persistedIsNonDev = !devAgentsForPersist.test(String(result.agent || '').trim());
         var resolvedAgent = result.agent;
+        var resolvedFromExtras = false;
         if (!resolvedAgent || resolvedAgent === 'extras') {
           var topExtra = result.extrasMatches && result.extrasMatches[0];
           resolvedAgent = topExtra ? topExtra.name : 'Specialist Agent';
+          resolvedFromExtras = true;
         }
         // If router was uncertain (< 90%) and picked a non-dev specialist,
         // show "AI selecting" in statusline rather than the wrong agent.
-        if (confForPersist < 0.90 && persistedIsNonDev && !String(result.reason || '').startsWith('Graph fallback')) {
+        // Exception: when agent was explicitly 'extras' and we resolved from extrasMatches,
+        // trust that resolution — the domain specialist was explicitly matched.
+        if (!resolvedFromExtras && confForPersist < 0.90 && persistedIsNonDev && !String(result.reason || '').startsWith('Graph fallback')) {
           resolvedAgent = 'AI selecting';
         }
         var routePayload = {
@@ -420,7 +424,10 @@ module.exports = {
             for (var si = 0; si < suggestions.length; si++) {
               var s = suggestions[si];
               var editTag = s._editBoost ? ' ✎' : '';
-              console.log('  · ' + s.name + ' [' + s.label + '] — ' + (s.file || '') + (s.deg ? ' (deg ' + s.deg + ')' : '') + editTag);
+              // Include :line suffix when available so LLM can navigate directly
+              var fileLoc = (s.file || '');
+              if (fileLoc && s.startLine != null) fileLoc = fileLoc + ':' + s.startLine;
+              console.log('  · ' + s.name + ' [' + s.label + '] — ' + fileLoc + (s.deg ? ' (deg ' + s.deg + ')' : '') + editTag);
             }
             console.log('  Use mcp__monomind__monograph_query / monograph_impact for deeper drill-down.');
             hCtx._recordGraphTelemetry('preresolve_hit');

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

@@ -291,8 +291,11 @@ module.exports = {
           daemonChild.on('error', function() {});
           daemonChild.unref();
           console.log('[DAEMON_AUTOSTART] Background daemon started (pid ' + daemonChild.pid + ')');
-        } else {
-          console.log('[DAEMON_STOPPED] Background daemon is not running. To auto-start, set daemon.autoStart=true in monomind.config.json or run: npx monomind daemon start');
+        }
+        // Daemon not running + no autoStart: emit only if this project has a config
+        // (i.e. daemon was intentionally set up). Avoids noisy output in daemon-less projects.
+        else if (fs.existsSync(path.join(CWD, 'monomind.config.json'))) {
+          console.log('[DAEMON_STOPPED] Run `npx monomind daemon start` to enable background workers');
         }
       }
     } catch (e) { /* non-fatal */ }
@@ -328,11 +331,13 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Monomind Control UI Status — only probe when a daemon has previously run
-    // (indicated by daemon.pid or monomind.config.json). Skips silently in fresh
-    // environments and test fixtures that have no daemon history.
-    var _controlUiShouldProbe = fs.existsSync(path.join(CWD, '.monomind', 'daemon.pid'))
-      || fs.existsSync(path.join(CWD, 'monomind.config.json'));
+    // Monomind Control UI Status — only probe when a daemon.pid file exists,
+    // meaning the daemon was intentionally started in this project. This avoids
+    // printing "[CONTROL_UI] offline" noise on every session in projects that
+    // never run the daemon.  The broader "monomind.config.json" check is dropped
+    // because that file is present in the dev repo itself and in any initialized
+    // project, making the old condition nearly always true.
+    var _controlUiShouldProbe = fs.existsSync(path.join(CWD, '.monomind', 'daemon.pid'));
     if (_controlUiShouldProbe) {
       try {
         var http = require('http');
@@ -344,7 +349,8 @@ module.exports = {
           res.resume();
         });
         req.on('error', function() {
-          console.log('[CONTROL_UI] offline — run: npx monomind mcp start');
+          // Only warn when daemon was previously running (pid file exists but server is gone)
+          console.log('[CONTROL_UI] offline — restart with: npx monomind mcp start');
         });
         req.setTimeout(800, function() { req.destroy(); });
       } catch (e) { /* non-fatal */ }

package/.claude/helpers/hook-handler.cjs

@@ -288,6 +288,46 @@ const handlers = {
     var tool = hCtx.toolName || '';
     if (tool === 'Grep') _recordGraphTelemetry('grep_call');
     else if (tool === 'Glob') _recordGraphTelemetry('glob_call');
+
+    // Monograph symbol hint: when the Grep pattern looks like a plain symbol name
+    // (no regex metacharacters), look it up directly in the graph index and print
+    // the file:line so the LLM may skip or narrow the Grep.
+    // Session-level cache prevents repeated identical DB lookups across Grep bursts.
+    try {
+      var grepPattern = (typeof toolInput === 'object' && toolInput !== null)
+        ? (toolInput.pattern || toolInput.query || '')
+        : '';
+      // Only attempt lookup for clean identifiers — skip regexes and paths
+      var isCleanSymbol = grepPattern.length >= 3 && grepPattern.length <= 80
+        && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(grepPattern);
+      if (isCleanSymbol) {
+        if (!hCtx._preSearchCache) hCtx._preSearchCache = {};
+        var cacheKey = 'presearch:' + grepPattern;
+        if (!(cacheKey in hCtx._preSearchCache)) {
+          var db = _openMonographDb();
+          var hint = null;
+          if (db) {
+            try {
+              var row = db.prepare(
+                'SELECT n.name, n.label, n.file_path, n.start_line FROM nodes n ' +
+                'WHERE n.name = ? AND n.label NOT IN (\'Concept\',\'Community\',\'Folder\') ' +
+                'AND n.file_path IS NOT NULL LIMIT 1'
+              ).get(grepPattern);
+              if (row) {
+                hint = row.file_path + (row.start_line != null ? ':' + row.start_line : '');
+              }
+            } catch (e) { /* non-fatal */ }
+          }
+          hCtx._preSearchCache[cacheKey] = hint;
+        }
+        var cachedHint = hCtx._preSearchCache[cacheKey];
+        if (cachedHint) {
+          // Use the correct MCP tool name — monograph_context does not exist;
+          // the callable tool is mcp__monomind__monograph_query
+          console.log('[MONOGRAPH_HINT] ' + grepPattern + ' found at ' + cachedHint + ' — use mcp__monomind__monograph_query instead of Grep for better results');
+        }
+      }
+    } catch (e) { /* non-fatal — telemetry always proceeds */ }
   },
 
   'post-graph-tool': () => {

package/.claude/helpers/intelligence.cjs

@@ -1,92 +1,164 @@
 'use strict';
 /**
  * Intelligence context module for hook-handler.cjs
- * Provides context injection, trajectory logging, and feedback recording.
+ * Provides context injection, trajectory logging, feedback recording,
+ * edit tracking, consolidation, and stats.
+ *
+ * Data directory: $CLAUDE_PROJECT_DIR/.monomind/data/
+ *   auto-memory-store.json      — persisted memory entries
+ *   ranked-context.json         — ranked view written by init()
+ *   pending-insights.jsonl      — pending entries to consolidate
+ *   intelligence-outcomes.jsonl — feedback records
  */
 
 const path = require('path');
 const fs = require('fs');
 
+// Resolve base dir at require-time so tests can inject CLAUDE_PROJECT_DIR
+// per fresh require() call.
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const INTEL_DIR = path.join(CWD, '.monomind', 'intelligence');
-const PATTERNS_FILE = path.join(INTEL_DIR, 'patterns.json');
-const TRAJECTORY_FILE = path.join(INTEL_DIR, 'trajectory.json');
+const DATA_DIR = path.join(CWD, '.monomind', 'data');
+const STORE_FILE = path.join(DATA_DIR, 'auto-memory-store.json');
+const RANKED_FILE = path.join(DATA_DIR, 'ranked-context.json');
+const PENDING_FILE = path.join(DATA_DIR, 'pending-insights.jsonl');
+const OUTCOMES_FILE = path.join(DATA_DIR, 'intelligence-outcomes.jsonl');
 
-var _initialized = false;
-var _patterns = [];
-var _trajectory = [];
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MiB guard
+const RING_BUFFER_MAX = 50;
 
-function ensureDir() {
-  try { fs.mkdirSync(INTEL_DIR, { recursive: true }); } catch (_) {}
+var _entries = [];        // deduplicated memory entries loaded from store
+var _recentEdits = [];    // ring buffer of recently edited paths
+
+function ensureDataDir() {
+  try { fs.mkdirSync(DATA_DIR, { recursive: true }); } catch (_) {}
 }
 
-var MAX_PATTERNS_SIZE = 10 * 1024 * 1024; // 10 MiB guard
+function safeReadJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    var st = fs.statSync(filePath);
+    if (st.size > MAX_FILE_SIZE) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (_) { return null; }
+}
 
-function loadPatterns() {
+function safeReadLines(filePath) {
   try {
-    if (fs.existsSync(PATTERNS_FILE)) {
-      var st = fs.statSync(PATTERNS_FILE);
-      if (st.size > MAX_PATTERNS_SIZE) { _patterns = []; return; }
-      _patterns = JSON.parse(fs.readFileSync(PATTERNS_FILE, 'utf-8'));
-    }
-  } catch (_) { _patterns = []; }
+    if (!fs.existsSync(filePath)) return [];
+    var st = fs.statSync(filePath);
+    if (st.size > MAX_FILE_SIZE) return [];
+    return fs.readFileSync(filePath, 'utf-8')
+      .split('\n')
+      .filter(function(l) { return l.trim().length > 0; });
+  } catch (_) { return []; }
 }
 
+// ── init ───────────────────────────────────────────────────────────────────────
+
 function init() {
-  if (_initialized) return { ok: true, patternCount: _patterns.length };
-  ensureDir();
-  loadPatterns();
-  _initialized = true;
-  return { ok: true, patternCount: _patterns.length };
+  ensureDataDir();
+
+  // Load entries from store, deduplicate by id
+  var raw = safeReadJson(STORE_FILE);
+  var arr = Array.isArray(raw) ? raw : [];
+  var seen = new Set();
+  _entries = arr.filter(function(e) {
+    var key = e && e.id ? String(e.id) : null;
+    if (!key) return true;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  // Write ranked-context.json (sorted by confidence desc) with version envelope
+  var ranked = _entries.slice().sort(function(a, b) {
+    return (b.confidence || 0) - (a.confidence || 0);
+  });
+  try {
+    fs.writeFileSync(RANKED_FILE, JSON.stringify({ version: 1, entries: ranked }, null, 2), 'utf-8');
+  } catch (_) {}
+
+  return { nodes: _entries.length, edges: 0 };
 }
 
+// ── getContext ─────────────────────────────────────────────────────────────────
+
 function getContext(prompt) {
-  if (!prompt || typeof prompt !== 'string') return null;
-  if (!_initialized) init();
-  // Match patterns against prompt
-  var matches = _patterns.filter(function(p) {
-    return p.keywords && p.keywords.some(function(kw) {
-      return prompt.toLowerCase().includes(kw.toLowerCase());
-    });
+  if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') return null;
+  if (_entries.length === 0) return null;
+
+  var promptWords = prompt.toLowerCase().split(/\W+/).filter(Boolean);
+  var promptSet = new Set(promptWords);
+
+  var matches = _entries.filter(function(e) {
+    var content = ((e.content || '') + ' ' + (e.summary || '')).toLowerCase();
+    var words = content.split(/\W+/).filter(Boolean);
+    return words.some(function(w) { return promptSet.has(w); });
   });
+
   if (matches.length === 0) return null;
+
   var top = matches[0];
-  return '[INTELLIGENCE] Pattern match: ' + (top.name || top.id || 'pattern') +
-         (top.suggestion ? ' — ' + top.suggestion : '');
+  return '[INTELLIGENCE] ' + (top.summary || top.content || top.id || 'context match');
 }
 
-function logTrajectory(step) {
-  ensureDir();
-  _trajectory.push(Object.assign({ ts: new Date().toISOString() }, step || {}));
-  // Flush every 10 steps to avoid excessive writes
-  if (_trajectory.length % 10 === 0) {
-    try {
-      fs.writeFileSync(TRAJECTORY_FILE, JSON.stringify(_trajectory.slice(-200), null, 2), 'utf-8');
-    } catch (_) {}
+// ── recordEdit ────────────────────────────────────────────────────────────────
+
+function recordEdit(filePath) {
+  _recentEdits.push({ path: String(filePath || ''), ts: Date.now() });
+  if (_recentEdits.length > RING_BUFFER_MAX) {
+    _recentEdits = _recentEdits.slice(-RING_BUFFER_MAX);
   }
 }
 
+// ── consolidate ───────────────────────────────────────────────────────────────
+
+function consolidate() {
+  ensureDataDir();
+  var lines = safeReadLines(PENDING_FILE);
+  var count = lines.length;
+
+  // Clear the pending file
+  try { fs.writeFileSync(PENDING_FILE, '', 'utf-8'); } catch (_) {}
+
+  return { entries: count, edges: 0, newEntries: count };
+}
+
+// ── feedback ──────────────────────────────────────────────────────────────────
+
 function feedback(success) {
-  // Record outcome for last trajectory step
-  if (_trajectory.length > 0) {
-    _trajectory[_trajectory.length - 1].outcome = success ? 'success' : 'failure';
-  }
-  // Persist
-  ensureDir();
-  try {
-    fs.writeFileSync(TRAJECTORY_FILE, JSON.stringify(_trajectory.slice(-200), null, 2), 'utf-8');
-  } catch (_) {}
+  ensureDataDir();
+  var record = JSON.stringify({
+    ts: Date.now(),
+    success: !!success,
+    context: null,
+    recentEdits: _recentEdits.slice(),
+  }) + '\n';
+  try { fs.appendFileSync(OUTCOMES_FILE, record, 'utf-8'); } catch (_) {}
+}
+
+// ── stats ─────────────────────────────────────────────────────────────────────
+
+function stats(asJson) {
+  var result = {
+    entries: _entries.length,
+    recentEdits: _recentEdits.length,
+    pending: safeReadLines(PENDING_FILE).length,
+  };
+  if (asJson) return JSON.stringify(result);
+  return result;
+}
+
+// ── legacy ────────────────────────────────────────────────────────────────────
+
+function logTrajectory(step) {
+  // no-op stub for backward compatibility
+  void step;
 }
 
 function storePattern(pattern) {
-  ensureDir();
-  loadPatterns();
-  var safeId = String(pattern.id || '').slice(0, 256);
-  _patterns = _patterns.filter(function(p) { return p.id !== safeId; });
-  _patterns.push(Object.assign({ storedAt: new Date().toISOString() }, pattern, { id: safeId }));
-  try {
-    fs.writeFileSync(PATTERNS_FILE, JSON.stringify(_patterns.slice(-500), null, 2), 'utf-8');
-  } catch (_) {}
+  // no-op stub for backward compatibility
+  void pattern;
 }
 
-module.exports = { init, getContext, logTrajectory, feedback, storePattern };
+module.exports = { init, getContext, recordEdit, consolidate, feedback, stats, logTrajectory, storePattern };