monomind 1.12.0 → 1.14.0

package/packages/@monomind/cli/dist/src/mcp-tools/task-tools.js

@@ -6,13 +6,12 @@
 import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { getProjectCwd } from './types.js';
-// Storage paths
-const STORAGE_DIR = '.monomind';
+import { getMonomindDataRoot } from './types.js';
+// Storage paths — relative to the git-safe data root
 const TASK_DIR = 'tasks';
 const TASK_FILE = 'store.json';
 function getTaskDir() {
-    return join(getProjectCwd(), STORAGE_DIR, TASK_DIR);
+    return join(getMonomindDataRoot(), TASK_DIR);
 }
 function getTaskPath() {
     return join(getTaskDir(), TASK_FILE);
@@ -248,7 +247,7 @@ export const taskTools = [
                 saveTaskStore(store);
                 // Sync assigned agents back to idle and increment taskCount
                 if (task.assignedTo.length > 0) {
-                    const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
+                    const agentStorePath = join(getMonomindDataRoot(), 'agents', 'store.json');
                     try {
                         let agentStore = { agents: {} };
                         if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
@@ -267,7 +266,7 @@ export const taskTools = [
                                     (agentStore.agents[agentId].taskCount || 0) + 1;
                             }
                         }
-                        const agentDir = join(getProjectCwd(), STORAGE_DIR, 'agents');
+                        const agentDir = join(getMonomindDataRoot(), 'agents');
                         if (!existsSync(agentDir))
                             mkdirSync(agentDir, { recursive: true });
                         const tmpAgent1 = `${agentStorePath}.${process.pid}.${Date.now()}.tmp`;
@@ -374,7 +373,7 @@ export const taskTools = [
             }
             const previouslyAssigned = [...task.assignedTo];
             // Load agent store to sync worker state
-            const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
+            const agentStorePath = join(getMonomindDataRoot(), 'agents', 'store.json');
             let agentStore = { agents: {} };
             try {
                 if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
@@ -424,7 +423,7 @@ export const taskTools = [
             }
             saveTaskStore(store);
             // Save agent store
-            const agentDir = join(getProjectCwd(), STORAGE_DIR, 'agents');
+            const agentDir = join(getMonomindDataRoot(), 'agents');
             if (!existsSync(agentDir)) {
                 mkdirSync(agentDir, { recursive: true });
             }

package/packages/@monomind/cli/dist/src/mcp-tools/types.d.ts

@@ -23,6 +23,7 @@ export interface MCPToolResult {
  * where process.cwd() may resolve to '/') over the real process.cwd().
  */
 export declare function getProjectCwd(): string;
+export declare function getMonomindDataRoot(cwd?: string): string;
 export interface MCPTool {
     name: string;
     description: string;

package/packages/@monomind/cli/dist/src/mcp-tools/types.js

@@ -3,6 +3,8 @@
  *
  * Local type definitions to avoid external imports outside package boundary.
  */
+import { statSync, readFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
 /**
  * Returns the effective project working directory.
  * Prefers MONOMIND_CWD (set by the install script for global/MCP installs
@@ -11,4 +13,51 @@
 export function getProjectCwd() {
     return process.env.MONOMIND_CWD || process.cwd();
 }
+/**
+ * Returns the stable Monomind data root that survives branch switches and is
+ * shared across all git worktrees of the same repository.
+ *
+ * Resolution order:
+ *   1. MONOMIND_DATA_DIR env var — allows overriding to e.g. ~/.monomind/<project>
+ *   2. <repo>/.git/monomind/     — regular repo (branch-agnostic, shared by design)
+ *   3. <main-repo>/.git/monomind/— worktree: .git is a pointer file → resolve to
+ *                                  the shared .git dir of the main worktree
+ *   4. <cwd>/.monomind/          — fallback when git is unavailable
+ *
+ * Mirrors the _getGitMonomindDir() function in server.mjs so session, task,
+ * memory, and org data all land in the same stable location.
+ */
+const _dataRootCache = new Map();
+export function getMonomindDataRoot(cwd) {
+    if (process.env.MONOMIND_DATA_DIR)
+        return process.env.MONOMIND_DATA_DIR;
+    const workDir = cwd || getProjectCwd();
+    if (_dataRootCache.has(workDir))
+        return _dataRootCache.get(workDir);
+    let result;
+    try {
+        const gitEntry = join(workDir, '.git');
+        const st = statSync(gitEntry);
+        if (st.isDirectory()) {
+            result = join(gitEntry, 'monomind');
+        }
+        else {
+            // Worktree: .git is a text file "gitdir: /main/.git/worktrees/name"
+            const m = readFileSync(gitEntry, 'utf8').match(/^gitdir:\s*(.+)/m);
+            if (m) {
+                const worktreeDir = resolve(workDir, m[1].trim());
+                const commonGitDir = dirname(dirname(worktreeDir));
+                result = join(commonGitDir, 'monomind');
+            }
+            else {
+                result = join(workDir, '.monomind');
+            }
+        }
+    }
+    catch {
+        result = join(workDir, '.monomind');
+    }
+    _dataRootCache.set(workDir, result);
+    return result;
+}
 //# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/services/worker-daemon.js

@@ -761,6 +761,59 @@ export class WorkerDaemon extends EventEmitter {
             },
             scannedAt: Date.now(),
         };
+        // Enrich with monograph graph stats for LLM context injection.
+        // Lazy-import to avoid hard dependency; silently skip on any error.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    // Node/edge counts
+                    map['graph'] = {
+                        nodes: countNodes(db),
+                        edges: countEdges(db),
+                    };
+                    // Top 3 god nodes (high degree internal files) — same SQL as monograph_god_nodes tool
+                    const excluded = ['File', 'Folder', 'Community', 'Concept'];
+                    const rows = db.prepare(`
+            SELECT n.name, n.file_path, n.start_line,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN (${excluded.map(() => '?').join(',')})
+            GROUP BY n.id HAVING degree > 0
+            ORDER BY degree DESC LIMIT 3
+          `).all(...excluded);
+                    if (rows.length > 0) {
+                        map['topFiles'] = rows.map(r => ({
+                            ref: r.file_path
+                                ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
+                                : r.name,
+                            degree: r.degree,
+                        }));
+                    }
+                    // Index staleness via git — same approach as monograph_health tool
+                    try {
+                        const { execSync } = await import('child_process');
+                        const lastHash = db.prepare("SELECT value FROM meta WHERE key = 'last_commit_hash' LIMIT 1").get()?.value;
+                        if (lastHash) {
+                            const countOut = execSync(`git -C ${JSON.stringify(this.projectRoot)} rev-list --count ${lastHash}..HEAD`, { timeout: 5000 }).toString().trim();
+                            const commitsBehind = parseInt(countOut, 10);
+                            if (!isNaN(commitsBehind)) {
+                                map['graphStaleness'] = { commitsBehind };
+                            }
+                        }
+                    }
+                    catch { /* git unavailable — skip staleness */ }
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+        }
+        catch { /* monograph unavailable — skip graph enrichment */ }
         const metricsFileTmp1 = metricsFile + '.tmp';
         writeFileSync(metricsFileTmp1, JSON.stringify(map, null, 2));
         renameSync(metricsFileTmp1, metricsFile);
@@ -788,6 +841,68 @@ export class WorkerDaemon extends EventEmitter {
             recommendations: [],
             note: 'Install Claude Code CLI for AI-powered security analysis',
         };
+        // Enrich with monograph high-centrality files and surprising cross-community edges.
+        // God-node files are high-value targets for security review: they are imported by
+        // many consumers, so a vulnerability there has the largest blast radius.
+        // Cross-community edges reveal unexpected coupling that may indicate hidden attack surfaces.
+        try {
+            const { openDb, closeDb } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const godFileRows = db.prepare(`
+            SELECT n.file_path,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN ('File','Folder','Community','Concept')
+              AND n.file_path IS NOT NULL
+              AND n.file_path NOT LIKE '%node_modules%'
+              AND n.file_path NOT LIKE '%/dist/%'
+              AND n.file_path NOT LIKE '%.test.%'
+              AND n.file_path NOT LIKE '%.spec.%'
+            GROUP BY n.file_path
+            ORDER BY degree DESC
+            LIMIT 5
+          `).all();
+                    const surpriseRows = db.prepare(`
+            SELECT n1.name as src_name, n2.name as tgt_name, e.relation, e.confidence_score,
+                   n1.file_path as src_file, n2.file_path as tgt_file
+            FROM edges e
+            JOIN nodes n1 ON n1.id = e.source_id
+            JOIN nodes n2 ON n2.id = e.target_id
+            WHERE e.confidence != 'EXTRACTED'
+              AND n1.community_id IS NOT NULL
+              AND n2.community_id IS NOT NULL
+              AND n1.community_id != n2.community_id
+            ORDER BY e.confidence_score ASC
+            LIMIT 5
+          `).all();
+                    if (godFileRows.length > 0) {
+                        audit['priorityScanTargets'] = godFileRows.map(r => ({
+                            file: r.file_path.replace(this.projectRoot + '/', '').replace(this.projectRoot + '\\', ''),
+                            degree: r.degree,
+                            reason: 'high-centrality: vulnerability here affects the most consumers',
+                        }));
+                    }
+                    if (surpriseRows.length > 0) {
+                        audit['unexpectedCoupling'] = surpriseRows.map(r => ({
+                            edge: `${r.src_name} --${r.relation}--> ${r.tgt_name}`,
+                            srcFile: r.src_file ?? '(unknown)',
+                            tgtFile: r.tgt_file ?? '(unknown)',
+                            confidenceScore: r.confidence_score,
+                            reason: 'cross-community edge: may indicate hidden dependency or attack surface',
+                        }));
+                    }
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+        }
+        catch { /* monograph unavailable — skip graph enrichment */ }
         const auditFileTmp = auditFile + '.tmp';
         writeFileSync(auditFileTmp, JSON.stringify(audit, null, 2));
         renameSync(auditFileTmp, auditFile);
@@ -927,13 +1042,95 @@ export class WorkerDaemon extends EventEmitter {
      * Local ultralearn worker (fallback when headless unavailable)
      */
     async runUltralearnWorkerLocal() {
-        return {
+        const result = {
             timestamp: new Date().toISOString(),
             mode: 'local',
             patternsLearned: 0,
             insightsGained: [],
-            note: 'Install Claude Code CLI for AI-powered deep learning',
         };
+        // Enrich with monograph community clusters and bridge-node patterns for LLM context injection.
+        // Bridge nodes (symbols that cross community boundaries) are architecturally significant —
+        // they represent coupling points an LLM should be aware of when reasoning about change impact.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const nodeCount = countNodes(db);
+                    const edgeCount = countEdges(db);
+                    const communityRows = db.prepare(`
+            SELECT community_id, COUNT(*) AS member_count
+            FROM nodes
+            WHERE community_id IS NOT NULL
+              AND label NOT IN ('File','Folder','Community','Concept')
+            GROUP BY community_id
+            ORDER BY member_count DESC
+            LIMIT 5
+          `).all();
+                    const bridgeRows = db.prepare(`
+            SELECT n.name, n.label, n.file_path, n.start_line,
+                   COUNT(DISTINCT e.id) AS cross_edges
+            FROM nodes n
+            JOIN edges e ON (e.source_id = n.id OR e.target_id = n.id)
+            JOIN nodes n2 ON (
+              CASE WHEN e.source_id = n.id THEN e.target_id ELSE e.source_id END = n2.id
+            )
+            WHERE n.community_id IS NOT NULL
+              AND n2.community_id IS NOT NULL
+              AND n.community_id != n2.community_id
+              AND n.label NOT IN ('File','Folder','Community','Concept')
+              AND (n.file_path IS NULL OR (
+                n.file_path NOT LIKE '%node_modules%'
+                AND n.file_path NOT LIKE '%/dist/%'
+                AND n.file_path NOT LIKE '%.test.%'
+                AND n.file_path NOT LIKE '%.spec.%'
+              ))
+            GROUP BY n.id
+            ORDER BY cross_edges DESC
+            LIMIT 5
+          `).all();
+                    const insights = result['insightsGained'];
+                    if (communityRows.length > 0) {
+                        insights.push({
+                            category: 'community_clusters',
+                            description: `Top ${communityRows.length} community clusters by size`,
+                            items: communityRows.map(r => ({
+                                communityId: r.community_id,
+                                memberCount: r.member_count,
+                            })),
+                        });
+                    }
+                    if (bridgeRows.length > 0) {
+                        insights.push({
+                            category: 'bridge_nodes',
+                            description: `Top ${bridgeRows.length} bridge nodes crossing community boundaries (high coupling risk)`,
+                            items: bridgeRows.map(r => {
+                                const loc = r.file_path
+                                    ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
+                                    : '(unknown)';
+                                return {
+                                    name: r.name,
+                                    label: r.label,
+                                    location: loc,
+                                    crossCommunityEdges: r.cross_edges,
+                                };
+                            }),
+                        });
+                        result['patternsLearned'] = bridgeRows.length + communityRows.length;
+                    }
+                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+            else {
+                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep learning';
+            }
+        }
+        catch { /* monograph unavailable — return minimal result */ }
+        return result;
     }
     /**
      * Local refactor worker (fallback when headless unavailable)
@@ -951,13 +1148,106 @@ export class WorkerDaemon extends EventEmitter {
      * Local deepdive worker (fallback when headless unavailable)
      */
     async runDeepdiveWorkerLocal() {
-        return {
+        const deepdiveFile = join(this.projectRoot, '.monomind', 'metrics', 'deepdive.json');
+        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
+        if (!existsSync(metricsDir)) {
+            mkdirSync(metricsDir, { recursive: true });
+        }
+        const result = {
             timestamp: new Date().toISOString(),
             mode: 'local',
-            analysisDepth: 'shallow',
+            analysisDepth: 'graph',
             findings: [],
-            note: 'Install Claude Code CLI for AI-powered deep code analysis',
         };
+        // Enrich with monograph god nodes and high-degree file analysis for LLM context injection.
+        // Lazy-import to avoid hard dependency; silently skip on any error.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const nodeCount = countNodes(db);
+                    const edgeCount = countEdges(db);
+                    const godNodeRows = db.prepare(`
+            SELECT n.name, n.file_path, n.label,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN ('File','Folder','Community','Concept')
+              AND (n.file_path IS NULL OR (
+                n.file_path NOT LIKE '%node_modules%'
+                AND n.file_path NOT LIKE '%/dist/%'
+                AND n.file_path NOT LIKE '%.test.%'
+                AND n.file_path NOT LIKE '%.spec.%'
+              ))
+            GROUP BY n.id
+            ORDER BY degree DESC
+            LIMIT 5
+          `).all();
+                    const godNodes = godNodeRows.map(r => ({
+                        name: r.name,
+                        label: r.label,
+                        file: r.file_path ?? '(unknown)',
+                        degree: r.degree,
+                    }));
+                    const fileRows = db.prepare(`
+            SELECT n.file_path,
+                   COUNT(DISTINCT e2.id) AS in_deg,
+                   COUNT(DISTINCT e1.id) AS out_deg
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label = 'File'
+              AND n.file_path NOT LIKE '%node_modules%'
+              AND n.file_path NOT LIKE '%/dist/%'
+              AND n.file_path NOT LIKE '%.test.%'
+              AND n.file_path NOT LIKE '%.spec.%'
+            GROUP BY n.id
+            ORDER BY (in_deg + out_deg) DESC
+            LIMIT 5
+          `).all();
+                    const highDegFiles = fileRows.map(r => ({
+                        file: r.file_path
+                            .replace(this.projectRoot + '/', '')
+                            .replace(this.projectRoot + '\\', ''),
+                        inDegree: r.in_deg,
+                        outDegree: r.out_deg,
+                        totalDegree: r.in_deg + r.out_deg,
+                    }));
+                    const findings = [];
+                    if (godNodes.length > 0) {
+                        findings.push({
+                            category: 'god_nodes',
+                            description: `Top ${godNodes.length} high-centrality symbols (most imported/referenced)`,
+                            items: godNodes,
+                        });
+                    }
+                    if (highDegFiles.length > 0) {
+                        findings.push({
+                            category: 'high_degree_files',
+                            description: `Top ${highDegFiles.length} files by total edge degree (import + export connections)`,
+                            items: highDegFiles,
+                        });
+                    }
+                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
+                    result['findings'] = findings;
+                    result['analysisDepth'] = 'graph';
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+            else {
+                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep analysis';
+            }
+        }
+        catch { /* monograph unavailable — return minimal result */ }
+        const deepdiveFileTmp = deepdiveFile + '.tmp';
+        writeFileSync(deepdiveFileTmp, JSON.stringify(result, null, 2));
+        renameSync(deepdiveFileTmp, deepdiveFile);
+        return result;
     }
     /**
      * Local benchmark worker

package/packages/@monomind/cli/dist/src/transfer/serialization/cfp.js

@@ -137,7 +137,7 @@ export function deserializeCFP(data) {
 export function validateCFP(cfp) {
     const errors = [];
     if (cfp.magic !== 'CFP1') {
-        errors.push('Invalid magic bytes');
+        errors.push(`Invalid magic bytes: ${cfp.magic}`);
     }
     if (!cfp.version) {
         errors.push('Missing version');

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "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",