kynjal-cli 3.1.3 → 4.0.0

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

@@ -0,0 +1,1964 @@
+/**
+ * Memory Bridge — Routes CLI memory operations through ControllerRegistry + AgentDB v3
+ *
+ * Per ADR-053 Phases 1-6: Full controller activation pipeline.
+ * CLI → ControllerRegistry → AgentDB v3 controllers.
+ *
+ * Phase 1: Core CRUD + embeddings + HNSW + controller access (complete)
+ * Phase 2: BM25 hybrid search, TieredCache read/write, MutationGuard validation
+ * Phase 3: ReasoningBank pattern store, recordFeedback, CausalMemoryGraph edges
+ * Phase 4: SkillLibrary promotion, ExplainableRecall provenance, AttestationLog
+ * Phase 5: ReflexionMemory session lifecycle, WitnessChain attestation
+ * Phase 6: AgentDB MCP tools (separate file), COW branching
+ *
+ * Uses better-sqlite3 API (synchronous .all()/.get()/.run()) since that's
+ * what AgentDB v3 uses internally.
+ *
+ * @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;
+/**
+ * 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');
+    if (!customPath)
+        return path.join(swarmDir, 'memory.db');
+    if (customPath === ':memory:')
+        return ':memory:';
+    var resolved = path.resolve(customPath);
+    // Ensure the path doesn't escape the working directory
+    var cwd = process.cwd();
+    if (!resolved.startsWith(cwd)) {
+        return path.join(swarmDir, 'memory.db'); // fallback to safe default
+    }
+    return resolved;
+}
+/**
+ * Generate a secure random ID for memory entries.
+ */
+function generateId(prefix) {
+    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*/];
+                        }
+                    });
+                }); })();
+            }
+            return [2 /*return*/, registryPromise];
+        });
+    });
+}
+// ===== Phase 2: BM25 hybrid scoring =====
+/**
+ * BM25 scoring for keyword-based search.
+ * Replaces naive String.includes() with proper information retrieval scoring.
+ * 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;
+        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))));
+        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;
+}
+/**
+ * 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+/);
+        totalLength += words.length;
+        for (var _a = 0, queryTerms_2 = queryTerms; _a < queryTerms_2.length; _a++) {
+            var term = queryTerms_2[_a];
+            if (content.includes(term)) {
+                termDocFreqs.set(term, (termDocFreqs.get(term) || 0) + 1);
+            }
+        }
+    }
+    return { termDocFreqs: 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*/];
+        });
+    });
+}
+/**
+ * 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*/];
+        });
+    });
+}
+/**
+ * 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*/];
+        });
+    });
+}
+// ===== Phase 2: MutationGuard helpers =====
+/**
+ * Validate a mutation through MutationGuard before executing.
+ * Returns true if the mutation is allowed, false if rejected.
+ * 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*/];
+        });
+    });
+}
+// ===== 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*/];
+        });
+    });
+}
+/**
+ * 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))
+        return null;
+    var 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    )");
+        // 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)");
+    }
+    catch (_a) {
+        // Table already exists or db is read-only — that's fine
+    }
+    return { db: db, agentdb: agentdb };
+}
+// ===== Bridge functions — match memory-initializer.ts signatures =====
+/**
+ * Store an entry via AgentDB v3.
+ * 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();
+                    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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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];
+            }
+        });
+    });
+}
+/**
+ * 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)];
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+// ===== 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();
+                    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();
+                    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";
+                    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();
+                    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";
+                        updated++;
+                    }
+                    return [2 /*return*/, { success: true, controller: controller, updated: updated }];
+                case 25:
+                    _f = _g.sent();
+                    return [2 /*return*/, null];
+                case 26: return [2 /*return*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+// ===== 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*/];
+            }
+        });
+    });
+}
+// ===== Phase 7: Hierarchical memory, consolidation, batch, context, semantic route =====
+/**
+ * Store to hierarchical memory with tier.
+ * Valid tiers: working, episodic, semantic
+ *
+ * Real HierarchicalMemory API (agentdb alpha.10+):
+ *   store(content, importance?, tier?, options?) → Promise<string>
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * Recall from hierarchical memory.
+ *
+ * Real HierarchicalMemory API (agentdb alpha.10+):
+ *   recall(query: MemoryQuery) → Promise<MemoryItem[]>
+ *   where MemoryQuery = { query, tier?, k?, threshold?, context?, includeDecayed? }
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * Run memory consolidation.
+ *
+ * Real MemoryConsolidation API (agentdb alpha.10+):
+ *   consolidate() → Promise<ConsolidationReport>
+ *   ConsolidationReport = { episodicProcessed, semanticCreated, memoriesForgotten, ... }
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * Batch operations (insert, update, delete).
+ * - insert: calls insertEpisodes(entries) where entries are {content, metadata?}
+ * - 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+/**
+ * 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*/];
+            }
+        });
+    });
+}
+// ===== 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];
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    var mag = Math.sqrt(normA * normB);
+    return mag === 0 ? 0 : dot / mag;
+}
+//# sourceMappingURL=memory-bridge.js.map