kynjal-cli 4.0.0 → 4.0.1

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

@@ -16,82 +16,26 @@
  *
  * @module v3/cli/memory-bridge
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import * as path from 'path';
 import * as crypto from 'crypto';
 // ===== Lazy singleton =====
-var registryPromise = null;
-var registryInstance = null;
-var bridgeAvailable = null;
+let registryPromise = null;
+let registryInstance = null;
+let bridgeAvailable = null;
 /**
  * Resolve database path with path traversal protection.
  * Only allows paths within or below the project's .swarm directory,
  * or the special ':memory:' path.
  */
 function getDbPath(customPath) {
-    var swarmDir = path.resolve(process.cwd(), '.swarm');
+    const swarmDir = path.resolve(process.cwd(), '.swarm');
     if (!customPath)
         return path.join(swarmDir, 'memory.db');
     if (customPath === ':memory:')
         return ':memory:';
-    var resolved = path.resolve(customPath);
+    const resolved = path.resolve(customPath);
     // Ensure the path doesn't escape the working directory
-    var cwd = process.cwd();
+    const cwd = process.cwd();
     if (!resolved.startsWith(cwd)) {
         return path.join(swarmDir, 'memory.db'); // fallback to safe default
     }
@@ -101,85 +45,63 @@ function getDbPath(customPath) {
  * Generate a secure random ID for memory entries.
  */
 function generateId(prefix) {
-    return prefix + "_" + Date.now() + "_" + crypto.randomBytes(8).toString('hex');
+    return `${prefix}_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
 }
 /**
  * Lazily initialize the ControllerRegistry singleton.
  * Returns null if @claude-flow/memory is not available.
  */
-function getRegistry(dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var _this = this;
-        return __generator(this, function (_a) {
-            if (bridgeAvailable === false)
-                return [2 /*return*/, null];
-            if (registryInstance)
-                return [2 /*return*/, registryInstance];
-            if (!registryPromise) {
-                registryPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                    var ControllerRegistry, registry, origLog_1, _a;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                _b.trys.push([0, 6, , 7]);
-                                return [4 /*yield*/, import('@claude-flow/memory')];
-                            case 1:
-                                ControllerRegistry = (_b.sent()).ControllerRegistry;
-                                registry = new ControllerRegistry();
-                                origLog_1 = console.log;
-                                console.log = function () {
-                                    var _a;
-                                    var args = [];
-                                    for (var _i = 0; _i < arguments.length; _i++) {
-                                        args[_i] = arguments[_i];
-                                    }
-                                    var msg = String((_a = args[0]) !== null && _a !== void 0 ? _a : '');
-                                    if (msg.includes('Transformers.js') ||
-                                        msg.includes('better-sqlite3') ||
-                                        msg.includes('[AgentDB]') ||
-                                        msg.includes('[HNSWLibBackend]') ||
-                                        msg.includes('RuVector graph'))
-                                        return;
-                                    origLog_1.apply(console, args);
-                                };
-                                _b.label = 2;
-                            case 2:
-                                _b.trys.push([2, , 4, 5]);
-                                return [4 /*yield*/, registry.initialize({
-                                        dbPath: dbPath || getDbPath(),
-                                        dimension: 384,
-                                        controllers: {
-                                            reasoningBank: true,
-                                            learningBridge: false,
-                                            tieredCache: true,
-                                            hierarchicalMemory: true,
-                                            memoryConsolidation: true,
-                                            memoryGraph: true
-                                        }
-                                    })];
-                            case 3:
-                                _b.sent();
-                                return [3 /*break*/, 5];
-                            case 4:
-                                console.log = origLog_1;
-                                return [7 /*endfinally*/];
-                            case 5:
-                                registryInstance = registry;
-                                bridgeAvailable = true;
-                                return [2 /*return*/, registry];
-                            case 6:
-                                _a = _b.sent();
-                                bridgeAvailable = false;
-                                registryPromise = null;
-                                return [2 /*return*/, null];
-                            case 7: return [2 /*return*/];
-                        }
+async function getRegistry(dbPath) {
+    if (bridgeAvailable === false)
+        return null;
+    if (registryInstance)
+        return registryInstance;
+    if (!registryPromise) {
+        registryPromise = (async () => {
+            try {
+                const { ControllerRegistry } = await import('@claude-flow/memory');
+                const registry = new ControllerRegistry();
+                // Suppress noisy console.log during init
+                const origLog = console.log;
+                console.log = (...args) => {
+                    const msg = String(args[0] ?? '');
+                    if (msg.includes('Transformers.js') ||
+                        msg.includes('better-sqlite3') ||
+                        msg.includes('[AgentDB]') ||
+                        msg.includes('[HNSWLibBackend]') ||
+                        msg.includes('RuVector graph'))
+                        return;
+                    origLog.apply(console, args);
+                };
+                try {
+                    await registry.initialize({
+                        dbPath: dbPath || getDbPath(),
+                        dimension: 384,
+                        controllers: {
+                            reasoningBank: true,
+                            learningBridge: false,
+                            tieredCache: true,
+                            hierarchicalMemory: true,
+                            memoryConsolidation: true,
+                            memoryGraph: true, // issue #1214: enable MemoryGraph for graph-aware ranking
+                        },
                     });
-                }); })();
+                }
+                finally {
+                    console.log = origLog;
+                }
+                registryInstance = registry;
+                bridgeAvailable = true;
+                return registry;
             }
-            return [2 /*return*/, registryPromise];
-        });
-    });
+            catch {
+                bridgeAvailable = false;
+                registryPromise = null;
+                return null;
+            }
+        })();
+    }
+    return registryPromise;
 }
 // ===== Phase 2: BM25 hybrid scoring =====
 /**
@@ -188,23 +110,19 @@ function getRegistry(dbPath) {
  * Parameters tuned for short memory entries (k1=1.2, b=0.75).
  */
 function bm25Score(queryTerms, docContent, avgDocLength, docCount, termDocFreqs) {
-    var k1 = 1.2;
-    var b = 0.75;
-    var docWords = docContent.toLowerCase().split(/\s+/);
-    var docLength = docWords.length;
-    var score = 0;
-    var _loop_1 = function (term) {
-        var tf = docWords.filter(function (w) { return w === term || w.includes(term); }).length;
+    const k1 = 1.2;
+    const b = 0.75;
+    const docWords = docContent.toLowerCase().split(/\s+/);
+    const docLength = docWords.length;
+    let score = 0;
+    for (const term of queryTerms) {
+        const tf = docWords.filter(w => w === term || w.includes(term)).length;
         if (tf === 0)
-            return "continue";
-        var df = termDocFreqs.get(term) || 1;
-        var idf = Math.log((docCount - df + 0.5) / (df + 0.5) + 1);
-        var tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (docLength / Math.max(1, avgDocLength))));
+            continue;
+        const df = termDocFreqs.get(term) || 1;
+        const idf = Math.log((docCount - df + 0.5) / (df + 0.5) + 1);
+        const tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (docLength / Math.max(1, avgDocLength))));
         score += idf * tfNorm;
-    };
-    for (var _i = 0, queryTerms_1 = queryTerms; _i < queryTerms_1.length; _i++) {
-        var term = queryTerms_1[_i];
-        _loop_1(term);
     }
     return score;
 }
@@ -212,84 +130,63 @@ function bm25Score(queryTerms, docContent, avgDocLength, docCount, termDocFreqs)
  * Compute BM25 term document frequencies for a set of rows.
  */
 function computeTermDocFreqs(queryTerms, rows) {
-    var termDocFreqs = new Map();
-    var totalLength = 0;
-    for (var _i = 0, rows_1 = rows; _i < rows_1.length; _i++) {
-        var row = rows_1[_i];
-        var content = (row.content || '').toLowerCase();
-        var words = content.split(/\s+/);
+    const termDocFreqs = new Map();
+    let totalLength = 0;
+    for (const row of rows) {
+        const content = (row.content || '').toLowerCase();
+        const words = content.split(/\s+/);
         totalLength += words.length;
-        for (var _a = 0, queryTerms_2 = queryTerms; _a < queryTerms_2.length; _a++) {
-            var term = queryTerms_2[_a];
+        for (const term of queryTerms) {
             if (content.includes(term)) {
                 termDocFreqs.set(term, (termDocFreqs.get(term) || 0) + 1);
             }
         }
     }
-    return { termDocFreqs: termDocFreqs, avgDocLength: rows.length > 0 ? totalLength / rows.length : 1 };
+    return { termDocFreqs, avgDocLength: rows.length > 0 ? totalLength / rows.length : 1 };
 }
 // ===== Phase 2: TieredCache helpers =====
 /**
  * Try to read from TieredCache before hitting DB.
  * Returns cached value or null if cache miss.
  */
-function cacheGet(registry, cacheKey) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var cache;
-        return __generator(this, function (_b) {
-            try {
-                cache = registry.get('tieredCache');
-                if (!cache || typeof cache.get !== 'function')
-                    return [2 /*return*/, null];
-                return [2 /*return*/, (_a = cache.get(cacheKey)) !== null && _a !== void 0 ? _a : null];
-            }
-            catch (_c) {
-                return [2 /*return*/, null];
-            }
-            return [2 /*return*/];
-        });
-    });
+async function cacheGet(registry, cacheKey) {
+    try {
+        const cache = registry.get('tieredCache');
+        if (!cache || typeof cache.get !== 'function')
+            return null;
+        return cache.get(cacheKey) ?? null;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Write to TieredCache after DB write.
  */
-function cacheSet(registry, cacheKey, value) {
-    return __awaiter(this, void 0, Promise, function () {
-        var cache;
-        return __generator(this, function (_a) {
-            try {
-                cache = registry.get('tieredCache');
-                if (cache && typeof cache.set === 'function') {
-                    cache.set(cacheKey, value);
-                }
-            }
-            catch (_b) {
-                // Non-fatal
-            }
-            return [2 /*return*/];
-        });
-    });
+async function cacheSet(registry, cacheKey, value) {
+    try {
+        const cache = registry.get('tieredCache');
+        if (cache && typeof cache.set === 'function') {
+            cache.set(cacheKey, value);
+        }
+    }
+    catch {
+        // Non-fatal
+    }
 }
 /**
  * Invalidate a cache key after mutation.
  */
-function cacheInvalidate(registry, cacheKey) {
-    return __awaiter(this, void 0, Promise, function () {
-        var cache;
-        return __generator(this, function (_a) {
-            try {
-                cache = registry.get('tieredCache');
-                if (cache && typeof cache["delete"] === 'function') {
-                    cache["delete"](cacheKey);
-                }
-            }
-            catch (_b) {
-                // Non-fatal
-            }
-            return [2 /*return*/];
-        });
-    });
+async function cacheInvalidate(registry, cacheKey) {
+    try {
+        const cache = registry.get('tieredCache');
+        if (cache && typeof cache.delete === 'function') {
+            cache.delete(cacheKey);
+        }
+    }
+    catch {
+        // Non-fatal
+    }
 }
 // ===== Phase 2: MutationGuard helpers =====
 /**
@@ -298,72 +195,79 @@ function cacheInvalidate(registry, cacheKey) {
  * When guard is unavailable (not installed), mutations are allowed.
  * When guard is present but throws, mutations are DENIED (fail-closed).
  */
-function guardValidate(registry, operation, params) {
-    return __awaiter(this, void 0, Promise, function () {
-        var guard, result;
-        return __generator(this, function (_a) {
-            try {
-                guard = registry.get('mutationGuard');
-                if (!guard || typeof guard.validate !== 'function') {
-                    return [2 /*return*/, { allowed: true }]; // No guard installed = allow (degraded mode)
-                }
-                result = guard.validate({ operation: operation, params: params, timestamp: Date.now() });
-                return [2 /*return*/, { allowed: (result === null || result === void 0 ? void 0 : result.allowed) === true, reason: result === null || result === void 0 ? void 0 : result.reason }];
-            }
-            catch (_b) {
-                return [2 /*return*/, { allowed: false, reason: 'MutationGuard validation error' }]; // Fail-closed
-            }
-            return [2 /*return*/];
-        });
-    });
+async function guardValidate(registry, operation, params) {
+    try {
+        const guard = registry.get('mutationGuard');
+        if (!guard || typeof guard.validate !== 'function') {
+            return { allowed: true }; // No guard installed = allow (degraded mode)
+        }
+        const result = guard.validate({ operation, params, timestamp: Date.now() });
+        return { allowed: result?.allowed === true, reason: result?.reason };
+    }
+    catch {
+        return { allowed: false, reason: 'MutationGuard validation error' }; // Fail-closed
+    }
 }
 // ===== Phase 3: AttestationLog helpers =====
 /**
  * Log a write operation to AttestationLog/WitnessChain.
  */
-function logAttestation(registry, operation, entryId, metadata) {
-    return __awaiter(this, void 0, Promise, function () {
-        var attestation;
-        return __generator(this, function (_a) {
-            try {
-                attestation = registry.get('attestationLog');
-                if (!attestation)
-                    return [2 /*return*/];
-                if (typeof attestation.record === 'function') {
-                    attestation.record(__assign({ operation: operation, entryId: entryId, timestamp: Date.now() }, metadata));
-                }
-                else if (typeof attestation.log === 'function') {
-                    attestation.log(operation, entryId, metadata);
-                }
-            }
-            catch (_b) {
-                // Non-fatal — attestation is observability, not correctness
-            }
-            return [2 /*return*/];
-        });
-    });
+async function logAttestation(registry, operation, entryId, metadata) {
+    try {
+        const attestation = registry.get('attestationLog');
+        if (!attestation)
+            return;
+        if (typeof attestation.record === 'function') {
+            attestation.record({ operation, entryId, timestamp: Date.now(), ...metadata });
+        }
+        else if (typeof attestation.log === 'function') {
+            attestation.log(operation, entryId, metadata);
+        }
+    }
+    catch {
+        // Non-fatal — attestation is observability, not correctness
+    }
 }
 /**
  * Get the AgentDB database handle and ensure memory_entries table exists.
  * Returns null if not available.
  */
 function getDb(registry) {
-    var agentdb = registry.getAgentDB();
-    if (!(agentdb === null || agentdb === void 0 ? void 0 : agentdb.database))
+    const agentdb = registry.getAgentDB();
+    if (!agentdb?.database)
         return null;
-    var db = agentdb.database;
+    const db = agentdb.database;
     // Ensure memory_entries table exists (idempotent)
     try {
-        db.exec("CREATE TABLE IF NOT EXISTS memory_entries (\n      id TEXT PRIMARY KEY,\n      key TEXT NOT NULL,\n      namespace TEXT DEFAULT 'default',\n      content TEXT NOT NULL,\n      type TEXT DEFAULT 'semantic',\n      embedding TEXT,\n      embedding_model TEXT DEFAULT 'local',\n      embedding_dimensions INTEGER,\n      tags TEXT,\n      metadata TEXT,\n      owner_id TEXT,\n      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n      updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n      expires_at INTEGER,\n      last_accessed_at INTEGER,\n      access_count INTEGER DEFAULT 0,\n      status TEXT DEFAULT 'active',\n      UNIQUE(namespace, key)\n    )");
+        db.exec(`CREATE TABLE IF NOT EXISTS memory_entries (
+      id TEXT PRIMARY KEY,
+      key TEXT NOT NULL,
+      namespace TEXT DEFAULT 'default',
+      content TEXT NOT NULL,
+      type TEXT DEFAULT 'semantic',
+      embedding TEXT,
+      embedding_model TEXT DEFAULT 'local',
+      embedding_dimensions INTEGER,
+      tags TEXT,
+      metadata TEXT,
+      owner_id TEXT,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      expires_at INTEGER,
+      last_accessed_at INTEGER,
+      access_count INTEGER DEFAULT 0,
+      status TEXT DEFAULT 'active',
+      UNIQUE(namespace, key)
+    )`);
         // Ensure indexes
-        db.exec("CREATE INDEX IF NOT EXISTS idx_bridge_ns ON memory_entries(namespace)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_bridge_key ON memory_entries(key)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_bridge_status ON memory_entries(status)");
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_bridge_ns ON memory_entries(namespace)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_bridge_key ON memory_entries(key)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_bridge_status ON memory_entries(status)`);
     }
-    catch (_a) {
+    catch {
         // Table already exists or db is read-only — that's fine
     }
-    return { db: db, agentdb: agentdb };
+    return { db, agentdb };
 }
 // ===== Bridge functions — match memory-initializer.ts signatures =====
 /**
@@ -371,1276 +275,994 @@ function getDb(registry) {
  * Phase 2-5: Routes through MutationGuard → TieredCache → DB → AttestationLog.
  * Returns null to signal fallback to sql.js.
  */
-export function bridgeStoreEntry(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, key, value, _a, namespace, _b, tags, ttl, id, now, guardResult, embeddingJson, dimensions, model, embedder, emb, _c, insertSql, stmt, safeNs, safeKey, cacheKey, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _e.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    ctx = getDb(registry);
-                    if (!ctx)
-                        return [2 /*return*/, null];
-                    _e.label = 2;
-                case 2:
-                    _e.trys.push([2, 11, , 12]);
-                    key = options.key, value = options.value, _a = options.namespace, namespace = _a === void 0 ? 'default' : _a, _b = options.tags, tags = _b === void 0 ? [] : _b, ttl = options.ttl;
-                    id = generateId('entry');
-                    now = Date.now();
-                    return [4 /*yield*/, guardValidate(registry, 'store', { key: key, namespace: namespace, size: value.length })];
-                case 3:
-                    guardResult = _e.sent();
-                    if (!guardResult.allowed) {
-                        return [2 /*return*/, { success: false, id: id, error: "MutationGuard rejected: " + guardResult.reason }];
-                    }
-                    embeddingJson = null;
-                    dimensions = 0;
-                    model = 'local';
-                    if (!(options.generateEmbeddingFlag !== false && value.length > 0)) return [3 /*break*/, 8];
-                    _e.label = 4;
-                case 4:
-                    _e.trys.push([4, 7, , 8]);
-                    embedder = ctx.agentdb.embedder;
-                    if (!embedder) return [3 /*break*/, 6];
-                    return [4 /*yield*/, embedder.embed(value)];
-                case 5:
-                    emb = _e.sent();
+export async function bridgeStoreEntry(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { key, value, namespace = 'default', tags = [], ttl } = options;
+        const id = generateId('entry');
+        const now = Date.now();
+        // Phase 5: MutationGuard validation before write
+        const guardResult = await guardValidate(registry, 'store', { key, namespace, size: value.length });
+        if (!guardResult.allowed) {
+            return { success: false, id, error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        // Generate embedding via AgentDB's embedder
+        let embeddingJson = null;
+        let dimensions = 0;
+        let model = 'local';
+        if (options.generateEmbeddingFlag !== false && value.length > 0) {
+            try {
+                const embedder = ctx.agentdb.embedder;
+                if (embedder) {
+                    const emb = await embedder.embed(value);
                     if (emb) {
                         embeddingJson = JSON.stringify(Array.from(emb));
                         dimensions = emb.length;
                         model = 'Xenova/all-MiniLM-L6-v2';
                     }
-                    _e.label = 6;
-                case 6: return [3 /*break*/, 8];
-                case 7:
-                    _c = _e.sent();
-                    return [3 /*break*/, 8];
-                case 8:
-                    insertSql = options.upsert
-                        ? "INSERT OR REPLACE INTO memory_entries (\n          id, key, namespace, content, type,\n          embedding, embedding_dimensions, embedding_model,\n          tags, metadata, created_at, updated_at, expires_at, status\n        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')"
-                        : "INSERT INTO memory_entries (\n          id, key, namespace, content, type,\n          embedding, embedding_dimensions, embedding_model,\n          tags, metadata, created_at, updated_at, expires_at, status\n        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')";
-                    stmt = ctx.db.prepare(insertSql);
-                    stmt.run(id, key, namespace, value, embeddingJson, dimensions || null, model, tags.length > 0 ? JSON.stringify(tags) : null, '{}', now, now, ttl ? now + (ttl * 1000) : null);
-                    safeNs = String(namespace).replace(/:/g, '_');
-                    safeKey = String(key).replace(/:/g, '_');
-                    cacheKey = "entry:" + safeNs + ":" + safeKey;
-                    return [4 /*yield*/, cacheSet(registry, cacheKey, { id: id, key: key, namespace: namespace, content: value, embedding: embeddingJson })];
-                case 9:
-                    _e.sent();
-                    // Phase 4: AttestationLog write audit
-                    return [4 /*yield*/, logAttestation(registry, 'store', id, { key: key, namespace: namespace, hasEmbedding: !!embeddingJson })];
-                case 10:
-                    // Phase 4: AttestationLog write audit
-                    _e.sent();
-                    return [2 /*return*/, {
-                            success: true,
-                            id: id,
-                            embedding: embeddingJson ? { dimensions: dimensions, model: model } : undefined,
-                            guarded: true,
-                            cached: true,
-                            attested: true
-                        }];
-                case 11:
-                    _d = _e.sent();
-                    return [2 /*return*/, null];
-                case 12: return [2 /*return*/];
+                }
             }
-        });
-    });
+            catch {
+                // Embedding failed — store without
+            }
+        }
+        // better-sqlite3 uses synchronous .run() with positional params
+        const insertSql = options.upsert
+            ? `INSERT OR REPLACE INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          tags, metadata, created_at, updated_at, expires_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')`
+            : `INSERT INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          tags, metadata, created_at, updated_at, expires_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')`;
+        const stmt = ctx.db.prepare(insertSql);
+        stmt.run(id, key, namespace, value, embeddingJson, dimensions || null, model, tags.length > 0 ? JSON.stringify(tags) : null, '{}', now, now, ttl ? now + (ttl * 1000) : null);
+        // Phase 2: Write-through to TieredCache
+        const safeNs = String(namespace).replace(/:/g, '_');
+        const safeKey = String(key).replace(/:/g, '_');
+        const cacheKey = `entry:${safeNs}:${safeKey}`;
+        await cacheSet(registry, cacheKey, { id, key, namespace, content: value, embedding: embeddingJson });
+        // Phase 4: AttestationLog write audit
+        await logAttestation(registry, 'store', id, { key, namespace, hasEmbedding: !!embeddingJson });
+        return {
+            success: true,
+            id,
+            embedding: embeddingJson ? { dimensions, model } : undefined,
+            guarded: true,
+            cached: true,
+            attested: true,
+        };
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Search entries via AgentDB v3.
  * Phase 2: BM25 hybrid scoring replaces naive String.includes() keyword fallback.
  * Combines cosine similarity (semantic) with BM25 (lexical) via reciprocal rank fusion.
  */
-export function bridgeSearchEntries(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, queryStr, _a, namespace, _b, limit, _c, threshold, startTime, queryEmbedding, embedder, emb, _d, nsFilter, rows, stmt, queryTerms, _e, termDocFreqs, avgDocLength, docCount, results, _i, rows_2, row, semanticScore, bm25ScoreVal, embedding, score, provenance, _f;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _g.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    ctx = getDb(registry);
-                    if (!ctx)
-                        return [2 /*return*/, null];
-                    _g.label = 2;
-                case 2:
-                    _g.trys.push([2, 8, , 9]);
-                    queryStr = options.query, _a = options.namespace, namespace = _a === void 0 ? 'default' : _a, _b = options.limit, limit = _b === void 0 ? 10 : _b, _c = options.threshold, threshold = _c === void 0 ? 0.3 : _c;
-                    startTime = Date.now();
-                    queryEmbedding = null;
-                    _g.label = 3;
-                case 3:
-                    _g.trys.push([3, 6, , 7]);
-                    embedder = ctx.agentdb.embedder;
-                    if (!embedder) return [3 /*break*/, 5];
-                    return [4 /*yield*/, embedder.embed(queryStr)];
-                case 4:
-                    emb = _g.sent();
-                    queryEmbedding = Array.from(emb);
-                    _g.label = 5;
-                case 5: return [3 /*break*/, 7];
-                case 6:
-                    _d = _g.sent();
-                    return [3 /*break*/, 7];
-                case 7:
-                    nsFilter = namespace !== 'all'
-                        ? "AND namespace = ?"
-                        : '';
-                    rows = void 0;
-                    try {
-                        stmt = ctx.db.prepare("\n        SELECT id, key, namespace, content, embedding\n        FROM memory_entries\n        WHERE status = 'active' " + nsFilter + "\n        LIMIT 1000\n      ");
-                        rows = namespace !== 'all' ? stmt.all(namespace) : stmt.all();
-                    }
-                    catch (_h) {
-                        return [2 /*return*/, null];
-                    }
-                    queryTerms = queryStr.toLowerCase().split(/\s+/).filter(function (t) { return t.length > 1; });
-                    _e = computeTermDocFreqs(queryTerms, rows), termDocFreqs = _e.termDocFreqs, avgDocLength = _e.avgDocLength;
-                    docCount = rows.length;
-                    results = [];
-                    for (_i = 0, rows_2 = rows; _i < rows_2.length; _i++) {
-                        row = rows_2[_i];
-                        semanticScore = 0;
-                        bm25ScoreVal = 0;
-                        // Semantic scoring via cosine similarity
-                        if (queryEmbedding && row.embedding) {
-                            try {
-                                embedding = JSON.parse(row.embedding);
-                                semanticScore = cosineSim(queryEmbedding, embedding);
-                            }
-                            catch (_j) {
-                                // Invalid embedding
-                            }
-                        }
-                        // Phase 2: BM25 keyword scoring (replaces String.includes fallback)
-                        if (queryTerms.length > 0 && row.content) {
-                            bm25ScoreVal = bm25Score(queryTerms, row.content, avgDocLength, docCount, termDocFreqs);
-                            // Normalize BM25 to 0-1 range (cap at 10 for normalization)
-                            bm25ScoreVal = Math.min(bm25ScoreVal / 10, 1.0);
-                        }
-                        score = queryEmbedding
-                            ? (0.7 * semanticScore + 0.3 * bm25ScoreVal)
-                            : bm25ScoreVal;
-                        if (score >= threshold) {
-                            provenance = queryEmbedding
-                                ? "semantic:" + semanticScore.toFixed(3) + "+bm25:" + bm25ScoreVal.toFixed(3)
-                                : "bm25:" + bm25ScoreVal.toFixed(3);
-                            results.push({
-                                id: String(row.id).substring(0, 12),
-                                key: row.key || String(row.id).substring(0, 15),
-                                content: (row.content || '').substring(0, 60) + ((row.content || '').length > 60 ? '...' : ''),
-                                score: score,
-                                namespace: row.namespace || 'default',
-                                provenance: provenance
-                            });
-                        }
-                    }
-                    results.sort(function (a, b) { return b.score - a.score; });
-                    return [2 /*return*/, {
-                            success: true,
-                            results: results.slice(0, limit),
-                            searchTime: Date.now() - startTime,
-                            searchMethod: queryEmbedding ? 'hybrid-bm25-semantic' : 'bm25-only'
-                        }];
-                case 8:
-                    _f = _g.sent();
-                    return [2 /*return*/, null];
-                case 9: return [2 /*return*/];
+export async function bridgeSearchEntries(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { query: queryStr, namespace = 'default', limit = 10, threshold = 0.3 } = options;
+        const startTime = Date.now();
+        // Generate query embedding
+        let queryEmbedding = null;
+        try {
+            const embedder = ctx.agentdb.embedder;
+            if (embedder) {
+                const emb = await embedder.embed(queryStr);
+                queryEmbedding = Array.from(emb);
             }
-        });
-    });
+        }
+        catch {
+            // Fall back to keyword search
+        }
+        // better-sqlite3: .prepare().all() returns array of objects
+        const nsFilter = namespace !== 'all'
+            ? `AND namespace = ?`
+            : '';
+        let rows;
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding
+        FROM memory_entries
+        WHERE status = 'active' ${nsFilter}
+        LIMIT 1000
+      `);
+            rows = namespace !== 'all' ? stmt.all(namespace) : stmt.all();
+        }
+        catch {
+            return null;
+        }
+        // Phase 2: Compute BM25 term stats for the corpus
+        const queryTerms = queryStr.toLowerCase().split(/\s+/).filter(t => t.length > 1);
+        const { termDocFreqs, avgDocLength } = computeTermDocFreqs(queryTerms, rows);
+        const docCount = rows.length;
+        const results = [];
+        for (const row of rows) {
+            let semanticScore = 0;
+            let bm25ScoreVal = 0;
+            // Semantic scoring via cosine similarity
+            if (queryEmbedding && row.embedding) {
+                try {
+                    const embedding = JSON.parse(row.embedding);
+                    semanticScore = cosineSim(queryEmbedding, embedding);
+                }
+                catch {
+                    // Invalid embedding
+                }
+            }
+            // Phase 2: BM25 keyword scoring (replaces String.includes fallback)
+            if (queryTerms.length > 0 && row.content) {
+                bm25ScoreVal = bm25Score(queryTerms, row.content, avgDocLength, docCount, termDocFreqs);
+                // Normalize BM25 to 0-1 range (cap at 10 for normalization)
+                bm25ScoreVal = Math.min(bm25ScoreVal / 10, 1.0);
+            }
+            // Reciprocal rank fusion: combine semantic and BM25
+            // Weight: 0.7 semantic + 0.3 BM25 (semantic preferred when embeddings available)
+            const score = queryEmbedding
+                ? (0.7 * semanticScore + 0.3 * bm25ScoreVal)
+                : bm25ScoreVal; // BM25-only when no embeddings
+            if (score >= threshold) {
+                // Phase 4: ExplainableRecall provenance
+                const provenance = queryEmbedding
+                    ? `semantic:${semanticScore.toFixed(3)}+bm25:${bm25ScoreVal.toFixed(3)}`
+                    : `bm25:${bm25ScoreVal.toFixed(3)}`;
+                results.push({
+                    id: String(row.id).substring(0, 12),
+                    key: row.key || String(row.id).substring(0, 15),
+                    content: (row.content || '').substring(0, 60) + ((row.content || '').length > 60 ? '...' : ''),
+                    score,
+                    namespace: row.namespace || 'default',
+                    provenance,
+                });
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return {
+            success: true,
+            results: results.slice(0, limit),
+            searchTime: Date.now() - startTime,
+            searchMethod: queryEmbedding ? 'hybrid-bm25-semantic' : 'bm25-only',
+        };
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * List entries via AgentDB v3.
  */
-export function bridgeListEntries(options) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, namespace, _c, limit, _d, offset, nsFilter, nsParams, total, countStmt, countRow, entries, stmt, rows, _i, rows_3, row;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _e.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    ctx = getDb(registry);
-                    if (!ctx)
-                        return [2 /*return*/, null];
-                    try {
-                        namespace = options.namespace, _c = options.limit, limit = _c === void 0 ? 20 : _c, _d = options.offset, offset = _d === void 0 ? 0 : _d;
-                        nsFilter = namespace ? "AND namespace = ?" : '';
-                        nsParams = namespace ? [namespace] : [];
-                        total = 0;
-                        try {
-                            countStmt = ctx.db.prepare("SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' " + nsFilter);
-                            countRow = countStmt.get.apply(countStmt, nsParams);
-                            total = (_a = countRow === null || countRow === void 0 ? void 0 : countRow.cnt) !== null && _a !== void 0 ? _a : 0;
-                        }
-                        catch (_f) {
-                            return [2 /*return*/, null];
-                        }
-                        entries = [];
-                        try {
-                            stmt = ctx.db.prepare("\n        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at\n        FROM memory_entries\n        WHERE status = 'active' " + nsFilter + "\n        ORDER BY updated_at DESC\n        LIMIT ? OFFSET ?\n      ");
-                            rows = stmt.all.apply(stmt, __spreadArray(__spreadArray([], nsParams, false), [limit, offset], false));
-                            for (_i = 0, rows_3 = rows; _i < rows_3.length; _i++) {
-                                row = rows_3[_i];
-                                entries.push({
-                                    id: String(row.id).substring(0, 20),
-                                    key: row.key || String(row.id).substring(0, 15),
-                                    namespace: row.namespace || 'default',
-                                    size: (row.content || '').length,
-                                    accessCount: (_b = row.access_count) !== null && _b !== void 0 ? _b : 0,
-                                    createdAt: row.created_at || new Date().toISOString(),
-                                    updatedAt: row.updated_at || new Date().toISOString(),
-                                    hasEmbedding: !!(row.embedding && String(row.embedding).length > 10)
-                                });
-                            }
-                        }
-                        catch (_g) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, { success: true, entries: entries, total: total }];
-                    }
-                    catch (_h) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
+export async function bridgeListEntries(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { namespace, limit = 20, offset = 0 } = options;
+        const nsFilter = namespace ? `AND namespace = ?` : '';
+        const nsParams = namespace ? [namespace] : [];
+        // Count
+        let total = 0;
+        try {
+            const countStmt = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' ${nsFilter}`);
+            const countRow = countStmt.get(...nsParams);
+            total = countRow?.cnt ?? 0;
+        }
+        catch {
+            return null;
+        }
+        // List
+        const entries = [];
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at
+        FROM memory_entries
+        WHERE status = 'active' ${nsFilter}
+        ORDER BY updated_at DESC
+        LIMIT ? OFFSET ?
+      `);
+            const rows = stmt.all(...nsParams, limit, offset);
+            for (const row of rows) {
+                entries.push({
+                    id: String(row.id).substring(0, 20),
+                    key: row.key || String(row.id).substring(0, 15),
+                    namespace: row.namespace || 'default',
+                    size: (row.content || '').length,
+                    accessCount: row.access_count ?? 0,
+                    createdAt: row.created_at || new Date().toISOString(),
+                    updatedAt: row.updated_at || new Date().toISOString(),
+                    hasEmbedding: !!(row.embedding && String(row.embedding).length > 10),
+                });
             }
-        });
-    });
+        }
+        catch {
+            return null;
+        }
+        return { success: true, entries, total };
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Get a specific entry via AgentDB v3.
  * Phase 2: TieredCache consulted before DB hit.
  */
-export function bridgeGetEntry(options) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, key, _c, namespace, safeNs, safeKey, cacheKey, cached, row, stmt, tags, entry, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _e.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    ctx = getDb(registry);
-                    if (!ctx)
-                        return [2 /*return*/, null];
-                    _e.label = 2;
-                case 2:
-                    _e.trys.push([2, 5, , 6]);
-                    key = options.key, _c = options.namespace, namespace = _c === void 0 ? 'default' : _c;
-                    safeNs = String(namespace).replace(/:/g, '_');
-                    safeKey = String(key).replace(/:/g, '_');
-                    cacheKey = "entry:" + safeNs + ":" + safeKey;
-                    return [4 /*yield*/, cacheGet(registry, cacheKey)];
-                case 3:
-                    cached = _e.sent();
-                    if (cached && cached.content) {
-                        return [2 /*return*/, {
-                                success: true,
-                                found: true,
-                                cacheHit: true,
-                                entry: {
-                                    id: String(cached.id || ''),
-                                    key: cached.key || key,
-                                    namespace: cached.namespace || namespace,
-                                    content: cached.content || '',
-                                    accessCount: (_a = cached.accessCount) !== null && _a !== void 0 ? _a : 0,
-                                    createdAt: cached.createdAt || new Date().toISOString(),
-                                    updatedAt: cached.updatedAt || new Date().toISOString(),
-                                    hasEmbedding: !!cached.embedding,
-                                    tags: cached.tags || []
-                                }
-                            }];
-                    }
-                    row = void 0;
-                    try {
-                        stmt = ctx.db.prepare("\n        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags\n        FROM memory_entries\n        WHERE status = 'active' AND key = ? AND namespace = ?\n        LIMIT 1\n      ");
-                        row = stmt.get(key, namespace);
-                    }
-                    catch (_f) {
-                        return [2 /*return*/, null];
-                    }
-                    if (!row) {
-                        return [2 /*return*/, { success: true, found: false }];
-                    }
-                    // Update access count
-                    try {
-                        ctx.db.prepare("UPDATE memory_entries SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?").run(Date.now(), row.id);
-                    }
-                    catch (_g) {
-                        // Non-fatal
-                    }
-                    tags = [];
-                    if (row.tags) {
-                        try {
-                            tags = JSON.parse(row.tags);
-                        }
-                        catch ( /* invalid */_h) { /* invalid */ }
-                    }
-                    entry = {
-                        id: String(row.id),
-                        key: row.key || String(row.id),
-                        namespace: row.namespace || 'default',
-                        content: row.content || '',
-                        accessCount: ((_b = row.access_count) !== null && _b !== void 0 ? _b : 0) + 1,
-                        createdAt: row.created_at || new Date().toISOString(),
-                        updatedAt: row.updated_at || new Date().toISOString(),
-                        hasEmbedding: !!(row.embedding && String(row.embedding).length > 10),
-                        tags: tags
-                    };
-                    // Phase 2: Populate cache for next read
-                    return [4 /*yield*/, cacheSet(registry, cacheKey, entry)];
-                case 4:
-                    // Phase 2: Populate cache for next read
-                    _e.sent();
-                    return [2 /*return*/, { success: true, found: true, cacheHit: false, entry: entry }];
-                case 5:
-                    _d = _e.sent();
-                    return [2 /*return*/, null];
-                case 6: return [2 /*return*/];
+export async function bridgeGetEntry(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { key, namespace = 'default' } = options;
+        // Phase 2: Check TieredCache first
+        const safeNs = String(namespace).replace(/:/g, '_');
+        const safeKey = String(key).replace(/:/g, '_');
+        const cacheKey = `entry:${safeNs}:${safeKey}`;
+        const cached = await cacheGet(registry, cacheKey);
+        if (cached && cached.content) {
+            return {
+                success: true,
+                found: true,
+                cacheHit: true,
+                entry: {
+                    id: String(cached.id || ''),
+                    key: cached.key || key,
+                    namespace: cached.namespace || namespace,
+                    content: cached.content || '',
+                    accessCount: cached.accessCount ?? 0,
+                    createdAt: cached.createdAt || new Date().toISOString(),
+                    updatedAt: cached.updatedAt || new Date().toISOString(),
+                    hasEmbedding: !!cached.embedding,
+                    tags: cached.tags || [],
+                },
+            };
+        }
+        let row;
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
+        FROM memory_entries
+        WHERE status = 'active' AND key = ? AND namespace = ?
+        LIMIT 1
+      `);
+            row = stmt.get(key, namespace);
+        }
+        catch {
+            return null;
+        }
+        if (!row) {
+            return { success: true, found: false };
+        }
+        // Update access count
+        try {
+            ctx.db.prepare(`UPDATE memory_entries SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?`).run(Date.now(), row.id);
+        }
+        catch {
+            // Non-fatal
+        }
+        let tags = [];
+        if (row.tags) {
+            try {
+                tags = JSON.parse(row.tags);
             }
-        });
-    });
+            catch { /* invalid */ }
+        }
+        const entry = {
+            id: String(row.id),
+            key: row.key || String(row.id),
+            namespace: row.namespace || 'default',
+            content: row.content || '',
+            accessCount: (row.access_count ?? 0) + 1,
+            createdAt: row.created_at || new Date().toISOString(),
+            updatedAt: row.updated_at || new Date().toISOString(),
+            hasEmbedding: !!(row.embedding && String(row.embedding).length > 10),
+            tags,
+        };
+        // Phase 2: Populate cache for next read
+        await cacheSet(registry, cacheKey, entry);
+        return { success: true, found: true, cacheHit: false, entry };
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Delete an entry via AgentDB v3.
  * Phase 5: MutationGuard validation, cache invalidation, attestation logging.
  */
