@monoes/monomindcli 2.9.2 → 2.9.4

package/dist/src/memory/memory-bridge.js

@@ -39,7 +39,8 @@ export function safeParseEmbedding(raw) {
     try {
         parsed = JSON.parse(raw);
     }
-    catch {
+    catch (e) {
+        logBridgeError('safeParseEmbedding', e);
         return null;
     }
     if (!Array.isArray(parsed))
@@ -65,7 +66,8 @@ const MAX_TAG_LEN = 64;
 const BRIDGE_RESULT_CONTENT_CAP = 500;
 function capResultContent(content) {
     return content.length > BRIDGE_RESULT_CONTENT_CAP
-        ? content.slice(0, BRIDGE_RESULT_CONTENT_CAP) + '…' : content;
+        ? content.slice(0, BRIDGE_RESULT_CONTENT_CAP) + '…'
+        : content;
 }
 // ===== DB path resolution =====
 // LanceDB commits via atomic rename, which exFAT/SMB project volumes don't support
@@ -88,7 +90,9 @@ function walkToProjectRoot(start) {
             if (fs.existsSync(path.join(dir, '.monomind')) || fs.existsSync(path.join(dir, '.git')))
                 return dir;
         }
-        catch { /* unreadable dir — keep walking */ }
+        catch (e) {
+            logBridgeError('walkToProjectRoot', e); /* unreadable dir — keep walking */
+        }
         const parent = path.dirname(dir);
         if (parent === dir)
             break;
@@ -136,7 +140,10 @@ export function getProjectRoot(from = process.env.MONOMIND_CWD || process.cwd())
 function projectDataDir() {
     const resolved = path.resolve(getProjectRoot());
     const hash = crypto.createHash('sha256').update(resolved).digest('hex').slice(0, 16);
-    const readable = path.basename(resolved).replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 40) || 'project';
+    const readable = path
+        .basename(resolved)
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .slice(0, 40) || 'project';
     return path.join(os.homedir(), '.monomind', 'projects', `${readable}-${hash}`);
 }
 /** Resolve symlinks so the traversal check below can't be bypassed by a link
@@ -145,7 +152,8 @@ function realOrResolved(p) {
     try {
         return fs.realpathSync(p);
     }
-    catch {
+    catch (e) {
+        logBridgeError('realOrResolved', e);
         return p;
     }
 }
@@ -155,7 +163,7 @@ function realOrResolved(p) {
  *  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');
+    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';
@@ -198,10 +206,15 @@ function getAutomemConfig() {
             return defaults;
         const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
         return {
-            dedupThreshold: typeof config?.scaffold?.dedupThreshold === 'number' ? config.scaffold.dedupThreshold : defaults.dedupThreshold,
-            staleDays: typeof config?.scaffold?.staleDays === 'number' ? config.scaffold.staleDays : defaults.staleDays,
+            dedupThreshold: typeof config?.scaffold?.dedupThreshold === 'number'
+                ? config.scaffold.dedupThreshold
+                : defaults.dedupThreshold,
+            staleDays: typeof config?.scaffold?.staleDays === 'number'
+                ? config.scaffold.staleDays
+                : defaults.staleDays,
             feedbackInfluence: typeof config?.scaffold?.feedbackInfluence === 'number'
-                ? Math.max(0, Math.min(1, config.scaffold.feedbackInfluence)) : defaults.feedbackInfluence,
+                ? Math.max(0, Math.min(1, config.scaffold.feedbackInfluence))
+                : defaults.feedbackInfluence,
         };
     }
     catch (e) {
@@ -223,9 +236,11 @@ const FREQUENCY_NORM_CAP = 10;
 function entryWeights(metadata) {
     const md = (metadata ?? {});
     const fw = typeof md.feedback_weight === 'number' && Number.isFinite(md.feedback_weight)
-        ? Math.max(0, Math.min(1, md.feedback_weight)) : DEFAULT_FEEDBACK_WEIGHT;
+        ? Math.max(0, Math.min(1, md.feedback_weight))
+        : DEFAULT_FEEDBACK_WEIGHT;
     const freq = typeof md.frequency_weight === 'number' && Number.isFinite(md.frequency_weight)
-        ? Math.max(0, md.frequency_weight) : 0;
+        ? Math.max(0, md.frequency_weight)
+        : 0;
     return { feedback: fw, frequency: freq };
 }
 /** Blend learned usefulness into a GENUINE embedding-similarity score.
@@ -289,7 +304,11 @@ export async function loadReranker() {
                 const tokenizer = await hf.AutoTokenizer.from_pretrained(modelId, opts);
                 const model = await hf.AutoModelForSequenceClassification.from_pretrained(modelId, opts);
                 _reranker = async (query, passage) => {
-                    const inputs = await tokenizer(query, { text_pair: passage, padding: true, truncation: true });
+                    const inputs = await tokenizer(query, {
+                        text_pair: passage,
+                        padding: true,
+                        truncation: true,
+                    });
                     const output = await model(inputs);
                     const logits = output.logits.data;
                     // num_labels=1 → [1,1] regression score, apply sigmoid
@@ -335,7 +354,9 @@ async function flushBackend(backend) {
     try {
         await backend?.persist?.();
     }
-    catch { /* best effort */ }
+    catch (e) {
+        logBridgeError('flushBackend', e); /* best effort */
+    }
 }
 /** Loads the local embedding model.
  *
@@ -360,7 +381,11 @@ async function loadEmbedder() {
                 // 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: 'q8', local_files_only: true });
+                const extractor = await hf.pipeline('feature-extraction', BRIDGE_EMBEDDING_MODEL, {
+                    revision: 'main',
+                    dtype: 'q8',
+                    local_files_only: true,
+                });
                 _embedder = async (text) => {
                     const output = await extractor(text, { pooling: 'cls', normalize: true });
                     return new Float32Array(output.data);
@@ -390,7 +415,9 @@ async function getBackend(dbPath) {
             try {
                 await evicted?.instance?.shutdown?.();
             }
-            catch { /* best effort */ }
+            catch (e) {
+                logBridgeError('getBackend.evictedShutdown', e); /* best effort */
+            }
             backendSlots.delete(oldest);
         }
         slot = { promise: null, instance: null, available: null, attempts: 0 };
