monomind 2.0.3 → 2.1.3

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

@@ -19,23 +19,36 @@ function _isValidDb(p) {
         return false;
     }
 }
-function getDbPath() {
-    const cwd = getProjectCwd();
+/**
+ * Resolve the monograph DB path for a given repo root (defaults to project cwd).
+ * Falls back to searching up to the git root when the DB isn't directly under
+ * `<cwd>/.monomind` — e.g. when called from a subdirectory of the repo. Only
+ * the no-arg (project cwd) form is cached; explicit `repoPath` overrides are
+ * cheap one-off lookups (staleness checks with a user-supplied path) so caching
+ * them isn't worth the invalidation complexity.
+ */
+function getDbPath(repoPathOverride) {
+    const cwd = repoPathOverride ?? getProjectCwd();
+    const useCache = repoPathOverride === undefined;
     // Invalidate cache when project root changes (e.g. MONOMIND_CWD set after initialize)
-    if (_cachedDbPath && _cachedCwd === cwd)
+    if (useCache && _cachedDbPath && _cachedCwd === cwd)
         return _cachedDbPath;
-    _cachedCwd = cwd;
-    _cachedDbPath = undefined;
+    if (useCache) {
+        _cachedCwd = cwd;
+        _cachedDbPath = undefined;
+    }
     const direct = join(cwd, '.monomind', 'monograph.db');
     if (_isValidDb(direct)) {
-        _cachedDbPath = direct;
+        if (useCache)
+            _cachedDbPath = direct;
         return direct;
     }
     try {
         const root = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf8' }).trim();
         const candidate = join(root, '.monomind', 'monograph.db');
         if (_isValidDb(candidate)) {
-            _cachedDbPath = candidate;
+            if (useCache)
+                _cachedDbPath = candidate;
             return candidate;
         }
     }
@@ -46,13 +59,6 @@ function getDbPath() {
 function text(t) {
     return { content: [{ type: 'text', text: t }] };
 }
-function ensureDbExists() {
-    const p = getDbPath();
-    if (!_isValidDb(p)) {
-        throw new Error(`Monograph index not built yet. Run monograph_build first (path: ${p}).`);
-    }
-    return p;
-}
 // ── Active watcher registry ──────────────────────────────────────────────────
 const _activeWatchers = new Map();
 function applyPprRerank(db, seedNodes, damping, maxResults) {
@@ -577,9 +583,13 @@ function taskRelevance(task, nodeText) {
     return taskTerms.filter(t => txt.includes(t)).length / taskTerms.length;
 }
 // ── monograph_visualize ───────────────────────────────────────────────────────
+// Columns needed to render/export the graph — deliberately excludes `embedding`,
+// which can be several KB per node (384D vectors) and would otherwise bloat
+// tool-result payloads and written files by many MB.
+const NODE_RENDER_COLUMNS = 'id, label, name, norm_label, file_path, start_line, end_line, community_id, is_exported, language, properties';
 const monographVisualizeTool = {
     name: 'monograph_visualize',
-    description: 'Render the knowledge graph as HTML (default), SVG, or JSON.',
+    description: 'Render the knowledge graph as HTML (default), SVG, or JSON. Writes output to a file under .monomind/visualize/ and returns the file path (output can be multi-MB at the max node count, too large to return inline).',
     inputSchema: {
         type: 'object',
         properties: {
@@ -589,6 +599,7 @@ const monographVisualizeTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb, toJson, toHtml, toSvg } = await import('@monoes/monograph');
+        const { writeFileSync, mkdirSync } = await import('fs');
         const db = openDb(getDbPath());
         try {
             // Cap maxNodes: passed to SQL LIMIT clause for both nodes (n) and edges
@@ -598,7 +609,7 @@ const monographVisualizeTool = {
             const limit = Number.isFinite(rawMaxNodes) && rawMaxNodes > 0
                 ? Math.min(Math.floor(rawMaxNodes), MAX_EXPORT_NODES)
                 : 500;
-            const nodes = db.prepare('SELECT * FROM nodes LIMIT ?').all(limit);
+            const nodes = db.prepare(`SELECT ${NODE_RENDER_COLUMNS} FROM nodes LIMIT ?`).all(limit);
             // Only include edges where both endpoints are in the visible node set
             const edges = db.prepare(`
         SELECT e.* FROM edges e
@@ -607,11 +618,15 @@ const monographVisualizeTool = {
         LIMIT ?
       `).all(limit, limit, limit * 3);
             const fmt = input.format ?? 'html';
-            if (fmt === 'json')
-                return text(toJson(nodes, edges));
-            if (fmt === 'svg')
-                return text(toSvg(nodes, edges));
-            return text(toHtml(nodes, edges));
+            const rendered = fmt === 'json' ? toJson(nodes, edges)
+                : fmt === 'svg' ? toSvg(nodes, edges)
+                    : toHtml(nodes, edges);
+            const ext = fmt === 'json' ? 'json' : fmt === 'svg' ? 'svg' : 'html';
+            const outDir = resolve(join(getProjectCwd(), '.monomind', 'visualize'));
+            mkdirSync(outDir, { recursive: true });
+            const outPath = join(outDir, `graph-${Date.now()}.${ext}`);
+            writeFileSync(outPath, rendered);
+            return text(`Visualization written to ${outPath} (${nodes.length} nodes, ${edges.length} edges)${ext === 'html' ? '\nNote: HTML uses the vis-network CDN script and requires network access to render.' : ''}`);
         }
         finally {
             closeDb(db);
@@ -700,7 +715,8 @@ const monographReportTool = {
                     return `${i + 1}. **${n.name}** (${n.label}) — degree ${n.degree}${loc ? `  \`${loc}\`` : ''}`;
                 }),
             ].join('\n');
-            const outPath = resolve(input.path ?? join(getProjectCwd(), '.monomind', 'GRAPH_REPORT.md'));
+            const rawOutPath = input.path ?? join(getProjectCwd(), '.monomind', 'GRAPH_REPORT.md');
+            const outPath = resolve(getProjectCwd(), rawOutPath);
             const allowedRoot = resolve(getProjectCwd());
             if (outPath !== allowedRoot && !outPath.startsWith(allowedRoot + sep)) {
                 return text(`Error: path must be within the project directory (${allowedRoot})`);
@@ -725,7 +741,13 @@ let _buildInProgress = false;
 async function computeCommitsBehind(repoPath) {
     const { openDb, closeDb } = await import('@monoes/monograph');
     const { execSync } = await import('child_process');
-    const db = openDb(join(repoPath, '.monomind', 'monograph.db'));
+    const dbPath = getDbPath(repoPath);
+    if (!_isValidDb(dbPath))
+        return null;
+    // openDb's fileMustExist option isn't in the currently-published
+    // @monoes/monograph release this CLI depends on — _isValidDb above is the
+    // real guard against openDb silently creating an empty DB at a missing path.
+    const db = openDb(dbPath);
     try {
         const meta = db.prepare("SELECT value FROM index_meta WHERE key = 'last_commit_hash'").get() ?? db.prepare("SELECT value FROM index_meta WHERE key = 'lastCommit'").get();
         const lastCommit = meta?.value ?? null;
@@ -929,11 +951,13 @@ const monographExportTool = {
         const { writeFileSync, mkdirSync } = await import('fs');
         const db = openDb(getDbPath());
         try {
-            const nodes = db.prepare('SELECT * FROM nodes').all();
+            // Exclude `embedding` — a several-KB-per-node vector column that would
+            // otherwise bloat exported files by many MB for no rendering benefit.
+            const nodes = db.prepare(`SELECT ${NODE_RENDER_COLUMNS} FROM nodes`).all();
             const edges = db.prepare('SELECT * FROM edges').all();
             const fmt = input.format;
             const requestedOut = input.outputPath ?? join(getProjectCwd(), '.monomind', 'export');
-            const outDir = resolve(requestedOut);
+            const outDir = resolve(getProjectCwd(), requestedOut);
             const allowedRoot = resolve(getProjectCwd());
             if (outDir !== allowedRoot && !outDir.startsWith(allowedRoot + sep)) {
                 return text(`Error: outputPath must be within the project directory (${allowedRoot})`);
@@ -1072,8 +1096,10 @@ const monographImpactTool = {
             const impactPath = typeof rawImpactPath === 'string' && rawImpactPath.length > MAX_IMPACT_PATH_LEN
                 ? rawImpactPath.slice(0, MAX_IMPACT_PATH_LEN) : rawImpactPath;
             const rawDepth = input.depth;
-            const depth = typeof rawDepth === 'number' && Number.isFinite(rawDepth) && rawDepth > 0
-                ? Math.min(Math.floor(rawDepth), 6) : rawDepth;
+            const depth = rawDepth === undefined
+                ? undefined
+                : (typeof rawDepth === 'number' && Number.isFinite(rawDepth) && rawDepth > 0
+                    ? Math.min(Math.floor(rawDepth), 6) : 3);
             const result = getMonographImpact(db, {
                 name: impactName,
                 filePath: impactPath,
@@ -1737,7 +1763,13 @@ const monographInstallSkillsTool = {
             return text(`Invalid platform "${platform}". Must be one of: ${validPlatforms.join(', ')}`);
         }
         // Load community data from graph
-        const dbPath = join(repoPath, '.monomind', 'monograph.db');
+        const dbPath = getDbPath(repoPath);
+        // openDb's fileMustExist option isn't in the currently-published
+        // @monoes/monograph release this CLI depends on — check validity
+        // ourselves so a missing DB doesn't get silently auto-created empty.
+        if (!_isValidDb(dbPath)) {
+            return text('Graph not built yet. Run monograph_build first.');
+        }
         let db;
         try {
             db = openDb(dbPath);
@@ -1846,21 +1878,19 @@ const monographListReposTool = {
 // ── monograph_group_contracts ─────────────────────────────────────────────────
 const monographGroupContractsTool = {
     name: 'monograph_group_contracts',
-    description: 'List public API contracts (exported symbols, interfaces, and types) for all groups defined in .monograph/groups.json.',
+    description: 'List public API contracts (exported symbols, interfaces, and types) for all groups defined in group.yaml.',
     inputSchema: {
         type: 'object',
         properties: {
-            repoPath: { type: 'string', description: 'Absolute path to the repository (defaults to cwd).' },
+            configPath: { type: 'string', description: 'Path to group.yaml (defaults to group.yaml in project cwd)' },
         },
     },
     handler: async (input) => {
         const { getGroupContracts } = await import('./monograph-compat.js');
-        const { join } = await import('path');
-        const repoPath = input.repoPath ?? getProjectCwd();
-        const configPath = join(repoPath, '.monograph', 'groups.json');
+        const configPath = input.configPath ?? join(getProjectCwd(), 'group.yaml');
         const contracts = await getGroupContracts(configPath);
         if (contracts.length === 0)
-            return text('No contracts found. Ensure groups are defined in .monograph/groups.json.');
+            return text(`No contracts found. Ensure groups are defined in ${configPath}.`);
         const lines = contracts.map(c => `[${c.groupName}] ${c.symbol} — ${c.filePath}:${c.line}`);
         return text(lines.join('\n'));
     },
@@ -1872,14 +1902,12 @@ const monographGroupStatusTool = {
     inputSchema: {
         type: 'object',
         properties: {
-            repoPath: { type: 'string', description: 'Absolute path to the repository (defaults to cwd).' },
+            configPath: { type: 'string', description: 'Path to group.yaml (defaults to group.yaml in project cwd)' },
         },
     },
     handler: async (input) => {
         const { getGroupStatus } = await import('./monograph-compat.js');
-        const { join } = await import('path');
-        const repoPath = input.repoPath ?? getProjectCwd();
-        const configPath = join(repoPath, '.monograph', 'groups.json');
+        const configPath = input.configPath ?? join(getProjectCwd(), 'group.yaml');
         const status = await getGroupStatus(configPath);
         const lines = [`Groups: ${status.totalGroups} (${status.indexedGroups} indexed, ${status.stalledGroups} stalled)`];
         for (const g of status.groups) {
@@ -1954,10 +1982,26 @@ const monographDeadCodeTool = {
         const repoPath = input.path ?? getProjectCwd();
         const cats = input.categories ?? ['dead-functions', 'orphan-files', 'stale-dist'];
         const result = {};
-        const dbPath = join(repoPath, '.monomind', 'monograph.db');
+        const dbPath = getDbPath(repoPath);
+        // openDb's fileMustExist option isn't in the currently-published
+        // @monoes/monograph release this CLI depends on — check validity
+        // ourselves so a missing DB doesn't get silently auto-created empty.
+        if (!_isValidDb(dbPath)) {
+            return text(JSON.stringify({ error: 'No monograph index found. Run monograph_build first.' }));
+        }
         let db = null;
         try {
             db = openDb(dbPath);
+            // _isValidDb's size check can't distinguish a real index from an
+            // empty-but-schema-migrated DB (better-sqlite3 auto-creates + migrates
+            // on open, and other unguarded openDb() call sites in this file can
+            // create exactly that as a side effect of an unrelated tool call before
+            // monograph_build ever runs). Verify actual content post-open so this
+            // reports "never built" instead of a misleading "0 dead functions found".
+            const { count } = db.prepare('SELECT COUNT(*) as count FROM nodes').get();
+            if (count === 0) {
+                return text(JSON.stringify({ error: 'No monograph index found. Run monograph_build first.' }));
+            }
         }
         catch {
             return text(JSON.stringify({ error: 'No monograph index found. Run monograph_build first.' }));
@@ -1997,9 +2041,12 @@ const monographDeadCodeTool = {
           FROM nodes n
           WHERE n.label = 'File'
             AND (SELECT COUNT(*) FROM edges e WHERE e.target_id = n.id AND e.relation = 'IMPORTS') = 0
-            AND n.file_path NOT LIKE '%test%'
+            AND n.file_path NOT LIKE '%/test/%'
+            AND n.file_path NOT LIKE '%/tests/%'
+            AND n.file_path NOT LIKE '%.test.%'
             AND n.file_path NOT LIKE '%__tests__%'
-            AND n.file_path NOT LIKE '%spec%'
+            AND n.file_path NOT LIKE '%/spec/%'
+            AND n.file_path NOT LIKE '%.spec.%'
             AND n.file_path NOT LIKE '%/index.%'
             AND n.file_path NOT LIKE 'bin/%'
             AND n.file_path NOT LIKE 'scripts/%'

package/packages/@monomind/cli/dist/src/mcp-tools/quality/coverage-analysis/prioritize-gaps.d.ts

@@ -13,14 +13,14 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         startLine: z.ZodNumber;
         endLine: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        type: "function" | "line" | "branch";
         id: string;
+        type: "branch" | "function" | "line";
         file: string;
         startLine: number;
         endLine: number;
     }, {
-        type: "function" | "line" | "branch";
         id: string;
+        type: "branch" | "function" | "line";
         file: string;
         startLine: number;
         endLine: number;
@@ -52,9 +52,15 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodNumber>;
     groupBy: z.ZodDefault<z.ZodEnum<["risk", "file", "type", "none"]>>;
 }, "strip", z.ZodTypeAny, {
-    limit: number;
-    factors: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[];
-    groupBy: "type" | "none" | "file" | "risk";
+    gaps?: {
+        id: string;
+        type: "branch" | "function" | "line";
+        file: string;
+        startLine: number;
+        endLine: number;
+    }[] | undefined;
+    targetPath?: string | undefined;
+    factors: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[];
     weights?: {
         complexity: number;
         changeFrequency: number;
@@ -63,16 +69,18 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         dependencyCount: number;
         testDifficulty: number;
     } | undefined;
+    limit: number;
+    groupBy: "file" | "none" | "risk" | "type";
+}, {
     gaps?: {
-        type: "function" | "line" | "branch";
         id: string;
+        type: "branch" | "function" | "line";
         file: string;
         startLine: number;
         endLine: number;
     }[] | undefined;
     targetPath?: string | undefined;
-}, {
-    limit?: number | undefined;
+    factors?: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[] | undefined;
     weights?: {
         complexity?: number | undefined;
         changeFrequency?: number | undefined;
@@ -81,16 +89,8 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         dependencyCount?: number | undefined;
         testDifficulty?: number | undefined;
     } | undefined;
-    gaps?: {
-        type: "function" | "line" | "branch";
-        id: string;
-        file: string;
-        startLine: number;
-        endLine: number;
-    }[] | undefined;
-    targetPath?: string | undefined;
-    factors?: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[] | undefined;
-    groupBy?: "type" | "none" | "file" | "risk" | undefined;
+    limit?: number | undefined;
+    groupBy?: "file" | "none" | "risk" | "type" | undefined;
 }>;
 export type PrioritizeGapsInput = z.infer<typeof PrioritizeGapsInputSchema>;
 export interface PrioritizeGapsOutput {
@@ -176,14 +176,14 @@ export declare const toolDefinition: {
             startLine: z.ZodNumber;
             endLine: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            type: "function" | "line" | "branch";
             id: string;
+            type: "branch" | "function" | "line";
             file: string;
             startLine: number;
             endLine: number;
         }, {
-            type: "function" | "line" | "branch";
             id: string;
+            type: "branch" | "function" | "line";
             file: string;
             startLine: number;
             endLine: number;
@@ -215,9 +215,15 @@ export declare const toolDefinition: {
         limit: z.ZodDefault<z.ZodNumber>;
         groupBy: z.ZodDefault<z.ZodEnum<["risk", "file", "type", "none"]>>;
     }, "strip", z.ZodTypeAny, {
-        limit: number;
-        factors: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[];
-        groupBy: "type" | "none" | "file" | "risk";
+        gaps?: {
+            id: string;
+            type: "branch" | "function" | "line";
+            file: string;
+            startLine: number;
+            endLine: number;
+        }[] | undefined;
+        targetPath?: string | undefined;
+        factors: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[];
         weights?: {
             complexity: number;
             changeFrequency: number;
@@ -226,16 +232,18 @@ export declare const toolDefinition: {
             dependencyCount: number;
             testDifficulty: number;
         } | undefined;
+        limit: number;
+        groupBy: "file" | "none" | "risk" | "type";
+    }, {
         gaps?: {
-            type: "function" | "line" | "branch";
             id: string;
+            type: "branch" | "function" | "line";
             file: string;
             startLine: number;
             endLine: number;
         }[] | undefined;
         targetPath?: string | undefined;
-    }, {
-        limit?: number | undefined;
+        factors?: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[] | undefined;
         weights?: {
             complexity?: number | undefined;
             changeFrequency?: number | undefined;
@@ -244,16 +252,8 @@ export declare const toolDefinition: {
             dependencyCount?: number | undefined;
             testDifficulty?: number | undefined;
         } | undefined;
-        gaps?: {
-            type: "function" | "line" | "branch";
-            id: string;
-            file: string;
-            startLine: number;
-            endLine: number;
-        }[] | undefined;
-        targetPath?: string | undefined;
-        factors?: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[] | undefined;
-        groupBy?: "type" | "none" | "file" | "risk" | undefined;
+        limit?: number | undefined;
+        groupBy?: "file" | "none" | "risk" | "type" | undefined;
     }>;
     handler: typeof handler;
 };

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/detect-secrets.d.ts

@@ -15,16 +15,16 @@ export declare const DetectSecretsInputSchema: z.ZodObject<{
     scanHistory: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     targetPath: string;
+    secretTypes: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[];
     excludePatterns: string[];
-    secretTypes: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
     includeEntropy: boolean;
     entropyThreshold: number;
     verifySecrets: boolean;
     scanHistory: boolean;
 }, {
     targetPath: string;
+    secretTypes?: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[] | undefined;
     excludePatterns?: string[] | undefined;
-    secretTypes?: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
     includeEntropy?: boolean | undefined;
     entropyThreshold?: number | undefined;
     verifySecrets?: boolean | undefined;
@@ -116,16 +116,16 @@ export declare const toolDefinition: {
         scanHistory: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         targetPath: string;
+        secretTypes: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[];
         excludePatterns: string[];
-        secretTypes: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
         includeEntropy: boolean;
         entropyThreshold: number;
         verifySecrets: boolean;
         scanHistory: boolean;
     }, {
         targetPath: string;
+        secretTypes?: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[] | undefined;
         excludePatterns?: string[] | undefined;
-        secretTypes?: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
         includeEntropy?: boolean | undefined;
         entropyThreshold?: number | undefined;
         verifySecrets?: boolean | undefined;

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

@@ -7,13 +7,14 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { getProjectCwd } from './types.js';
+import { getMonomindDataRoot, migrateLegacyStoreFile } from './types.js';
 import { agentTools } from './agent-tools.js';
-// Swarm state persistence
-const SWARM_DIR = '.monomind/swarm';
+// Swarm state persistence — relative to the git-safe data root (see
+// getMonomindDataRoot()), matching agent/task/hive-mind stores.
+const SWARM_DIR = 'swarm';
 const SWARM_STATE_FILE = 'swarm-state.json';
 function getSwarmDir() {
-    return join(getProjectCwd(), SWARM_DIR);
+    return join(getMonomindDataRoot(), SWARM_DIR);
 }
 function getSwarmStatePath() {
     return join(getSwarmDir(), SWARM_STATE_FILE);
@@ -28,6 +29,7 @@ const MAX_SWARM_STORE_BYTES = 10 * 1024 * 1024;
 function loadSwarmStore() {
     try {
         const path = getSwarmStatePath();
+        migrateLegacyStoreFile(path, join(SWARM_DIR, SWARM_STATE_FILE));
         if (existsSync(path)) {
             if (statSync(path).size > MAX_SWARM_STORE_BYTES)
                 return { swarms: {}, version: '3.0.0' };

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

@@ -8,7 +8,7 @@
  * - process.cpuUsage() for real CPU stats
  * - os module for system information
  */
-import { getProjectCwd } from './types.js';
+import { getProjectCwd, getMonomindDataRoot } from './types.js';
 import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -184,7 +184,7 @@ export const systemTools = [
             // Fallback: JSON store files (backward compatibility)
             if (_metricsSource === 'none') {
                 try {
-                    const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
+                    const agentStorePath = join(getMonomindDataRoot(), 'agents', 'store.json');
                     if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_SYSTEM_STORE_BYTES) {
                         const agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
                         const agents = Object.values(agentStore.agents || {});
@@ -197,7 +197,7 @@ export const systemTools = [
                 }
                 catch { /* agent store not available */ }
                 try {
-                    const taskStorePath = join(getProjectCwd(), STORAGE_DIR, 'tasks', 'store.json');
+                    const taskStorePath = join(getMonomindDataRoot(), 'tasks', 'store.json');
                     if (existsSync(taskStorePath) && statSync(taskStorePath).size <= MAX_SYSTEM_STORE_BYTES) {
                         const taskStore = JSON.parse(readFileSync(taskStorePath, 'utf-8'));
                         const tasks = Object.values(taskStore.tasks || {});
@@ -534,7 +534,7 @@ export const systemTools = [
         },
         handler: async () => {
             // Read from the task store file
-            const storePath = join(getProjectCwd(), '.monomind', 'tasks', 'store.json');
+            const storePath = join(getMonomindDataRoot(), 'tasks', 'store.json');
             let tasks = [];
             try {
                 if (existsSync(storePath) && statSync(storePath).size <= MAX_SYSTEM_STORE_BYTES) {

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

@@ -24,6 +24,26 @@ export interface MCPToolResult {
  */
 export declare function getProjectCwd(): string;
 export declare function getMonomindDataRoot(cwd?: string): string;
+/**
+ * One-time migration for the agent/task/hive/swarm stores that historically lived
+ * under `<projectCwd>/.monomind/<subpath>` (via getProjectCwd()) before being
+ * consolidated onto the canonical getMonomindDataRoot() location (typically
+ * `<repo>/.git/monomind/<subpath>`). Several MCP tool files (agent-tools.ts,
+ * hive-mind-tools.ts, swarm-tools.ts, system-tools.ts) used to read/write the
+ * legacy path directly, causing the same logical store to physically split from
+ * task-tools.ts/session-tools.ts, which always used getMonomindDataRoot().
+ *
+ * If the canonical file is missing but the legacy file exists, copy (never move,
+ * for safety) the legacy file into place so pre-existing data isn't silently
+ * orphaned. Best-effort and idempotent — never throws, and it's a no-op once the
+ * canonical file exists or when the two paths already coincide (e.g. no .git).
+ *
+ * @param canonicalPath Absolute path under getMonomindDataRoot() the tool now reads from.
+ * @param legacySubpath Path relative to `.monomind/` that the tool used to read from
+ *   (e.g. `join('agents', 'store.json')`).
+ * @param cwd Optional project cwd override (defaults to getProjectCwd()).
+ */
+export declare function migrateLegacyStoreFile(canonicalPath: string, legacySubpath: string, cwd?: string): void;
 export interface MCPTool {
     name: string;
     description: string;

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

@@ -3,7 +3,7 @@
  *
  * Local type definitions to avoid external imports outside package boundary.
  */
-import { statSync, readFileSync } from 'node:fs';
+import { statSync, readFileSync, existsSync, mkdirSync, copyFileSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 /**
  * Returns the effective project working directory.
@@ -60,4 +60,39 @@ export function getMonomindDataRoot(cwd) {
     _dataRootCache.set(workDir, result);
     return result;
 }
+/**
+ * One-time migration for the agent/task/hive/swarm stores that historically lived
+ * under `<projectCwd>/.monomind/<subpath>` (via getProjectCwd()) before being
+ * consolidated onto the canonical getMonomindDataRoot() location (typically
+ * `<repo>/.git/monomind/<subpath>`). Several MCP tool files (agent-tools.ts,
+ * hive-mind-tools.ts, swarm-tools.ts, system-tools.ts) used to read/write the
+ * legacy path directly, causing the same logical store to physically split from
+ * task-tools.ts/session-tools.ts, which always used getMonomindDataRoot().
+ *
+ * If the canonical file is missing but the legacy file exists, copy (never move,
+ * for safety) the legacy file into place so pre-existing data isn't silently
+ * orphaned. Best-effort and idempotent — never throws, and it's a no-op once the
+ * canonical file exists or when the two paths already coincide (e.g. no .git).
+ *
+ * @param canonicalPath Absolute path under getMonomindDataRoot() the tool now reads from.
+ * @param legacySubpath Path relative to `.monomind/` that the tool used to read from
+ *   (e.g. `join('agents', 'store.json')`).
+ * @param cwd Optional project cwd override (defaults to getProjectCwd()).
+ */
+export function migrateLegacyStoreFile(canonicalPath, legacySubpath, cwd) {
+    try {
+        if (existsSync(canonicalPath))
+            return;
+        const legacyPath = join(cwd || getProjectCwd(), '.monomind', legacySubpath);
+        if (legacyPath === canonicalPath)
+            return;
+        if (!existsSync(legacyPath))
+            return;
+        mkdirSync(dirname(canonicalPath), { recursive: true });
+        copyFileSync(legacyPath, canonicalPath);
+    }
+    catch {
+        // Best-effort; leave both stores as-is on any failure.
+    }
+}
 //# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/memory/ewc-consolidation.d.ts

@@ -127,6 +127,12 @@ export declare class EWCConsolidator {
     private globalFisher;
     private consolidationHistory;
     private initialized;
+    /** Dirty flag: true when in-memory state diverges from disk */
+    private dirty;
+    /** Pending debounced write timer */
+    private saveTimer;
+    /** Debounce window for disk writes (ms) */
+    private static readonly SAVE_DEBOUNCE_MS;
     constructor(config?: Partial<EWCConfig>);
     /**
      * Initialize the consolidator by loading persisted state
@@ -237,6 +243,12 @@ export declare class EWCConsolidator {
      * Prune old, low-importance patterns to stay within limit
      */
     private pruneOldPatterns;
+    /**
+     * Schedule a debounced disk flush.
+     * Multiple calls within SAVE_DEBOUNCE_MS coalesce into one write,
+     * preventing blocking I/O on every consolidation or gradient event.
+     */
+    private scheduleSave;
     /**
      * Save state to disk
      */

package/packages/@monomind/cli/dist/src/memory/hnsw-operations.d.ts

@@ -10,8 +10,20 @@ interface HNSWEntry {
     namespace: string;
     content: string;
 }
+/** Minimal shape of the real @monoes/memory HNSWIndex class relied on here. */
+interface RealHNSWIndex {
+    addPoint(id: string, vector: Float32Array): Promise<void>;
+    search(query: Float32Array, k: number, ef?: number): Promise<Array<{
+        id: string;
+        distance: number;
+    }>>;
+    rebuild(entries: Array<{
+        id: string;
+        vector: Float32Array;
+    }>): Promise<void>;
+}
 interface HNSWIndex {
-    db: any;
+    instance: RealHNSWIndex;
     entries: Map<string, HNSWEntry>;
     dimensions: number;
     initialized: boolean;