-export function bridgeDeleteEntry(options) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, key, _c, namespace, guardResult, changes, result, safeNs, safeKey, remaining, row, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _e.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    ctx = getDb(registry);
-                    if (!ctx)
-                        return [2 /*return*/, null];
-                    _e.label = 2;
-                case 2:
-                    _e.trys.push([2, 7, , 8]);
-                    key = options.key, _c = options.namespace, namespace = _c === void 0 ? 'default' : _c;
-                    return [4 /*yield*/, guardValidate(registry, 'delete', { key: key, namespace: namespace })];
-                case 3:
-                    guardResult = _e.sent();
-                    if (!guardResult.allowed) {
-                        return [2 /*return*/, { success: false, deleted: false, key: key, namespace: namespace, remainingEntries: 0, error: "MutationGuard rejected: " + guardResult.reason }];
-                    }
-                    changes = 0;
-                    try {
-                        result = ctx.db.prepare("\n        UPDATE memory_entries\n        SET status = 'deleted', updated_at = ?\n        WHERE key = ? AND namespace = ? AND status = 'active'\n      ").run(Date.now(), key, namespace);
-                        changes = (_a = result === null || result === void 0 ? void 0 : result.changes) !== null && _a !== void 0 ? _a : 0;
-                    }
-                    catch (_f) {
-                        return [2 /*return*/, null];
-                    }
-                    safeNs = String(namespace).replace(/:/g, '_');
-                    safeKey = String(key).replace(/:/g, '_');
-                    return [4 /*yield*/, cacheInvalidate(registry, "entry:" + safeNs + ":" + safeKey)];
-                case 4:
-                    _e.sent();
-                    if (!(changes > 0)) return [3 /*break*/, 6];
-                    return [4 /*yield*/, logAttestation(registry, 'delete', key, { namespace: namespace })];
-                case 5:
-                    _e.sent();
-                    _e.label = 6;
-                case 6:
-                    remaining = 0;
-                    try {
-                        row = ctx.db.prepare("SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'").get();
-                        remaining = (_b = row === null || row === void 0 ? void 0 : row.cnt) !== null && _b !== void 0 ? _b : 0;
-                    }
-                    catch (_g) {
-                        // Non-fatal
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            deleted: changes > 0,
-                            key: key,
-                            namespace: namespace,
-                            remainingEntries: remaining,
-                            guarded: true
-                        }];
-                case 7:
-                    _d = _e.sent();
-                    return [2 /*return*/, null];
-                case 8: return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeDeleteEntry(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { key, namespace = 'default' } = options;
+        // Phase 5: MutationGuard validation before delete
+        const guardResult = await guardValidate(registry, 'delete', { key, namespace });
+        if (!guardResult.allowed) {
+            return { success: false, deleted: false, key, namespace, remainingEntries: 0, error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        // Soft delete using parameterized query
+        let changes = 0;
+        try {
+            const result = ctx.db.prepare(`
+        UPDATE memory_entries
+        SET status = 'deleted', updated_at = ?
+        WHERE key = ? AND namespace = ? AND status = 'active'
+      `).run(Date.now(), key, namespace);
+            changes = result?.changes ?? 0;
+        }
+        catch {
+            return null;
+        }
+        // Phase 2: Invalidate cache
+        const safeNs = String(namespace).replace(/:/g, '_');
+        const safeKey = String(key).replace(/:/g, '_');
+        await cacheInvalidate(registry, `entry:${safeNs}:${safeKey}`);
+        // Phase 4: AttestationLog delete audit
+        if (changes > 0) {
+            await logAttestation(registry, 'delete', key, { namespace });
+        }
+        let remaining = 0;
+        try {
+            const row = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`).get();
+            remaining = row?.cnt ?? 0;
+        }
+        catch {
+            // Non-fatal
+        }
+        return {
+            success: true,
+            deleted: changes > 0,
+            key,
+            namespace,
+            remainingEntries: remaining,
+            guarded: true,
+        };
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 2: Embedding bridge =====
 /**
  * Generate embedding via AgentDB v3's embedder.
  * Returns null if bridge unavailable — caller falls back to own ONNX/hash.
  */
-export function bridgeGenerateEmbedding(text, dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, agentdb, embedder, emb, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    agentdb = registry.getAgentDB();
-                    embedder = agentdb === null || agentdb === void 0 ? void 0 : agentdb.embedder;
-                    if (!embedder)
-                        return [2 /*return*/, null];
-                    return [4 /*yield*/, embedder.embed(text)];
-                case 3:
-                    emb = _b.sent();
-                    if (!emb)
-                        return [2 /*return*/, null];
-                    return [2 /*return*/, {
-                            embedding: Array.from(emb),
-                            dimensions: emb.length,
-                            model: 'Xenova/all-MiniLM-L6-v2'
-                        }];
-                case 4:
-                    _a = _b.sent();
-                    return [2 /*return*/, null];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeGenerateEmbedding(text, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        const agentdb = registry.getAgentDB();
+        const embedder = agentdb?.embedder;
+        if (!embedder)
+            return null;
+        const emb = await embedder.embed(text);
+        if (!emb)
+            return null;
+        return {
+            embedding: Array.from(emb),
+            dimensions: emb.length,
+            model: 'Xenova/all-MiniLM-L6-v2',
+        };
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Load embedding model via AgentDB v3 (it loads on init).
  * Returns null if unavailable.
  */
-export function bridgeLoadEmbeddingModel(dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var startTime, registry, agentdb, embedder, test, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    startTime = Date.now();
-                    return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    agentdb = registry.getAgentDB();
-                    embedder = agentdb === null || agentdb === void 0 ? void 0 : agentdb.embedder;
-                    if (!embedder)
-                        return [2 /*return*/, null];
-                    return [4 /*yield*/, embedder.embed('test')];
-                case 3:
-                    test = _b.sent();
-                    if (!test)
-                        return [2 /*return*/, null];
-                    return [2 /*return*/, {
-                            success: true,
-                            dimensions: test.length,
-                            modelName: 'Xenova/all-MiniLM-L6-v2',
-                            loadTime: Date.now() - startTime
-                        }];
-                case 4:
-                    _a = _b.sent();
-                    return [2 /*return*/, null];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeLoadEmbeddingModel(dbPath) {
+    const startTime = Date.now();
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        const agentdb = registry.getAgentDB();
+        const embedder = agentdb?.embedder;
+        if (!embedder)
+            return null;
+        // Verify embedder works by generating a test embedding
+        const test = await embedder.embed('test');
+        if (!test)
+            return null;
+        return {
+            success: true,
+            dimensions: test.length,
+            modelName: 'Xenova/all-MiniLM-L6-v2',
+            loadTime: Date.now() - startTime,
+        };
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 3: HNSW bridge =====
 /**
  * Get HNSW status from AgentDB v3's vector backend or HNSW index.
  * Returns null if unavailable.
  */
-export function bridgeGetHNSWStatus(dbPath) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, entryCount, row;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    try {
-                        ctx = getDb(registry);
-                        if (!ctx)
-                            return [2 /*return*/, null];
-                        entryCount = 0;
-                        try {
-                            row = ctx.db.prepare("SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND embedding IS NOT NULL").get();
-                            entryCount = (_a = row === null || row === void 0 ? void 0 : row.cnt) !== null && _a !== void 0 ? _a : 0;
-                        }
-                        catch (_c) {
-                            // Table might not exist
-                        }
-                        return [2 /*return*/, {
-                                available: true,
-                                initialized: true,
-                                entryCount: entryCount,
-                                dimensions: 384
-                            }];
-                    }
-                    catch (_d) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeGetHNSWStatus(dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        const ctx = getDb(registry);
+        if (!ctx)
+            return null;
+        // Count entries with embeddings
+        let entryCount = 0;
+        try {
+            const row = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND embedding IS NOT NULL`).get();
+            entryCount = row?.cnt ?? 0;
+        }
+        catch {
+            // Table might not exist
+        }
+        return {
+            available: true,
+            initialized: true,
+            entryCount,
+            dimensions: 384,
+        };
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Search using AgentDB v3's embedder + SQLite entries.
  * This is the HNSW-equivalent search through the bridge.
  * Returns null if unavailable.
  */
-export function bridgeSearchHNSW(queryEmbedding, options, dbPath) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, k, threshold, nsFilter, rows, stmt, results, _i, rows_4, row, emb, score;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _c.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    ctx = getDb(registry);
-                    if (!ctx)
-                        return [2 /*return*/, null];
-                    try {
-                        k = (_a = options === null || options === void 0 ? void 0 : options.k) !== null && _a !== void 0 ? _a : 10;
-                        threshold = (_b = options === null || options === void 0 ? void 0 : options.threshold) !== null && _b !== void 0 ? _b : 0.3;
-                        nsFilter = (options === null || options === void 0 ? void 0 : options.namespace) && options.namespace !== 'all'
-                            ? "AND namespace = ?"
-                            : '';
-                        rows = void 0;
-                        try {
-                            stmt = ctx.db.prepare("\n        SELECT id, key, namespace, content, embedding\n        FROM memory_entries\n        WHERE status = 'active' AND embedding IS NOT NULL " + nsFilter + "\n        LIMIT 10000\n      ");
-                            rows = nsFilter
-                                ? stmt.all(options.namespace)
-                                : stmt.all();
-                        }
-                        catch (_d) {
-                            return [2 /*return*/, null];
-                        }
-                        results = [];
-                        for (_i = 0, rows_4 = rows; _i < rows_4.length; _i++) {
-                            row = rows_4[_i];
-                            if (!row.embedding)
-                                continue;
-                            try {
-                                emb = JSON.parse(row.embedding);
-                                score = cosineSim(queryEmbedding, emb);
-                                if (score >= threshold) {
-                                    results.push({
-                                        id: String(row.id).substring(0, 12),
-                                        key: row.key || String(row.id).substring(0, 15),
-                                        content: (row.content || '').substring(0, 60) +
-                                            ((row.content || '').length > 60 ? '...' : ''),
-                                        score: score,
-                                        namespace: row.namespace || 'default'
-                                    });
-                                }
-                            }
-                            catch (_e) {
-                                // Skip invalid embeddings
-                            }
-                        }
-                        results.sort(function (a, b) { return b.score - a.score; });
-                        return [2 /*return*/, results.slice(0, k)];
-                    }
-                    catch (_f) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
+export async function bridgeSearchHNSW(queryEmbedding, options, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const k = options?.k ?? 10;
+        const threshold = options?.threshold ?? 0.3;
+        const nsFilter = options?.namespace && options.namespace !== 'all'
+            ? `AND namespace = ?`
+            : '';
+        let rows;
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding
+        FROM memory_entries
+        WHERE status = 'active' AND embedding IS NOT NULL ${nsFilter}
+        LIMIT 10000
+      `);
+            rows = nsFilter
+                ? stmt.all(options.namespace)
+                : stmt.all();
+        }
+        catch {
+            return null;
+        }
+        const results = [];
+        for (const row of rows) {
+            if (!row.embedding)
+                continue;
+            try {
+                const emb = JSON.parse(row.embedding);
+                const score = cosineSim(queryEmbedding, emb);
+                if (score >= threshold) {
+                    results.push({
+                        id: String(row.id).substring(0, 12),
+                        key: row.key || String(row.id).substring(0, 15),
+                        content: (row.content || '').substring(0, 60) +
+                            ((row.content || '').length > 60 ? '...' : ''),
+                        score,
+                        namespace: row.namespace || 'default',
+                    });
+                }
             }
-        });
-    });
+            catch {
+                // Skip invalid embeddings
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, k);
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Add entry to the bridge's database with embedding.
  * Returns null if unavailable.
  */
-export function bridgeAddToHNSW(id, embedding, entry, dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, ctx, now, embeddingJson;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    ctx = getDb(registry);
-                    if (!ctx)
-                        return [2 /*return*/, null];
-                    try {
-                        now = Date.now();
-                        embeddingJson = JSON.stringify(embedding);
-                        ctx.db.prepare("\n      INSERT OR REPLACE INTO memory_entries (\n        id, key, namespace, content, type,\n        embedding, embedding_dimensions, embedding_model,\n        created_at, updated_at, status\n      ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, 'Xenova/all-MiniLM-L6-v2', ?, ?, 'active')\n    ").run(id, entry.key, entry.namespace, entry.content, embeddingJson, embedding.length, now, now);
-                        return [2 /*return*/, true];
-                    }
-                    catch (_b) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeAddToHNSW(id, embedding, entry, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const now = Date.now();
+        const embeddingJson = JSON.stringify(embedding);
+        ctx.db.prepare(`
+      INSERT OR REPLACE INTO memory_entries (
+        id, key, namespace, content, type,
+        embedding, embedding_dimensions, embedding_model,
+        created_at, updated_at, status
+      ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, 'Xenova/all-MiniLM-L6-v2', ?, ?, 'active')
+    `).run(id, entry.key, entry.namespace, entry.content, embeddingJson, embedding.length, now, now);
+        return true;
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 4: Controller access =====
 /**
  * Get a named controller from AgentDB v3 via ControllerRegistry.
  * Returns null if unavailable.
  */
-export function bridgeGetController(name, dbPath) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    try {
-                        return [2 /*return*/, (_a = registry.get(name)) !== null && _a !== void 0 ? _a : null];
-                    }
-                    catch (_c) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeGetController(name, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        return registry.get(name) ?? null;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Check if a controller is available.
  */
-export function bridgeHasController(name, dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, controller;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, false];
-                    try {
-                        controller = registry.get(name);
-                        return [2 /*return*/, controller !== null && controller !== undefined];
-                    }
-                    catch (_b) {
-                        return [2 /*return*/, false];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeHasController(name, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return false;
+    try {
+        const controller = registry.get(name);
+        return controller !== null && controller !== undefined;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * List all controllers and their status.
  */
-export function bridgeListControllers(dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    try {
-                        return [2 /*return*/, registry.listControllers()];
-                    }
-                    catch (_b) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeListControllers(dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        return registry.listControllers();
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Check if the AgentDB v3 bridge is available.
  */
-export function isBridgeAvailable(dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (bridgeAvailable !== null)
-                        return [2 /*return*/, bridgeAvailable];
-                    return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _a.sent();
-                    return [2 /*return*/, registry !== null];
-            }
-        });
-    });
+export async function isBridgeAvailable(dbPath) {
+    if (bridgeAvailable !== null)
+        return bridgeAvailable;
+    const registry = await getRegistry(dbPath);
+    return registry !== null;
 }
 /**
  * Get the ControllerRegistry instance (for advanced consumers).
  */
-export function getControllerRegistry(dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, getRegistry(dbPath)];
-        });
-    });
+export async function getControllerRegistry(dbPath) {
+    return getRegistry(dbPath);
 }
 /**
  * Shutdown the bridge and release resources.
  */
-export function shutdownBridge() {
-    return __awaiter(this, void 0, Promise, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!registryInstance) return [3 /*break*/, 5];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, registryInstance.shutdown()];
-                case 2:
-                    _b.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    _a = _b.sent();
-                    return [3 /*break*/, 4];
-                case 4:
-                    registryInstance = null;
-                    registryPromise = null;
-                    bridgeAvailable = null;
-                    _b.label = 5;
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function shutdownBridge() {
+    if (registryInstance) {
+        try {
+            await registryInstance.shutdown();
+        }
+        catch {
+            // Best-effort
+        }
+        registryInstance = null;
+        registryPromise = null;
+        bridgeAvailable = null;
+    }
 }
 // ===== Phase 3: ReasoningBank pattern operations =====
 /**
  * Store a pattern via ReasoningBank controller.
  * Falls back to raw SQL if ReasoningBank unavailable.
  */
-export function bridgeStorePattern(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, reasoningBank, patternId, result, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 6, , 7]);
-                    reasoningBank = registry.get('reasoningBank');
-                    patternId = generateId('pattern');
-                    if (!(reasoningBank && typeof reasoningBank.store === 'function')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, reasoningBank.store({
-                            id: patternId,
-                            content: options.pattern,
-                            type: options.type,
-                            confidence: options.confidence,
-                            metadata: options.metadata,
-                            timestamp: Date.now()
-                        })];
-                case 3:
-                    _b.sent();
-                    return [2 /*return*/, { success: true, patternId: patternId, controller: 'reasoningBank' }];
-                case 4: return [4 /*yield*/, bridgeStoreEntry({
-                        key: patternId,
-                        value: JSON.stringify({ pattern: options.pattern, type: options.type, confidence: options.confidence, metadata: options.metadata }),
-                        namespace: 'pattern',
-                        generateEmbeddingFlag: true,
-                        tags: [options.type, 'reasoning-pattern'],
-                        dbPath: options.dbPath
-                    })];
-                case 5:
-                    result = _b.sent();
-                    return [2 /*return*/, result ? { success: true, patternId: result.id, controller: 'bridge-fallback' } : null];
-                case 6:
-                    _a = _b.sent();
-                    return [2 /*return*/, null];
-                case 7: return [2 /*return*/];
-            }
+export async function bridgeStorePattern(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const reasoningBank = registry.get('reasoningBank');
+        const patternId = generateId('pattern');
+        if (reasoningBank && typeof reasoningBank.store === 'function') {
+            await reasoningBank.store({
+                id: patternId,
+                content: options.pattern,
+                type: options.type,
+                confidence: options.confidence,
+                metadata: options.metadata,
+                timestamp: Date.now(),
+            });
+            return { success: true, patternId, controller: 'reasoningBank' };
+        }
+        // Fallback: store via bridge SQL
+        const result = await bridgeStoreEntry({
+            key: patternId,
+            value: JSON.stringify({ pattern: options.pattern, type: options.type, confidence: options.confidence, metadata: options.metadata }),
+            namespace: 'pattern',
+            generateEmbeddingFlag: true,
+            tags: [options.type, 'reasoning-pattern'],
+            dbPath: options.dbPath,
         });
-    });
+        return result ? { success: true, patternId: result.id, controller: 'bridge-fallback' } : null;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Search patterns via ReasoningBank controller.
  */
-export function bridgeSearchPatterns(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, reasoningBank, results, result, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 6, , 7]);
-                    reasoningBank = registry.get('reasoningBank');
-                    if (!(reasoningBank && typeof reasoningBank.search === 'function')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, reasoningBank.search(options.query, {
-                            topK: options.topK || 5,
-                            minScore: options.minConfidence || 0.3
-                        })];
-                case 3:
-                    results = _b.sent();
-                    return [2 /*return*/, {
-                            results: Array.isArray(results) ? results.map(function (r) {
-                                var _a, _b;
-                                return ({
-                                    id: r.id || r.patternId || '',
-                                    content: r.content || r.pattern || '',
-                                    score: (_b = (_a = r.score) !== null && _a !== void 0 ? _a : r.confidence) !== null && _b !== void 0 ? _b : 0
-                                });
-                            }) : [],
-                            controller: 'reasoningBank'
-                        }];
-                case 4: return [4 /*yield*/, bridgeSearchEntries({
-                        query: options.query,
-                        namespace: 'pattern',
-                        limit: options.topK || 5,
-                        threshold: options.minConfidence || 0.3,
-                        dbPath: options.dbPath
-                    })];
-                case 5:
-                    result = _b.sent();
-                    return [2 /*return*/, result ? {
-                            results: result.results.map(function (r) { return ({ id: r.id, content: r.content, score: r.score }); }),
-                            controller: 'bridge-fallback'
-                        } : null];
-                case 6:
-                    _a = _b.sent();
-                    return [2 /*return*/, null];
-                case 7: return [2 /*return*/];
-            }
+export async function bridgeSearchPatterns(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const reasoningBank = registry.get('reasoningBank');
+        if (reasoningBank && typeof reasoningBank.search === 'function') {
+            const results = await reasoningBank.search(options.query, {
+                topK: options.topK || 5,
+                minScore: options.minConfidence || 0.3,
+            });
+            return {
+                results: Array.isArray(results) ? results.map((r) => ({
+                    id: r.id || r.patternId || '',
+                    content: r.content || r.pattern || '',
+                    score: r.score ?? r.confidence ?? 0,
+                })) : [],
+                controller: 'reasoningBank',
+            };
+        }
+        // Fallback: search via bridge
+        const result = await bridgeSearchEntries({
+            query: options.query,
+            namespace: 'pattern',
+            limit: options.topK || 5,
+            threshold: options.minConfidence || 0.3,
+            dbPath: options.dbPath,
         });
-    });
+        return result ? {
+            results: result.results.map(r => ({ id: r.id, content: r.content, score: r.score })),
+            controller: 'bridge-fallback',
+        } : null;
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 3: Feedback recording =====
 /**
  * Record task feedback for learning via ReasoningBank or LearningSystem.
  * Wired into hooks_post-task handler.
  */
-export function bridgeRecordFeedback(options) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, controller, updated, learningSystem, _b, reasoningBank, _c, skills, _i, _d, pattern, _e, storeResult, _f;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _g.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _g.label = 2;
-                case 2:
-                    _g.trys.push([2, 25, , 26]);
-                    controller = 'none';
-                    updated = 0;
-                    learningSystem = registry.get('learningSystem');
-                    if (!learningSystem) return [3 /*break*/, 9];
-                    _g.label = 3;
-                case 3:
-                    _g.trys.push([3, 8, , 9]);
-                    if (!(typeof learningSystem.recordFeedback === 'function')) return [3 /*break*/, 5];
-                    return [4 /*yield*/, learningSystem.recordFeedback({
-                            taskId: options.taskId, success: options.success, quality: options.quality,
-                            agent: options.agent, duration: options.duration, timestamp: Date.now()
-                        })];
-                case 4:
-                    _g.sent();
+export async function bridgeRecordFeedback(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        let controller = 'none';
+        let updated = 0;
+        // Try LearningSystem first (Phase 4)
+        const learningSystem = registry.get('learningSystem');
+        if (learningSystem) {
+            try {
+                if (typeof learningSystem.recordFeedback === 'function') {
+                    await learningSystem.recordFeedback({
+                        taskId: options.taskId, success: options.success, quality: options.quality,
+                        agent: options.agent, duration: options.duration, timestamp: Date.now(),
+                    });
                     controller = 'learningSystem';
                     updated++;
-                    return [3 /*break*/, 7];
-                case 5:
-                    if (!(typeof learningSystem.record === 'function')) return [3 /*break*/, 7];
-                    return [4 /*yield*/, learningSystem.record(options.taskId, options.quality, options.success ? 'success' : 'failure')];
-                case 6:
-                    _g.sent();
+                }
+                else if (typeof learningSystem.record === 'function') {
+                    await learningSystem.record(options.taskId, options.quality, options.success ? 'success' : 'failure');
                     controller = 'learningSystem';
                     updated++;
-                    _g.label = 7;
-                case 7: return [3 /*break*/, 9];
-                case 8:
-                    _b = _g.sent();
-                    return [3 /*break*/, 9];
-                case 9:
-                    reasoningBank = registry.get('reasoningBank');
-                    if (!reasoningBank) return [3 /*break*/, 16];
-                    _g.label = 10;
-                case 10:
-                    _g.trys.push([10, 15, , 16]);
-                    if (!(typeof reasoningBank.recordOutcome === 'function')) return [3 /*break*/, 12];
-                    return [4 /*yield*/, reasoningBank.recordOutcome({
-                            taskId: options.taskId, verdict: options.success ? 'success' : 'failure',
-                            score: options.quality, timestamp: Date.now()
-                        })];
-                case 11:
-                    _g.sent();
-                    controller = controller === 'none' ? 'reasoningBank' : controller + "+reasoningBank";
-                    updated++;
-                    return [3 /*break*/, 14];
-                case 12:
-                    if (!(typeof reasoningBank.record === 'function')) return [3 /*break*/, 14];
-                    return [4 /*yield*/, reasoningBank.record(options.taskId, options.quality)];
-                case 13:
-                    _g.sent();
-                    controller = controller === 'none' ? 'reasoningBank' : controller + "+reasoningBank";
+                }
+            }
+            catch { /* API mismatch — skip */ }
+        }
+        // Also record in ReasoningBank for pattern reinforcement
+        const reasoningBank = registry.get('reasoningBank');
+        if (reasoningBank) {
+            try {
+                if (typeof reasoningBank.recordOutcome === 'function') {
+                    await reasoningBank.recordOutcome({
+                        taskId: options.taskId, verdict: options.success ? 'success' : 'failure',
+                        score: options.quality, timestamp: Date.now(),
+                    });
+                    controller = controller === 'none' ? 'reasoningBank' : `${controller}+reasoningBank`;
                     updated++;
-                    _g.label = 14;
-                case 14: return [3 /*break*/, 16];
-                case 15:
-                    _c = _g.sent();
-                    return [3 /*break*/, 16];
-                case 16:
-                    if (!(options.success && options.quality >= 0.9 && ((_a = options.patterns) === null || _a === void 0 ? void 0 : _a.length))) return [3 /*break*/, 23];
-                    skills = registry.get('skills');
-                    if (!(skills && typeof skills.promote === 'function')) return [3 /*break*/, 23];
-                    _i = 0, _d = options.patterns;
-                    _g.label = 17;
-                case 17:
-                    if (!(_i < _d.length)) return [3 /*break*/, 22];
-                    pattern = _d[_i];
-                    _g.label = 18;
-                case 18:
-                    _g.trys.push([18, 20, , 21]);
-                    return [4 /*yield*/, skills.promote(pattern, options.quality)];
-                case 19:
-                    _g.sent();
+                }
+                else if (typeof reasoningBank.record === 'function') {
+                    await reasoningBank.record(options.taskId, options.quality);
+                    controller = controller === 'none' ? 'reasoningBank' : `${controller}+reasoningBank`;
                     updated++;
-                    return [3 /*break*/, 21];
-                case 20:
-                    _e = _g.sent();
-                    return [3 /*break*/, 21];
-                case 21:
-                    _i++;
-                    return [3 /*break*/, 17];
-                case 22:
-                    controller += '+skills';
-                    _g.label = 23;
-                case 23: return [4 /*yield*/, bridgeStoreEntry({
-                        key: "feedback-" + options.taskId,
-                        value: JSON.stringify(options),
-                        namespace: 'feedback',
-                        tags: [options.success ? 'success' : 'failure', options.agent || 'unknown'],
-                        dbPath: options.dbPath
-                    })];
-                case 24:
-                    storeResult = _g.sent();
-                    if (storeResult === null || storeResult === void 0 ? void 0 : storeResult.success) {
-                        controller = controller === 'none' ? 'bridge-store' : controller + "+bridge-store";
+                }
+            }
+            catch { /* API mismatch — skip */ }
+        }
+        // Phase 4: SkillLibrary promotion for high-quality patterns
+        if (options.success && options.quality >= 0.9 && options.patterns?.length) {
+            const skills = registry.get('skills');
+            if (skills && typeof skills.promote === 'function') {
+                for (const pattern of options.patterns) {
+                    try {
+                        await skills.promote(pattern, options.quality);
                         updated++;
                     }
-                    return [2 /*return*/, { success: true, controller: controller, updated: updated }];
-                case 25:
-                    _f = _g.sent();
-                    return [2 /*return*/, null];
-                case 26: return [2 /*return*/];
+                    catch { /* skip */ }
+                }
+                controller += '+skills';
             }
+        }
+        // Always store feedback as a memory entry for retrieval (ensures it persists)
+        const storeResult = await bridgeStoreEntry({
+            key: `feedback-${options.taskId}`,
+            value: JSON.stringify(options),
+            namespace: 'feedback',
+            tags: [options.success ? 'success' : 'failure', options.agent || 'unknown'],
+            dbPath: options.dbPath,
         });
-    });
+        if (storeResult?.success) {
+            controller = controller === 'none' ? 'bridge-store' : `${controller}+bridge-store`;
+            updated++;
+        }
+        return { success: true, controller, updated };
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 3: CausalMemoryGraph =====
 /**
  * Record a causal edge between two entries (e.g., task → result).
  */
-export function bridgeRecordCausalEdge(options) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, causalGraph, ctx;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    try {
-                        causalGraph = registry.get('causalGraph');
-                        if (causalGraph && typeof causalGraph.addEdge === 'function') {
-                            causalGraph.addEdge(options.sourceId, options.targetId, {
-                                relation: options.relation,
-                                weight: (_a = options.weight) !== null && _a !== void 0 ? _a : 1.0,
-                                timestamp: Date.now()
-                            });
-                            return [2 /*return*/, { success: true, controller: 'causalGraph' }];
-                        }
-                        ctx = getDb(registry);
-                        if (ctx) {
-                            try {
-                                ctx.db.prepare("\n          INSERT OR REPLACE INTO memory_entries (id, key, namespace, content, type, created_at, updated_at, status)\n          VALUES (?, ?, 'causal-edges', ?, 'procedural', ?, ?, 'active')\n        ").run(generateId('edge'), options.sourceId + "\u2192" + options.targetId, JSON.stringify(options), Date.now(), Date.now());
-                                return [2 /*return*/, { success: true, controller: 'bridge-fallback' }];
-                            }
-                            catch ( /* skip */_c) { /* skip */ }
-                        }
-                        return [2 /*return*/, null];
-                    }
-                    catch (_d) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
+export async function bridgeRecordCausalEdge(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const causalGraph = registry.get('causalGraph');
+        if (causalGraph && typeof causalGraph.addEdge === 'function') {
+            causalGraph.addEdge(options.sourceId, options.targetId, {
+                relation: options.relation,
+                weight: options.weight ?? 1.0,
+                timestamp: Date.now(),
+            });
+            return { success: true, controller: 'causalGraph' };
+        }
+        // Fallback: store edge as metadata
+        const ctx = getDb(registry);
+        if (ctx) {
+            try {
+                ctx.db.prepare(`
+          INSERT OR REPLACE INTO memory_entries (id, key, namespace, content, type, created_at, updated_at, status)
+          VALUES (?, ?, 'causal-edges', ?, 'procedural', ?, ?, 'active')
+        `).run(generateId('edge'), `${options.sourceId}→${options.targetId}`, JSON.stringify(options), Date.now(), Date.now());
+                return { success: true, controller: 'bridge-fallback' };
             }
-        });
-    });
+            catch { /* skip */ }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 5: ReflexionMemory session lifecycle =====
 /**
  * Start a session with ReflexionMemory episodic replay.
  * Loads relevant past session patterns for the new session.
  */
-export function bridgeSessionStart(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, restoredPatterns, controller, reflexion, searchResult, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _b.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 6, , 7]);
-                    restoredPatterns = 0;
-                    controller = 'none';
-                    reflexion = registry.get('reflexion');
-                    if (!(reflexion && typeof reflexion.startEpisode === 'function')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, reflexion.startEpisode(options.sessionId, { context: options.context })];
-                case 3:
-                    _b.sent();
-                    controller = 'reflexion';
-                    _b.label = 4;
-                case 4: return [4 /*yield*/, bridgeSearchEntries({
-                        query: options.context || 'session patterns',
-                        namespace: 'session',
-                        limit: 10,
-                        threshold: 0.2,
-                        dbPath: options.dbPath
-                    })];
-                case 5:
-                    searchResult = _b.sent();
-                    if (searchResult === null || searchResult === void 0 ? void 0 : searchResult.results) {
-                        restoredPatterns = searchResult.results.length;
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            controller: controller === 'none' ? 'bridge-search' : controller,
-                            restoredPatterns: restoredPatterns,
-                            sessionId: options.sessionId
-                        }];
-                case 6:
-                    _a = _b.sent();
-                    return [2 /*return*/, null];
-                case 7: return [2 /*return*/];
-            }
+export async function bridgeSessionStart(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        let restoredPatterns = 0;
+        let controller = 'none';
+        // Try ReflexionMemory for episodic session replay
+        const reflexion = registry.get('reflexion');
+        if (reflexion && typeof reflexion.startEpisode === 'function') {
+            await reflexion.startEpisode(options.sessionId, { context: options.context });
+            controller = 'reflexion';
+        }
+        // Load recent patterns from past sessions
+        const searchResult = await bridgeSearchEntries({
+            query: options.context || 'session patterns',
+            namespace: 'session',
+            limit: 10,
+            threshold: 0.2,
+            dbPath: options.dbPath,
         });
-    });
+        if (searchResult?.results) {
+            restoredPatterns = searchResult.results.length;
+        }
+        return {
+            success: true,
+            controller: controller === 'none' ? 'bridge-search' : controller,
+            restoredPatterns,
+            sessionId: options.sessionId,
+        };
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * End a session and persist episodic summary to ReflexionMemory.
  */
-export function bridgeSessionEnd(options) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, controller, persisted, reflexion, nightlyLearner, _c, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _e.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _e.label = 2;
-                case 2:
-                    _e.trys.push([2, 10, , 11]);
-                    controller = 'none';
-                    persisted = false;
-                    reflexion = registry.get('reflexion');
-                    if (!(reflexion && typeof reflexion.endEpisode === 'function')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, reflexion.endEpisode(options.sessionId, {
-                            summary: options.summary,
-                            tasksCompleted: options.tasksCompleted,
-                            patternsLearned: options.patternsLearned
-                        })];
-                case 3:
-                    _e.sent();
-                    controller = 'reflexion';
-                    persisted = true;
-                    _e.label = 4;
-                case 4: 
-                // Persist session summary as memory entry
-                return [4 /*yield*/, bridgeStoreEntry({
-                        key: "session-" + options.sessionId,
-                        value: JSON.stringify({
-                            sessionId: options.sessionId,
-                            summary: options.summary || 'Session ended',
-                            tasksCompleted: (_a = options.tasksCompleted) !== null && _a !== void 0 ? _a : 0,
-                            patternsLearned: (_b = options.patternsLearned) !== null && _b !== void 0 ? _b : 0,
-                            endedAt: new Date().toISOString()
-                        }),
-                        namespace: 'session',
-                        tags: ['session-end'],
-                        upsert: true,
-                        dbPath: options.dbPath
-                    })];
-                case 5:
-                    // Persist session summary as memory entry
-                    _e.sent();
-                    if (controller === 'none')
-                        controller = 'bridge-store';
-                    persisted = true;
-                    nightlyLearner = registry.get('nightlyLearner');
-                    if (!(nightlyLearner && typeof nightlyLearner.consolidate === 'function')) return [3 /*break*/, 9];
-                    _e.label = 6;
-                case 6:
-                    _e.trys.push([6, 8, , 9]);
-                    return [4 /*yield*/, nightlyLearner.consolidate({ sessionId: options.sessionId })];
-                case 7:
-                    _e.sent();
-                    controller += '+nightlyLearner';
-                    return [3 /*break*/, 9];
-                case 8:
-                    _c = _e.sent();
-                    return [3 /*break*/, 9];
-                case 9: return [2 /*return*/, { success: true, controller: controller, persisted: persisted }];
-                case 10:
-                    _d = _e.sent();
-                    return [2 /*return*/, null];
-                case 11: return [2 /*return*/];
-            }
+export async function bridgeSessionEnd(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        let controller = 'none';
+        let persisted = false;
+        // End episode in ReflexionMemory
+        const reflexion = registry.get('reflexion');
+        if (reflexion && typeof reflexion.endEpisode === 'function') {
+            await reflexion.endEpisode(options.sessionId, {
+                summary: options.summary,
+                tasksCompleted: options.tasksCompleted,
+                patternsLearned: options.patternsLearned,
+            });
+            controller = 'reflexion';
+            persisted = true;
+        }
+        // Persist session summary as memory entry
+        await bridgeStoreEntry({
+            key: `session-${options.sessionId}`,
+            value: JSON.stringify({
+                sessionId: options.sessionId,
+                summary: options.summary || 'Session ended',
+                tasksCompleted: options.tasksCompleted ?? 0,
+                patternsLearned: options.patternsLearned ?? 0,
+                endedAt: new Date().toISOString(),
+            }),
+            namespace: 'session',
+            tags: ['session-end'],
+            upsert: true,
+            dbPath: options.dbPath,
         });
-    });
+        if (controller === 'none')
+            controller = 'bridge-store';
+        persisted = true;
+        // Phase 3: Trigger NightlyLearner consolidation if available
+        const nightlyLearner = registry.get('nightlyLearner');
+        if (nightlyLearner && typeof nightlyLearner.consolidate === 'function') {
+            try {
+                await nightlyLearner.consolidate({ sessionId: options.sessionId });
+                controller += '+nightlyLearner';
+            }
+            catch { /* non-fatal */ }
+        }
+        return { success: true, controller, persisted };
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 5: SemanticRouter bridge =====
 /**
  * Route a task via AgentDB's SemanticRouter.
  * Returns null to fall back to local ruvector router.
  */
-export function bridgeRouteTask(options) {
-    var _a, _b, _c;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, semanticRouter, result, learningSystem, rec, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getRegistry(options.dbPath)];
-                case 1:
-                    registry = _e.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _e.label = 2;
-                case 2:
-                    _e.trys.push([2, 7, , 8]);
-                    semanticRouter = registry.get('semanticRouter');
-                    if (!(semanticRouter && typeof semanticRouter.route === 'function')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, semanticRouter.route(options.task, { context: options.context })];
-                case 3:
-                    result = _e.sent();
-                    if (result) {
-                        return [2 /*return*/, {
-                                route: result.route || result.category || 'general',
-                                confidence: (_b = (_a = result.confidence) !== null && _a !== void 0 ? _a : result.score) !== null && _b !== void 0 ? _b : 0.5,
-                                agents: result.agents || result.suggestedAgents || [],
-                                controller: 'semanticRouter'
-                            }];
-                    }
-                    _e.label = 4;
-                case 4:
-                    learningSystem = registry.get('learningSystem');
-                    if (!(learningSystem && typeof learningSystem.recommendAlgorithm === 'function')) return [3 /*break*/, 6];
-                    return [4 /*yield*/, learningSystem.recommendAlgorithm(options.task)];
-                case 5:
-                    rec = _e.sent();
-                    if (rec) {
-                        return [2 /*return*/, {
-                                route: rec.algorithm || rec.route || 'general',
-                                confidence: (_c = rec.confidence) !== null && _c !== void 0 ? _c : 0.5,
-                                agents: rec.agents || [],
-                                controller: 'learningSystem'
-                            }];
-                    }
-                    _e.label = 6;
-                case 6: return [2 /*return*/, null]; // Fall back to local router
-                case 7:
-                    _d = _e.sent();
-                    return [2 /*return*/, null];
-                case 8: return [2 /*return*/];
+export async function bridgeRouteTask(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        // Try AgentDB's SemanticRouter
+        const semanticRouter = registry.get('semanticRouter');
+        if (semanticRouter && typeof semanticRouter.route === 'function') {
+            const result = await semanticRouter.route(options.task, { context: options.context });
+            if (result) {
+                return {
+                    route: result.route || result.category || 'general',
+                    confidence: result.confidence ?? result.score ?? 0.5,
+                    agents: result.agents || result.suggestedAgents || [],
+                    controller: 'semanticRouter',
+                };
             }
-        });
-    });
+        }
+        // Try LearningSystem recommendAlgorithm (Phase 4)
+        const learningSystem = registry.get('learningSystem');
+        if (learningSystem && typeof learningSystem.recommendAlgorithm === 'function') {
+            const rec = await learningSystem.recommendAlgorithm(options.task);
+            if (rec) {
+                return {
+                    route: rec.algorithm || rec.route || 'general',
+                    confidence: rec.confidence ?? 0.5,
+                    agents: rec.agents || [],
+                    controller: 'learningSystem',
+                };
+            }
+        }
+        return null; // Fall back to local router
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 4: Health check with attestation =====
 /**
  * Get comprehensive bridge health including all controller statuses.
  */
-export function bridgeHealthCheck(dbPath) {
-    var _a, _b, _c;
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, controllers, attestationCount, attestation, cacheStats, cache, s;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0: return [4 /*yield*/, getRegistry(dbPath)];
-                case 1:
-                    registry = _d.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    try {
-                        controllers = registry.listControllers();
-                        attestationCount = 0;
-                        attestation = registry.get('attestationLog');
-                        if (attestation && typeof attestation.count === 'function') {
-                            attestationCount = attestation.count();
-                        }
-                        cacheStats = { size: 0, hits: 0, misses: 0 };
-                        cache = registry.get('tieredCache');
-                        if (cache && typeof cache.stats === 'function') {
-                            s = cache.stats();
-                            cacheStats = { size: (_a = s.size) !== null && _a !== void 0 ? _a : 0, hits: (_b = s.hits) !== null && _b !== void 0 ? _b : 0, misses: (_c = s.misses) !== null && _c !== void 0 ? _c : 0 };
-                        }
-                        return [2 /*return*/, { available: true, controllers: controllers, attestationCount: attestationCount, cacheStats: cacheStats }];
-                    }
-                    catch (_e) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeHealthCheck(dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        const controllers = registry.listControllers();
+        // Phase 4: AttestationLog stats
+        let attestationCount = 0;
+        const attestation = registry.get('attestationLog');
+        if (attestation && typeof attestation.count === 'function') {
+            attestationCount = attestation.count();
+        }
+        // Phase 2: TieredCache stats
+        let cacheStats = { size: 0, hits: 0, misses: 0 };
+        const cache = registry.get('tieredCache');
+        if (cache && typeof cache.stats === 'function') {
+            const s = cache.stats();
+            cacheStats = { size: s.size ?? 0, hits: s.hits ?? 0, misses: s.misses ?? 0 };
+        }
+        return { available: true, controllers, attestationCount, cacheStats };
+    }
+    catch {
+        return null;
+    }
 }
 // ===== Phase 7: Hierarchical memory, consolidation, batch, context, semantic route =====
 /**
@@ -1652,42 +1274,31 @@ export function bridgeHealthCheck(dbPath) {
  * Stub API (fallback):
  *   store(key, value, tier) — synchronous
  */
-export function bridgeHierarchicalStore(params) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, hm, tier, id, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry()];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 6]);
-                    hm = registry.get('hierarchicalMemory');
-                    if (!hm)
-                        return [2 /*return*/, { success: false, error: 'HierarchicalMemory not available' }];
-                    tier = params.tier || 'working';
-                    if (!(typeof hm.getStats === 'function' && typeof hm.promote === 'function')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, hm.store(params.value, params.importance || 0.5, tier, {
-                            metadata: { key: params.key },
-                            tags: [params.key]
-                        })];
-                case 3:
-                    id = _a.sent();
-                    return [2 /*return*/, { success: true, id: id, key: params.key, tier: tier }];
-                case 4:
-                    // Stub fallback
-                    hm.store(params.key, params.value, tier);
-                    return [2 /*return*/, { success: true, key: params.key, tier: tier }];
-                case 5:
-                    e_1 = _a.sent();
-                    return [2 /*return*/, { success: false, error: e_1.message }];
-                case 6: return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeHierarchicalStore(params) {
+    const registry = await getRegistry();
+    if (!registry)
+        return null;
+    try {
+        const hm = registry.get('hierarchicalMemory');
+        if (!hm)
+            return { success: false, error: 'HierarchicalMemory not available' };
+        const tier = params.tier || 'working';
+        // Detect real HierarchicalMemory (has async store returning id) vs stub
+        if (typeof hm.getStats === 'function' && typeof hm.promote === 'function') {
+            // Real agentdb HierarchicalMemory
+            const id = await hm.store(params.value, params.importance || 0.5, tier, {
+                metadata: { key: params.key },
+                tags: [params.key],
+            });
+            return { success: true, id, key: params.key, tier };
+        }
+        // Stub fallback
+        hm.store(params.key, params.value, tier);
+        return { success: true, key: params.key, tier };
+    }
+    catch (e) {
+        return { success: false, error: e.message };
+    }
 }
 /**
  * Recall from hierarchical memory.
@@ -1698,47 +1309,37 @@ export function bridgeHierarchicalStore(params) {
  * Stub API (fallback):
  *   recall(query: string, topK: number) → synchronous array
  */
-export function bridgeHierarchicalRecall(params) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, hm, memoryQuery, results_1, results, filtered, e_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry()];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 6]);
-                    hm = registry.get('hierarchicalMemory');
-                    if (!hm)
-                        return [2 /*return*/, { results: [], error: 'HierarchicalMemory not available' }];
-                    if (!(typeof hm.getStats === 'function' && typeof hm.promote === 'function')) return [3 /*break*/, 4];
-                    memoryQuery = {
-                        query: params.query,
-                        k: params.topK || 5
-                    };
-                    if (params.tier) {
-                        memoryQuery.tier = params.tier;
-                    }
-                    return [4 /*yield*/, hm.recall(memoryQuery)];
-                case 3:
-                    results_1 = _a.sent();
-                    return [2 /*return*/, { results: results_1 || [], controller: 'hierarchicalMemory' }];
-                case 4:
-                    results = hm.recall(params.query, params.topK || 5);
-                    filtered = params.tier
-                        ? results.filter(function (r) { return r.tier === params.tier; })
-                        : results;
-                    return [2 /*return*/, { results: filtered, controller: 'hierarchicalMemory' }];
-                case 5:
-                    e_2 = _a.sent();
-                    return [2 /*return*/, { results: [], error: e_2.message }];
-                case 6: return [2 /*return*/];
+export async function bridgeHierarchicalRecall(params) {
+    const registry = await getRegistry();
+    if (!registry)
+        return null;
+    try {
+        const hm = registry.get('hierarchicalMemory');
+        if (!hm)
+            return { results: [], error: 'HierarchicalMemory not available' };
+        // Detect real HierarchicalMemory vs stub
+        if (typeof hm.getStats === 'function' && typeof hm.promote === 'function') {
+            // Real agentdb HierarchicalMemory — recall takes MemoryQuery object
+            const memoryQuery = {
+                query: params.query,
+                k: params.topK || 5,
+            };
+            if (params.tier) {
+                memoryQuery.tier = params.tier;
             }
-        });
-    });
+            const results = await hm.recall(memoryQuery);
+            return { results: results || [], controller: 'hierarchicalMemory' };
+        }
+        // Stub fallback — recall(string, number)
+        const results = hm.recall(params.query, params.topK || 5);
+        const filtered = params.tier
+            ? results.filter((r) => r.tier === params.tier)
+            : results;
+        return { results: filtered, controller: 'hierarchicalMemory' };
+    }
+    catch (e) {
+        return { results: [], error: e.message };
+    }
 }
 /**
  * Run memory consolidation.
@@ -1749,33 +1350,20 @@ export function bridgeHierarchicalRecall(params) {
  * Stub API (fallback):
  *   consolidate() → { promoted, pruned, timestamp }
  */
-export function bridgeConsolidate(params) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, mc, result, e_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry()];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 4, , 5]);
-                    mc = registry.get('memoryConsolidation');
-                    if (!mc)
-                        return [2 /*return*/, { success: false, error: 'MemoryConsolidation not available' }];
-                    return [4 /*yield*/, mc.consolidate()];
-                case 3:
-                    result = _a.sent();
-                    return [2 /*return*/, { success: true, consolidated: result }];
-                case 4:
-                    e_3 = _a.sent();
-                    return [2 /*return*/, { success: false, error: e_3.message }];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeConsolidate(params) {
+    const registry = await getRegistry();
+    if (!registry)
+        return null;
+    try {
+        const mc = registry.get('memoryConsolidation');
+        if (!mc)
+            return { success: false, error: 'MemoryConsolidation not available' };
+        const result = await mc.consolidate();
+        return { success: true, consolidated: result };
+    }
+    catch (e) {
+        return { success: false, error: e.message };
+    }
 }
 /**
  * Batch operations (insert, update, delete).
@@ -1783,182 +1371,124 @@ export function bridgeConsolidate(params) {
  * - delete: calls bulkDelete(table, conditions) on episodes table
  * - update: calls bulkUpdate(table, updates, conditions) on episodes table
  */
-export function bridgeBatchOperation(params) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, batch, result, _a, episodes, keys, _i, keys_1, key, _b, _c, entry, e_4;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0: return [4 /*yield*/, getRegistry()];
-                case 1:
-                    registry = _d.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _d.label = 2;
-                case 2:
-                    _d.trys.push([2, 17, , 18]);
-                    batch = registry.get('batchOperations');
-                    if (!batch)
-                        return [2 /*return*/, { success: false, error: 'BatchOperations not available' }];
-                    result = void 0;
-                    _a = params.operation;
-                    switch (_a) {
-                        case 'insert': return [3 /*break*/, 3];
-                        case 'delete': return [3 /*break*/, 5];
-                        case 'update': return [3 /*break*/, 10];
-                    }
-                    return [3 /*break*/, 15];
-                case 3:
-                    episodes = params.entries.map(function (e) { return ({
-                        content: e.value || e.content || JSON.stringify(e),
-                        metadata: e.metadata || { key: e.key }
-                    }); });
-                    return [4 /*yield*/, batch.insertEpisodes(episodes)];
-                case 4:
-                    result = _d.sent();
-                    return [3 /*break*/, 16];
-                case 5:
-                    keys = params.entries.map(function (e) { return e.key; }).filter(Boolean);
-                    _i = 0, keys_1 = keys;
-                    _d.label = 6;
-                case 6:
-                    if (!(_i < keys_1.length)) return [3 /*break*/, 9];
-                    key = keys_1[_i];
-                    return [4 /*yield*/, batch.bulkDelete('episodes', { key: key })];
-                case 7:
-                    _d.sent();
-                    _d.label = 8;
-                case 8:
-                    _i++;
-                    return [3 /*break*/, 6];
-                case 9:
-                    result = { deleted: keys.length };
-                    return [3 /*break*/, 16];
-                case 10:
-                    _b = 0, _c = params.entries;
-                    _d.label = 11;
-                case 11:
-                    if (!(_b < _c.length)) return [3 /*break*/, 14];
-                    entry = _c[_b];
-                    return [4 /*yield*/, batch.bulkUpdate('episodes', { content: entry.value || entry.content }, { key: entry.key })];
-                case 12:
-                    _d.sent();
-                    _d.label = 13;
-                case 13:
-                    _b++;
-                    return [3 /*break*/, 11];
-                case 14:
-                    result = { updated: params.entries.length };
-                    return [3 /*break*/, 16];
-                case 15: return [2 /*return*/, { success: false, error: "Unknown operation: " + params.operation }];
-                case 16: return [2 /*return*/, { success: true, operation: params.operation, count: params.entries.length, result: result }];
-                case 17:
-                    e_4 = _d.sent();
-                    return [2 /*return*/, { success: false, error: e_4.message }];
-                case 18: return [2 /*return*/];
+export async function bridgeBatchOperation(params) {
+    const registry = await getRegistry();
+    if (!registry)
+        return null;
+    try {
+        const batch = registry.get('batchOperations');
+        if (!batch)
+            return { success: false, error: 'BatchOperations not available' };
+        let result;
+        switch (params.operation) {
+            case 'insert': {
+                // insertEpisodes expects [{content, metadata?, embedding?}]
+                const episodes = params.entries.map((e) => ({
+                    content: e.value || e.content || JSON.stringify(e),
+                    metadata: e.metadata || { key: e.key },
+                }));
+                result = await batch.insertEpisodes(episodes);
+                break;
             }
-        });
-    });
+            case 'delete': {
+                // bulkDelete(table, conditions) — conditions is a WHERE clause object
+                const keys = params.entries.map((e) => e.key).filter(Boolean);
+                for (const key of keys) {
+                    await batch.bulkDelete('episodes', { key });
+                }
+                result = { deleted: keys.length };
+                break;
+            }
+            case 'update': {
+                // bulkUpdate(table, updates, conditions)
+                for (const entry of params.entries) {
+                    await batch.bulkUpdate('episodes', { content: entry.value || entry.content }, { key: entry.key });
+                }
+                result = { updated: params.entries.length };
+                break;
+            }
+            default: return { success: false, error: `Unknown operation: ${params.operation}` };
+        }
+        return { success: true, operation: params.operation, count: params.entries.length, result };
+    }
+    catch (e) {
+        return { success: false, error: e.message };
+    }
 }
 /**
  * Synthesize context from memories.
  * ContextSynthesizer.synthesize is a static method that takes MemoryPattern[] (not a string).
  */
-export function bridgeContextSynthesize(params) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, CS, hm, memories, recalled, result, e_5;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry()];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 7, , 8]);
-                    CS = registry.get('contextSynthesizer');
-                    if (!CS || typeof CS.synthesize !== 'function') {
-                        return [2 /*return*/, { success: false, error: 'ContextSynthesizer not available' }];
-                    }
-                    hm = registry.get('hierarchicalMemory');
-                    memories = [];
-                    if (!(hm && typeof hm.recall === 'function')) return [3 /*break*/, 6];
-                    recalled = void 0;
-                    if (!(typeof hm.promote === 'function')) return [3 /*break*/, 4];
-                    return [4 /*yield*/, hm.recall({ query: params.query, k: params.maxEntries || 10 })];
-                case 3:
-                    // Real agentdb HierarchicalMemory
-                    recalled = _a.sent();
-                    return [3 /*break*/, 5];
-                case 4:
-                    // Stub
-                    recalled = hm.recall(params.query, params.maxEntries || 10);
-                    _a.label = 5;
-                case 5:
-                    memories = (recalled || []).map(function (r) { return ({
-                        content: r.value || r.content || '',
-                        key: r.key || r.id || '',
-                        reward: 1,
-                        verdict: 'success'
-                    }); });
-                    _a.label = 6;
-                case 6:
-                    result = CS.synthesize(memories, { includeRecommendations: true });
-                    return [2 /*return*/, { success: true, synthesis: result }];
-                case 7:
-                    e_5 = _a.sent();
-                    return [2 /*return*/, { success: false, error: e_5.message }];
-                case 8: return [2 /*return*/];
+export async function bridgeContextSynthesize(params) {
+    const registry = await getRegistry();
+    if (!registry)
+        return null;
+    try {
+        const CS = registry.get('contextSynthesizer');
+        if (!CS || typeof CS.synthesize !== 'function') {
+            return { success: false, error: 'ContextSynthesizer not available' };
+        }
+        // Gather memory patterns from hierarchical memory as input
+        const hm = registry.get('hierarchicalMemory');
+        let memories = [];
+        if (hm && typeof hm.recall === 'function') {
+            // Detect real HierarchicalMemory (MemoryQuery object) vs stub (string, number)
+            let recalled;
+            if (typeof hm.promote === 'function') {
+                // Real agentdb HierarchicalMemory
+                recalled = await hm.recall({ query: params.query, k: params.maxEntries || 10 });
             }
-        });
-    });
+            else {
+                // Stub
+                recalled = hm.recall(params.query, params.maxEntries || 10);
+            }
+            memories = (recalled || []).map((r) => ({
+                content: r.value || r.content || '',
+                key: r.key || r.id || '',
+                reward: 1,
+                verdict: 'success',
+            }));
+        }
+        const result = CS.synthesize(memories, { includeRecommendations: true });
+        return { success: true, synthesis: result };
+    }
+    catch (e) {
+        return { success: false, error: e.message };
+    }
 }
 /**
  * Route via SemanticRouter.
  * Available since agentdb 3.0.0-alpha.10 — uses @ruvector/router for
  * semantic matching with keyword fallback.
  */
-export function bridgeSemanticRoute(params) {
-    return __awaiter(this, void 0, Promise, function () {
-        var registry, router, result, e_6;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getRegistry()];
-                case 1:
-                    registry = _a.sent();
-                    if (!registry)
-                        return [2 /*return*/, null];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 4, , 5]);
-                    router = registry.get('semanticRouter');
-                    if (!router)
-                        return [2 /*return*/, { route: null, error: 'SemanticRouter not available' }];
-                    return [4 /*yield*/, router.route(params.input)];
-                case 3:
-                    result = _a.sent();
-                    return [2 /*return*/, { route: result, controller: 'semanticRouter' }];
-                case 4:
-                    e_6 = _a.sent();
-                    return [2 /*return*/, { route: null, error: e_6.message }];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function bridgeSemanticRoute(params) {
+    const registry = await getRegistry();
+    if (!registry)
+        return null;
+    try {
+        const router = registry.get('semanticRouter');
+        if (!router)
+            return { route: null, error: 'SemanticRouter not available' };
+        const result = await router.route(params.input);
+        return { route: result, controller: 'semanticRouter' };
+    }
+    catch (e) {
+        return { route: null, error: e.message };
+    }
 }
 // ===== Utility =====
 function cosineSim(a, b) {
     if (!a || !b || a.length === 0 || b.length === 0)
         return 0;
-    var len = Math.min(a.length, b.length);
-    var dot = 0, normA = 0, normB = 0;
-    for (var i = 0; i < len; i++) {
-        var ai = a[i], bi = b[i];
+    const len = Math.min(a.length, b.length);
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < len; i++) {
+        const ai = a[i], bi = b[i];
         dot += ai * bi;
         normA += ai * ai;
         normB += bi * bi;
     }
-    var mag = Math.sqrt(normA * normB);
+    const mag = Math.sqrt(normA * normB);
     return mag === 0 ? 0 : dot / mag;
 }
 //# sourceMappingURL=memory-bridge.js.map