monomind 2.7.7 → 2.7.8

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

@@ -8,19 +8,45 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { writeJsonFileAtomic } from '../utils/json-file.js';
-// Canonical paths — shared with MCP tools so CLI and MCP see the same state
-const SWARM_STATE_DIR = '.monomind/swarm';
+import { getMonomindDataRoot, getProjectCwd, migrateLegacyStoreFile } from '../mcp-tools/types.js';
+// Canonical paths — resolved through getMonomindDataRoot() so the CLI and the MCP
+// tools (agent-tools.ts / swarm-tools.ts / task-tools.ts) read and write the SAME
+// physical files. These used to be `path.join(process.cwd(), '.monomind/...')`,
+// which only coincides with the canonical root when there is no `.git` directory;
+// inside a real repo the canonical root is `<repo>/.git/monomind`, so the CLI read
+// an empty parallel store ("0 agents" with agents on disk) and `swarm init` wrote a
+// second, divergent swarm-state.json no MCP tool ever read.
+const SWARM_STATE_SUBDIR = 'swarm';
 const SWARM_STATE_FILE = 'swarm-state.json';
-const AGENT_STORE_PATH = '.monomind/agents/store.json';
+const AGENT_STORE_SUBDIR = 'agents';
+const AGENT_STORE_FILE = 'store.json';
+function getSwarmDir() {
+    return path.join(getMonomindDataRoot(), SWARM_STATE_SUBDIR);
+}
+// Canonical swarm-state.json path. Also pulls a pre-existing legacy
+// `<cwd>/.monomind/swarm/swarm-state.json` into place (copy, never move; no-op once
+// the canonical file exists or when the two paths coincide) so state written by an
+// older CLI isn't silently orphaned — same helper the MCP tools use.
+function getSwarmStateFile() {
+    const file = path.join(getSwarmDir(), SWARM_STATE_FILE);
+    migrateLegacyStoreFile(file, path.join(SWARM_STATE_SUBDIR, SWARM_STATE_FILE));
+    return file;
+}
+function getAgentStoreFile() {
+    const file = path.join(getMonomindDataRoot(), AGENT_STORE_SUBDIR, AGENT_STORE_FILE);
+    migrateLegacyStoreFile(file, path.join(AGENT_STORE_SUBDIR, AGENT_STORE_FILE));
+    return file;
+}
 // Get dynamic swarm status from MCP-canonical state files
 function getSwarmStatus(swarmId) {
-    const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
+    const projectCwd = getProjectCwd();
+    const sessionDir = path.join(projectCwd, '.claude', 'sessions');
     const memoryPaths = [
-        path.join(process.cwd(), '.monomind', 'memory.db'),
-        path.join(process.cwd(), '.claude', 'memory.db'),
+        path.join(projectCwd, '.monomind', 'memory.db'),
+        path.join(projectCwd, '.claude', 'memory.db'),
     ];
-    // Read swarm state from MCP-canonical path (.monomind/swarm/swarm-state.json)
-    const swarmStateFile = path.join(process.cwd(), SWARM_STATE_DIR, SWARM_STATE_FILE);
+    // Read swarm state from the MCP-canonical path
+    const swarmStateFile = getSwarmStateFile();
     let swarmState = null;
     if (fs.existsSync(swarmStateFile)) {
         try {
@@ -52,10 +78,11 @@ function getSwarmStatus(swarmId) {
             // Ignore parse errors
         }
     }
-    // Count agents from MCP-canonical agent store (.monomind/agents/store.json)
+    // Count agents from the MCP-canonical agent store (the same physical file
+    // agent_spawn writes to — see getAgentStoreFile()).
     let activeAgents = 0;
     let totalAgents = 0;
-    const agentStoreFile = path.join(process.cwd(), AGENT_STORE_PATH);
+    const agentStoreFile = getAgentStoreFile();
     if (fs.existsSync(agentStoreFile)) {
         try {
             const agentSz = fs.statSync(agentStoreFile).size;
@@ -102,7 +129,7 @@ function getSwarmStatus(swarmId) {
     let completedTasks = 0;
     let inProgressTasks = 0;
     let pendingTasks = 0;
-    const tasksDir = path.join(process.cwd(), SWARM_STATE_DIR, 'tasks');
+    const tasksDir = path.join(getSwarmDir(), 'tasks');
     if (fs.existsSync(tasksDir)) {
         try {
             const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
@@ -311,7 +338,7 @@ const initCommand = {
             output.printSuccess('Swarm initialized successfully');
             // Save swarm state to MCP-canonical path so CLI and MCP share state
             try {
-                const swarmDir2 = path.join(process.cwd(), SWARM_STATE_DIR);
+                const swarmDir2 = getSwarmDir();
                 if (!fs.existsSync(swarmDir2)) {
                     fs.mkdirSync(swarmDir2, { recursive: true });
                 }
@@ -466,7 +493,7 @@ const startCommand = {
             output.writeln(output.dim('  Run with -v/--verbose for more detail, or `monomind doctor` to check config/permission issues.'));
         }
         // Persist swarm state to MCP-canonical path so CLI and MCP share state
-        const swarmDir = path.join(process.cwd(), SWARM_STATE_DIR);
+        const swarmDir = getSwarmDir();
         if (!fs.existsSync(swarmDir))
             fs.mkdirSync(swarmDir, { recursive: true });
         // Read existing store to preserve other swarms
@@ -627,7 +654,7 @@ const stopCommand = {
         }
         // Only update persisted swarm state if the MCP call succeeded (#1423)
         if (mcpStopped) {
-            const stopStateFile = path.join(process.cwd(), SWARM_STATE_DIR, SWARM_STATE_FILE);
+            const stopStateFile = getSwarmStateFile();
             if (fs.existsSync(stopStateFile)) {
                 try {
                     const stopStatSz = fs.statSync(stopStateFile).size;

package/packages/@monomind/cli/dist/src/consensus/audit-writer.js

@@ -177,19 +177,20 @@ export class AuditWriter {
         appendFileSync(filePath, JSON.stringify(data) + '\n', 'utf-8');
     }
     readLines(filePath) {
+        // A missing log is a genuine empty trail. Everything else — an oversized
+        // log, a permissions error, an I/O failure — is an *unreadable* trail, and
+        // must not be reported as an empty one: this file is the tamper-evidence
+        // record, so "0 records" and "cannot read" have opposite meanings.
+        // Callers (hive-mind_audit_list / _verify) already surface a throw as
+        // `success: false` with the message.
         if (!existsSync(filePath))
             return [];
-        try {
-            const MAX_BYTES = 50 * 1024 * 1024;
-            if (statSync(filePath).size > MAX_BYTES) {
-                throw new Error(`Audit log ${filePath} exceeds 50MB — run rotation/cleanup`);
-            }
-            const content = readFileSync(filePath, 'utf-8');
-            return parseJsonl(content);
-        }
-        catch {
-            return [];
+        const MAX_BYTES = 50 * 1024 * 1024;
+        if (statSync(filePath).size > MAX_BYTES) {
+            throw new Error(`Audit log ${filePath} exceeds 50MB — run rotation/cleanup`);
         }
+        const content = readFileSync(filePath, 'utf-8');
+        return parseJsonl(content);
     }
 }
 //# sourceMappingURL=audit-writer.js.map

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

@@ -410,17 +410,37 @@ try { await buildAsync(${JSON.stringify(targetDir)}); } finally {
  * Non-fatal: best-effort health check and auto-install.
  */
 async function runDoctorFix(targetDir, result) {
+    // Run the doctor THIS binary ships, in-process.
+    //
+    // This used to be `execSync('npx monomind@latest doctor --install')`, which
+    // was wrong in three ways at once: it downloaded and ran a DIFFERENT version
+    // than the one the user deliberately invoked (so `monomind@2.7.0 init` was
+    // finished by whatever `latest` happened to be), it silently required network
+    // — on a machine without it, the 120s timeout elapsed and init reported
+    // "skipped" with no explanation — and `stdio: 'ignore'` discarded everything
+    // it said, so a failed health check looked identical to a passing one.
     try {
-        const { execSync } = await import('child_process');
-        execSync('npx monomind@latest doctor --install', {
+        const { doctorCommand } = await import('../commands/doctor.js');
+        if (!doctorCommand.action) {
+            result.skipped.push('doctor: auto-fix unavailable (run: monomind doctor --install)');
+            return;
+        }
+        const res = await doctorCommand.action({
+            args: [],
+            flags: { install: true },
             cwd: targetDir,
-            stdio: 'ignore',
-            timeout: 120000,
         });
-        result.created.files.push('doctor --install (health check + auto-fix)');
+        // Report what actually happened rather than asserting success either way.
+        if (res && res.success === false) {
+            result.skipped.push('doctor: reported issues (run: monomind doctor for details)');
+        }
+        else {
+            result.created.files.push('doctor --install (health check + auto-fix)');
+        }
     }
-    catch {
-        result.skipped.push('doctor: auto-fix skipped (run: monomind doctor --install)');
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        result.skipped.push(`doctor: auto-fix failed (${detail}) — run: monomind doctor --install`);
     }
 }
 /**
@@ -953,6 +973,73 @@ async function writeMCPConfig(targetDir, options, result) {
     atomicWriteFile(mcpPath, content);
     result.created.files.push('.mcp.json');
 }
+/**
+ * Provenance manifest for generated .claude content.
+ *
+ * init used to "clean stale" entries by deleting every name under
+ * .claude/{skills,commands,agents} that was absent from the current version's
+ * SKILLS_MAP/COMMANDS_MAP/AGENTS_MAP. Every user-authored command and skill is
+ * absent from those maps, so that pass deleted user content on the very first
+ * run — unrecoverable data loss.
+ *
+ * The manifest records exactly which entries *this tool* wrote, so the stale
+ * sweep can be restricted to those. Anything init did not write is never
+ * removed. Projects initialised by an older version have no manifest, so their
+ * first run under the fix deletes nothing and seeds the manifest instead;
+ * stale generated content may survive one extra run, which is the correct
+ * trade (preserving stale generated content is recoverable, deleting user
+ * content is not).
+ */
+const INIT_MANIFEST_REL = path.join('.monomind', 'init-manifest.json');
+/**
+ * Read the provenance manifest. Returns null when absent or unreadable —
+ * callers must treat that as "provenance unknown", i.e. delete nothing.
+ */
+function readInitManifest(targetDir) {
+    const manifestPath = path.join(targetDir, INIT_MANIFEST_REL);
+    try {
+        if (!fs.existsSync(manifestPath))
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return {
+            version: typeof parsed.version === 'number' ? parsed.version : 1,
+            skills: Array.isArray(parsed.skills) ? parsed.skills.filter((s) => typeof s === 'string') : [],
+            commands: Array.isArray(parsed.commands) ? parsed.commands.filter((s) => typeof s === 'string') : [],
+            agents: Array.isArray(parsed.agents) ? parsed.agents.filter((s) => typeof s === 'string') : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Names init previously generated in one section. Empty set when no manifest
+ * exists — which makes the stale sweep a no-op rather than a delete-everything.
+ */
+function previouslyGenerated(targetDir, section) {
+    return new Set(readInitManifest(targetDir)?.[section] ?? []);
+}
+/**
+ * Record the entries init just wrote for one section, merging into any
+ * existing manifest so a partial run (e.g. --only-claude, or a section whose
+ * source dir was missing) never drops provenance for the other sections.
+ */
+function recordGenerated(targetDir, section, entries) {
+    const manifestPath = path.join(targetDir, INIT_MANIFEST_REL);
+    const existing = readInitManifest(targetDir);
+    const manifest = existing ?? { version: 1, skills: [], commands: [], agents: [] };
+    manifest.version = 1;
+    manifest[section] = [...new Set(entries)].sort();
+    try {
+        fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+        atomicWriteFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    }
+    catch {
+        // Non-fatal: without a manifest the next run simply deletes nothing.
+    }
+}
 /**
  * Copy skills from source
  */
@@ -992,11 +1079,14 @@ async function copySkills(targetDir, options, result) {
         skillsToCopy.push(...fs.readdirSync(sourceSkillsDir).filter(n => n.startsWith(prefix) &&
             fs.existsSync(path.join(sourceSkillsDir, n, 'SKILL.md'))));
     }
-    // Remove stale skill directories no longer in the current version's map
+    // Remove stale skill directories that a PREVIOUS init generated and this
+    // version no longer ships. Entries init never wrote (user-authored skills,
+    // skills installed by other tools) are left untouched — see readInitManifest.
     const knownSkills = new Set([...new Set(skillsToCopy)]);
+    const priorSkills = previouslyGenerated(targetDir, 'skills');
     if (fs.existsSync(targetSkillsDir)) {
         for (const existing of fs.readdirSync(targetSkillsDir)) {
-            if (!knownSkills.has(existing)) {
+            if (!knownSkills.has(existing) && priorSkills.has(existing)) {
                 const stalePath = path.join(targetSkillsDir, existing);
                 fs.rmSync(stalePath, { recursive: true, force: true });
                 result.created.files.push(`[cleaned] .claude/skills/${existing} (stale)`);
@@ -1004,14 +1094,19 @@ async function copySkills(targetDir, options, result) {
         }
     }
     // Always copy/overwrite skills (never skip — ensures new version content lands)
+    const writtenSkills = [];
     for (const skillName of knownSkills) {
         const sourcePath = path.join(sourceSkillsDir, skillName);
         const targetPath = path.join(targetSkillsDir, skillName);
         if (fs.existsSync(sourcePath)) {
-            if (fs.existsSync(targetPath)) {
-                fs.rmSync(targetPath, { recursive: true, force: true });
-            }
+            // Deliberately NOT rmSync'd first. copyDirRecursive overwrites every
+            // file it ships, so wiping the directory adds nothing except destroying
+            // anything the user put inside it — notes beside a shipped skill, an
+            // extra command in a shipped folder. `init --force` did exactly that.
+            // The cost of not wiping is that a file removed from a newer version
+            // lingers; the cost of wiping is silent data loss, which is worse.
             copyDirRecursive(sourcePath, targetPath);
+            writtenSkills.push(skillName);
             result.created.files.push(`.claude/skills/${skillName}`);
             result.summary.skillsCount++;
         }
@@ -1022,6 +1117,12 @@ async function copySkills(targetDir, options, result) {
             result.errors.push(`Skill '${skillName}' listed in SKILLS_MAP has no source directory at ${sourcePath} — skipped`);
         }
     }
+    // Record provenance so the next run can distinguish "we wrote this" from
+    // "the user wrote this". Keep entries this run did not re-write but that a
+    // previous run generated and that still exist, so provenance is not lost
+    // when a section is partially skipped.
+    const retainedSkills = [...priorSkills].filter(n => !writtenSkills.includes(n) && fs.existsSync(path.join(targetSkillsDir, n)));
+    recordGenerated(targetDir, 'skills', [...writtenSkills, ...retainedSkills]);
 }
 /**
  * Copy commands from source
@@ -1084,11 +1185,13 @@ async function copyCommands(targetDir, options, result) {
         result.errors.push('Could not find source commands directory');
         return;
     }
-    // Remove stale command files/directories no longer in the current version's map
+    // Remove stale command files/directories that a PREVIOUS init generated and
+    // this version no longer ships. User-authored commands are never touched.
     const knownCommands = new Set([...new Set(commandsToCopy)]);
+    const priorCommands = previouslyGenerated(targetDir, 'commands');
     if (fs.existsSync(targetCommandsDir)) {
         for (const existing of fs.readdirSync(targetCommandsDir)) {
-            if (!knownCommands.has(existing)) {
+            if (!knownCommands.has(existing) && priorCommands.has(existing)) {
                 const stalePath = path.join(targetCommandsDir, existing);
                 fs.rmSync(stalePath, { recursive: true, force: true });
                 result.created.files.push(`[cleaned] .claude/commands/${existing} (stale)`);
@@ -1096,23 +1199,27 @@ async function copyCommands(targetDir, options, result) {
         }
     }
     // Always copy/overwrite commands (never skip — ensures new version content lands)
+    const writtenCommands = [];
     for (const cmdName of knownCommands) {
         const sourcePath = path.join(sourceCommandsDir, cmdName);
         const targetPath = path.join(targetCommandsDir, cmdName);
         if (fs.existsSync(sourcePath)) {
-            if (fs.existsSync(targetPath)) {
-                fs.rmSync(targetPath, { recursive: true, force: true });
-            }
+            // No pre-copy rmSync — see the note in copySkills. Both branches below
+            // overwrite what they ship, so wiping first only destroys files the user
+            // added inside a shipped command directory.
             if (fs.statSync(sourcePath).isDirectory()) {
                 copyDirRecursive(sourcePath, targetPath);
             }
             else {
                 fs.copyFileSync(sourcePath, targetPath);
             }
+            writtenCommands.push(cmdName);
             result.created.files.push(`.claude/commands/${cmdName}`);
             result.summary.commandsCount++;
         }
     }
+    const retainedCommands = [...priorCommands].filter(n => !writtenCommands.includes(n) && fs.existsSync(path.join(targetCommandsDir, n)));
+    recordGenerated(targetDir, 'commands', [...writtenCommands, ...retainedCommands]);
 }
 /**
  * Copy agents from source
@@ -1147,11 +1254,13 @@ async function copyAgents(targetDir, options, result) {
         result.errors.push('Could not find source agents directory');
         return;
     }
-    // Remove stale agent category directories no longer in the current version's map
+    // Remove stale agent category directories that a PREVIOUS init generated and
+    // this version no longer ships. User-authored agent dirs are never touched.
     const knownAgents = new Set([...new Set(agentsToCopy)]);
+    const priorAgents = previouslyGenerated(targetDir, 'agents');
     if (fs.existsSync(targetAgentsDir)) {
         for (const existing of fs.readdirSync(targetAgentsDir)) {
-            if (!knownAgents.has(existing)) {
+            if (!knownAgents.has(existing) && priorAgents.has(existing)) {
                 const stalePath = path.join(targetAgentsDir, existing);
                 fs.rmSync(stalePath, { recursive: true, force: true });
                 result.created.files.push(`[cleaned] .claude/agents/${existing} (stale)`);
@@ -1159,20 +1268,27 @@ async function copyAgents(targetDir, options, result) {
         }
     }
     // Always copy/overwrite agents (never skip — ensures new version content lands)
+    const writtenAgents = [];
     for (const agentCategory of knownAgents) {
         const sourcePath = path.join(sourceAgentsDir, agentCategory);
         const targetPath = path.join(targetAgentsDir, agentCategory);
         if (fs.existsSync(sourcePath)) {
-            if (fs.existsSync(targetPath)) {
-                fs.rmSync(targetPath, { recursive: true, force: true });
-            }
+            // Deliberately NOT rmSync'd first. copyDirRecursive overwrites every
+            // file it ships, so wiping the directory adds nothing except destroying
+            // anything the user put inside it — notes beside a shipped skill, an
+            // extra command in a shipped folder. `init --force` did exactly that.
+            // The cost of not wiping is that a file removed from a newer version
+            // lingers; the cost of wiping is silent data loss, which is worse.
             copyDirRecursive(sourcePath, targetPath);
             // Count agent files (.md only — .yaml agents were migrated to .md)
             const mdFiles = countFiles(sourcePath, '.md');
             result.summary.agentsCount += mdFiles;
+            writtenAgents.push(agentCategory);
             result.created.files.push(`.claude/agents/${agentCategory}`);
         }
     }
+    const retainedAgents = [...priorAgents].filter(n => !writtenAgents.includes(n) && fs.existsSync(path.join(targetAgentsDir, n)));
+    recordGenerated(targetDir, 'agents', [...writtenAgents, ...retainedAgents]);
 }
 /**
  * Find source helpers directory.

package/packages/@monomind/cli/dist/src/init/settings-generator.js

@@ -226,7 +226,10 @@ function generateHooksConfig(config, graphify = true) {
                 ],
             },
             {
-                matcher: 'Write|Edit|MultiEdit',
+                // NotebookEdit is listed explicitly: its content field (`new_source`)
+                // is scanned by the same secrets gate as Write/Edit/MultiEdit, so it
+                // must not depend on `Edit` happening to substring-match.
+                matcher: 'Write|Edit|MultiEdit|NotebookEdit',
                 hooks: [
                     {
                         // Was 'pre-edit' — not a registered hook-handler.cjs dispatch

package/packages/@monomind/cli/dist/src/knowledge/document-pipeline.d.ts

@@ -26,6 +26,10 @@ export interface KnowledgeExcerpt {
     similarity: number;
     chunkIndex: number;
     scope: string;
+    /** True when this chunk belongs to a document version that has since been
+     *  re-ingested (its contentHash is no longer the file's current one). Only
+     *  ever set when the caller opted into `includeSuperseded`. */
+    superseded?: boolean;
 }
 export interface DocumentMeta {
     filePath: string;
@@ -40,6 +44,16 @@ export declare function ingestDirectory(dirPath: string, scope?: string, opts?:
     rootDir?: string;
     onProgress?: (file: string, done: number, total: number) => void;
 }): Promise<BatchIngestResult>;
+/** Content hashes of the documents currently indexed under `rootDir`. */
+export declare function liveContentHashes(rootDir: string): Set<string>;
+/**
+ * True when `key` is a document chunk whose version is no longer current.
+ * Non-`doc:` keys are never superseded, and an empty `live` set means the
+ * metadata log is missing/unreadable — in that case nothing is filtered,
+ * because "no metadata" must not read as "everything is stale".
+ */
+export declare function isSupersededKey(key: string, live: Set<string>): boolean;
+export declare function supersededOverfetchLimit(limit: number, live: Set<string>): number;
 export declare function searchKnowledge(query: string, opts?: {
     scope?: string;
     limit?: number;
@@ -47,6 +61,9 @@ export declare function searchKnowledge(query: string, opts?: {
     rootDir?: string;
     /** which store(s): project-only, global-only, or both (default). */
     store?: 'project' | 'global' | 'all';
+    /** Return chunks from superseded document versions too, flagged
+     *  `superseded: true`. Default false — see the note above `liveContentHashes`. */
+    includeSuperseded?: boolean;
 }): Promise<KnowledgeExcerpt[]>;
 export declare function listDocuments(rootDir?: string, scope?: string): DocumentMeta[];
 export declare function removeDocument(filePath: string, scope?: string, rootDir?: string): Promise<void>;

package/packages/@monomind/cli/dist/src/knowledge/document-pipeline.js

@@ -358,6 +358,52 @@ export async function ingestDirectory(dirPath, scope = 'shared', opts) {
 /** Small additive boost so project knowledge wins ties against the global
  *  brain — local context is more likely to be what the user means. */
 const PROJECT_SCOPE_BOOST = 0.05;
+// ── Superseded-version filtering ───────────────────────────────────
+//
+// Chunk keys are `doc:<contentHash>:<chunkIndex>`. Re-ingesting a changed file
+// produces a NEW contentHash, so its chunks land under new keys — the previous
+// version's rows are never touched (`removeDocument` only tombstones metadata;
+// the bridge exposes no delete-by-prefix). The store therefore accumulates every
+// version a document has ever had, and all of them stay searchable.
+//
+// Measured on this repo's own store (2026-07-26): 9,067 `doc:`-keyed rows in
+// `knowledge:shared` spanning 798 distinct content hashes, of which only 139
+// are current — 8,542 rows (94.2%) are orphaned older versions.
+//
+// Nothing is deleted here. The current-hash set from doc-metadata.jsonl is used
+// to decide what search RETURNS; `includeSuperseded` puts the old versions back
+// (flagged `superseded: true`) for anyone who wants document history.
+/** Content hashes of the documents currently indexed under `rootDir`. */
+export function liveContentHashes(rootDir) {
+    const live = new Set();
+    for (const m of readMetadata(rootDir))
+        if (m.contentHash)
+            live.add(m.contentHash);
+    return live;
+}
+/**
+ * True when `key` is a document chunk whose version is no longer current.
+ * Non-`doc:` keys are never superseded, and an empty `live` set means the
+ * metadata log is missing/unreadable — in that case nothing is filtered,
+ * because "no metadata" must not read as "everything is stale".
+ */
+export function isSupersededKey(key, live) {
+    if (!key || !key.startsWith('doc:'))
+        return false;
+    if (live.size === 0)
+        return false;
+    return !live.has(key.split(':')[1] ?? '');
+}
+/** How many rows to ask the backend for per requested result when superseded
+ *  filtering is active — most rows in a long-lived store are old versions, so
+ *  a 1:1 fetch would return an almost-empty page. */
+const SUPERSEDED_OVERFETCH = 20;
+const SUPERSEDED_OVERFETCH_CAP = 300;
+export function supersededOverfetchLimit(limit, live) {
+    if (live.size === 0)
+        return limit;
+    return Math.min(Math.max(limit * SUPERSEDED_OVERFETCH, limit), SUPERSEDED_OVERFETCH_CAP);
+}
 export async function searchKnowledge(query, opts) {
     const bridge = await getBridge();
     if (!bridge)
@@ -373,17 +419,28 @@ export async function searchKnowledge(query, opts) {
     if (store !== 'project') {
         targets.push({ ns: namespace('global'), dbPath: GLOBAL_BRAIN_SENTINEL, root: globalBrainRoot(), label: 'global', boost: 0 });
     }
+    const includeSuperseded = opts?.includeSuperseded === true;
     const perTarget = await Promise.all(targets.map(async (t) => {
+        const meta = readMetadata(t.root);
+        const live = new Set();
+        for (const m of meta)
+            if (m.contentHash)
+                live.add(m.contentHash);
+        // Old versions dominate a long-lived store, so a 1:1 fetch would come back
+        // nearly empty once they are filtered out. Over-fetch, then trim.
+        const fetchLimit = includeSuperseded ? limit : supersededOverfetchLimit(limit, live);
         const result = await bridge.bridgeSearchEntries({
-            query, namespace: t.ns, limit, threshold: minScore, dbPath: t.dbPath,
+            query, namespace: t.ns, limit: fetchLimit, threshold: minScore, dbPath: t.dbPath,
         }).catch(() => null);
         if (!result?.success || !result.results.length)
             return [];
-        const meta = readMetadata(t.root);
         const hashToFile = new Map();
         for (const m of meta)
             hashToFile.set(m.contentHash, m.filePath);
-        return result.results.map((r) => {
+        const kept = includeSuperseded
+            ? result.results
+            : result.results.filter((r) => !isSupersededKey(String(r.key ?? ''), live));
+        return kept.slice(0, limit).map((r) => {
             const parts = r.key.startsWith('doc:') ? r.key.split(':') : [];
             const hash = parts[1] ?? '';
             const idx = parseInt(parts[2] ?? '0', 10);
@@ -391,6 +448,7 @@ export async function searchKnowledge(query, opts) {
             // hash→file map can misattribute when two documents share identical
             // content, and goes empty when a re-ingested file's hash changed.
             const srcTag = (r.tags ?? []).find((tag) => tag.startsWith('src:'));
+            const superseded = includeSuperseded && isSupersededKey(String(r.key ?? ''), live);
             return {
                 id: r.id,
                 filePath: srcTag ? srcTag.slice(4) : hashToFile.get(hash) ?? '',
@@ -398,6 +456,7 @@ export async function searchKnowledge(query, opts) {
                 similarity: r.score + t.boost,
                 chunkIndex: isNaN(idx) ? 0 : idx,
                 scope: t.label,
+                ...(superseded ? { superseded: true } : {}),
             };
         });
     }));

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

@@ -544,9 +544,13 @@ export const allEmbeddingsTools = [
                         message: 'Embedding substrate initialized',
                     };
                 case 'drift':
-                    // Get real drift metrics if available
+                    // Get real drift metrics if available.
+                    // initializeIntelligence() MUST run first: getIntelligenceStats()
+                    // reads module singletons (sonaCoordinator / reasoningBank) that are
+                    // null until init, so a populated store otherwise reports 0 patterns.
                     try {
-                        const { getIntelligenceStats } = await import('../memory/intelligence.js');
+                        const { getIntelligenceStats, initializeIntelligence } = await import('../memory/intelligence.js');
+                        await initializeIntelligence();
                         const stats = getIntelligenceStats();
                         return {
                             success: true,
@@ -564,17 +568,20 @@ export const allEmbeddingsTools = [
                                 : 'No patterns stored yet - drift detection inactive',
                         };
                     }
-                    catch {
+                    catch (e) {
+                        // Failing to read the store is NOT a drift report of zero.
                         return {
-                            success: true,
+                            success: false,
                             action: 'drift',
+                            error: `Intelligence store unavailable — drift status unknown: ${e.message}`,
                             status: { semanticDrift: { enabled: false, reason: 'Intelligence module unavailable' } },
                         };
                     }
                 case 'consolidate':
-                    // Get real consolidation metrics
+                    // Get real consolidation metrics — same init requirement as 'drift'.
                     try {
-                        const { getIntelligenceStats } = await import('../memory/intelligence.js');
+                        const { getIntelligenceStats, initializeIntelligence } = await import('../memory/intelligence.js');
+                        await initializeIntelligence();
                         const stats = getIntelligenceStats();
                         return {
                             success: true,
@@ -590,10 +597,11 @@ export const allEmbeddingsTools = [
                             message: `ReasoningBank: ${stats.reasoningBankSize} patterns, ${stats.trajectoriesRecorded} trajectories`,
                         };
                     }
-                    catch {
+                    catch (e) {
                         return {
-                            success: true,
+                            success: false,
                             action: 'consolidate',
+                            error: `Intelligence store unavailable — consolidation status unknown: ${e.message}`,
                             status: { memoryPhysics: { enabled: false, reason: 'Intelligence module unavailable' } },
                         };
                     }