monomind 1.10.26 → 1.10.27

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

@@ -167,26 +167,61 @@ function _recordGraphTelemetry(event) {
   } catch (e) { /* non-fatal */ }
 }
 
-// Re-inject graph god nodes after compaction so the LLM doesn't lose its spatial map.
+// Re-inject graph context after compaction so the LLM doesn't lose its spatial map.
+// Prefers recently-edited files (session context) over pure degree centrality so
+// the injected anchors match what the LLM was actually working on.
 function _injectCompactGraphMap() {
   try {
     var db = _openMonographDb();
     if (!db) return;
     try {
       var nodeC = db.prepare("SELECT COUNT(*) AS c FROM nodes").get().c;
-      var gods = db.prepare(
-        "SELECT n.name, n.label, n.file_path, " +
-        "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
-        "FROM nodes n " +
-        "WHERE n.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
-        "AND n.name NOT LIKE '(%' AND n.name NOT LIKE '%=>%' AND length(n.name) >= 3 " +
-        "ORDER BY deg DESC LIMIT 8"
-      ).all();
-      if (gods.length > 0) {
-        console.log('[COMPACT_GRAPH] ' + nodeC + ' nodes available. Top spatial anchors:');
-        for (var ci = 0; ci < gods.length; ci++) {
-          var g = gods[ci];
-          console.log('  · ' + g.name + ' [' + g.label + '] — ' + g.file_path + ' (deg ' + g.deg + ')');
+      var anchors = [];
+      var seenPaths = {};
+
+      // 1. Prefer recently-edited files (up to 5) — these are what matters NOW.
+      var recentEdits = _getRecentEdits();
+      for (var ri = 0; ri < Math.min(recentEdits.length, 5); ri++) {
+        var rfile = recentEdits[ri].file;
+        // Normalise to relative path for DB lookup
+        var rrel = (rfile.indexOf(CWD) === 0) ? rfile.slice(CWD.length + 1) : rfile;
+        try {
+          var rnode = db.prepare(
+            "SELECT n.name, n.label, n.file_path, " +
+            "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
+            "FROM nodes n WHERE n.label='File' AND (n.file_path=? OR n.file_path=?) LIMIT 1"
+          ).get(rfile, rrel);
+          if (rnode && !seenPaths[rnode.file_path]) {
+            seenPaths[rnode.file_path] = 1;
+            anchors.push({ name: rnode.name, label: rnode.label, file_path: rnode.file_path, deg: rnode.deg, tag: '✎' });
+          }
+        } catch (e) { /* ignore — file may not be in graph yet */ }
+      }
+
+      // 2. Fill remaining slots (up to 8 total) with god nodes (high centrality).
+      var slotsLeft = 8 - anchors.length;
+      if (slotsLeft > 0) {
+        var gods = db.prepare(
+          "SELECT n.name, n.label, n.file_path, " +
+          "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
+          "FROM nodes n " +
+          "WHERE n.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
+          "AND n.name NOT LIKE '(%' AND n.name NOT LIKE '%=>%' AND length(n.name) >= 3 " +
+          "ORDER BY deg DESC LIMIT 15"
+        ).all();
+        for (var gi = 0; gi < gods.length && anchors.length < 8; gi++) {
+          if (!seenPaths[gods[gi].file_path]) {
+            seenPaths[gods[gi].file_path] = 1;
+            anchors.push({ name: gods[gi].name, label: gods[gi].label, file_path: gods[gi].file_path, deg: gods[gi].deg, tag: '' });
+          }
+        }
+      }
+
+      if (anchors.length > 0) {
+        console.log('[COMPACT_GRAPH] ' + nodeC + ' nodes. Session context (✎ = recently edited):');
+        for (var ci = 0; ci < anchors.length; ci++) {
+          var g = anchors[ci];
+          console.log('  ' + (g.tag || ' ') + ' ' + g.name + ' [' + g.label + '] — ' + g.file_path + ' (deg ' + g.deg + ')');
         }
         console.log('  Use mcp__monomind__monograph_suggest first when navigating.');
       }
@@ -194,6 +229,37 @@ function _injectCompactGraphMap() {
   } catch (e) {}
 }
 
+// ── Recent edit history ────────────────────────────────────────────────────────
+// Track last N edited file paths so compact injection and pre-resolve can surface
+// the files the LLM was actively working on instead of pure centrality anchors.
+function _recordRecentEdit(filePath) {
+  if (!filePath) return;
+  try {
+    var f = path.join(CWD, '.monomind', 'metrics', 'recent-edits.json');
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    var d = { edits: [] };
+    try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
+    if (!Array.isArray(d.edits)) d.edits = [];
+    // Remove stale entry for same file, then prepend fresh one
+    d.edits = d.edits.filter(function(e) { return e.file !== filePath; });
+    d.edits.unshift({ file: filePath, editedAt: Date.now() });
+    if (d.edits.length > 10) d.edits = d.edits.slice(0, 10);
+    fs.writeFileSync(f, JSON.stringify(d));
+  } catch (e) { /* non-fatal */ }
+}
+
+function _getRecentEdits() {
+  try {
+    var f = path.join(CWD, '.monomind', 'metrics', 'recent-edits.json');
+    if (!fs.existsSync(f)) return [];
+    var d = JSON.parse(fs.readFileSync(f, 'utf-8'));
+    if (!Array.isArray(d.edits)) return [];
+    // Only return edits from the last 2 hours (session-scoped)
+    var cutoff = Date.now() - 2 * 60 * 60 * 1000;
+    return d.edits.filter(function(e) { return e.editedAt > cutoff; });
+  } catch (e) { return []; }
+}
+
 // ── Loop drift detection ───────────────────────────────────────────────────────
 // Record tool call signatures per session, warn when the same call recurs ≥3×.
 function _recordToolCall(signature) {
@@ -910,11 +976,14 @@ const handlers = {
             else if (topGraph.label === 'Class' || topGraph.label === 'Interface') agent = 'system-architect';
             // Functions, files, methods → coder
             else                                                             agent = 'coder';
+            // Scale confidence by graph degree: well-connected nodes are stronger anchors.
+            var topDeg = topGraph.deg || 0;
+            var graphConf = topDeg > 30 ? 0.80 : (topDeg > 10 ? 0.75 : 0.70);
             result = Object.assign({}, result, {
               agent: agent,
               agentSlug: agent,
-              confidence: 0.70,
-              reason: 'Graph fallback: top file ' + (topGraph.name || '').substring(0, 30) + ' [' + topGraph.label + ']',
+              confidence: graphConf,
+              reason: 'Graph fallback: top file ' + (topGraph.name || '').substring(0, 30) + ' [' + topGraph.label + '] deg=' + topDeg,
               specificAgents: [],
               extrasMatches: [],
             });
@@ -1133,11 +1202,46 @@ const handlers = {
           // Pre-resolve top-5 relevant files for the user's prompt — the LLM
           // sees the answer inline instead of being told to call a tool.
           var suggestions = getMonographSuggestions(prompt, 5);
+
+          // Boost recently-edited files to the top of pre-resolve suggestions.
+          // Even when the FTS index hasn't caught up to the latest edits, the
+          // LLM should see the files it just modified as the primary context.
+          try {
+            var recentEditsForRoute = _getRecentEdits();
+            if (recentEditsForRoute.length > 0) {
+              // Extract prompt keywords for relevance gating
+              var promptWords = (prompt || '').toLowerCase().match(/[a-z][a-z0-9_-]{2,}/g) || [];
+              var promptWordSet = {};
+              for (var pw = 0; pw < promptWords.length; pw++) promptWordSet[promptWords[pw]] = 1;
+
+              var existingFiles = {};
+              for (var se = 0; se < suggestions.length; se++) existingFiles[suggestions[se].file || ''] = 1;
+
+              var editBoosts = [];
+              for (var re = 0; re < recentEditsForRoute.length && editBoosts.length < 2; re++) {
+                var reFile = recentEditsForRoute[re].file;
+                // Skip if already in suggestions
+                if (existingFiles[reFile]) continue;
+                var reName = path.basename(reFile, path.extname(reFile)).toLowerCase();
+                // Only boost if filename shares a keyword with the prompt OR the edit is very recent (<3 min)
+                var veryRecent = (Date.now() - recentEditsForRoute[re].editedAt) < 3 * 60 * 1000;
+                var matches = promptWordSet[reName] || veryRecent;
+                if (matches) {
+                  editBoosts.push({ name: path.basename(reFile), label: 'File', file: reFile, deg: 0, _editBoost: true });
+                }
+              }
+              if (editBoosts.length > 0) {
+                suggestions = editBoosts.concat(suggestions).slice(0, 5);
+              }
+            }
+          } catch (e) { /* non-fatal */ }
+
           if (suggestions.length > 0) {
             console.log('\n[MONOGRAPH] ' + nodeCount + ' nodes indexed. Top files for this task (pre-resolved from graph):');
             for (var si = 0; si < suggestions.length; si++) {
               var s = suggestions[si];
-              console.log('  · ' + s.name + ' [' + s.label + '] — ' + (s.file || '') + ' (deg ' + s.deg + ')');
+              var editTag = s._editBoost ? ' ✎' : '';
+              console.log('  · ' + s.name + ' [' + s.label + '] — ' + (s.file || '') + (s.deg ? ' (deg ' + s.deg + ')' : '') + editTag);
             }
             console.log('  Use mcp__monomind__monograph_query / monograph_impact for deeper drill-down.');
             _recordGraphTelemetry('preresolve_hit');
@@ -1347,6 +1451,12 @@ const handlers = {
         intelligence.recordEdit(file);
       } catch (e) { /* non-fatal */ }
     }
+    // Track recently-edited files for compact injection and pre-resolve boosting.
+    try {
+      var editedForRecent = hookInput.file_path || toolInput.file_path
+        || process.env.TOOL_INPUT_file_path || args[0] || '';
+      if (editedForRecent) _recordRecentEdit(editedForRecent);
+    } catch (e) { /* non-fatal */ }
     // Increment write counter and rebuild monograph when threshold hit.
     _maybeRebuildMonograph();
 

package/.claude/settings.local.json

@@ -47,5 +47,6 @@
       "Bash(mv monomind-memory.md monomind-memory.md)",
       "Bash(mv monomind-swarm.md monomind-swarm.md)"
     ]
-  }
+  },
+  "model": "opusplan"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.26",
+  "version": "1.10.27",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -127,4 +127,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}

package/packages/@monomind/cli/dist/src/commands/init.js

@@ -6,7 +6,7 @@ import { output } from '../output.js';
 import { confirm, select, multiSelect, input } from '../prompt.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
+import { executeInit, executeUpgrade, executeUpgradeWithMissing, findMonomindProjects, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
 // Check if project is already initialized
 function isInitialized(cwd) {
     const claudePath = path.join(cwd, '.claude', 'settings.json');
@@ -663,10 +663,57 @@ const upgradeCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'all',
+            description: 'Upgrade all known monomind projects on this machine (scans ~/Desktop, ~/projects, etc.)',
+            type: 'boolean',
+            default: false,
+        },
     ],
     action: async (ctx) => {
         const addMissing = (ctx.flags['add-missing'] || ctx.flags.addMissing);
         const upgradeSettings = (ctx.flags.settings);
+        const upgradeAll = (ctx.flags.all);
+        // ── --all: scan for every monomind project and upgrade each ──────────────
+        if (upgradeAll) {
+            output.writeln();
+            output.writeln(output.bold('Upgrading all monomind projects'));
+            output.writeln(output.dim('Scanning ~/Desktop, ~/projects, ~/code… (this may take a moment)'));
+            output.writeln();
+            const projects = findMonomindProjects();
+            if (projects.length === 0) {
+                output.printInfo('No monomind projects found. Install monomind in a project first: npx monomind init');
+                return { success: true, exitCode: 0 };
+            }
+            output.printInfo(`Found ${projects.length} project(s). Upgrading…`);
+            output.writeln();
+            let succeeded = 0;
+            let failed = 0;
+            for (const projDir of projects) {
+                const spinner = output.createSpinner({ text: projDir });
+                spinner.start();
+                try {
+                    const res = addMissing
+                        ? await executeUpgradeWithMissing(projDir, upgradeSettings)
+                        : await executeUpgrade(projDir, upgradeSettings);
+                    if (res.success) {
+                        spinner.succeed(projDir + ' (' + res.updated.length + ' updated)');
+                        succeeded++;
+                    }
+                    else {
+                        spinner.fail(projDir + ' — ' + (res.errors[0] || 'unknown error'));
+                        failed++;
+                    }
+                }
+                catch (e) {
+                    spinner.fail(projDir + ' — ' + (e instanceof Error ? e.message : String(e)));
+                    failed++;
+                }
+            }
+            output.writeln();
+            output.printInfo(`Done: ${succeeded} upgraded, ${failed} failed out of ${projects.length} projects.`);
+            return { success: failed === 0, exitCode: failed > 0 ? 1 : 0 };
+        }
         output.writeln();
         output.writeln(output.bold('Upgrading MonoMind'));
         if (addMissing && upgradeSettings) {

package/packages/@monomind/cli/dist/src/init/executor.d.ts

@@ -34,5 +34,11 @@ export declare function executeUpgrade(targetDir: string, upgradeSettings?: bool
  * @param upgradeSettings - If true, merge new settings into existing settings.json
  */
 export declare function executeUpgradeWithMissing(targetDir: string, upgradeSettings?: boolean): Promise<UpgradeResult>;
+/**
+ * Scan common locations for directories that have monomind installed
+ * (presence of .claude/helpers/hook-handler.cjs is the definitive signal).
+ * Searches up to maxDepth directory levels below each search root.
+ */
+export declare function findMonomindProjects(maxDepth?: number): string[];
 export default executeInit;
 //# sourceMappingURL=executor.d.ts.map

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -2168,5 +2168,65 @@ function countEnabledHooks(options) {
         count++;
     return count;
 }
+/**
+ * Scan common locations for directories that have monomind installed
+ * (presence of .claude/helpers/hook-handler.cjs is the definitive signal).
+ * Searches up to maxDepth directory levels below each search root.
+ */
+export function findMonomindProjects(maxDepth = 3) {
+    const os = require('os');
+    const home = os.homedir();
+    const searchRoots = [
+        path.join(home, 'Desktop'),
+        path.join(home, 'projects'),
+        path.join(home, 'code'),
+        path.join(home, 'work'),
+        path.join(home, 'dev'),
+        path.join(home, 'repos'),
+        path.join(home, 'src'),
+    ].filter(r => fs.existsSync(r));
+    // Also check known-projects registry if it exists
+    const registryPath = path.join(home, '.monomind-projects.json');
+    if (fs.existsSync(registryPath)) {
+        try {
+            const reg = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+            if (Array.isArray(reg.projects)) {
+                for (const p of reg.projects) {
+                    if (!searchRoots.includes(p) && fs.existsSync(p))
+                        searchRoots.push(p);
+                }
+            }
+        }
+        catch { }
+    }
+    const found = new Set();
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        const marker = path.join(dir, '.claude', 'helpers', 'hook-handler.cjs');
+        if (fs.existsSync(marker)) {
+            found.add(dir);
+            return;
+        } // don't recurse into a monomind project
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (!e.isDirectory())
+                continue;
+            if (e.name.startsWith('.') || e.name === 'node_modules')
+                continue;
+            walk(path.join(dir, e.name), depth + 1);
+        }
+    }
+    for (const root of searchRoots) {
+        walk(root, 0);
+    }
+    return [...found];
+}
 export default executeInit;
 //# sourceMappingURL=executor.js.map

package/packages/@monomind/cli/dist/src/init/index.d.ts

@@ -8,6 +8,6 @@ export { generateMCPConfig, generateMCPJson, } from './mcp-generator.js';
 export { generateStatuslineScript, generateStatuslineHook, } from './statusline-generator.js';
 export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHookHandler, generateIntelligenceStub, generateAutoMemoryHook, } from './helpers-generator.js';
 export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
-export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, findMonomindProjects, default } from './executor.js';
 export type { UpgradeResult } from './executor.js';
 //# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/init/index.js

@@ -11,5 +11,5 @@ export { generateStatuslineScript, generateStatuslineHook, } from './statusline-
 export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHookHandler, generateIntelligenceStub, generateAutoMemoryHook, } from './helpers-generator.js';
 export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
 // Main executor
-export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, findMonomindProjects, default } from './executor.js';
 //# sourceMappingURL=index.js.map

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.26",
+  "version": "1.10.27",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -112,4 +112,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}

