monomind 2.3.3 → 2.4.0

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

@@ -7,6 +7,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
+import * as os from 'node:os';
 import { DOC_EXTENSIONS, extractText } from '../capabilities/cap-documents.js';
 const DEFAULT_CHUNK_SIZE = 3200;
 const DEFAULT_OVERLAP = 400;
@@ -14,23 +15,52 @@ const DEFAULT_OVERLAP = 400;
 // used only if the dynamic import below fails (package not installed/built).
 // Keep in sync if the shared chunker's boundary-snapping logic changes.
 const HEADING_LINE_RE = /^#{1,6} /;
-function lastHeadingBefore(text, pos) {
+const FENCE_LINE_RE = /^\s{0,3}(`{3,}|~{3,})/;
+function fenceTogglesInline(text) {
+    const toggles = [];
+    let lineStart = 0;
+    while (lineStart <= text.length) {
+        const eol = text.indexOf('\n', lineStart);
+        const line = text.slice(lineStart, eol === -1 ? undefined : eol);
+        if (FENCE_LINE_RE.test(line))
+            toggles.push(lineStart);
+        if (eol === -1)
+            break;
+        lineStart = eol + 1;
+    }
+    return toggles;
+}
+function inFenceInline(toggles, pos) {
+    let lo = 0, hi = toggles.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (toggles[mid] <= pos)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return (lo & 1) === 1;
+}
+function lastHeadingBefore(text, pos, toggles) {
     let i = text.lastIndexOf('\n#', pos - 1);
     while (i !== -1) {
         const eol = text.indexOf('\n', i + 1);
         const line = text.slice(i + 1, eol === -1 ? undefined : eol);
-        if (HEADING_LINE_RE.test(line))
+        if (HEADING_LINE_RE.test(line) && !inFenceInline(toggles, i + 1))
             return line.replace(/^#+ /, '').trim();
-        i = text.lastIndexOf('\n#', i - 1);
+        i = i > 0 ? text.lastIndexOf('\n#', i - 1) : -1; // fromIndex -1 clamps to 0 — would loop on a match at 0
     }
     const firstEol = text.indexOf('\n');
     const firstLine = firstEol === -1 ? text : text.slice(0, firstEol);
-    return HEADING_LINE_RE.test(firstLine) && firstEol !== -1 && firstEol < pos
+    return HEADING_LINE_RE.test(firstLine) && !inFenceInline(toggles, 0) && firstEol !== -1 && firstEol < pos
         ? firstLine.replace(/^#+ /, '').trim() : null;
 }
 function chunkDocumentInline(docId, text) {
+    if (text.includes('\r\n'))
+        text = text.replace(/\r\n/g, '\n');
     if (text.length === 0)
         return [];
+    const toggles = fenceTogglesInline(text);
     const chunks = [];
     let startChar = 0;
     let chunkIndex = 0;
@@ -44,22 +74,27 @@ function chunkDocumentInline(docId, text) {
             while (h !== -1) {
                 const eol = window.indexOf('\n', h + 1);
                 const line = window.slice(h + 1, eol === -1 ? undefined : eol);
-                if (HEADING_LINE_RE.test(line) && windowStart + h > startChar)
+                if (HEADING_LINE_RE.test(line) && windowStart + h > startChar && !inFenceInline(toggles, windowStart + h + 1))
                     break;
-                h = window.lastIndexOf('\n#', h - 1);
+                h = h > 0 ? window.lastIndexOf('\n#', h - 1) : -1;
             }
             if (h !== -1 && windowStart + h > startChar) {
                 endChar = windowStart + h + 1;
                 brokeAtHeading = true;
             }
             else {
-                const lastParagraph = window.lastIndexOf('\n\n');
+                let lastParagraph = window.lastIndexOf('\n\n');
+                while (lastParagraph > 0 && inFenceInline(toggles, windowStart + lastParagraph + 1)) {
+                    lastParagraph = window.lastIndexOf('\n\n', lastParagraph - 1);
+                }
+                if (lastParagraph === 0 && inFenceInline(toggles, windowStart + 1))
+                    lastParagraph = -1;
                 if (lastParagraph !== -1)
                     endChar = windowStart + lastParagraph + 2;
             }
         }
         let chunkText = text.slice(startChar, endChar);
-        const heading = lastHeadingBefore(text, startChar + 1);
+        const heading = lastHeadingBefore(text, startChar + 1, toggles);
         if (heading && !HEADING_LINE_RE.test(chunkText.trimStart()))
             chunkText = `§ ${heading}\n${chunkText}`;
         chunks.push({ chunkId: `${docId}:${chunkIndex}`, docId, text: chunkText, startChar, endChar, chunkIndex });
@@ -82,6 +117,15 @@ async function chunkDocument(docId, text) {
 // ── Constants ──────────────────────────────────────────────────────
 const KNOWLEDGE_NS_PREFIX = 'knowledge:';
 const METADATA_FILE = 'doc-metadata.jsonl';
+// Global brain constants — canonical definitions live in memory-bridge.ts
+// (GLOBAL_BRAIN / GLOBAL_BRAIN_DIR); duplicated here because the bridge is
+// imported lazily and these are needed synchronously.
+const GLOBAL_BRAIN_SENTINEL = '@global';
+const globalBrainRoot = () => process.env.MONOMIND_GLOBAL_BRAIN_DIR || path.join(os.homedir(), '.monomind', 'global-brain');
+/** scope 'global' routes to the personal cross-project store. */
+const isGlobalScope = (scope) => scope === 'global';
+const effectiveRoot = (scope, rootDir) => isGlobalScope(scope) ? globalBrainRoot() : rootDir;
+const storeDbPath = (scope) => isGlobalScope(scope) ? GLOBAL_BRAIN_SENTINEL : undefined;
 const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', '.monomind', '.claude', '.next', '__pycache__', '.venv', 'vendor']);
 const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
 // ── Helpers ────────────────────────────────────────────────────────
@@ -100,7 +144,34 @@ function readMetadata(rootDir) {
     const file = metadataPath(rootDir);
     if (!fs.existsSync(file))
         return [];
-    return fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean).map(l => JSON.parse(l));
+    // Last-wins per (filePath, scope): the file is append-only under concurrent
+    // ingests (session-start detached reindex + a manual `doc ingest` can
+    // overlap), so duplicates are expected and the newest record is truth.
+    // Corrupt lines (torn concurrent writes) are skipped, not fatal.
+    const latest = new Map();
+    for (const l of fs.readFileSync(file, 'utf-8').split('\n')) {
+        if (!l.trim())
+            continue;
+        try {
+            const m = JSON.parse(l);
+            latest.set(`${m.filePath} ${m.scope}`, m);
+        }
+        catch { /* torn line */ }
+    }
+    // chunkCount -1 records are removal tombstones (see removeMetadataEntry)
+    const live = [...latest.values()].filter(m => m.chunkCount >= 0);
+    // Occasional compaction: append-only + tombstones grow without bound; when
+    // the log gets big, rewrite it deduped (atomic rename — a concurrent append
+    // in the tiny window loses only its own record and self-heals on re-ingest).
+    try {
+        if (fs.statSync(file).size > 1024 * 1024) {
+            const tmp = `${file}.${process.pid}.compact`;
+            fs.writeFileSync(tmp, live.map(r => JSON.stringify(r)).join('\n') + (live.length ? '\n' : ''), 'utf-8');
+            fs.renameSync(tmp, file);
+        }
+    }
+    catch { /* compaction is best-effort */ }
+    return live;
 }
 function appendMetadata(rootDir, meta) {
     fs.appendFileSync(metadataPath(rootDir), JSON.stringify(meta) + '\n', 'utf-8');
@@ -109,8 +180,12 @@ function removeMetadataEntry(rootDir, filePath, scope) {
     const file = metadataPath(rootDir);
     if (!fs.existsSync(file))
         return;
-    const records = readMetadata(rootDir).filter(m => !(m.filePath === filePath && m.scope === scope));
-    fs.writeFileSync(file, records.map(r => JSON.stringify(r)).join('\n') + (records.length ? '\n' : ''), 'utf-8');
+    // Tombstone by APPEND (chunkCount -1) instead of read-filter-rewrite — the
+    // rewrite raced concurrent appends and silently dropped them.
+    appendMetadata(rootDir, {
+        filePath, scope, contentHash: '', chunkCount: -1,
+        indexedAt: new Date().toISOString(), size: 0,
+    });
 }
 function toFileEntry(filePath) {
     const stat = fs.statSync(filePath);
@@ -153,6 +228,7 @@ export async function ingestDocument(filePath, scope = 'shared', rootDir = proce
     if (stat.size > MAX_FILE_SIZE) {
         return { filePath: resolved, chunksIndexed: 0, scope, skipped: true, error: 'file too large (>50MB)' };
     }
+    rootDir = effectiveRoot(scope, rootDir);
     const meta = _metadataCache ?? readMetadata(rootDir);
     const existing = meta.find(m => m.filePath === resolved && m.scope === scope);
     let fullContent;
@@ -189,6 +265,7 @@ export async function ingestDocument(filePath, scope = 'shared', rootDir = proce
                     generateEmbeddingFlag: true,
                     tags: ['document', ext, `src:${resolved}`],
                     upsert: true,
+                    dbPath: storeDbPath(scope),
                 });
                 if (storeResult?.success)
                     indexed++;
@@ -199,16 +276,26 @@ export async function ingestDocument(filePath, scope = 'shared', rootDir = proce
             }
         }
     }
-    // Persist metadata
-    appendMetadata(rootDir, {
-        filePath: resolved,
-        contentHash: hash,
-        chunkCount: chunks.length,
-        indexedAt: new Date().toISOString(),
-        scope,
-        size: stat.size,
-    });
-    return { filePath: resolved, chunksIndexed: indexed, scope, skipped: false };
+    // Persist metadata — but ONLY when something was actually stored (or the
+    // document legitimately produced zero chunks). Recording the content hash
+    // after a total store failure (bridge unavailable, every store rejected)
+    // made the hash check skip the file on every future ingest: a permanent,
+    // silent search miss.
+    if (indexed > 0 || chunks.length === 0) {
+        appendMetadata(rootDir, {
+            filePath: resolved,
+            contentHash: hash,
+            chunkCount: indexed,
+            indexedAt: new Date().toISOString(),
+            scope,
+            size: stat.size,
+        });
+    }
+    const storeFailed = chunks.length > 0 && indexed === 0;
+    return {
+        filePath: resolved, chunksIndexed: indexed, scope, skipped: false,
+        ...(storeFailed ? { error: bridge ? 'all chunk stores failed' : 'memory bridge unavailable — nothing indexed' } : {}),
+    };
 }
 export async function ingestDirectory(dirPath, scope = 'shared', opts) {
     const scanDir = path.resolve(dirPath);
@@ -266,6 +353,9 @@ export async function ingestDirectory(dirPath, scope = 'shared', opts) {
     return result;
 }
 // ── Search ─────────────────────────────────────────────────────────
+/** 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;
 export async function searchKnowledge(query, opts) {
     const bridge = await getBridge();
     if (!bridge)
@@ -273,31 +363,44 @@ export async function searchKnowledge(query, opts) {
     const scope = opts?.scope ?? 'shared';
     const limit = opts?.limit ?? 10;
     const minScore = opts?.minScore ?? 0.3;
-    const result = await bridge.bridgeSearchEntries({
-        query,
-        namespace: namespace(scope),
-        limit,
-        threshold: minScore,
-    });
-    if (!result?.success || !result.results.length)
-        return [];
-    const meta = readMetadata(opts?.rootDir ?? process.cwd());
-    const hashToFile = new Map();
-    for (const m of meta) {
-        hashToFile.set(m.contentHash, m.filePath);
+    const store = opts?.store ?? 'all';
+    const targets = [];
+    if (store !== 'global') {
+        targets.push({ ns: namespace(scope), root: opts?.rootDir ?? process.cwd(), label: scope, boost: PROJECT_SCOPE_BOOST });
     }
-    return result.results.map(r => {
-        const parts = r.key.startsWith('doc:') ? r.key.split(':') : [];
-        const hash = parts[1] ?? '';
-        const idx = parseInt(parts[2] ?? '0', 10);
-        return {
-            filePath: hashToFile.get(hash) ?? '',
-            text: r.content,
-            similarity: r.score,
-            chunkIndex: isNaN(idx) ? 0 : idx,
-            scope,
-        };
-    });
+    if (store !== 'project') {
+        targets.push({ ns: namespace('global'), dbPath: GLOBAL_BRAIN_SENTINEL, root: globalBrainRoot(), label: 'global', boost: 0 });
+    }
+    const perTarget = await Promise.all(targets.map(async (t) => {
+        const result = await bridge.bridgeSearchEntries({
+            query, namespace: t.ns, limit, 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 parts = r.key.startsWith('doc:') ? r.key.split(':') : [];
+            const hash = parts[1] ?? '';
+            const idx = parseInt(parts[2] ?? '0', 10);
+            // The src: tag stored at ingest is the chunk's OWN provenance — the
+            // 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:'));
+            return {
+                filePath: srcTag ? srcTag.slice(4) : hashToFile.get(hash) ?? '',
+                text: r.content,
+                similarity: r.score + t.boost,
+                chunkIndex: isNaN(idx) ? 0 : idx,
+                scope: t.label,
+            };
+        });
+    }));
+    return perTarget.flat()
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, limit);
 }
 // ── List / Remove ──────────────────────────────────────────────────
 export function listDocuments(rootDir = process.cwd(), scope) {

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

@@ -7,6 +7,14 @@
  * @module v1/cli/memory-bridge
  */
 export declare function safeParseEmbedding(raw: string | null | undefined): number[] | null;
+/** The personal, cross-project knowledge store. Deliberately a SIBLING of
+ *  ~/.monomind/projects (never inside it) so per-project pruning heuristics
+ *  (`cleanup --data`) can never touch it. Env-overridable for tests and for
+ *  users who keep their brain on a synced/external location. Resolved lazily
+ *  so the override works regardless of import order. */
+export declare function getGlobalBrainDir(): string;
+/** Sentinel callers pass as dbPath to address the global brain. */
+export declare const GLOBAL_BRAIN = "@global";
 /** Resolve the real on-disk LanceDB path for a given custom path (or the default). */
 export declare function bridgeGetDbPath(customPath?: string): string;
 export declare function bridgeStoreEntry(options: {
@@ -46,6 +54,7 @@ export declare function bridgeSearchEntries(options: {
         score: number;
         namespace: string;
         provenance?: string;
+        tags?: string[];
     }[];
     searchTime: number;
     searchMethod?: string;

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -70,22 +70,37 @@ function realOrResolved(p) {
         return p;
     }
 }
+/** The personal, cross-project knowledge store. Deliberately a SIBLING of
+ *  ~/.monomind/projects (never inside it) so per-project pruning heuristics
+ *  (`cleanup --data`) can never touch it. Env-overridable for tests and for
+ *  users who keep their brain on a synced/external location. Resolved lazily
+ *  so the override works regardless of import order. */
+export function getGlobalBrainDir() {
+    return process.env.MONOMIND_GLOBAL_BRAIN_DIR || path.join(os.homedir(), '.monomind', 'global-brain');
+}
+/** Sentinel callers pass as dbPath to address the global brain. */
+export const GLOBAL_BRAIN = '@global';
 function getDbPath(customPath) {
     const defaultDir = path.join(projectDataDir(), 'lancedb');
     if (!customPath || customPath === ':memory:')
         return defaultDir;
+    if (customPath === GLOBAL_BRAIN)
+        return getGlobalBrainDir();
     // Treat legacy .db paths (and the legacy .swarm dir) as a signal to use the default
     if (customPath.endsWith('.db'))
         return defaultDir;
     const resolved = realOrResolved(path.resolve(customPath));
     // Guard against path traversal from MCP inputs: only allow paths inside the
-    // project or inside the per-project home data dir.
+    // project, the per-project home data dir, or the global brain.
     const relCwd = path.relative(realOrResolved(process.cwd()), resolved);
     const relHome = path.relative(realOrResolved(projectDataDir()), resolved);
+    const relGlobal = path.relative(realOrResolved(getGlobalBrainDir()), resolved);
     if (!relCwd.startsWith('..') && !path.isAbsolute(relCwd))
         return resolved;
     if (!relHome.startsWith('..') && !path.isAbsolute(relHome))
         return resolved;
+    if (!relGlobal.startsWith('..') && !path.isAbsolute(relGlobal))
+        return resolved;
     return defaultDir;
 }
 /** Resolve the real on-disk LanceDB path for a given custom path (or the default). */
@@ -114,13 +129,10 @@ function getAutomemConfig() {
 function generateId(prefix) {
     return `${prefix}_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
 }
-// ===== Lazy singleton LanceDB backend =====
-let backendPromise = null;
-let backendInstance = null;
-let bridgeAvailable = null;
+const backendSlots = new Map();
 let _embedder = null;
+let _embedderPromise = null;
 const MAX_INIT_ATTEMPTS = 3;
-let initAttempts = 0;
 /** Flush after mutations: the sql.js fallback backend is in-memory WASM and
  *  only reaches disk via persist(); the CLI process is short-lived, so waiting
  *  for an auto-persist interval would lose writes. No-op on better-sqlite3. */
@@ -130,59 +142,73 @@ async function flushBackend(backend) {
     }
     catch { /* best effort */ }
 }