@@ -426,9 +453,12 @@ async function getBackend(dbPath) {
                         // would make `cleanup --data` prune the WHOLE project's brain as
                         // orphaned.
                         const originFile = path.join(projectDataDir(), 'origin.json');
-                        fs.writeFileSync(originFile, JSON.stringify({ path: getProjectRoot(), updatedAt: new Date().toISOString() }) + '\n', 'utf-8');
+                        fs.writeFileSync(originFile, JSON.stringify({ path: getProjectRoot(), updatedAt: new Date().toISOString() }) +
+                            '\n', 'utf-8');
+                    }
+                    catch (e) {
+                        logBridgeError('getBackend.originWrite', e); /* non-fatal */
                     }
-                    catch { /* non-fatal */ }
                 }
                 const cfg = {
                     databasePath: path.join(dir, 'memory.db'),
@@ -489,7 +519,8 @@ export async function bridgeStoreEntry(options) {
         return null;
     try {
         const key = typeof options.key === 'string' && options.key.length > BRIDGE_MAX_KEY_LEN
-            ? options.key.slice(0, BRIDGE_MAX_KEY_LEN) : options.key;
+            ? options.key.slice(0, BRIDGE_MAX_KEY_LEN)
+            : options.key;
         if (typeof options.value === 'string' && options.value.length > BRIDGE_MAX_VALUE_LEN) {
             return {
                 success: false,
@@ -500,9 +531,13 @@ export async function bridgeStoreEntry(options) {
         const value = options.value;
         const namespace = options.namespace ?? 'default';
         const tags = Array.isArray(options.tags)
-            // src: tags carry the ingest source path for excerpt provenance — paths
-            // routinely exceed the general 64-char tag cap, so they get 512.
-            ? options.tags.filter(t => typeof t === 'string' && t.length > 0 && t.length <= (t.startsWith('src:') ? 512 : MAX_TAG_LEN)).slice(0, MAX_TAGS)
+            ? // src: tags carry the ingest source path for excerpt provenance — paths
+                // routinely exceed the general 64-char tag cap, so they get 512.
+                options.tags
+                    .filter((t) => typeof t === 'string' &&
+                    t.length > 0 &&
+                    t.length <= (t.startsWith('src:') ? 512 : MAX_TAG_LEN))
+                    .slice(0, MAX_TAGS)
             : [];
         const now = Date.now();
         const id = generateId('entry');
@@ -540,7 +575,9 @@ export async function bridgeStoreEntry(options) {
             try {
                 upsertVictim = await backend.getByKey(namespace, key);
             }
-            catch { /* treat as no existing entry */ }
+            catch (e) {
+                logBridgeError('bridgeStoreEntry.upsertLookup', e); /* treat as no existing entry */
+            }
         }
         // Dedup gate: skip if a near-duplicate already exists IN THIS NAMESPACE —
         // an unscoped search let a similar entry in some other namespace swallow
@@ -549,17 +586,22 @@ export async function bridgeStoreEntry(options) {
         if (embedding && !options.upsert) {
             try {
                 const similar = await backend.search(embedding, {
-                    k: 1, threshold: automemCfg.dedupThreshold,
+                    k: 1,
+                    threshold: automemCfg.dedupThreshold,
                     filters: { type: 'exact', namespace },
                 });
                 if (similar.length > 0 && similar[0].score >= automemCfg.dedupThreshold) {
                     // Re-storing near-identical content is a usage signal: the fact keeps
                     // being worth remembering. Reinforce the surviving entry.
-                    await recordUsageOnBackend(backend, [similar[0].entry.id]).catch(() => { });
+                    await recordUsageOnBackend(backend, [similar[0].entry.id]).catch(() => {
+                        /* best effort */
+                    });
                     return { success: true, id: similar[0].entry.id, duplicate: true };
                 }
             }
-            catch { /* non-fatal — store anyway */ }
+            catch (e) {
+                logBridgeError('bridgeStoreEntry.dedupSearch', e); /* non-fatal — store anyway */
+            }
         }
         await backend.store(entry);
         if (upsertVictim && upsertVictim.id !== id) {
@@ -575,7 +617,9 @@ export async function bridgeStoreEntry(options) {
         return { success: true, id, embedding: embeddingInfo };
     }
     catch (err) {
-        return { success: false, id: '', error: String(err?.message ?? err) };
+        logBridgeError('bridgeStoreEntry', err);
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, id: '', error: message };
     }
 }
 export async function bridgeSearchEntries(options) {
@@ -587,17 +631,49 @@ export async function bridgeSearchEntries(options) {
         // CLI callers pass 'all' as a no-filter sentinel — never treat it as a literal namespace
         const namespace = options.namespace && options.namespace !== 'all' ? options.namespace : undefined;
         const startTime = Date.now();
+        // ── Knowledge removal support (issue #106) ──────────────────────
+        // Pre-compute live document hashes for knowledge namespaces so we can
+        // (a) over-fetch to compensate for superseded entries being filtered,
+        // (b) filter them out after retrieval — ensuring removed documents
+        //     are invisible to EVERY caller, not just searchKnowledge.
+        // Dynamic import breaks the circular dependency: document-pipeline
+        // imports getProjectRoot from this module.
+        let _knowledgeLive = null;
+        let _knowledgeHasMeta = false;
+        let _isSupersededKey = null;
+        const knowledgeFilterActive = namespace?.startsWith('knowledge:') && !options.includeSuperseded;
+        if (knowledgeFilterActive) {
+            try {
+                const dp = await import('../knowledge/document-pipeline.js');
+                const rootDir = options.dbPath === GLOBAL_BRAIN ? getGlobalBrainDir() : getProjectRoot();
+                _knowledgeLive = dp.liveContentHashes(rootDir);
+                _knowledgeHasMeta = dp.hasKnowledgeMetadata(rootDir);
+                _isSupersededKey = dp.isSupersededKey;
+            }
+            catch (e) {
+                logBridgeError('bridgeSearchEntries.knowledgeFilter', e); /* non-fatal: skip filtering when pipeline is unavailable */
+            }
+        }
         // Over-retrieve when the reranker is available: fetch more candidates so the
         // cross-encoder can reshuffle them. The reranker trims back to `limit`.
+        // For knowledge namespaces, also over-fetch to compensate for superseded
+        // document versions that will be filtered out below.
         const rerankerActive = !options.skipRerank && _reranker !== null && process.env.MONOMIND_RERANKER !== '0';
-        const retrieveK = rerankerActive ? Math.min(limit * 3, 20) : limit;
+        const knowledgeLimit = _knowledgeLive && _knowledgeLive.size > 0
+            ? Math.min(Math.max(limit * 20, limit), 300)
+            : limit;
+        const retrieveK = rerankerActive
+            ? Math.min(knowledgeLimit * 3, Math.max(20, knowledgeLimit))
+            : knowledgeLimit;
         let results = [];
         let searchMethod = 'keyword';
         // Reported to callers so "(semantic)" can never be printed over keyword hits.
         // The two reasons for skipping the vector path are distinct and must not be
         // conflated: a healthy model given an empty query is not a missing model.
-        let fallbackReason = !_embedder ? 'no-embedding-model'
-            : queryStr.length === 0 ? 'empty-query'
+        let fallbackReason = !_embedder
+            ? 'no-embedding-model'
+            : queryStr.length === 0
+                ? 'empty-query'
                 : undefined;
         let semanticAttempted = false;
         if (_embedder && queryStr.length > 0) {
@@ -610,7 +686,8 @@ export async function bridgeSearchEntries(options) {
                     filters: namespace ? { type: 'exact', namespace } : undefined,
                 });
                 const { feedbackInfluence } = getAutomemConfig();
-                results = searchResults.map((r) => {
+                results = searchResults
+                    .map((r) => {
                     const weights = entryWeights(r.entry.metadata);
                     // Blend only here (semantic path): r.score is a genuine cosine similarity.
                     const blended = blendScore(r.score, weights, feedbackInfluence);
@@ -624,7 +701,8 @@ export async function bridgeSearchEntries(options) {
                         tags: r.entry.tags ?? [],
                         _createdAt: r.entry.createdAt || 0,
                     };
-                }).sort((a, b) => b.score - a.score);
+                })
+                    .sort((a, b) => b.score - a.score);
                 searchMethod = 'semantic';
                 fallbackReason = undefined;
             }
@@ -646,7 +724,10 @@ export async function bridgeSearchEntries(options) {
         // loaded up to 50k rows and scanned them in JS. The JS fallback is
         // kept for sql.js WASM builds that lack the FTS5 extension.
         {
-            const tokens = queryStr.toLowerCase().split(/[^a-z0-9]+/).filter(t => t.length > 1);
+            const tokens = queryStr
+                .toLowerCase()
+                .split(/[^a-z0-9]+/)
+                .filter((t) => t.length > 1);
             let keywordHits = [];
             if (tokens.length) {
                 // ── FTS5 fast path ──────────────────────────────────────────
@@ -674,26 +755,92 @@ export async function bridgeSearchEntries(options) {
                         ...(namespace ? { namespace } : {}),
                         limit: 50000,
                     });
-                    keywordHits = entries
-                        .map((e) => {
-                        const haystack = `${e.key || ''} ${e.content || ''}`.toLowerCase();
-                        const hits = tokens.filter(t => haystack.includes(t)).length;
-                        return { e, score: hits / tokens.length };
-                    })
-                        .filter((x) => x.score > 0)
-                        .sort((a, b) => b.score - a.score)
-                        .slice(0, limit)
-                        .map(({ e, score }) => ({
-                        id: e.id,
-                        key: e.key,
-                        content: capResultContent(e.content || ''),
-                        // Raw token-overlap fraction, NOT rescaled to look like a cosine.
-                        score,
-                        namespace: e.namespace,
-                        provenance: `keyword:${score.toFixed(2)}`,
-                        tags: e.tags ?? [],
-                        _createdAt: e.createdAt || 0,
-                    }));
+                    // #126: Bm25Index.build() costs real time at scale (measured in
+                    // bm25-index.ts's own header: ~113ms/673 chunks, ~1.7s/12.5k
+                    // chunks) — this fallback can be handed up to 50,000 entries, so
+                    // building a fresh index on every call without a cap would make
+                    // large stores' searches slower, not better. Below the cap, BM25
+                    // (proper IDF weighting) replaces the naive token-overlap-fraction
+                    // scan; above it, the fast scan keeps running so latency never
+                    // regresses. MONOMIND_BM25=0 disables this arm entirely (mirrors
+                    // the MONOMIND_RERANKER kill-switch).
+                    const BM25_ENTRY_CAP = 1500;
+                    const bm25Enabled = (process.env.MONOMIND_BM25 ?? '1') !== '0';
+                    let bm25Ok = false;
+                    if (bm25Enabled && entries.length > 0 && entries.length <= BM25_ENTRY_CAP) {
+                        try {
+                            const { Bm25Index } = await import('./bm25-index.js');
+                            // #126-review: index by the entry's ARRAY POSITION, not e.key —
+                            // memory_entries only enforces UNIQUE(namespace, key), so a bare
+                            // key string can legitimately repeat across namespaces (e.g. two
+                            // agents each storing a 'summary' key in their own namespace).
+                            // Keying by e.key alone collided in that case: every BM25 hit
+                            // sharing that key string resolved to whichever entry happened
+                            // to be inserted last into the lookup map, silently returning
+                            // the wrong entry's id/content/namespace.
+                            const chunks = entries.map((e, i) => ({
+                                key: String(i),
+                                text: `${e.key || ''} ${e.content || ''}`,
+                            }));
+                            const idx = Bm25Index.build(chunks, () => false); // no superseded concept at this generic KV level — filtered later by callers that care
+                            const hits = idx.search(queryStr, limit);
+                            // #126-review: Math.max(..., 1) as a divide-by-zero guard also
+                            // silently floors the normalization divisor whenever every real
+                            // score is < 1 (common for small/sparse corpora — exactly the
+                            // regime this capped fallback runs in), so the top hit stopped
+                            // normalizing to 1.0 as the comment below claims. Only fall
+                            // back to 1 when there is no positive score to divide by.
+                            const rawMax = hits.length ? Math.max(...hits.map((h) => h.score)) : 0;
+                            const maxScore = rawMax > 0 ? rawMax : 1;
+                            keywordHits = hits.map((h) => {
+                                const e = entries[Number(h.key)];
+                                const normalized = h.score / maxScore; // BM25 scores aren't comparable across queries/corpora — normalise 0-1 like the FTS5 path does
+                                return {
+                                    id: e.id,
+                                    key: e.key,
+                                    content: capResultContent(e.content || ''),
+                                    score: normalized,
+                                    namespace: e.namespace,
+                                    provenance: `keyword-bm25:${normalized.toFixed(2)}`,
+                                    tags: e.tags ?? [],
+                                    _createdAt: e.createdAt || 0,
+                                };
+                            });
+                            bm25Ok = true;
+                        }
+                        catch (e) {
+                            // #126-review: BM25 build/search had no local try/catch, unlike
+                            // every other sub-path in this function — an exception here
+                            // used to propagate to the function's single outer catch,
+                            // discarding the whole call (including already-computed
+                            // semantic results) instead of degrading to the naive scan
+                            // below, which is what every other keyword-path failure does.
+                            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                                console.error('[memory-bridge] BM25 keyword search failed — falling back to token-overlap scan:', e);
+                        }
+                    }
+                    if (!bm25Ok) {
+                        keywordHits = entries
+                            .map((e) => {
+                            const haystack = `${e.key || ''} ${e.content || ''}`.toLowerCase();
+                            const hits = tokens.filter((t) => haystack.includes(t)).length;
+                            return { e, score: hits / tokens.length };
+                        })
+                            .filter((x) => x.score > 0)
+                            .sort((a, b) => b.score - a.score)
+                            .slice(0, limit)
+                            .map(({ e, score }) => ({
+                            id: e.id,
+                            key: e.key,
+                            content: capResultContent(e.content || ''),
+                            // Raw token-overlap fraction, NOT rescaled to look like a cosine.
+                            score,
+                            namespace: e.namespace,
+                            provenance: `keyword:${score.toFixed(2)}`,
+                            tags: e.tags ?? [],
+                            _createdAt: e.createdAt || 0,
+                        }));
+                    }
                 }
                 if (results.length === 0) {
                     // No semantic results — keyword is all we have.
@@ -728,15 +875,30 @@ export async function bridgeSearchEntries(options) {
         // stale cutoff.
         // org:* (cross-run org memory) and rules are durable learned state like
         // documents — the stale cliff silently erased org recall after a week.
-        const durableNs = (ns) => ns.startsWith('knowledge:') || ns.startsWith('org:') || ns.startsWith('agent:') || ns.startsWith('kg:') || ns === 'rules';
+        const durableNs = (ns) => ns.startsWith('knowledge:') ||
+            ns.startsWith('org:') ||
+            ns.startsWith('agent:') ||
+            ns.startsWith('kg:') ||
+            ns === 'rules';
         const isKnowledgeNs = namespace ? durableNs(namespace) : false;
         if (!isKnowledgeNs) {
             const { staleDays } = getAutomemConfig();
             const staleCutoff = Date.now() - staleDays * 86400000;
-            results = results.filter((r) => durableNs(String(r.namespace ?? ''))
-                || !r._createdAt || r._createdAt > staleCutoff);
+            results = results.filter((r) => durableNs(String(r.namespace ?? '')) || !r._createdAt || r._createdAt > staleCutoff);
         }
         results.forEach((r) => delete r._createdAt);
+        // ── Knowledge superseded filtering (issue #106) ─────────────────
+        // Remove document chunks whose content hash is no longer current
+        // (i.e. the document was removed via `knowledge_remove` or replaced
+        // by a newer ingest). This runs inside the bridge so every caller —
+        // embeddings_search, CLI `memory search`, and searchKnowledge — gets
+        // the same removal guarantee.
+        if (_knowledgeLive && _isSupersededKey && results.length > 0) {
+            results = results.filter((r) => !_isSupersededKey(String(r.key ?? ''), _knowledgeLive, _knowledgeHasMeta));
+            // Trim back to the originally requested limit after overfetch.
+            if (results.length > limit)
+                results = results.slice(0, limit);
+        }
         // ── Cross-encoder reranking ──────────────────────────────────────
         // Fires only when: reranker loaded, >1 result, not explicitly skipped.
         // Lazy-load on first qualifying search so startup stays fast.
@@ -745,7 +907,9 @@ export async function bridgeSearchEntries(options) {
             if (!_reranker && !_rerankerPromise) {
                 // First qualifying search — kick off the lazy load. This search
                 // proceeds without reranking; the NEXT search will use it.
-                loadReranker().catch(() => { });
+                loadReranker().catch(() => {
+                    /* swallowed — retry next time */
+                });
             }
             if (_reranker) {
                 const rr = await rerankResults(queryStr, results, limit);
@@ -774,7 +938,12 @@ export async function bridgeListEntries(options) {
     try {
         const entries = await backend.query({
             type: 'exact',
-            namespace: options.namespace ?? 'default',
+            // No namespace means "all namespaces" — the query builder (sql-backend.ts)
+            // already skips its filter clause on a falsy namespace. Defaulting to the
+            // literal string 'default' here (as this used to) overrode that legitimate
+            // "no filter" signal and silently scoped every unfiltered list/search to a
+            // namespace that's usually near-empty in practice.
+            namespace: options.namespace,
             limit: options.limit ?? 100,
             offset: options.offset,
         });
@@ -902,7 +1071,8 @@ export async function bridgeGetBackendStats(dbPath) {
             memoryUsage: stats?.memoryUsage ?? 0,
         };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeGetBackendStats', e);
         return null;
     }
 }
@@ -915,7 +1085,8 @@ export async function bridgeGetHNSWStatus(dbPath) {
         const stats = await backend.getStats();
         return { built: true, size: stats?.totalEntries ?? 0, dimensions: BRIDGE_EMBEDDING_DIMS };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeGetHNSWStatus', e);
         return { built: false, size: 0, dimensions: BRIDGE_EMBEDDING_DIMS };
     }
 }
@@ -932,7 +1103,12 @@ export async function bridgeSearchHNSW(options) {
         return null;
     return {
         success: result.success,
-        results: result.results.map(r => ({ id: r.id, key: r.key, score: r.score, namespace: r.namespace })),
+        results: result.results.map((r) => ({
+            id: r.id,
+            key: r.key,
+            score: r.score,
+            namespace: r.namespace,
+        })),
         searchTime: result.searchTime,
     };
 }
@@ -945,7 +1121,8 @@ export async function bridgeAddToHNSW(options) {
         const stats = await backend.getStats();
         return { success: true, indexSize: stats?.totalEntries ?? 0 };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeAddToHNSW', e);
         return { success: true };
     }
 }
@@ -977,7 +1154,9 @@ export async function shutdownBridge() {
             try {
                 await slot.instance.shutdown();
             }
-            catch { /* ignore */ }
+            catch (e) {
+                logBridgeError('bridgeShutdown.slotShutdown', e); /* ignore */
+            }
         }
     }
     backendSlots.clear();
@@ -1013,12 +1192,14 @@ export async function bridgeSearchPatterns(options) {
         return null;
     return {
         success: result.success,
-        patterns: result.results.map(r => {
+        patterns: result.results.map((r) => {
             let parsed = {};
             try {
                 parsed = JSON.parse(r.content);
             }
-            catch { /* use raw */ }
+            catch (e) {
+                logBridgeError('bridgeSearchPatterns.parseContent', e); /* use raw */
+            }
             return {
                 id: r.id,
                 pattern: parsed.pattern ?? r.content,
@@ -1046,7 +1227,9 @@ async function recordUsageOnBackend(backend, entryIds) {
             });
             updated++;
         }
-        catch { /* skip unreadable entries */ }
+        catch (e) {
+            logBridgeError('recordUsageOnBackend.entryUpdate', e); /* skip unreadable entries */
+        }
     }
     return updated;
 }
@@ -1062,7 +1245,8 @@ export async function bridgeRecordUsage(options) {
             await flushBackend(backend);
         return { success: true, updated };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeRecordUsage', e);
         return { success: false, updated: 0 };
     }
 }
@@ -1076,7 +1260,9 @@ export async function bridgeApplyFeedback(options) {
         return null;
     try {
         const score = Math.max(0, Math.min(1, options.score));
-        const alpha = typeof options.alpha === 'number' ? Math.max(0, Math.min(1, options.alpha)) : FEEDBACK_EWMA_ALPHA;
+        const alpha = typeof options.alpha === 'number'
+            ? Math.max(0, Math.min(1, options.alpha))
+            : FEEDBACK_EWMA_ALPHA;
         const ledgerEntryKey = options.ledgerKey ? `applied_${options.ledgerKey.slice(0, 500)}` : null;
         if (ledgerEntryKey) {
             const existing = await backend.getByKey('feedback', ledgerEntryKey).catch(() => null);
@@ -1096,12 +1282,19 @@ export async function bridgeApplyFeedback(options) {
                 await backend.update(id, { metadata: { feedback_weight: next } });
                 applied++;
             }
-            catch { /* skip unreadable entries */ }
+            catch (e) {
+                logBridgeError('bridgeApplyFeedback.entryUpdate', e); /* skip unreadable entries */
+            }
         }
         if (ledgerEntryKey) {
             await bridgeStoreEntry({
                 key: ledgerEntryKey,
-                value: JSON.stringify({ score, entryIds: options.entryIds.slice(0, 100), appliedAt: Date.now(), applied }),
+                value: JSON.stringify({
+                    score,
+                    entryIds: options.entryIds.slice(0, 100),
+                    appliedAt: Date.now(),
+                    applied,
+                }),
                 namespace: 'feedback',
                 generateEmbeddingFlag: false,
                 dbPath: options.dbPath,
@@ -1113,7 +1306,9 @@ export async function bridgeApplyFeedback(options) {
         return { success: true, applied };
     }
     catch (err) {
-        return { success: false, applied: 0, error: String(err?.message ?? err) };
+        logBridgeError('bridgeApplyFeedback', err);
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, applied: 0, error: message };
     }
 }
 // ===== Feedback =====
@@ -1198,7 +1393,8 @@ export async function bridgeSessionEnd(options) {
         }
         return { success: true };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeSessionEnd', e);
         return { success: false };
     }
 }
@@ -1214,12 +1410,14 @@ export async function bridgeRouteTask(options) {
         return null;
     return {
         success: result.success,
-        routes: result.results.map(r => {
+        routes: result.results.map((r) => {
             let parsed = {};
             try {
                 parsed = JSON.parse(r.content);
             }
-            catch { /* use raw */ }
+            catch (e) {
+                logBridgeError('bridgeRouteTask.parseContent', e); /* use raw */
+            }
             return {
                 agentType: parsed.taskType ?? 'coder',
                 confidence: r.score,
@@ -1239,13 +1437,16 @@ export async function bridgeHealthCheck(dbPath) {
         return {
             healthy: health?.healthy ?? true,
             backend: 'sqlite',
-            stats: stats ? {
-                totalEntries: stats.totalEntries ?? 0,
-                namespaces: Object.keys(stats.entriesByNamespace ?? {}),
-            } : undefined,
+            stats: stats
+                ? {
+                    totalEntries: stats.totalEntries ?? 0,
+                    namespaces: Object.keys(stats.entriesByNamespace ?? {}),
+                }
+                : undefined,
         };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeHealthCheck', e);
         return { healthy: false, backend: 'sqlite' };
     }
 }
@@ -1298,7 +1499,9 @@ export async function bridgeConsolidate(params) {
                 continue;
             }
             if ((e.accessCount ?? 0) === 0) {
-                await backend.delete(e.id).catch(() => { });
+                await backend.delete(e.id).catch(() => {
+                    /* non-fatal */
+                });
                 deleted++;
             }
         }
@@ -1306,7 +1509,8 @@ export async function bridgeConsolidate(params) {
             await flushBackend(backend);
         return { success: true, consolidated: deleted, preserved: kept };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeConsolidate', e);
         return { success: false, consolidated: 0 };
     }
 }
@@ -1319,7 +1523,11 @@ export async function bridgeBatchOperation(params) {
         let processed = 0;
         if (params.operation === 'store') {
             for (const e of params.entries) {
-                const result = await bridgeStoreEntry({ key: e.key, value: e.value, namespace: e.namespace });
+                const result = await bridgeStoreEntry({
+                    key: e.key,
+                    value: e.value,
+                    namespace: e.namespace,
+                });
                 if (result?.success)
                     processed++;
             }
@@ -1333,7 +1541,8 @@ export async function bridgeBatchOperation(params) {
         }
         return { success: true, processed };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeBatchOperation', e);
         return { success: false, processed: 0 };
     }
 }