package/packages/@monomind/cli/scripts/understand-analyze.mjs

@@ -48,11 +48,12 @@ const dbPathArg   = argVal('db')   ? resolve(argVal('db'))   : join(projectDir,
 const outputArg   = argVal('output')? resolve(argVal('output')) : join(projectDir, '.understand', 'knowledge-graph.json');
 const batchSize      = parseInt(argVal('batch-size') || '5',  10);
 const maxFiles       = parseInt(argVal('max-files')  || '0',  10);
-const dryRun         = hasFlag('dry-run');
-const noLlm          = hasFlag('no-llm');
-const layersOnly     = hasFlag('layers-only');
-const incremental    = hasFlag('incremental');
-const onboard        = hasFlag('onboard');
+const dryRun               = hasFlag('dry-run');
+const noLlm                = hasFlag('no-llm');
+const layersOnly           = hasFlag('layers-only');
+const incremental          = hasFlag('incremental');
+const importAnalysesStdin  = hasFlag('import-analyses-stdin');
+const onboard              = hasFlag('onboard');
 const onboardOut     = argVal('onboard-out') ? resolve(argVal('onboard-out')) : join(projectDir, 'ONBOARDING.md');
 
 // ── Resolve @monoes/monograph for DB access ──────────────────────────────────
@@ -629,6 +630,59 @@ async function main() {
   try { db.prepare(`ALTER TABLE nodes ADD COLUMN properties TEXT`).run(); } catch {}
   try { db.prepare(`CREATE TABLE IF NOT EXISTS communities (id INTEGER PRIMARY KEY, label TEXT, size INTEGER NOT NULL DEFAULT 0, cohesion_score REAL NOT NULL DEFAULT 0.0)`).run(); } catch {}
 
+  // ── Import analyses from stdin (slash-command write-back path) ───────────
+  // When Claude Code's /monomind:understand has collected per-file summaries
+  // through the active session, it pipes them back via:
+  //   echo "$ANALYSES_JSON" | node understand-analyze.mjs --import-analyses-stdin
+  // The JSON shape: { "analyses": [{ "id": <nodeId>, "fileSummary": "...", "tags": [...], ... }] }
+  if (importAnalysesStdin) {
+    const stdinText = await new Promise((resolve) => {
+      let buf = '';
+      process.stdin.setEncoding('utf-8');
+      process.stdin.on('data', c => { buf += c; });
+      process.stdin.on('end', () => resolve(buf));
+      process.stdin.on('error', () => resolve(buf));
+      // Bail out after 30 s so the slash command never hangs
+      setTimeout(() => resolve(buf), 30000);
+      process.stdin.resume();
+    });
+    let parsed = null;
+    try { parsed = JSON.parse(stdinText); } catch {}
+    const analyses = (parsed && Array.isArray(parsed.analyses)) ? parsed.analyses : [];
+    if (analyses.length === 0) {
+      console.error('[understand] --import-analyses-stdin: no analyses found in stdin JSON');
+      mg.closeDb(db);
+      process.exit(1);
+    }
+    const updateNode = db.prepare(`UPDATE nodes SET properties = ? WHERE id = ?`);
+    let written = 0;
+    const tx = db.transaction(() => {
+      for (const analysis of analyses) {
+        if (!analysis || !analysis.id) continue;
+        const existing = (() => {
+          try { const row = db.prepare('SELECT properties FROM nodes WHERE id=?').get(analysis.id); return row?.properties ? JSON.parse(row.properties) : {}; } catch { return {}; }
+        })();
+        const merged = {
+          ...existing,
+          ...(analysis.fileSummary   ? { summary:             analysis.fileSummary }            : {}),
+          ...(analysis.tags          ? { tags:                 analysis.tags }                   : {}),
+          ...(analysis.complexity    ? { complexity:           analysis.complexity }              : {}),
+          ...(analysis.functionSummaries ? { functionSummaries: analysis.functionSummaries }     : {}),
+          ...(analysis.classSummaries    ? { classSummaries:    analysis.classSummaries }        : {}),
+          ua_analyzed_at: new Date().toISOString(),
+        };
+        updateNode.run(JSON.stringify(merged), analysis.id);
+        written++;
+      }
+    });
+    tx();
+    // Rebuild FTS so summaries are immediately searchable
+    try { db.prepare(`INSERT INTO nodes_fts(nodes_fts) VALUES('rebuild')`).run(); } catch {}
+    mg.closeDb(db);
+    console.log(`[understand] Imported ${written} analyses from stdin. FTS rebuilt.`);
+    return;
+  }
+
   // ── Load all file nodes ──────────────────────────────────────────────────
   let fileNodes = db.prepare(`SELECT id, name, file_path, properties FROM nodes WHERE label = 'File' AND file_path IS NOT NULL`).all();
   console.log(`[understand] Found ${fileNodes.length} file nodes in DB`);