+async function loadEmbedder() {
+    if (_embedder)
+        return;
+    if (!_embedderPromise) {
+        _embedderPromise = (async () => {
+            try {
+                const hf = await import('@huggingface/transformers');
+                // revision must be a git ref — 'main' is the HF default; 'default' 404s and
+                // silently killed embeddings (every search degraded to keyword matching)
+                // dtype pinned explicitly: transformers.js logs a "dtype not specified"
+                // warning to the console on every load otherwise (leaks into CLI output).
+                const extractor = await hf.pipeline('feature-extraction', BRIDGE_EMBEDDING_MODEL, { revision: 'main', dtype: 'fp32' });
+                _embedder = async (text) => {
+                    const output = await extractor(text, { pooling: 'mean', normalize: true });
+                    return new Float32Array(output.data);
+                };
+            }
+            catch (e) {
+                _embedderPromise = null; // allow retry (e.g. first call offline)
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] embedding model failed to load — store and search without vectors:', e);
+            }
+        })();
+    }
+    await _embedderPromise;
+}
 async function getBackend(dbPath) {
-    if (bridgeAvailable === false)
+    const dir = getDbPath(dbPath);
+    let slot = backendSlots.get(dir);
+    if (!slot) {
+        slot = { promise: null, instance: null, available: null, attempts: 0 };
+        backendSlots.set(dir, slot);
+    }
+    if (slot.available === false)
         return null;
-    if (initAttempts >= MAX_INIT_ATTEMPTS) {
-        bridgeAvailable = false;
+    if (slot.attempts >= MAX_INIT_ATTEMPTS) {
+        slot.available = false;
         return null;
     }
-    if (backendInstance)
-        return backendInstance;
-    if (!backendPromise) {
-        backendPromise = (async () => {
+    if (slot.instance)
+        return slot.instance;
+    if (!slot.promise) {
+        slot.promise = (async () => {
             try {
                 const mod = await import('@monoes/memory');
-                // Try to create embedding generator from HuggingFace transformers
-                let embeddingGenerator;
-                try {
-                    const hf = await import('@huggingface/transformers');
-                    // revision must be a git ref — 'main' is the HF default; 'default' 404s and
-                    // silently killed embeddings (every search degraded to keyword matching)
-                    // dtype pinned explicitly: transformers.js logs a "dtype not specified"
-                    // warning to the console on every load otherwise (leaks into CLI output).
-                    const extractor = await hf.pipeline('feature-extraction', BRIDGE_EMBEDDING_MODEL, { revision: 'main', dtype: 'fp32' });
-                    embeddingGenerator = async (text) => {
-                        const output = await extractor(text, { pooling: 'mean', normalize: true });
-                        return new Float32Array(output.data);
-                    };
-                    _embedder = embeddingGenerator;
-                }
-                catch (e) {
-                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                        console.error('[memory-bridge] embedding model failed to load — store and search without vectors:', e);
-                }
+                await loadEmbedder();
                 // Local SQLite engine (LanceDB replaced 2026-07): better-sqlite3 when its
                 // native binding loads, sql.js (pure WASM) otherwise — both persist text
                 // AND embeddings, so vectors are always recomputable/derivable data.
-                // getDbPath keeps its traversal guard and directory semantics; the SQLite
-                // file lives inside that directory.
-                const dir = getDbPath(dbPath);
                 fs.mkdirSync(dir, { recursive: true });
                 // Origin marker: records which project this data dir belongs to, so
                 // `monomind cleanup --data` can verifiably prune dirs whose project
-                // no longer exists (the dir-name hash is one-way). Best-effort.
-                try {
-                    const originFile = path.join(projectDataDir(), 'origin.json');
-                    fs.writeFileSync(originFile, JSON.stringify({ path: path.resolve(process.cwd()), updatedAt: new Date().toISOString() }) + '\n', 'utf-8');
+                // no longer exists (the dir-name hash is one-way). Best-effort; never
+                // written for the global brain (it has no single origin project).
+                if (dir !== getGlobalBrainDir()) {
+                    try {
+                        const originFile = path.join(projectDataDir(), 'origin.json');
+                        fs.writeFileSync(originFile, JSON.stringify({ path: path.resolve(process.cwd()), updatedAt: new Date().toISOString() }) + '\n', 'utf-8');
+                    }
+                    catch { /* non-fatal */ }
                 }
-                catch { /* non-fatal */ }
                 const cfg = {
                     databasePath: path.join(dir, 'memory.db'),
                     walMode: true,
                     optimize: true,
                     defaultNamespace: 'default',
-                    embeddingGenerator,
+                    embeddingGenerator: _embedder ?? undefined,
                 };
                 const origLog = console.log;
                 console.log = (...args) => {
@@ -207,20 +233,20 @@ async function getBackend(dbPath) {
                 finally {
                     console.log = origLog;
                 }
-                backendInstance = backend;
-                bridgeAvailable = true;
+                slot.instance = backend;
+                slot.available = true;
                 return backend;
             }
             catch {
-                initAttempts++;
-                backendPromise = null;
-                if (initAttempts >= MAX_INIT_ATTEMPTS)
-                    bridgeAvailable = false;
+                slot.attempts++;
+                slot.promise = null;
+                if (slot.attempts >= MAX_INIT_ATTEMPTS)
+                    slot.available = false;
                 return null;
             }
         })();
     }
-    return backendPromise;
+    return slot.promise;
 }
 // ===== Core CRUD =====
 export async function bridgeStoreEntry(options) {
@@ -263,23 +289,26 @@ export async function bridgeStoreEntry(options) {
         entry.id = id;
         if (embedding)
             entry.embedding = embedding;
-        // Upsert: delete existing entry with same key+namespace first
+        // Upsert: find any existing entry with the same key+namespace — deleted
+        // only AFTER the new entry stores successfully, so a failed store() can't
+        // destroy the existing data (old order was delete-then-store).
+        let upsertVictim = null;
         if (options.upsert) {
             try {
-                const existing = await backend.getByKey(namespace, key);
-                if (existing)
-                    await backend.delete(existing.id);
-            }
-            catch (e) {
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[memory-bridge] upsert failed to delete existing entry — may create a duplicate:', e);
+                upsertVictim = await backend.getByKey(namespace, key);
             }
+            catch { /* treat as no existing entry */ }
         }
-        // Dedup gate: skip if a near-duplicate already exists
+        // Dedup gate: skip if a near-duplicate already exists IN THIS NAMESPACE —
+        // an unscoped search let a similar entry in some other namespace swallow
+        // the store entirely (returned duplicate:true, nothing written where asked).
         const automemCfg = getAutomemConfig();
         if (embedding && !options.upsert) {
             try {
-                const similar = await backend.search(embedding, { k: 1, threshold: automemCfg.dedupThreshold });
+                const similar = await backend.search(embedding, {
+                    k: 1, threshold: automemCfg.dedupThreshold,
+                    filters: { type: 'exact', namespace },
+                });
                 if (similar.length > 0 && similar[0].score >= automemCfg.dedupThreshold) {
                     return { success: true, id: similar[0].entry.id, duplicate: true };
                 }
@@ -287,6 +316,15 @@ export async function bridgeStoreEntry(options) {
             catch { /* non-fatal — store anyway */ }
         }
         await backend.store(entry);
+        if (upsertVictim && upsertVictim.id !== id) {
+            try {
+                await backend.delete(upsertVictim.id);
+            }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] upsert stored new entry but failed to delete the old one — duplicate may remain:', e);
+            }
+        }
         await flushBackend(backend);
         return { success: true, id, embedding: embeddingInfo };
     }
@@ -320,6 +358,7 @@ export async function bridgeSearchEntries(options) {
                     score: r.score,
                     namespace: r.entry.namespace,
                     provenance: `semantic:${r.score.toFixed(3)}`,
+                    tags: r.entry.tags ?? [],
                     _createdAt: r.entry.createdAt || 0,
                 }));
                 searchMethod = 'semantic';
@@ -329,9 +368,11 @@ export async function bridgeSearchEntries(options) {
         // Keyword fallback — scan all entries in namespace (not just first 100)
         // to avoid missing documents that were ingested later in the batch.
         if (results.length === 0) {
+            // No namespace filter means ALL namespaces — collapsing to 'default'
+            // made "search everything" silently miss every non-default entry.
             const entries = await backend.query({
                 type: 'exact',
-                namespace: namespace ?? 'default',
+                ...(namespace ? { namespace } : {}),
                 limit: 50000,
             });
             // Token-based matching, not whole-phrase substring: "semantic test" must
@@ -356,6 +397,7 @@ export async function bridgeSearchEntries(options) {
                     score: Math.min(0.9, 0.3 + score * 0.6),
                     namespace: e.namespace,
                     provenance: `keyword:${score.toFixed(2)}`,
+                    tags: e.tags ?? [],
                     _createdAt: e.createdAt || 0,
                 }));
             }
@@ -363,11 +405,16 @@ export async function bridgeSearchEntries(options) {
         }
         // Filter stale entries based on automem config — skip for knowledge
         // namespaces (documents should remain searchable indefinitely)
+        // Stale filtering is per-RESULT namespace (documents stay searchable
+        // forever) — keying it on the query's namespace filter meant an
+        // all-namespace search silently dropped knowledge:* results past the
+        // stale cutoff.
         const isKnowledgeNs = namespace?.startsWith('knowledge:');
         if (!isKnowledgeNs) {
             const { staleDays } = getAutomemConfig();
             const staleCutoff = Date.now() - staleDays * 86400000;
-            results = results.filter((r) => !r._createdAt || r._createdAt > staleCutoff);
+            results = results.filter((r) => String(r.namespace ?? '').startsWith('knowledge:')
+                || !r._createdAt || r._createdAt > staleCutoff);
         }
         results.forEach((r) => delete r._createdAt);
         return {
@@ -579,17 +626,17 @@ export async function getControllerRegistry(dbPath) {
     return getBackend(dbPath);
 }
 export async function shutdownBridge() {
-    if (backendInstance) {
-        try {
-            await backendInstance.shutdown();
+    for (const slot of backendSlots.values()) {
+        if (slot.instance) {
+            try {
+                await slot.instance.shutdown();
+            }
+            catch { /* ignore */ }
         }
-        catch { /* ignore */ }
     }
-    backendInstance = null;
-    backendPromise = null;
-    bridgeAvailable = null;
+    backendSlots.clear();
     _embedder = null;
-    initAttempts = 0;
+    _embedderPromise = null;
 }
 // ===== Pattern store =====
 export async function bridgeStorePattern(options) {