monomind 2.7.12 → 2.7.13

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

@@ -1,1104 +0,0 @@
-/**
- * Memory Bridge — Routes CLI memory operations through SQLite
- *
- * Uses SQLiteBackend (better-sqlite3, sql.js WASM fallback) from @monoes/memory.
- * LanceDB was replaced by this SQLite engine 2026-07; the on-disk data
- * directory is still named `lancedb` for legacy/back-compat path resolution
- * (see getDbPath below) but no longer holds LanceDB data.
- * All exported function signatures are unchanged.
- *
- * @module v1/cli/memory-bridge
- */
-import * as path from 'path';
-import * as crypto from 'crypto';
-import * as os from 'os';
-import * as fs from 'fs';
-// ===== Embedding validation =====
-const MAX_EMBEDDING_DIMS = 8192;
-const MAX_EMBEDDING_JSON_BYTES = MAX_EMBEDDING_DIMS * 32; // ~256KB ceiling
-export function safeParseEmbedding(raw) {
-    if (typeof raw !== 'string' || raw.length === 0)
-        return null;
-    if (raw.length > MAX_EMBEDDING_JSON_BYTES)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (!Array.isArray(parsed))
-        return null;
-    if (parsed.length === 0 || parsed.length > MAX_EMBEDDING_DIMS)
-        return null;
-    for (let i = 0; i < parsed.length; i++) {
-        const v = parsed[i];
-        if (typeof v !== 'number' || !Number.isFinite(v))
-            return null;
-    }
-    return parsed;
-}
-// ===== Constants =====
-const BRIDGE_EMBEDDING_MODEL = 'Xenova/all-MiniLM-L6-v2';
-const BRIDGE_EMBEDDING_DIMS = 384;
-const BRIDGE_MAX_KEY_LEN = 4 * 1024;
-const BRIDGE_MAX_VALUE_LEN = 1024 * 1024;
-const MAX_TAGS = 32;
-const MAX_TAG_LEN = 64;
-// ===== DB path resolution =====
-// LanceDB commits via atomic rename, which exFAT/SMB project volumes don't support
-// (ENOTSUP os error 45) — and non-APFS volumes grow ._ AppleDouble sidecars inside
-// the .lance datasets that corrupt reads. So the store always lives on the home
-// volume, namespaced per project directory.
-//
-// The slug is a hash of the full resolved path, not a character-substitution of
-// it — flattening separators to '-' is not collision-safe ('/x/foo-bar' and
-// '/x/foo/bar' would both flatten to 'x-foo-bar'). A short readable prefix is
-// kept purely so the directory name is browsable; only the hash guarantees
-// uniqueness.
-function projectDataDir() {
-    const resolved = path.resolve(process.cwd());
-    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';
-    return path.join(os.homedir(), '.monomind', 'projects', `${readable}-${hash}`);
-}
-/** Resolve symlinks so the traversal check below can't be bypassed by a link
- * that lexically resolves inside the allowed trees but points outside them. */
-function realOrResolved(p) {
-    try {
-        return fs.realpathSync(p);
-    }
-    catch {
-        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, 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 SQLite data-dir path for a given custom path (or the
- *  default) — the dir is still named `lancedb` for legacy path back-compat. */
-export function bridgeGetDbPath(customPath) {
-    return getDbPath(customPath);
-}
-function getAutomemConfig() {
-    const defaults = { dedupThreshold: 0.85, staleDays: 7, feedbackInfluence: 0.2 };
-    try {
-        const configPath = path.join(process.cwd(), '.monomind', 'automem-config.json');
-        if (!fs.existsSync(configPath))
-            return defaults;
-        const stat = fs.statSync(configPath);
-        if (stat.size > 64 * 1024)
-            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,
-            feedbackInfluence: typeof config?.scaffold?.feedbackInfluence === 'number'
-                ? Math.max(0, Math.min(1, config.scaffold.feedbackInfluence)) : defaults.feedbackInfluence,
-        };
-    }
-    catch {
-        return defaults;
-    }
-}
-// ===== Usage/feedback weights (cognee-style, stored in entry metadata) =====
-//
-// feedback_weight (0..1, default 0.5): EWMA of explicit/auto ratings applied to
-// the entries actually used to produce an answer. frequency_weight (>=0): how
-// often the entry was returned by a search. Both live in the entry's metadata
-// JSON — deliberately NOT backend schema columns, so no @monoes/memory publish
-// is needed and both backends work unchanged.
-const DEFAULT_FEEDBACK_WEIGHT = 0.5;
-const FEEDBACK_EWMA_ALPHA = 0.1;
-/** frequency_weight normalization ceiling: 10+ uses counts as fully reinforced. */
-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;
-    const freq = typeof md.frequency_weight === 'number' && Number.isFinite(md.frequency_weight)
-        ? Math.max(0, md.frequency_weight) : 0;
-    return { feedback: fw, frequency: freq };
-}
-/** Blend learned usefulness into a GENUINE embedding-similarity score.
- *  Cognee guard: never applied to keyword-fallback scores — those carry no
- *  real relevance signal, and blending there lets a high-feedback stale entry
- *  outrank relevant matches and self-reinforce (rich-get-richer). */
-function blendScore(cosineSim, weights, influence) {
-    if (influence <= 0)
-        return cosineSim;
-    const usefulness = 0.7 * weights.feedback + 0.3 * Math.min(1, weights.frequency / FREQUENCY_NORM_CAP);
-    return (1 - influence) * cosineSim + influence * usefulness;
-}
-function generateId(prefix) {
-    return `${prefix}_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
-}
-const backendSlots = new Map();
-const MAX_BACKEND_SLOTS = 5;
-let _embedder = null;
-let _embedderPromise = null;
-const MAX_INIT_ATTEMPTS = 3;
-/** 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. */
-async function flushBackend(backend) {
-    try {
-        await backend?.persist?.();
-    }
-    catch { /* best effort */ }
-}
-/** Loads the local embedding model.
- *
- *  This is the single point where `onnxruntime-node` enters the CLI process
- *  (via @huggingface/transformers). Once it has run, the process is subject to
- *  docs/adrs/ADR-R001-onnxruntime-process-teardown.md: calling process.exit()
- *  will abort with SIGABRT ("mutex lock failed") instead of exiting cleanly,
- *  and disposing the pipeline first does not help.
- *
- *  Anything that reaches this — `doctor`, `memory store`, `memory search`, the
- *  MCP memory tools — inherits that constraint, which is why it bit commands
- *  that look nothing like ML work. Adding a new caller is fine; adding a new
- *  process-exit path is not. */
-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) {
-    const dir = getDbPath(dbPath);
-    let slot = backendSlots.get(dir);
-    if (!slot) {
-        if (backendSlots.size >= MAX_BACKEND_SLOTS) {
-            const oldest = backendSlots.keys().next().value;
-            const evicted = backendSlots.get(oldest);
-            try {
-                evicted?.instance?.close?.();
-            }
-            catch { /* best effort */ }
-            backendSlots.delete(oldest);
-        }
-        slot = { promise: null, instance: null, available: null, attempts: 0 };
-        backendSlots.set(dir, slot);
-    }
-    if (slot.available === false)
-        return null;
-    if (slot.attempts >= MAX_INIT_ATTEMPTS) {
-        slot.available = false;
-        return null;
-    }
-    if (slot.instance)
-        return slot.instance;
-    if (!slot.promise) {
-        slot.promise = (async () => {
-            try {
-                const mod = await import('@monoes/memory');
-                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.
-                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; 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 */ }
-                }
-                const cfg = {
-                    databasePath: path.join(dir, 'memory.db'),
-                    walMode: true,
-                    optimize: true,
-                    defaultNamespace: 'default',
-                    embeddingGenerator: _embedder ?? undefined,
-                };
-                const origLog = console.log;
-                console.log = (...args) => {
-                    const msg = String(args[0] ?? '');
-                    if (msg.includes('Transformers.js') || msg.includes('Loading model'))
-                        return;
-                    origLog.apply(console, args);
-                };
-                let backend;
-                try {
-                    try {
-                        backend = new mod.SQLiteBackend(cfg);
-                        await backend.initialize();
-                    }
-                    catch (e) {
-                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                            console.error('[memory-bridge] better-sqlite3 unavailable — using sql.js backend:', e);
-                        backend = new mod.SqlJsBackend(cfg);
-                        await backend.initialize();
-                    }
-                }
-                finally {
-                    console.log = origLog;
-                }
-                slot.instance = backend;
-                slot.available = true;
-                return backend;
-            }
-            catch {
-                slot.attempts++;
-                slot.promise = null;
-                if (slot.attempts >= MAX_INIT_ATTEMPTS)
-                    slot.available = false;
-                return null;
-            }
-        })();
-    }
-    return slot.promise;
-}
-// ===== Core CRUD =====
-export async function bridgeStoreEntry(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        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;
-        const value = typeof options.value === 'string' && options.value.length > BRIDGE_MAX_VALUE_LEN
-            ? options.value.slice(0, BRIDGE_MAX_VALUE_LEN) : 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)
-            : [];
-        const now = Date.now();
-        const id = generateId('entry');
-        // Generate embedding
-        let embedding;
-        let embeddingInfo;
-        if (options.generateEmbeddingFlag !== false && value.length > 0 && _embedder) {
-            try {
-                embedding = await _embedder(value);
-                embeddingInfo = { dimensions: embedding.length, model: BRIDGE_EMBEDDING_MODEL };
-            }
-            catch (e) {
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[memory-bridge] embedding generation failed — storing entry without embedding:', e);
-            }
-        }
-        const mod = await import('@monoes/memory');
-        const entry = mod.createDefaultEntry({
-            key,
-            content: value,
-            namespace,
-            tags,
-            metadata: options.metadata,
-            expiresAt: options.ttl ? now + options.ttl * 1000 : undefined,
-        });
-        // Override id and set embedding
-        entry.id = id;
-        if (embedding)
-            entry.embedding = embedding;
-        // 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 {
-                upsertVictim = await backend.getByKey(namespace, key);
-            }
-            catch { /* 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
-        // 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,
-                    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(() => { });
-                    return { success: true, id: similar[0].entry.id, duplicate: true };
-                }
-            }
-            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 };
-    }
-    catch (err) {
-        return { success: false, id: '', error: String(err?.message ?? err) };
-    }
-}
-export async function bridgeSearchEntries(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        return null;
-    try {
-        const { query: queryStr, limit = 10, threshold = 0.3 } = 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();
-        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'
-                : undefined;
-        let semanticAttempted = false;
-        if (_embedder && queryStr.length > 0) {
-            semanticAttempted = true;
-            try {
-                const queryEmbedding = await _embedder(queryStr);
-                const searchResults = await backend.search(queryEmbedding, {
-                    k: limit,
-                    threshold,
-                    filters: namespace ? { type: 'exact', namespace } : undefined,
-                });
-                const { feedbackInfluence } = getAutomemConfig();
-                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);
-                    return {
-                        id: r.entry.id,
-                        key: r.entry.key,
-                        content: r.entry.content || '',
-                        score: blended,
-                        namespace: r.entry.namespace,
-                        provenance: `semantic:${r.score.toFixed(3)}${blended !== r.score ? `→${blended.toFixed(3)}` : ''}`,
-                        tags: r.entry.tags ?? [],
-                        _createdAt: r.entry.createdAt || 0,
-                    };
-                }).sort((a, b) => b.score - a.score);
-                searchMethod = 'semantic';
-                fallbackReason = undefined;
-            }
-            catch (e) {
-                // fall through to keyword search — but never claim this was semantic
-                fallbackReason = 'embedding-failed';
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[memory-bridge] semantic search failed — falling back to keyword matching:', e);
-            }
-        }
-        // 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 } : {}),
-                limit: 50000,
-            });
-            // Token-based matching, not whole-phrase substring: "semantic test" must
-            // match an entry keyed "semantic-test" (the old .includes(query) required
-            // the exact phrase — including its whitespace — to appear verbatim).
-            // Score = fraction of query tokens present in key+content.
-            const tokens = queryStr.toLowerCase().split(/[^a-z0-9]+/).filter(t => t.length > 1);
-            if (tokens.length) {
-                results = 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: e.content || '',
-                    // Raw token-overlap fraction, NOT rescaled to look like a cosine.
-                    // The old `min(0.9, 0.3 + score*0.6)` floor/ceiling made a weak
-                    // keyword hit outrank a genuine cosine match (0.90 vs 0.63 for the
-                    // same entry) and fed cosine-calibrated gates (memory-kg dedup)
-                    // scores that never came from a vector.
-                    score,
-                    namespace: e.namespace,
-                    provenance: `keyword:${score.toFixed(2)}`,
-                    tags: e.tags ?? [],
-                    _createdAt: e.createdAt || 0,
-                }));
-            }
-            // The vector path ran and simply matched nothing — still not semantic.
-            searchMethod = semanticAttempted ? 'keyword-fallback' : 'keyword';
-            if (semanticAttempted && !fallbackReason)
-                fallbackReason = 'no-semantic-matches';
-        }
-        // 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.
-        // 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 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.forEach((r) => delete r._createdAt);
-        return {
-            success: true,
-            results,
-            searchTime: Date.now() - startTime,
-            searchMethod,
-            ...(searchMethod === 'semantic' ? {} : { fallbackReason }),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function bridgeListEntries(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        return null;
-    try {
-        const entries = await backend.query({
-            type: 'exact',
-            namespace: options.namespace ?? 'default',
-            limit: options.limit ?? 100,
-            offset: options.offset,
-        });
-        return {
-            success: true,
-            entries: entries.map((e) => ({
-                id: e.id,
-                key: e.key,
-                namespace: e.namespace,
-                content: e.content,
-                accessCount: e.accessCount ?? 0,
-                createdAt: new Date(e.createdAt).toISOString(),
-                updatedAt: new Date(e.updatedAt).toISOString(),
-                hasEmbedding: !!(e.embedding && e.embedding.length > 0),
-                tags: e.tags ?? [],
-                metadata: e.metadata ?? {},
-            })),
-            total: entries.length,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function bridgeGetEntry(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        return null;
-    try {
-        const { key, namespace = 'default' } = options;
-        const entry = await backend.getByKey(namespace, key);
-        if (!entry)
-            return { success: true, found: false };
-        return {
-            success: true,
-            found: true,
-            entry: {
-                id: entry.id,
-                key: entry.key,
-                namespace: entry.namespace,
-                content: entry.content,
-                accessCount: entry.accessCount ?? 0,
-                createdAt: new Date(entry.createdAt).toISOString(),
-                updatedAt: new Date(entry.updatedAt).toISOString(),
-                hasEmbedding: !!(entry.embedding && entry.embedding.length > 0),
-                tags: entry.tags ?? [],
-                metadata: entry.metadata ?? {},
-            },
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function bridgeDeleteEntry(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        return null;
-    try {
-        const namespace = options.namespace ?? 'default';
-        let deleted = false;
-        if (options.id) {
-            deleted = await backend.delete(options.id);
-        }
-        else if (options.key) {
-            const entry = await backend.getByKey(namespace, options.key);
-            if (entry)
-                deleted = await backend.delete(entry.id);
-        }
-        if (deleted)
-            await flushBackend(backend);
-        return { success: true, deleted };
-    }
-    catch {
-        return { success: false, deleted: false };
-    }
-}
-// ===== Embeddings =====
-export async function bridgeGenerateEmbedding(text, dbPath) {
-    await getBackend(dbPath); // ensure embedder is initialized
-    if (!_embedder)
-        return null;
-    try {
-        const emb = await _embedder(text);
-        return { embedding: Array.from(emb), dimensions: emb.length, model: BRIDGE_EMBEDDING_MODEL };
-    }
-    catch {
-        return null;
-    }
-}
-export async function bridgeLoadEmbeddingModel(dbPath) {
-    const startTime = Date.now();
-    await getBackend(dbPath);
-    if (!_embedder)
-        return null;
-    try {
-        const test = await _embedder('test');
-        if (!test)
-            return null;
-        return {
-            success: true,
-            dimensions: test.length,
-            modelName: BRIDGE_EMBEDDING_MODEL,
-            loadTime: Date.now() - startTime,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function bridgeGetBackendStats(dbPath) {
-    const backend = await getBackend(dbPath);
-    if (!backend)
-        return null;
-    try {
-        const stats = await backend.getStats();
-        return {
-            totalEntries: stats?.totalEntries ?? 0,
-            entriesByNamespace: stats?.entriesByNamespace ?? {},
-            memoryUsage: stats?.memoryUsage ?? 0,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-// ===== HNSW (replaced by the SQLite backend's ANN search — stubs kept for API compat) =====
-export async function bridgeGetHNSWStatus(dbPath) {
-    const backend = await getBackend(dbPath);
-    if (!backend)
-        return null;
-    try {
-        const stats = await backend.getStats();
-        return { built: true, size: stats?.totalEntries ?? 0, dimensions: BRIDGE_EMBEDDING_DIMS };
-    }
-    catch {
-        return { built: false, size: 0, dimensions: BRIDGE_EMBEDDING_DIMS };
-    }
-}
-export async function bridgeSearchHNSW(options) {
-    // Delegate to bridgeSearchEntries which uses the SQLite backend's ANN search
-    const result = await bridgeSearchEntries({
-        query: options.query,
-        namespace: options.namespace,
-        limit: options.limit,
-        threshold: options.threshold,
-        dbPath: options.dbPath,
-    });
-    if (!result)
-        return null;
-    return {
-        success: result.success,
-        results: result.results.map(r => ({ id: r.id, key: r.key, score: r.score, namespace: r.namespace })),
-        searchTime: result.searchTime,
-    };
-}
-export async function bridgeAddToHNSW(options) {
-    // The SQLite backend indexes entries automatically on store — this is a no-op
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        return null;
-    try {
-        const stats = await backend.getStats();
-        return { success: true, indexSize: stats?.totalEntries ?? 0 };
-    }
-    catch {
-        return { success: true };
-    }
-}
-// ===== Controller stubs (the SQLite backend has no equivalent controllers) =====
-export async function bridgeGetController(controllerName, dbPath) {
-    await getBackend(dbPath);
-    return null;
-}
-export async function bridgeHasController(controllerName, dbPath) {
-    return false;
-}
-export async function bridgeListControllers(dbPath) {
-    const backend = await getBackend(dbPath);
-    if (!backend)
-        return null;
-    return { controllers: [], active: [] };
-}
-// ===== Availability / lifecycle =====
-export async function isBridgeAvailable(dbPath) {
-    const backend = await getBackend(dbPath);
-    return !!backend;
-}
-export async function getControllerRegistry(dbPath) {
-    return getBackend(dbPath);
-}
-export async function shutdownBridge() {
-    for (const slot of backendSlots.values()) {
-        if (slot.instance) {
-            try {
-                await slot.instance.shutdown();
-            }
-            catch { /* ignore */ }
-        }
-    }
-    backendSlots.clear();
-    _embedder = null;
-    _embedderPromise = null;
-}
-// ===== Pattern store =====
-export async function bridgeStorePattern(options) {
-    return bridgeStoreEntry({
-        key: `pattern_${options.taskType ?? 'general'}_${generateId('p')}`,
-        value: JSON.stringify({
-            pattern: options.pattern,
-            taskType: options.taskType,
-            outcome: options.outcome,
-            confidence: options.confidence ?? 0.5,
-        }),
-        namespace: 'patterns',
-        tags: options.taskType ? [options.taskType] : [],
-        generateEmbeddingFlag: true,
-        dbPath: options.dbPath,
-    });
-}
-export async function bridgeSearchPatterns(options) {
-    const result = await bridgeSearchEntries({
-        query: options.query,
-        namespace: 'patterns',
-        limit: options.limit ?? 5,
-        dbPath: options.dbPath,
-    });
-    if (!result)
-        return null;
-    return {
-        success: result.success,
-        patterns: result.results.map(r => {
-            let parsed = {};
-            try {
-                parsed = JSON.parse(r.content);
-            }
-            catch { /* use raw */ }
-            return {
-                id: r.id,
-                pattern: parsed.pattern ?? r.content,
-                confidence: parsed.confidence ?? r.score,
-                taskType: parsed.taskType,
-                score: r.score,
-            };
-        }),
-    };
-}
-// ===== Usage capture & feedback weighting (closed loop) =====
-async function recordUsageOnBackend(backend, entryIds) {
-    let updated = 0;
-    for (const id of entryIds) {
-        if (typeof id !== 'string' || !id)
-            continue;
-        try {
-            const entry = await backend.get(id);
-            if (!entry)
-                continue;
-            const { frequency } = entryWeights(entry.metadata);
-            await backend.update(id, {
-                metadata: { frequency_weight: frequency + 1 },
-                lastAccessedAt: Date.now(),
-            });
-            updated++;
-        }
-        catch { /* skip unreadable entries */ }
-    }
-    return updated;
-}
-/** Record that these entries were actually USED (returned to and consumed by a
- *  caller) — increments frequency_weight, which feeds the ranking blend. */
-export async function bridgeRecordUsage(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        return null;
-    try {
-        const updated = await recordUsageOnBackend(backend, (options.entryIds ?? []).slice(0, 100));
-        if (updated)
-            await flushBackend(backend);
-        return { success: true, updated };
-    }
-    catch {
-        return { success: false, updated: 0 };
-    }
-}
-/** Apply a usefulness rating to the entries that produced an answer:
- *  EWMA feedback_weight' = w + alpha*(score - w), clipped [0,1] (cognee's
- *  apply_feedback_weights). `ledgerKey` makes application idempotent — a
- *  daemon retry or duplicate MCP call must never compound the update. */
-export async function bridgeApplyFeedback(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        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 ledgerEntryKey = options.ledgerKey ? `applied_${options.ledgerKey.slice(0, 500)}` : null;
-        if (ledgerEntryKey) {
-            const existing = await backend.getByKey('feedback', ledgerEntryKey).catch(() => null);
-            if (existing)
-                return { success: true, applied: 0, alreadyApplied: true };
-        }
-        let applied = 0;
-        for (const id of (options.entryIds ?? []).slice(0, 100)) {
-            if (typeof id !== 'string' || !id)
-                continue;
-            try {
-                const entry = await backend.get(id);
-                if (!entry)
-                    continue;
-                const { feedback } = entryWeights(entry.metadata);
-                const next = Math.max(0, Math.min(1, feedback + alpha * (score - feedback)));
-                await backend.update(id, { metadata: { feedback_weight: next } });
-                applied++;
-            }
-            catch { /* skip unreadable entries */ }
-        }
-        if (ledgerEntryKey) {
-            await bridgeStoreEntry({
-                key: ledgerEntryKey,
-                value: JSON.stringify({ score, entryIds: options.entryIds.slice(0, 100), appliedAt: Date.now(), applied }),
-                namespace: 'feedback',
-                generateEmbeddingFlag: false,
-                dbPath: options.dbPath,
-                upsert: true,
-            });
-        }
-        if (applied)
-            await flushBackend(backend);
-        return { success: true, applied };
-    }
-    catch (err) {
-        return { success: false, applied: 0, error: String(err?.message ?? err) };
-    }
-}
-// ===== Feedback =====
-export async function bridgeRecordFeedback(options) {
-    return bridgeStoreEntry({
-        key: `feedback_${options.taskType}_${Date.now()}`,
-        value: JSON.stringify({
-            taskType: options.taskType,
-            action: options.action,
-            outcome: options.outcome,
-            confidence: options.confidence ?? 0.5,
-            metadata: options.metadata ?? {},
-            recordedAt: Date.now(),
-        }),
-        namespace: 'feedback',
-        tags: [options.taskType, options.outcome],
-        generateEmbeddingFlag: true,
-        dbPath: options.dbPath,
-    });
-}
-// ===== Causal edges =====
-export async function bridgeRecordCausalEdge(options) {
-    return bridgeStoreEntry({
-        key: `causal_${options.sourceId}_${options.targetId}`,
-        value: JSON.stringify({
-            sourceId: options.sourceId,
-            targetId: options.targetId,
-            relation: options.relation,
-            strength: options.strength ?? 1.0,
-        }),
-        namespace: 'causal',
-        tags: ['causal', options.relation],
-        generateEmbeddingFlag: false,
-        dbPath: options.dbPath,
-        upsert: true,
-    });
-}
-// ===== Session lifecycle =====
-export async function bridgeSessionStart(options) {
-    return bridgeStoreEntry({
-        key: `session_${options.sessionId}`,
-        value: JSON.stringify({
-            sessionId: options.sessionId,
-            agentId: options.agentId,
-            startedAt: Date.now(),
-            status: 'active',
-            metadata: options.metadata ?? {},
-        }),
-        namespace: 'sessions',
-        tags: ['session', 'active'],
-        generateEmbeddingFlag: false,
-        dbPath: options.dbPath,
-        upsert: true,
-    });
-}
-export async function bridgeSessionEnd(options) {
-    const backend = await getBackend(options.dbPath);
-    if (!backend)
-        return null;
-    try {
-        const existing = await backend.getByKey('sessions', `session_${options.sessionId}`);
-        if (existing) {
-            let data = {};
-            try {
-                data = JSON.parse(existing.content);
-            }
-            catch (e) {
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[memory-bridge] session content failed to parse — ending session with empty prior state:', e);
-            }
-            await backend.update(existing.id, {
-                content: JSON.stringify({
-                    ...data,
-                    status: 'ended',
-                    endedAt: Date.now(),
-                    summary: options.summary,
-                    metrics: options.metrics ?? {},
-                }),
-                tags: ['session', 'ended'],
-            });
-            await flushBackend(backend);
-        }
-        return { success: true };
-    }
-    catch {
-        return { success: false };
-    }
-}
-// ===== Task routing =====
-export async function bridgeRouteTask(options) {
-    const result = await bridgeSearchEntries({
-        query: options.task,
-        namespace: 'patterns',
-        limit: options.topK ?? 3,
-        dbPath: options.dbPath,
-    });
-    if (!result)
-        return null;
-    return {
-        success: result.success,
-        routes: result.results.map(r => {
-            let parsed = {};
-            try {
-                parsed = JSON.parse(r.content);
-            }
-            catch { /* use raw */ }
-            return {
-                agentType: parsed.taskType ?? 'coder',
-                confidence: r.score,
-                pattern: parsed.pattern,
-            };
-        }),
-    };
-}
-// ===== Health check =====
-export async function bridgeHealthCheck(dbPath) {
-    const backend = await getBackend(dbPath);
-    if (!backend)
-        return { healthy: false, backend: 'sqlite', error: 'unavailable' };
-    try {
-        const health = await backend.healthCheck?.();
-        const stats = await backend.getStats?.();
-        return {
-            healthy: health?.healthy ?? true,
-            backend: 'sqlite',
-            stats: stats ? {
-                totalEntries: stats.totalEntries ?? 0,
-                namespaces: Object.keys(stats.entriesByNamespace ?? {}),
-            } : undefined,
-        };
-    }
-    catch {
-        return { healthy: false, backend: 'sqlite' };
-    }
-}
-// ===== Hierarchical memory =====
-export async function bridgeHierarchicalStore(params) {
-    return bridgeStoreEntry({
-        key: params.key,
-        value: params.value,
-        namespace: `tier_${params.tier ?? 'working'}`,
-        tags: [params.tier ?? 'working'],
-        generateEmbeddingFlag: true,
-    });
-}
-export async function bridgeHierarchicalRecall(params) {
-    return bridgeSearchEntries({
-        query: params.query,
-        namespace: params.tier ? `tier_${params.tier}` : undefined,
-        limit: params.topK ?? 5,
-    });
-}
-// ===== Consolidation =====
-/** Namespaces GC must never touch: durable knowledge/org/rule state, and the
- *  feedback ledger (deleting it would un-idempotent past ratings). */
-const GC_PROTECTED_NS = /^(knowledge:|org:|agent:|kg:|rules$|feedback$)/;
-export async function bridgeConsolidate(params) {
-    const backend = await getBackend(params.dbPath);
-    if (!backend)
-        return { success: false, consolidated: 0 };
-    try {
-        const minAge = params.minAge ?? 7 * 24 * 3600 * 1000; // default: 7 days
-        const cutoff = Date.now() - minAge;
-        const ns = params.namespace ?? 'default';
-        const entries = await backend.query({
-            type: 'exact',
-            ...(ns === 'all' ? {} : { namespace: ns }),
-            limit: params.maxEntries ?? 1000,
-        });
-        let deleted = 0;
-        let kept = 0;
-        for (const e of entries) {
-            if (GC_PROTECTED_NS.test(String(e.namespace ?? '')))
-                continue;
-            if (e.updatedAt >= cutoff)
-                continue;
-            const { feedback, frequency } = entryWeights(e.metadata);
-            // Weight-aware GC (first real consumer of the closed loop): entries the
-            // system learned are useful never age out; unused, unrated ones do.
-            if (feedback > 0.6 || frequency >= 3) {
-                kept++;
-                continue;
-            }
-            if ((e.accessCount ?? 0) === 0) {
-                await backend.delete(e.id).catch(() => { });
-                deleted++;
-            }
-        }
-        if (deleted)
-            await flushBackend(backend);
-        return { success: true, consolidated: deleted, preserved: kept };
-    }
-    catch {
-        return { success: false, consolidated: 0 };
-    }
-}
-// ===== Batch operations =====
-export async function bridgeBatchOperation(params) {
-    const backend = await getBackend();
-    if (!backend)
-        return { success: false, processed: 0 };
-    try {
-        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 });
-                if (result?.success)
-                    processed++;
-            }
-        }
-        else if (params.operation === 'delete') {
-            for (const e of params.entries) {
-                const result = await bridgeDeleteEntry({ key: e.key, namespace: e.namespace });
-                if (result?.deleted)
-                    processed++;
-            }
-        }
-        return { success: true, processed };
-    }
-    catch {
-        return { success: false, processed: 0 };
-    }
-}
-// ===== Context synthesis =====
-export async function bridgeContextSynthesize(params) {
-    const result = await bridgeSearchEntries({
-        query: params.query,
-        limit: params.maxEntries ?? 5,
-    });
-    if (!result?.success)
-        return null;
-    const context = result.results.map(r => `[${r.key}]: ${r.content}`).join('\n');
-    return { success: true, context, sources: result.results.length };
-}
-// ===== Semantic routing =====
-export async function bridgeSemanticRoute(params) {
-    return bridgeRouteTask({ task: params.input });
-}
-//# sourceMappingURL=memory-bridge.js.map