@monoes/monomindcli 2.9.3 → 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) {
@@ -601,29 +645,35 @@ export async function bridgeSearchEntries(options) {
         if (knowledgeFilterActive) {
             try {
                 const dp = await import('../knowledge/document-pipeline.js');
-                const rootDir = options.dbPath === GLOBAL_BRAIN
-                    ? getGlobalBrainDir() : getProjectRoot();
+                const rootDir = options.dbPath === GLOBAL_BRAIN ? getGlobalBrainDir() : getProjectRoot();
                 _knowledgeLive = dp.liveContentHashes(rootDir);
                 _knowledgeHasMeta = dp.hasKnowledgeMetadata(rootDir);
                 _isSupersededKey = dp.isSupersededKey;
             }
-            catch { /* non-fatal: skip filtering when pipeline is unavailable */ }
+            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 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;
+        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) {
@@ -636,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);
@@ -650,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;
             }
@@ -672,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 ──────────────────────────────────────────
@@ -723,7 +778,10 @@ export async function bridgeSearchEntries(options) {
                             // 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 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
@@ -732,7 +790,7 @@ export async function bridgeSearchEntries(options) {
                             // 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 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)];
@@ -765,7 +823,7 @@ export async function bridgeSearchEntries(options) {
                         keywordHits = entries
                             .map((e) => {
                             const haystack = `${e.key || ''} ${e.content || ''}`.toLowerCase();
-                            const hits = tokens.filter(t => haystack.includes(t)).length;
+                            const hits = tokens.filter((t) => haystack.includes(t)).length;
                             return { e, score: hits / tokens.length };
                         })
                             .filter((x) => x.score > 0)
@@ -817,13 +875,16 @@ 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) ─────────────────
@@ -846,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);
@@ -1008,7 +1071,8 @@ export async function bridgeGetBackendStats(dbPath) {
             memoryUsage: stats?.memoryUsage ?? 0,
         };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeGetBackendStats', e);
         return null;
     }
 }
@@ -1021,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 };
     }
 }
@@ -1038,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,
     };
 }
@@ -1051,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 };
     }
 }
@@ -1083,7 +1154,9 @@ export async function shutdownBridge() {
             try {
                 await slot.instance.shutdown();
             }
-            catch { /* ignore */ }
+            catch (e) {
+                logBridgeError('bridgeShutdown.slotShutdown', e); /* ignore */
+            }
         }
     }
     backendSlots.clear();
@@ -1119,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,
@@ -1152,7 +1227,9 @@ async function recordUsageOnBackend(backend, entryIds) {
             });
             updated++;
         }
-        catch { /* skip unreadable entries */ }
+        catch (e) {
+            logBridgeError('recordUsageOnBackend.entryUpdate', e); /* skip unreadable entries */
+        }
     }
     return updated;
 }
@@ -1168,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 };
     }
 }
@@ -1182,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);
@@ -1202,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,
@@ -1219,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 =====
@@ -1304,7 +1393,8 @@ export async function bridgeSessionEnd(options) {
         }
         return { success: true };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeSessionEnd', e);
         return { success: false };
     }
 }
@@ -1320,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,
@@ -1345,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' };
     }
 }
@@ -1404,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++;
             }
         }
@@ -1412,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 };
     }
 }
@@ -1425,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++;
             }
@@ -1439,7 +1541,8 @@ export async function bridgeBatchOperation(params) {
         }
         return { success: true, processed };
     }
-    catch {
+    catch (e) {
+        logBridgeError('bridgeBatchOperation', e);
         return { success: false, processed: 0 };
     }
 }