kynjal-cli 4.0.0 → 4.0.1

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

@@ -8,384 +8,563 @@
  *
  * @module v3/cli/memory-initializer
  */
-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 };
-    }
-};
 import * as fs from 'fs';
 import * as path from 'path';
 // ADR-053: Lazy import of AgentDB v3 bridge
-var _bridge;
-function getBridge() {
-    return __awaiter(this, void 0, Promise, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (_bridge === null)
-                        return [2 /*return*/, null];
-                    if (_bridge)
-                        return [2 /*return*/, _bridge];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import('./memory-bridge.js')];
-                case 2:
-                    _bridge = _b.sent();
-                    return [2 /*return*/, _bridge];
-                case 3:
-                    _a = _b.sent();
-                    _bridge = null;
-                    return [2 /*return*/, null];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+let _bridge;
+async function getBridge() {
+    if (_bridge === null)
+        return null;
+    if (_bridge)
+        return _bridge;
+    try {
+        _bridge = await import('./memory-bridge.js');
+        return _bridge;
+    }
+    catch {
+        _bridge = null;
+        return null;
+    }
 }
 /**
  * Enhanced schema with pattern confidence, temporal decay, versioning
  * Vector embeddings enabled for semantic search
  */
-export var MEMORY_SCHEMA_V3 = "\n-- RuFlo V3 Memory Database\n-- Version: 3.0.0\n-- Features: Pattern learning, vector embeddings, temporal decay, migration tracking\n\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA foreign_keys = ON;\n\n-- ============================================\n-- CORE MEMORY TABLES\n-- ============================================\n\n-- Memory entries (main storage)\nCREATE 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' CHECK(type IN ('semantic', 'episodic', 'procedural', 'working', 'pattern')),\n\n  -- Vector embedding for semantic search (stored as JSON array)\n  embedding TEXT,\n  embedding_model TEXT DEFAULT 'local',\n  embedding_dimensions INTEGER,\n\n  -- Metadata\n  tags TEXT, -- JSON array\n  metadata TEXT, -- JSON object\n  owner_id TEXT,\n\n  -- Timestamps\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\n  -- Access tracking for hot/cold detection\n  access_count INTEGER DEFAULT 0,\n\n  -- Status\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'archived', 'deleted')),\n\n  UNIQUE(namespace, key)\n);\n\n-- Indexes for memory entries\nCREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace);\nCREATE INDEX IF NOT EXISTS idx_memory_key ON memory_entries(key);\nCREATE INDEX IF NOT EXISTS idx_memory_type ON memory_entries(type);\nCREATE INDEX IF NOT EXISTS idx_memory_status ON memory_entries(status);\nCREATE INDEX IF NOT EXISTS idx_memory_created ON memory_entries(created_at);\nCREATE INDEX IF NOT EXISTS idx_memory_accessed ON memory_entries(last_accessed_at);\nCREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_entries(owner_id);\n\n-- ============================================\n-- PATTERN LEARNING TABLES\n-- ============================================\n\n-- Learned patterns with confidence scoring and versioning\nCREATE TABLE IF NOT EXISTS patterns (\n  id TEXT PRIMARY KEY,\n\n  -- Pattern identification\n  name TEXT NOT NULL,\n  pattern_type TEXT NOT NULL CHECK(pattern_type IN (\n    'task-routing', 'error-recovery', 'optimization', 'learning',\n    'coordination', 'prediction', 'code-pattern', 'workflow'\n  )),\n\n  -- Pattern definition\n  condition TEXT NOT NULL, -- Regex or semantic match\n  action TEXT NOT NULL, -- What to do when pattern matches\n  description TEXT,\n\n  -- Confidence scoring (0.0 - 1.0)\n  confidence REAL DEFAULT 0.5,\n  success_count INTEGER DEFAULT 0,\n  failure_count INTEGER DEFAULT 0,\n\n  -- Temporal decay\n  decay_rate REAL DEFAULT 0.01, -- How fast confidence decays\n  half_life_days INTEGER DEFAULT 30, -- Days until confidence halves without use\n\n  -- Vector embedding for semantic pattern matching\n  embedding TEXT,\n  embedding_dimensions INTEGER,\n\n  -- Versioning\n  version INTEGER DEFAULT 1,\n  parent_id TEXT REFERENCES patterns(id),\n\n  -- Metadata\n  tags TEXT, -- JSON array\n  metadata TEXT, -- JSON object\n  source TEXT, -- Where the pattern was learned from\n\n  -- Timestamps\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  last_matched_at INTEGER,\n  last_success_at INTEGER,\n  last_failure_at INTEGER,\n\n  -- Status\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'archived', 'deprecated', 'experimental'))\n);\n\n-- Indexes for patterns\nCREATE INDEX IF NOT EXISTS idx_patterns_type ON patterns(pattern_type);\nCREATE INDEX IF NOT EXISTS idx_patterns_confidence ON patterns(confidence DESC);\nCREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status);\nCREATE INDEX IF NOT EXISTS idx_patterns_last_matched ON patterns(last_matched_at);\n\n-- Pattern evolution history (for versioning)\nCREATE TABLE IF NOT EXISTS pattern_history (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  pattern_id TEXT NOT NULL REFERENCES patterns(id),\n  version INTEGER NOT NULL,\n\n  -- Snapshot of pattern state\n  confidence REAL,\n  success_count INTEGER,\n  failure_count INTEGER,\n  condition TEXT,\n  action TEXT,\n\n  -- What changed\n  change_type TEXT CHECK(change_type IN ('created', 'updated', 'success', 'failure', 'decay', 'merged', 'split')),\n  change_reason TEXT,\n\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_pattern_history_pattern ON pattern_history(pattern_id);\n\n-- ============================================\n-- LEARNING & TRAJECTORY TABLES\n-- ============================================\n\n-- Learning trajectories (SONA integration)\nCREATE TABLE IF NOT EXISTS trajectories (\n  id TEXT PRIMARY KEY,\n  session_id TEXT,\n\n  -- Trajectory state\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'completed', 'failed', 'abandoned')),\n  verdict TEXT CHECK(verdict IN ('success', 'failure', 'partial', NULL)),\n\n  -- Context\n  task TEXT,\n  context TEXT, -- JSON object\n\n  -- Metrics\n  total_steps INTEGER DEFAULT 0,\n  total_reward REAL DEFAULT 0,\n\n  -- Timestamps\n  started_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  ended_at INTEGER,\n\n  -- Reference to extracted pattern (if any)\n  extracted_pattern_id TEXT REFERENCES patterns(id)\n);\n\n-- Trajectory steps\nCREATE TABLE IF NOT EXISTS trajectory_steps (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  trajectory_id TEXT NOT NULL REFERENCES trajectories(id),\n  step_number INTEGER NOT NULL,\n\n  -- Step data\n  action TEXT NOT NULL,\n  observation TEXT,\n  reward REAL DEFAULT 0,\n\n  -- Metadata\n  metadata TEXT, -- JSON object\n\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_steps_trajectory ON trajectory_steps(trajectory_id);\n\n-- ============================================\n-- MIGRATION STATE TRACKING\n-- ============================================\n\n-- Migration state (for resume capability)\nCREATE TABLE IF NOT EXISTS migration_state (\n  id TEXT PRIMARY KEY,\n  migration_type TEXT NOT NULL, -- 'v2-to-v3', 'pattern', 'memory', etc.\n\n  -- Progress tracking\n  status TEXT DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'rolled_back')),\n  total_items INTEGER DEFAULT 0,\n  processed_items INTEGER DEFAULT 0,\n  failed_items INTEGER DEFAULT 0,\n  skipped_items INTEGER DEFAULT 0,\n\n  -- Current position (for resume)\n  current_batch INTEGER DEFAULT 0,\n  last_processed_id TEXT,\n\n  -- Source/destination info\n  source_path TEXT,\n  source_type TEXT,\n  destination_path TEXT,\n\n  -- Backup info\n  backup_path TEXT,\n  backup_created_at INTEGER,\n\n  -- Error tracking\n  last_error TEXT,\n  errors TEXT, -- JSON array of errors\n\n  -- Timestamps\n  started_at INTEGER,\n  completed_at INTEGER,\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\n-- ============================================\n-- SESSION MANAGEMENT\n-- ============================================\n\n-- Sessions for context persistence\nCREATE TABLE IF NOT EXISTS sessions (\n  id TEXT PRIMARY KEY,\n\n  -- Session state\n  state TEXT NOT NULL, -- JSON object with full session state\n  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'paused', 'completed', 'expired')),\n\n  -- Context\n  project_path TEXT,\n  branch TEXT,\n\n  -- Metrics\n  tasks_completed INTEGER DEFAULT 0,\n  patterns_learned INTEGER DEFAULT 0,\n\n  -- Timestamps\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);\n\n-- ============================================\n-- VECTOR INDEX METADATA (for HNSW)\n-- ============================================\n\n-- Track HNSW index state\nCREATE TABLE IF NOT EXISTS vector_indexes (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL UNIQUE,\n\n  -- Index configuration\n  dimensions INTEGER NOT NULL,\n  metric TEXT DEFAULT 'cosine' CHECK(metric IN ('cosine', 'euclidean', 'dot')),\n\n  -- HNSW parameters\n  hnsw_m INTEGER DEFAULT 16,\n  hnsw_ef_construction INTEGER DEFAULT 200,\n  hnsw_ef_search INTEGER DEFAULT 100,\n\n  -- Quantization\n  quantization_type TEXT CHECK(quantization_type IN ('none', 'scalar', 'product')),\n  quantization_bits INTEGER DEFAULT 8,\n\n  -- Statistics\n  total_vectors INTEGER DEFAULT 0,\n  last_rebuild_at INTEGER,\n\n  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\n-- ============================================\n-- SYSTEM METADATA\n-- ============================================\n\nCREATE TABLE IF NOT EXISTS metadata (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL,\n  updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n";
-var hnswIndex = null;
-var hnswInitializing = false;
+export const MEMORY_SCHEMA_V3 = `
+-- RuFlo V3 Memory Database
+-- Version: 3.0.0
+-- Features: Pattern learning, vector embeddings, temporal decay, migration tracking
+
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+PRAGMA foreign_keys = ON;
+
+-- ============================================
+-- CORE MEMORY TABLES
+-- ============================================
+
+-- Memory entries (main storage)
+CREATE TABLE IF NOT EXISTS memory_entries (
+  id TEXT PRIMARY KEY,
+  key TEXT NOT NULL,
+  namespace TEXT DEFAULT 'default',
+  content TEXT NOT NULL,
+  type TEXT DEFAULT 'semantic' CHECK(type IN ('semantic', 'episodic', 'procedural', 'working', 'pattern')),
+
+  -- Vector embedding for semantic search (stored as JSON array)
+  embedding TEXT,
+  embedding_model TEXT DEFAULT 'local',
+  embedding_dimensions INTEGER,
+
+  -- Metadata
+  tags TEXT, -- JSON array
+  metadata TEXT, -- JSON object
+  owner_id TEXT,
+
+  -- Timestamps
+  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  expires_at INTEGER,
+  last_accessed_at INTEGER,
+
+  -- Access tracking for hot/cold detection
+  access_count INTEGER DEFAULT 0,
+
+  -- Status
+  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'archived', 'deleted')),
+
+  UNIQUE(namespace, key)
+);
+
+-- Indexes for memory entries
+CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace);
+CREATE INDEX IF NOT EXISTS idx_memory_key ON memory_entries(key);
+CREATE INDEX IF NOT EXISTS idx_memory_type ON memory_entries(type);
+CREATE INDEX IF NOT EXISTS idx_memory_status ON memory_entries(status);
+CREATE INDEX IF NOT EXISTS idx_memory_created ON memory_entries(created_at);
+CREATE INDEX IF NOT EXISTS idx_memory_accessed ON memory_entries(last_accessed_at);
+CREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_entries(owner_id);
+
+-- ============================================
+-- PATTERN LEARNING TABLES
+-- ============================================
+
+-- Learned patterns with confidence scoring and versioning
+CREATE TABLE IF NOT EXISTS patterns (
+  id TEXT PRIMARY KEY,
+
+  -- Pattern identification
+  name TEXT NOT NULL,
+  pattern_type TEXT NOT NULL CHECK(pattern_type IN (
+    'task-routing', 'error-recovery', 'optimization', 'learning',
+    'coordination', 'prediction', 'code-pattern', 'workflow'
+  )),
+
+  -- Pattern definition
+  condition TEXT NOT NULL, -- Regex or semantic match
+  action TEXT NOT NULL, -- What to do when pattern matches
+  description TEXT,
+
+  -- Confidence scoring (0.0 - 1.0)
+  confidence REAL DEFAULT 0.5,
+  success_count INTEGER DEFAULT 0,
+  failure_count INTEGER DEFAULT 0,
+
+  -- Temporal decay
+  decay_rate REAL DEFAULT 0.01, -- How fast confidence decays
+  half_life_days INTEGER DEFAULT 30, -- Days until confidence halves without use
+
+  -- Vector embedding for semantic pattern matching
+  embedding TEXT,
+  embedding_dimensions INTEGER,
+
+  -- Versioning
+  version INTEGER DEFAULT 1,
+  parent_id TEXT REFERENCES patterns(id),
+
+  -- Metadata
+  tags TEXT, -- JSON array
+  metadata TEXT, -- JSON object
+  source TEXT, -- Where the pattern was learned from
+
+  -- Timestamps
+  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  last_matched_at INTEGER,
+  last_success_at INTEGER,
+  last_failure_at INTEGER,
+
+  -- Status
+  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'archived', 'deprecated', 'experimental'))
+);
+
+-- Indexes for patterns
+CREATE INDEX IF NOT EXISTS idx_patterns_type ON patterns(pattern_type);
+CREATE INDEX IF NOT EXISTS idx_patterns_confidence ON patterns(confidence DESC);
+CREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status);
+CREATE INDEX IF NOT EXISTS idx_patterns_last_matched ON patterns(last_matched_at);
+
+-- Pattern evolution history (for versioning)
+CREATE TABLE IF NOT EXISTS pattern_history (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  pattern_id TEXT NOT NULL REFERENCES patterns(id),
+  version INTEGER NOT NULL,
+
+  -- Snapshot of pattern state
+  confidence REAL,
+  success_count INTEGER,
+  failure_count INTEGER,
+  condition TEXT,
+  action TEXT,
+
+  -- What changed
+  change_type TEXT CHECK(change_type IN ('created', 'updated', 'success', 'failure', 'decay', 'merged', 'split')),
+  change_reason TEXT,
+
+  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+CREATE INDEX IF NOT EXISTS idx_pattern_history_pattern ON pattern_history(pattern_id);
+
+-- ============================================
+-- LEARNING & TRAJECTORY TABLES
+-- ============================================
+
+-- Learning trajectories (SONA integration)
+CREATE TABLE IF NOT EXISTS trajectories (
+  id TEXT PRIMARY KEY,
+  session_id TEXT,
+
+  -- Trajectory state
+  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'completed', 'failed', 'abandoned')),
+  verdict TEXT CHECK(verdict IN ('success', 'failure', 'partial', NULL)),
+
+  -- Context
+  task TEXT,
+  context TEXT, -- JSON object
+
+  -- Metrics
+  total_steps INTEGER DEFAULT 0,
+  total_reward REAL DEFAULT 0,
+
+  -- Timestamps
+  started_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  ended_at INTEGER,
+
+  -- Reference to extracted pattern (if any)
+  extracted_pattern_id TEXT REFERENCES patterns(id)
+);
+
+-- Trajectory steps
+CREATE TABLE IF NOT EXISTS trajectory_steps (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  trajectory_id TEXT NOT NULL REFERENCES trajectories(id),
+  step_number INTEGER NOT NULL,
+
+  -- Step data
+  action TEXT NOT NULL,
+  observation TEXT,
+  reward REAL DEFAULT 0,
+
+  -- Metadata
+  metadata TEXT, -- JSON object
+
+  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+CREATE INDEX IF NOT EXISTS idx_steps_trajectory ON trajectory_steps(trajectory_id);
+
+-- ============================================
+-- MIGRATION STATE TRACKING
+-- ============================================
+
+-- Migration state (for resume capability)
+CREATE TABLE IF NOT EXISTS migration_state (
+  id TEXT PRIMARY KEY,
+  migration_type TEXT NOT NULL, -- 'v2-to-v3', 'pattern', 'memory', etc.
+
+  -- Progress tracking
+  status TEXT DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'rolled_back')),
+  total_items INTEGER DEFAULT 0,
+  processed_items INTEGER DEFAULT 0,
+  failed_items INTEGER DEFAULT 0,
+  skipped_items INTEGER DEFAULT 0,
+
+  -- Current position (for resume)
+  current_batch INTEGER DEFAULT 0,
+  last_processed_id TEXT,
+
+  -- Source/destination info
+  source_path TEXT,
+  source_type TEXT,
+  destination_path TEXT,
+
+  -- Backup info
+  backup_path TEXT,
+  backup_created_at INTEGER,
+
+  -- Error tracking
+  last_error TEXT,
+  errors TEXT, -- JSON array of errors
+
+  -- Timestamps
+  started_at INTEGER,
+  completed_at INTEGER,
+  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+-- ============================================
+-- SESSION MANAGEMENT
+-- ============================================
+
+-- Sessions for context persistence
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+
+  -- Session state
+  state TEXT NOT NULL, -- JSON object with full session state
+  status TEXT DEFAULT 'active' CHECK(status IN ('active', 'paused', 'completed', 'expired')),
+
+  -- Context
+  project_path TEXT,
+  branch TEXT,
+
+  -- Metrics
+  tasks_completed INTEGER DEFAULT 0,
+  patterns_learned INTEGER DEFAULT 0,
+
+  -- Timestamps
+  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  expires_at INTEGER
+);
+
+-- ============================================
+-- VECTOR INDEX METADATA (for HNSW)
+-- ============================================
+
+-- Track HNSW index state
+CREATE TABLE IF NOT EXISTS vector_indexes (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+
+  -- Index configuration
+  dimensions INTEGER NOT NULL,
+  metric TEXT DEFAULT 'cosine' CHECK(metric IN ('cosine', 'euclidean', 'dot')),
+
+  -- HNSW parameters
+  hnsw_m INTEGER DEFAULT 16,
+  hnsw_ef_construction INTEGER DEFAULT 200,
+  hnsw_ef_search INTEGER DEFAULT 100,
+
+  -- Quantization
+  quantization_type TEXT CHECK(quantization_type IN ('none', 'scalar', 'product')),
+  quantization_bits INTEGER DEFAULT 8,
+
+  -- Statistics
+  total_vectors INTEGER DEFAULT 0,
+  last_rebuild_at INTEGER,
+
+  created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+-- ============================================
+-- SYSTEM METADATA
+-- ============================================
+
+CREATE TABLE IF NOT EXISTS metadata (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)
+);
+`;
+let hnswIndex = null;
+let hnswInitializing = false;
 /**
  * Get or create the HNSW index singleton
  * Lazily initializes from SQLite data on first use
  */
-export function getHNSWIndex(options) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var dimensions, ruvectorModule, ruvectorCore, VectorDb, swarmDir, hnswPath, metadataPath, dbPath, db, entries, metadataJson, metadata, _i, metadata_1, _c, key, value, existingLen, initSqlJs, SQL, fileBuffer, sqlDb, result, _d, _e, row, _f, id, key, ns, content, embeddingJson, embedding, vector, _g, _h, _j;
-        return __generator(this, function (_k) {
-            switch (_k.label) {
-                case 0:
-                    dimensions = (_a = options === null || options === void 0 ? void 0 : options.dimensions) !== null && _a !== void 0 ? _a : 384;
-                    // Return existing index if already initialized
-                    if ((hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.initialized) && !(options === null || options === void 0 ? void 0 : options.forceRebuild)) {
-                        return [2 /*return*/, hnswIndex];
-                    }
-                    if (!hnswInitializing) return [3 /*break*/, 4];
-                    _k.label = 1;
-                case 1:
-                    if (!hnswInitializing) return [3 /*break*/, 3];
-                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
-                case 2:
-                    _k.sent();
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/, hnswIndex];
-                case 4:
-                    hnswInitializing = true;
-                    _k.label = 5;
-                case 5:
-                    _k.trys.push([5, 19, , 20]);
-                    return [4 /*yield*/, import('@ruvector/core')["catch"](function () { return null; })];
-                case 6:
-                    ruvectorModule = _k.sent();
-                    if (!ruvectorModule) {
-                        hnswInitializing = false;
-                        return [2 /*return*/, null]; // HNSW not available
-                    }
-                    ruvectorCore = ruvectorModule["default"] || ruvectorModule;
-                    if (!(ruvectorCore === null || ruvectorCore === void 0 ? void 0 : ruvectorCore.VectorDb)) {
-                        hnswInitializing = false;
-                        return [2 /*return*/, null]; // VectorDb not found
-                    }
-                    VectorDb = ruvectorCore.VectorDb;
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    if (!fs.existsSync(swarmDir)) {
-                        fs.mkdirSync(swarmDir, { recursive: true });
-                    }
-                    hnswPath = path.join(swarmDir, 'hnsw.index');
-                    metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
-                    dbPath = (options === null || options === void 0 ? void 0 : options.dbPath) || path.join(swarmDir, 'memory.db');
-                    db = new VectorDb({
-                        dimensions: dimensions,
-                        distanceMetric: 'Cosine',
-                        storagePath: hnswPath // Persistent storage!
-                    });
-                    entries = new Map();
-                    if (fs.existsSync(metadataPath)) {
-                        try {
-                            metadataJson = fs.readFileSync(metadataPath, 'utf-8');
-                            metadata = JSON.parse(metadataJson);
-                            for (_i = 0, metadata_1 = metadata; _i < metadata_1.length; _i++) {
-                                _c = metadata_1[_i], key = _c[0], value = _c[1];
-                                entries.set(key, value);
+export async function getHNSWIndex(options) {
+    const dimensions = options?.dimensions ?? 384;
+    // Return existing index if already initialized
+    if (hnswIndex?.initialized && !options?.forceRebuild) {
+        return hnswIndex;
+    }
+    // Prevent concurrent initialization
+    if (hnswInitializing) {
+        // Wait for initialization to complete
+        while (hnswInitializing) {
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        return hnswIndex;
+    }
+    hnswInitializing = true;
+    try {
+        // Import @ruvector/core dynamically
+        // Handle both ESM (default export) and CJS patterns
+        const ruvectorModule = await import('@ruvector/core').catch(() => null);
+        if (!ruvectorModule) {
+            hnswInitializing = false;
+            return null; // HNSW not available
+        }
+        // ESM returns { default: { VectorDb, ... } }, CJS returns { VectorDb, ... }
+        const ruvectorCore = ruvectorModule.default || ruvectorModule;
+        if (!ruvectorCore?.VectorDb) {
+            hnswInitializing = false;
+            return null; // VectorDb not found
+        }
+        const { VectorDb } = ruvectorCore;
+        // Persistent storage paths
+        const swarmDir = path.join(process.cwd(), '.swarm');
+        if (!fs.existsSync(swarmDir)) {
+            fs.mkdirSync(swarmDir, { recursive: true });
+        }
+        const hnswPath = path.join(swarmDir, 'hnsw.index');
+        const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
+        const dbPath = options?.dbPath || path.join(swarmDir, 'memory.db');
+        // Create HNSW index with persistent storage
+        // @ruvector/core uses string enum for distanceMetric: 'Cosine', 'Euclidean', 'DotProduct', 'Manhattan'
+        const db = new VectorDb({
+            dimensions,
+            distanceMetric: 'Cosine',
+            storagePath: hnswPath // Persistent storage!
+        });
+        // Load metadata (entry info) if exists
+        const entries = new Map();
+        if (fs.existsSync(metadataPath)) {
+            try {
+                const metadataJson = fs.readFileSync(metadataPath, 'utf-8');
+                const metadata = JSON.parse(metadataJson);
+                for (const [key, value] of metadata) {
+                    entries.set(key, value);
+                }
+            }
+            catch {
+                // Metadata load failed, will rebuild
+            }
+        }
+        hnswIndex = {
+            db,
+            entries,
+            dimensions,
+            initialized: false
+        };
+        // Check if index already has data (from persistent storage)
+        const existingLen = await db.len();
+        if (existingLen > 0 && entries.size > 0) {
+            // Index loaded from disk, skip SQLite sync
+            hnswIndex.initialized = true;
+            hnswInitializing = false;
+            return hnswIndex;
+        }
+        if (fs.existsSync(dbPath)) {
+            try {
+                const initSqlJs = (await import('sql.js')).default;
+                const SQL = await initSqlJs();
+                const fileBuffer = fs.readFileSync(dbPath);
+                const sqlDb = new SQL.Database(fileBuffer);
+                // Load all entries with embeddings
+                const result = sqlDb.exec(`
+          SELECT id, key, namespace, content, embedding
+          FROM memory_entries
+          WHERE status = 'active' AND embedding IS NOT NULL
+          LIMIT 10000
+        `);
+                if (result[0]?.values) {
+                    for (const row of result[0].values) {
+                        const [id, key, ns, content, embeddingJson] = row;
+                        if (embeddingJson) {
+                            try {
+                                const embedding = JSON.parse(embeddingJson);
+                                const vector = new Float32Array(embedding);
+                                await db.insert({
+                                    id: String(id),
+                                    vector
+                                });
+                                hnswIndex.entries.set(String(id), {
+                                    id: String(id),
+                                    key: key || String(id),
+                                    namespace: ns || 'default',
+                                    content: content || ''
+                                });
+                            }
+                            catch {
+                                // Skip invalid embeddings
                             }
                         }
-                        catch (_l) {
-                            // Metadata load failed, will rebuild
-                        }
-                    }
-                    hnswIndex = {
-                        db: db,
-                        entries: entries,
-                        dimensions: dimensions,
-                        initialized: false
-                    };
-                    return [4 /*yield*/, db.len()];
-                case 7:
-                    existingLen = _k.sent();
-                    if (existingLen > 0 && entries.size > 0) {
-                        // Index loaded from disk, skip SQLite sync
-                        hnswIndex.initialized = true;
-                        hnswInitializing = false;
-                        return [2 /*return*/, hnswIndex];
                     }
-                    if (!fs.existsSync(dbPath)) return [3 /*break*/, 18];
-                    _k.label = 8;
-                case 8:
-                    _k.trys.push([8, 17, , 18]);
-                    return [4 /*yield*/, import('sql.js')];
-                case 9:
-                    initSqlJs = (_k.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 10:
-                    SQL = _k.sent();
-                    fileBuffer = fs.readFileSync(dbPath);
-                    sqlDb = new SQL.Database(fileBuffer);
-                    result = sqlDb.exec("\n          SELECT id, key, namespace, content, embedding\n          FROM memory_entries\n          WHERE status = 'active' AND embedding IS NOT NULL\n          LIMIT 10000\n        ");
-                    if (!((_b = result[0]) === null || _b === void 0 ? void 0 : _b.values)) return [3 /*break*/, 16];
-                    _d = 0, _e = result[0].values;
-                    _k.label = 11;
-                case 11:
-                    if (!(_d < _e.length)) return [3 /*break*/, 16];
-                    row = _e[_d];
-                    _f = row, id = _f[0], key = _f[1], ns = _f[2], content = _f[3], embeddingJson = _f[4];
-                    if (!embeddingJson) return [3 /*break*/, 15];
-                    _k.label = 12;
-                case 12:
-                    _k.trys.push([12, 14, , 15]);
-                    embedding = JSON.parse(embeddingJson);
-                    vector = new Float32Array(embedding);
-                    return [4 /*yield*/, db.insert({
-                            id: String(id),
-                            vector: vector
-                        })];
-                case 13:
-                    _k.sent();
-                    hnswIndex.entries.set(String(id), {
-                        id: String(id),
-                        key: key || String(id),
-                        namespace: ns || 'default',
-                        content: content || ''
-                    });
-                    return [3 /*break*/, 15];
-                case 14:
-                    _g = _k.sent();
-                    return [3 /*break*/, 15];
-                case 15:
-                    _d++;
-                    return [3 /*break*/, 11];
-                case 16:
-                    sqlDb.close();
-                    return [3 /*break*/, 18];
-                case 17:
-                    _h = _k.sent();
-                    return [3 /*break*/, 18];
-                case 18:
-                    hnswIndex.initialized = true;
-                    hnswInitializing = false;
-                    return [2 /*return*/, hnswIndex];
-                case 19:
-                    _j = _k.sent();
-                    hnswInitializing = false;
-                    return [2 /*return*/, null];
-                case 20: return [2 /*return*/];
+                }
+                sqlDb.close();
             }
-        });
-    });
+            catch {
+                // SQLite load failed, start with empty index
+            }
+        }
+        hnswIndex.initialized = true;
+        hnswInitializing = false;
+        return hnswIndex;
+    }
+    catch {
+        hnswInitializing = false;
+        return null;
+    }
 }
 /**
  * Save HNSW metadata to disk for persistence
  */
 function saveHNSWMetadata() {
-    if (!(hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.entries))
+    if (!hnswIndex?.entries)
         return;
     try {
-        var swarmDir = path.join(process.cwd(), '.swarm');
-        var metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
-        var metadata = Array.from(hnswIndex.entries.entries());
+        const swarmDir = path.join(process.cwd(), '.swarm');
+        const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
+        const metadata = Array.from(hnswIndex.entries.entries());
         fs.writeFileSync(metadataPath, JSON.stringify(metadata));
     }
-    catch (_a) {
+    catch {
         // Silently fail - metadata save is best-effort
     }
 }
 /**
  * Add entry to HNSW index (with automatic persistence)
  */
-export function addToHNSWIndex(id, embedding, entry) {
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, index, vector, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeAddToHNSW(id, embedding, entry)];
-                case 2:
-                    bridgeResult = _b.sent();
-                    if (bridgeResult === true)
-                        return [2 /*return*/, true];
-                    _b.label = 3;
-                case 3: return [4 /*yield*/, getHNSWIndex({ dimensions: embedding.length })];
-                case 4:
-                    index = _b.sent();
-                    if (!index)
-                        return [2 /*return*/, false];
-                    _b.label = 5;
-                case 5:
-                    _b.trys.push([5, 7, , 8]);
-                    vector = new Float32Array(embedding);
-                    return [4 /*yield*/, index.db.insert({
-                            id: id,
-                            vector: vector
-                        })];
-                case 6:
-                    _b.sent();
-                    index.entries.set(id, entry);
-                    // Save metadata for persistence (debounced would be better for high-volume)
-                    saveHNSWMetadata();
-                    return [2 /*return*/, true];
-                case 7:
-                    _a = _b.sent();
-                    return [2 /*return*/, false];
-                case 8: return [2 /*return*/];
-            }
+export async function addToHNSWIndex(id, embedding, entry) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeAddToHNSW(id, embedding, entry);
+        if (bridgeResult === true)
+            return true;
+    }
+    const index = await getHNSWIndex({ dimensions: embedding.length });
+    if (!index)
+        return false;
+    try {
+        const vector = new Float32Array(embedding);
+        await index.db.insert({
+            id,
+            vector
         });
-    });
+        index.entries.set(id, entry);
+        // Save metadata for persistence (debounced would be better for high-volume)
+        saveHNSWMetadata();
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Search HNSW index (150x faster than brute-force)
  * Returns results sorted by similarity (highest first)
  */
-export function searchHNSWIndex(queryEmbedding, options) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, index, vector, k, results, filtered, _i, results_1, result, entry, score, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _c.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeSearchHNSW(queryEmbedding, options)];
-                case 2:
-                    bridgeResult = _c.sent();
-                    if (bridgeResult)
-                        return [2 /*return*/, bridgeResult];
-                    _c.label = 3;
-                case 3: return [4 /*yield*/, getHNSWIndex({ dimensions: queryEmbedding.length })];
-                case 4:
-                    index = _c.sent();
-                    if (!index)
-                        return [2 /*return*/, null];
-                    _c.label = 5;
-                case 5:
-                    _c.trys.push([5, 7, , 8]);
-                    vector = new Float32Array(queryEmbedding);
-                    k = (_a = options === null || options === void 0 ? void 0 : options.k) !== null && _a !== void 0 ? _a : 10;
-                    return [4 /*yield*/, index.db.search({ vector: vector, k: k * 2 })];
-                case 6:
-                    results = _c.sent();
-                    filtered = [];
-                    for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
-                        result = results_1[_i];
-                        entry = index.entries.get(result.id);
-                        if (!entry)
-                            continue;
-                        // Filter by namespace if specified
-                        if ((options === null || options === void 0 ? void 0 : options.namespace) && options.namespace !== 'all' && entry.namespace !== options.namespace) {
-                            continue;
-                        }
-                        score = 1 - (result.score / 2);
-                        filtered.push({
-                            id: entry.id.substring(0, 12),
-                            key: entry.key || entry.id.substring(0, 15),
-                            content: entry.content.substring(0, 60) + (entry.content.length > 60 ? '...' : ''),
-                            score: score,
-                            namespace: entry.namespace
-                        });
-                        if (filtered.length >= k)
-                            break;
-                    }
-                    // Sort by score descending (highest similarity first)
-                    filtered.sort(function (a, b) { return b.score - a.score; });
-                    return [2 /*return*/, filtered];
-                case 7:
-                    _b = _c.sent();
-                    return [2 /*return*/, null];
-                case 8: return [2 /*return*/];
+export async function searchHNSWIndex(queryEmbedding, options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeSearchHNSW(queryEmbedding, options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    const index = await getHNSWIndex({ dimensions: queryEmbedding.length });
+    if (!index)
+        return null;
+    try {
+        const vector = new Float32Array(queryEmbedding);
+        const k = options?.k ?? 10;
+        // HNSW search returns results with cosine distance (lower = more similar)
+        const results = await index.db.search({ vector, k: k * 2 }); // Get extra for filtering
+        const filtered = [];
+        for (const result of results) {
+            const entry = index.entries.get(result.id);
+            if (!entry)
+                continue;
+            // Filter by namespace if specified
+            if (options?.namespace && options.namespace !== 'all' && entry.namespace !== options.namespace) {
+                continue;
             }
-        });
-    });
+            // Convert cosine distance to similarity score (1 - distance)
+            // Cosine distance from @ruvector/core: 0 = identical, 2 = opposite
+            const score = 1 - (result.score / 2);
+            filtered.push({
+                id: entry.id.substring(0, 12),
+                key: entry.key || entry.id.substring(0, 15),
+                content: entry.content.substring(0, 60) + (entry.content.length > 60 ? '...' : ''),
+                score,
+                namespace: entry.namespace
+            });
+            if (filtered.length >= k)
+                break;
+        }
+        // Sort by score descending (highest similarity first)
+        filtered.sort((a, b) => b.score - a.score);
+        return filtered;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Get HNSW index status
  */
 export function getHNSWStatus() {
-    var _a, _b, _c, _d, _e;
     // ADR-053: If bridge was previously loaded, report availability
     if (_bridge && _bridge !== null) {
         // Bridge is loaded — HNSW-equivalent is available via AgentDB v3
         return {
             available: true,
             initialized: true,
-            entryCount: (_a = hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.entries.size) !== null && _a !== void 0 ? _a : 0,
-            dimensions: (_b = hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.dimensions) !== null && _b !== void 0 ? _b : 384
+            entryCount: hnswIndex?.entries.size ?? 0,
+            dimensions: hnswIndex?.dimensions ?? 384
         };
     }
     return {
         available: hnswIndex !== null,
-        initialized: (_c = hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.initialized) !== null && _c !== void 0 ? _c : false,
-        entryCount: (_d = hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.entries.size) !== null && _d !== void 0 ? _d : 0,
-        dimensions: (_e = hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.dimensions) !== null && _e !== void 0 ? _e : 384
+        initialized: hnswIndex?.initialized ?? false,
+        entryCount: hnswIndex?.entries.size ?? 0,
+        dimensions: hnswIndex?.dimensions ?? 384
     };
 }
 /**
@@ -414,27 +593,27 @@ export function rebuildSearchIndex() {
  * @returns Quantized Int8 array with scale factor
  */
 export function quantizeInt8(embedding) {
-    var arr = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
+    const arr = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
     // Find min/max for symmetric quantization
-    var min = Infinity, max = -Infinity;
-    for (var i = 0; i < arr.length; i++) {
+    let min = Infinity, max = -Infinity;
+    for (let i = 0; i < arr.length; i++) {
         if (arr[i] < min)
             min = arr[i];
         if (arr[i] > max)
             max = arr[i];
     }
     // Symmetric quantization: scale = max(|min|, |max|) / 127
-    var absMax = Math.max(Math.abs(min), Math.abs(max));
-    var scale = absMax / 127 || 1e-10; // Avoid division by zero
-    var zeroPoint = 0; // Symmetric quantization
+    const absMax = Math.max(Math.abs(min), Math.abs(max));
+    const scale = absMax / 127 || 1e-10; // Avoid division by zero
+    const zeroPoint = 0; // Symmetric quantization
     // Quantize
-    var quantized = new Int8Array(arr.length);
-    for (var i = 0; i < arr.length; i++) {
+    const quantized = new Int8Array(arr.length);
+    for (let i = 0; i < arr.length; i++) {
         // Clamp to [-127, 127] to leave room for potential rounding
-        var q = Math.round(arr[i] / scale);
+        const q = Math.round(arr[i] / scale);
         quantized[i] = Math.max(-127, Math.min(127, q));
     }
-    return { quantized: quantized, scale: scale, zeroPoint: zeroPoint };
+    return { quantized, scale, zeroPoint };
 }
 /**
  * Dequantize Int8 back to Float32
@@ -444,10 +623,9 @@ export function quantizeInt8(embedding) {
  * @param zeroPoint - Zero point (usually 0 for symmetric)
  * @returns Float32Array
  */
-export function dequantizeInt8(quantized, scale, zeroPoint) {
-    if (zeroPoint === void 0) { zeroPoint = 0; }
-    var result = new Float32Array(quantized.length);
-    for (var i = 0; i < quantized.length; i++) {
+export function dequantizeInt8(quantized, scale, zeroPoint = 0) {
+    const result = new Float32Array(quantized.length);
+    for (let i = 0; i < quantized.length; i++) {
         result[i] = (quantized[i] - zeroPoint) * scale;
     }
     return result;
@@ -459,25 +637,25 @@ export function dequantizeInt8(quantized, scale, zeroPoint) {
 export function quantizedCosineSim(a, aScale, b, bScale) {
     if (a.length !== b.length)
         return 0;
-    var dot = 0, normA = 0, normB = 0;
-    for (var i = 0; i < a.length; i++) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
         dot += a[i] * b[i];
         normA += a[i] * a[i];
         normB += b[i] * b[i];
     }
     // Scales cancel out in cosine similarity for normalized vectors
-    var mag = Math.sqrt(normA * normB);
+    const mag = Math.sqrt(normA * normB);
     return mag === 0 ? 0 : dot / mag;
 }
 /**
  * Get quantization statistics for an embedding
  */
 export function getQuantizationStats(embedding) {
-    var len = embedding.length;
-    var originalBytes = len * 4; // Float32 = 4 bytes
-    var quantizedBytes = len + 8; // Int8 = 1 byte + 8 bytes for scale/zeroPoint
-    var compressionRatio = originalBytes / quantizedBytes;
-    return { originalBytes: originalBytes, quantizedBytes: quantizedBytes, compressionRatio: compressionRatio };
+    const len = embedding.length;
+    const originalBytes = len * 4; // Float32 = 4 bytes
+    const quantizedBytes = len + 8; // Int8 = 1 byte + 8 bytes for scale/zeroPoint
+    const compressionRatio = originalBytes / quantizedBytes;
+    return { originalBytes, quantizedBytes, compressionRatio };
 }
 // ============================================================================
 // FLASH ATTENTION-STYLE BATCH OPERATIONS (V8-Optimized)
@@ -488,24 +666,24 @@ export function getQuantizationStats(embedding) {
  * ~50μs per 1000 vectors (384-dim)
  */
 export function batchCosineSim(query, vectors) {
-    var n = vectors.length;
-    var scores = new Float32Array(n);
+    const n = vectors.length;
+    const scores = new Float32Array(n);
     if (n === 0 || query.length === 0)
         return scores;
     // Pre-compute query norm
-    var queryNorm = 0;
-    for (var i = 0; i < query.length; i++) {
+    let queryNorm = 0;
+    for (let i = 0; i < query.length; i++) {
         queryNorm += query[i] * query[i];
     }
     queryNorm = Math.sqrt(queryNorm);
     if (queryNorm === 0)
         return scores;
     // Compute similarities
-    for (var v = 0; v < n; v++) {
-        var vec = vectors[v];
-        var len = Math.min(query.length, vec.length);
-        var dot = 0, vecNorm = 0;
-        for (var i = 0; i < len; i++) {
+    for (let v = 0; v < n; v++) {
+        const vec = vectors[v];
+        const len = Math.min(query.length, vec.length);
+        let dot = 0, vecNorm = 0;
+        for (let i = 0; i < len; i++) {
             dot += query[i] * vec[i];
             vecNorm += vec[i] * vec[i];
         }
@@ -518,27 +696,26 @@ export function batchCosineSim(query, vectors) {
  * Softmax normalization for attention scores
  * Numerically stable implementation
  */
-export function softmaxAttention(scores, temperature) {
-    if (temperature === void 0) { temperature = 1.0; }
-    var n = scores.length;
-    var result = new Float32Array(n);
+export function softmaxAttention(scores, temperature = 1.0) {
+    const n = scores.length;
+    const result = new Float32Array(n);
     if (n === 0)
         return result;
     // Find max for numerical stability
-    var max = scores[0];
-    for (var i = 1; i < n; i++) {
+    let max = scores[0];
+    for (let i = 1; i < n; i++) {
         if (scores[i] > max)
             max = scores[i];
     }
     // Compute exp and sum
-    var sum = 0;
-    for (var i = 0; i < n; i++) {
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
         result[i] = Math.exp((scores[i] - max) / temperature);
         sum += result[i];
     }
     // Normalize
     if (sum > 0) {
-        for (var i = 0; i < n; i++) {
+        for (let i = 0; i < n; i++) {
             result[i] /= sum;
         }
     }
@@ -549,24 +726,23 @@ export function softmaxAttention(scores, temperature) {
  * More efficient than full sort for small k
  */
 export function topKIndices(scores, k) {
-    var _a, _b;
-    var n = scores.length;
+    const n = scores.length;
     if (k >= n) {
         // Return all indices sorted by score
-        return Array.from({ length: n }, function (_, i) { return i; })
-            .sort(function (a, b) { return scores[b] - scores[a]; });
+        return Array.from({ length: n }, (_, i) => i)
+            .sort((a, b) => scores[b] - scores[a]);
     }
     // Build min-heap of size k
-    var heap = [];
-    for (var i = 0; i < n; i++) {
+    const heap = [];
+    for (let i = 0; i < n; i++) {
         if (heap.length < k) {
             heap.push({ idx: i, score: scores[i] });
             // Bubble up
-            var j = heap.length - 1;
+            let j = heap.length - 1;
             while (j > 0) {
-                var parent = Math.floor((j - 1) / 2);
+                const parent = Math.floor((j - 1) / 2);
                 if (heap[j].score < heap[parent].score) {
-                    _a = [heap[parent], heap[j]], heap[j] = _a[0], heap[parent] = _a[1];
+                    [heap[j], heap[parent]] = [heap[parent], heap[j]];
                     j = parent;
                 }
                 else
@@ -576,46 +752,45 @@ export function topKIndices(scores, k) {
         else if (scores[i] > heap[0].score) {
             // Replace min and heapify down
             heap[0] = { idx: i, score: scores[i] };
-            var j = 0;
+            let j = 0;
             while (true) {
-                var left = 2 * j + 1, right = 2 * j + 2;
-                var smallest = j;
+                const left = 2 * j + 1, right = 2 * j + 2;
+                let smallest = j;
                 if (left < k && heap[left].score < heap[smallest].score)
                     smallest = left;
                 if (right < k && heap[right].score < heap[smallest].score)
                     smallest = right;
                 if (smallest === j)
                     break;
-                _b = [heap[smallest], heap[j]], heap[j] = _b[0], heap[smallest] = _b[1];
+                [heap[j], heap[smallest]] = [heap[smallest], heap[j]];
                 j = smallest;
             }
         }
     }
     // Extract and sort descending
-    return heap.sort(function (a, b) { return b.score - a.score; }).map(function (h) { return h.idx; });
+    return heap.sort((a, b) => b.score - a.score).map(h => h.idx);
 }
 /**
  * Flash Attention-style search
  * Combines batch similarity, softmax, and top-k in one pass
  * Returns indices and attention weights
  */
-export function flashAttentionSearch(query, vectors, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.k, k = _a === void 0 ? 10 : _a, _b = options.temperature, temperature = _b === void 0 ? 1.0 : _b, _c = options.threshold, threshold = _c === void 0 ? 0 : _c;
+export function flashAttentionSearch(query, vectors, options = {}) {
+    const { k = 10, temperature = 1.0, threshold = 0 } = options;
     // Compute batch similarity
-    var scores = batchCosineSim(query, vectors);
+    const scores = batchCosineSim(query, vectors);
     // Get top-k indices
-    var indices = topKIndices(scores, k);
+    const indices = topKIndices(scores, k);
     // Filter by threshold
-    var filtered = indices.filter(function (i) { return scores[i] >= threshold; });
+    const filtered = indices.filter(i => scores[i] >= threshold);
     // Extract scores for filtered results
-    var topScores = new Float32Array(filtered.length);
-    for (var i = 0; i < filtered.length; i++) {
+    const topScores = new Float32Array(filtered.length);
+    for (let i = 0; i < filtered.length; i++) {
         topScores[i] = scores[filtered[i]];
     }
     // Compute attention weights (softmax over top-k)
-    var weights = softmaxAttention(topScores, temperature);
-    return { indices: filtered, scores: topScores, weights: weights };
+    const weights = softmaxAttention(topScores, temperature);
+    return { indices: filtered, scores: topScores, weights };
 }
 // ============================================================================
 // METADATA AND INITIALIZATION
@@ -624,143 +799,129 @@ export function flashAttentionSearch(query, vectors, options) {
  * Initial metadata to insert after schema creation
  */
 export function getInitialMetadata(backend) {
-    return "\nINSERT OR REPLACE INTO metadata (key, value) VALUES\n  ('schema_version', '3.0.0'),\n  ('backend', '" + backend + "'),\n  ('created_at', '" + new Date().toISOString() + "'),\n  ('sql_js', 'true'),\n  ('vector_embeddings', 'enabled'),\n  ('pattern_learning', 'enabled'),\n  ('temporal_decay', 'enabled'),\n  ('hnsw_indexing', 'enabled');\n\n-- Create default vector index configuration\nINSERT OR IGNORE INTO vector_indexes (id, name, dimensions) VALUES\n  ('default', 'default', 768),\n  ('patterns', 'patterns', 768);\n";
+    return `
+INSERT OR REPLACE INTO metadata (key, value) VALUES
+  ('schema_version', '3.0.0'),
+  ('backend', '${backend}'),
+  ('created_at', '${new Date().toISOString()}'),
+  ('sql_js', 'true'),
+  ('vector_embeddings', 'enabled'),
+  ('pattern_learning', 'enabled'),
+  ('temporal_decay', 'enabled'),
+  ('hnsw_indexing', 'enabled');
+
+-- Create default vector index configuration
+INSERT OR IGNORE INTO vector_indexes (id, name, dimensions) VALUES
+  ('default', 'default', 768),
+  ('patterns', 'patterns', 768);
+`;
 }
 /**
  * Ensure memory_entries table has all required columns
  * Adds missing columns for older databases (e.g., 'content' column)
  */
-export function ensureSchemaColumns(dbPath) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var columnsAdded, initSqlJs, SQL, fileBuffer, db, tableInfo, existingColumns, requiredColumns, modified, _i, requiredColumns_1, col, data, error_1;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    columnsAdded = [];
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 4, , 5]);
-                    if (!fs.existsSync(dbPath)) {
-                        return [2 /*return*/, { success: true, columnsAdded: [] }];
-                    }
-                    return [4 /*yield*/, import('sql.js')];
-                case 2:
-                    initSqlJs = (_c.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 3:
-                    SQL = _c.sent();
-                    fileBuffer = fs.readFileSync(dbPath);
-                    db = new SQL.Database(fileBuffer);
-                    tableInfo = db.exec("PRAGMA table_info(memory_entries)");
-                    existingColumns = new Set(((_b = (_a = tableInfo[0]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b.map(function (row) { return row[1]; })) || []);
-                    requiredColumns = [
-                        { name: 'content', definition: "content TEXT DEFAULT ''" },
-                        { name: 'type', definition: "type TEXT DEFAULT 'semantic'" },
-                        { name: 'embedding', definition: 'embedding TEXT' },
-                        { name: 'embedding_model', definition: "embedding_model TEXT DEFAULT 'local'" },
-                        { name: 'embedding_dimensions', definition: 'embedding_dimensions INTEGER' },
-                        { name: 'tags', definition: 'tags TEXT' },
-                        { name: 'metadata', definition: 'metadata TEXT' },
-                        { name: 'owner_id', definition: 'owner_id TEXT' },
-                        { name: 'expires_at', definition: 'expires_at INTEGER' },
-                        { name: 'last_accessed_at', definition: 'last_accessed_at INTEGER' },
-                        { name: 'access_count', definition: 'access_count INTEGER DEFAULT 0' },
-                        { name: 'status', definition: "status TEXT DEFAULT 'active'" }
-                    ];
-                    modified = false;
-                    for (_i = 0, requiredColumns_1 = requiredColumns; _i < requiredColumns_1.length; _i++) {
-                        col = requiredColumns_1[_i];
-                        if (!existingColumns.has(col.name)) {
-                            try {
-                                db.run("ALTER TABLE memory_entries ADD COLUMN " + col.definition);
-                                columnsAdded.push(col.name);
-                                modified = true;
-                            }
-                            catch (e) {
-                                // Column might already exist or other error - continue
-                            }
-                        }
-                    }
-                    if (modified) {
-                        data = db["export"]();
-                        fs.writeFileSync(dbPath, Buffer.from(data));
-                    }
-                    db.close();
-                    return [2 /*return*/, { success: true, columnsAdded: columnsAdded }];
-                case 4:
-                    error_1 = _c.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            columnsAdded: columnsAdded,
-                            error: error_1 instanceof Error ? error_1.message : String(error_1)
-                        }];
-                case 5: return [2 /*return*/];
+export async function ensureSchemaColumns(dbPath) {
+    const columnsAdded = [];
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: true, columnsAdded: [] };
+        }
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        // Get current columns in memory_entries
+        const tableInfo = db.exec("PRAGMA table_info(memory_entries)");
+        const existingColumns = new Set(tableInfo[0]?.values?.map(row => row[1]) || []);
+        // Required columns that may be missing in older schemas
+        // Issue #977: 'type' column was missing from this list, causing store failures on older DBs
+        const requiredColumns = [
+            { name: 'content', definition: "content TEXT DEFAULT ''" },
+            { name: 'type', definition: "type TEXT DEFAULT 'semantic'" },
+            { name: 'embedding', definition: 'embedding TEXT' },
+            { name: 'embedding_model', definition: "embedding_model TEXT DEFAULT 'local'" },
+            { name: 'embedding_dimensions', definition: 'embedding_dimensions INTEGER' },
+            { name: 'tags', definition: 'tags TEXT' },
+            { name: 'metadata', definition: 'metadata TEXT' },
+            { name: 'owner_id', definition: 'owner_id TEXT' },
+            { name: 'expires_at', definition: 'expires_at INTEGER' },
+            { name: 'last_accessed_at', definition: 'last_accessed_at INTEGER' },
+            { name: 'access_count', definition: 'access_count INTEGER DEFAULT 0' },
+            { name: 'status', definition: "status TEXT DEFAULT 'active'" }
+        ];
+        let modified = false;
+        for (const col of requiredColumns) {
+            if (!existingColumns.has(col.name)) {
+                try {
+                    db.run(`ALTER TABLE memory_entries ADD COLUMN ${col.definition}`);
+                    columnsAdded.push(col.name);
+                    modified = true;
+                }
+                catch (e) {
+                    // Column might already exist or other error - continue
+                }
             }
-        });
-    });
+        }
+        if (modified) {
+            // Save updated database
+            const data = db.export();
+            fs.writeFileSync(dbPath, Buffer.from(data));
+        }
+        db.close();
+        return { success: true, columnsAdded };
+    }
+    catch (error) {
+        return {
+            success: false,
+            columnsAdded,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 /**
  * Check for legacy database installations and migrate if needed
  */
-export function checkAndMigrateLegacy(options) {
-    var _a, _b, _c, _d;
-    return __awaiter(this, void 0, Promise, function () {
-        var dbPath, _e, verbose, legacyPaths, _i, legacyPaths_1, legacyPath, initSqlJs, SQL, legacyBuffer, legacyDb, countResult, count, version, versionResult, _f;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
-                case 0:
-                    dbPath = options.dbPath, _e = options.verbose, verbose = _e === void 0 ? false : _e;
-                    legacyPaths = [
-                        path.join(process.cwd(), 'memory.db'),
-                        path.join(process.cwd(), '.claude/memory.db'),
-                        path.join(process.cwd(), 'data/memory.db'),
-                        path.join(process.cwd(), '.claude-flow/memory.db')
-                    ];
-                    _i = 0, legacyPaths_1 = legacyPaths;
-                    _g.label = 1;
-                case 1:
-                    if (!(_i < legacyPaths_1.length)) return [3 /*break*/, 7];
-                    legacyPath = legacyPaths_1[_i];
-                    if (!(fs.existsSync(legacyPath) && legacyPath !== dbPath)) return [3 /*break*/, 6];
-                    _g.label = 2;
-                case 2:
-                    _g.trys.push([2, 5, , 6]);
-                    return [4 /*yield*/, import('sql.js')];
-                case 3:
-                    initSqlJs = (_g.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 4:
-                    SQL = _g.sent();
-                    legacyBuffer = fs.readFileSync(legacyPath);
-                    legacyDb = new SQL.Database(legacyBuffer);
-                    countResult = legacyDb.exec('SELECT COUNT(*) FROM memory_entries');
-                    count = ((_b = (_a = countResult[0]) === null || _a === void 0 ? void 0 : _a.values[0]) === null || _b === void 0 ? void 0 : _b[0]) || 0;
-                    version = 'unknown';
-                    try {
-                        versionResult = legacyDb.exec("SELECT value FROM metadata WHERE key='schema_version'");
-                        version = ((_d = (_c = versionResult[0]) === null || _c === void 0 ? void 0 : _c.values[0]) === null || _d === void 0 ? void 0 : _d[0]) || 'unknown';
-                    }
-                    catch ( /* no metadata table */_h) { /* no metadata table */ }
-                    legacyDb.close();
-                    if (count > 0) {
-                        return [2 /*return*/, {
-                                needsMigration: true,
-                                legacyVersion: version,
-                                legacyEntries: count
-                            }];
-                    }
-                    return [3 /*break*/, 6];
-                case 5:
-                    _f = _g.sent();
-                    return [3 /*break*/, 6];
-                case 6:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 7: return [2 /*return*/, { needsMigration: false }];
+export async function checkAndMigrateLegacy(options) {
+    const { dbPath, verbose = false } = options;
+    // Check for legacy locations
+    const legacyPaths = [
+        path.join(process.cwd(), 'memory.db'),
+        path.join(process.cwd(), '.claude/memory.db'),
+        path.join(process.cwd(), 'data/memory.db'),
+        path.join(process.cwd(), '.claude-flow/memory.db')
+    ];
+    for (const legacyPath of legacyPaths) {
+        if (fs.existsSync(legacyPath) && legacyPath !== dbPath) {
+            try {
+                const initSqlJs = (await import('sql.js')).default;
+                const SQL = await initSqlJs();
+                const legacyBuffer = fs.readFileSync(legacyPath);
+                const legacyDb = new SQL.Database(legacyBuffer);
+                // Check if it has data
+                const countResult = legacyDb.exec('SELECT COUNT(*) FROM memory_entries');
+                const count = countResult[0]?.values[0]?.[0] || 0;
+                // Get version if available
+                let version = 'unknown';
+                try {
+                    const versionResult = legacyDb.exec("SELECT value FROM metadata WHERE key='schema_version'");
+                    version = versionResult[0]?.values[0]?.[0] || 'unknown';
+                }
+                catch { /* no metadata table */ }
+                legacyDb.close();
+                if (count > 0) {
+                    return {
+                        needsMigration: true,
+                        legacyVersion: version,
+                        legacyEntries: count
+                    };
+                }
             }
-        });
-    });
+            catch {
+                // Not a valid SQLite database, skip
+            }
+        }
+    }
+    return { needsMigration: false };
 }
 /**
  * ADR-053: Activate ControllerRegistry so AgentDB v3 controllers
@@ -773,585 +934,509 @@ export function checkAndMigrateLegacy(options) {
  * Failures are isolated: if @claude-flow/memory or agentdb is not installed,
  * this returns an empty result without throwing.
  */
-function activateControllerRegistry(dbPath, verbose) {
-    return __awaiter(this, void 0, Promise, function () {
-        var startTime, activated, failed, bridge, registry, controllers, _i, controllers_1, ctrl, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    startTime = performance.now();
-                    activated = [];
-                    failed = [];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, getBridge()];
-                case 2:
-                    bridge = _b.sent();
-                    if (!bridge) {
-                        return [2 /*return*/, { activated: activated, failed: failed, initTimeMs: performance.now() - startTime }];
-                    }
-                    return [4 /*yield*/, bridge.getControllerRegistry(dbPath)];
-                case 3:
-                    registry = _b.sent();
-                    if (!registry) {
-                        return [2 /*return*/, { activated: activated, failed: failed, initTimeMs: performance.now() - startTime }];
-                    }
-                    // Collect controller status from the registry
-                    if (typeof registry.listControllers === 'function') {
-                        controllers = registry.listControllers();
-                        for (_i = 0, controllers_1 = controllers; _i < controllers_1.length; _i++) {
-                            ctrl = controllers_1[_i];
-                            if (ctrl.enabled) {
-                                activated.push(ctrl.name);
-                            }
-                            else {
-                                failed.push(ctrl.name);
-                            }
-                        }
-                    }
-                    if (verbose && activated.length > 0) {
-                        console.log("ControllerRegistry: " + activated.length + " controllers activated");
-                    }
-                    return [3 /*break*/, 5];
-                case 4:
-                    _a = _b.sent();
-                    return [3 /*break*/, 5];
-                case 5: return [2 /*return*/, { activated: activated, failed: failed, initTimeMs: performance.now() - startTime }];
+async function activateControllerRegistry(dbPath, verbose) {
+    const startTime = performance.now();
+    const activated = [];
+    const failed = [];
+    try {
+        const bridge = await getBridge();
+        if (!bridge) {
+            return { activated, failed, initTimeMs: performance.now() - startTime };
+        }
+        const registry = await bridge.getControllerRegistry(dbPath);
+        if (!registry) {
+            return { activated, failed, initTimeMs: performance.now() - startTime };
+        }
+        // Collect controller status from the registry
+        if (typeof registry.listControllers === 'function') {
+            const controllers = registry.listControllers();
+            for (const ctrl of controllers) {
+                if (ctrl.enabled) {
+                    activated.push(ctrl.name);
+                }
+                else {
+                    failed.push(ctrl.name);
+                }
             }
-        });
-    });
+        }
+        if (verbose && activated.length > 0) {
+            console.log(`ControllerRegistry: ${activated.length} controllers activated`);
+        }
+    }
+    catch {
+        // ControllerRegistry activation is best-effort
+    }
+    return { activated, failed, initTimeMs: performance.now() - startTime };
 }
 /**
  * Initialize the memory database properly using sql.js
  */
-export function initializeMemoryDatabase(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var _a, backend, customPath, _b, force, _c, verbose, _d, migrate, swarmDir, dbPath, dbDir, legacyCheck, db, usedSqlJs, initSqlJs, SQL, e_1, data, buffer, schemaPath, controllerResult, schemaPath, sqliteHeader, controllerResult, error_2;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    _a = options.backend, backend = _a === void 0 ? 'hybrid' : _a, customPath = options.dbPath, _b = options.force, force = _b === void 0 ? false : _b, _c = options.verbose, verbose = _c === void 0 ? false : _c, _d = options.migrate, migrate = _d === void 0 ? true : _d;
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    dbPath = customPath || path.join(swarmDir, 'memory.db');
-                    dbDir = path.dirname(dbPath);
-                    _e.label = 1;
-                case 1:
-                    _e.trys.push([1, 13, , 14]);
-                    // Create directory if needed
-                    if (!fs.existsSync(dbDir)) {
-                        fs.mkdirSync(dbDir, { recursive: true });
-                    }
-                    if (!migrate) return [3 /*break*/, 3];
-                    return [4 /*yield*/, checkAndMigrateLegacy({ dbPath: dbPath, verbose: verbose })];
-                case 2:
-                    legacyCheck = _e.sent();
-                    if (legacyCheck.needsMigration && verbose) {
-                        console.log("Found legacy database (v" + legacyCheck.legacyVersion + ") with " + legacyCheck.legacyEntries + " entries");
-                    }
-                    _e.label = 3;
-                case 3:
-                    // Check existing database
-                    if (fs.existsSync(dbPath) && !force) {
-                        return [2 /*return*/, {
-                                success: false,
-                                backend: backend,
-                                dbPath: dbPath,
-                                schemaVersion: '3.0.0',
-                                tablesCreated: [],
-                                indexesCreated: [],
-                                features: {
-                                    vectorEmbeddings: false,
-                                    patternLearning: false,
-                                    temporalDecay: false,
-                                    hnswIndexing: false,
-                                    migrationTracking: false
-                                },
-                                error: 'Database already exists. Use --force to reinitialize.'
-                            }];
-                    }
-                    db = void 0;
-                    usedSqlJs = false;
-                    _e.label = 4;
-                case 4:
-                    _e.trys.push([4, 7, , 8]);
-                    return [4 /*yield*/, import('sql.js')];
-                case 5:
-                    initSqlJs = (_e.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 6:
-                    SQL = _e.sent();
-                    // Load existing database or create new
-                    if (fs.existsSync(dbPath) && force) {
-                        fs.unlinkSync(dbPath);
-                    }
-                    db = new SQL.Database();
-                    usedSqlJs = true;
-                    return [3 /*break*/, 8];
-                case 7:
-                    e_1 = _e.sent();
-                    // sql.js not available, fall back to writing schema file
-                    if (verbose) {
-                        console.log('sql.js not available, writing schema file for later initialization');
-                    }
-                    return [3 /*break*/, 8];
-                case 8:
-                    if (!(usedSqlJs && db)) return [3 /*break*/, 10];
-                    // Execute schema
-                    db.run(MEMORY_SCHEMA_V3);
-                    // Insert initial metadata
-                    db.run(getInitialMetadata(backend));
-                    data = db["export"]();
-                    buffer = Buffer.from(data);
-                    fs.writeFileSync(dbPath, buffer);
-                    // Close database
-                    db.close();
-                    schemaPath = path.join(dbDir, 'schema.sql');
-                    fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
-                    return [4 /*yield*/, activateControllerRegistry(dbPath, verbose)];
-                case 9:
-                    controllerResult = _e.sent();
-                    return [2 /*return*/, {
-                            success: true,
-                            backend: backend,
-                            dbPath: dbPath,
-                            schemaVersion: '3.0.0',
-                            tablesCreated: [
-                                'memory_entries',
-                                'patterns',
-                                'pattern_history',
-                                'trajectories',
-                                'trajectory_steps',
-                                'migration_state',
-                                'sessions',
-                                'vector_indexes',
-                                'metadata'
-                            ],
-                            indexesCreated: [
-                                'idx_memory_namespace',
-                                'idx_memory_key',
-                                'idx_memory_type',
-                                'idx_memory_status',
-                                'idx_memory_created',
-                                'idx_memory_accessed',
-                                'idx_memory_owner',
-                                'idx_patterns_type',
-                                'idx_patterns_confidence',
-                                'idx_patterns_status',
-                                'idx_patterns_last_matched',
-                                'idx_pattern_history_pattern',
-                                'idx_steps_trajectory'
-                            ],
-                            features: {
-                                vectorEmbeddings: true,
-                                patternLearning: true,
-                                temporalDecay: true,
-                                hnswIndexing: true,
-                                migrationTracking: true
-                            },
-                            controllers: controllerResult
-                        }];
-                case 10:
-                    schemaPath = path.join(dbDir, 'schema.sql');
-                    fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
-                    sqliteHeader = Buffer.alloc(4096, 0);
-                    // SQLite format 3 header
-                    Buffer.from('SQLite format 3\0').copy(sqliteHeader, 0);
-                    sqliteHeader[16] = 0x10; // page size high byte (4096)
-                    sqliteHeader[17] = 0x00; // page size low byte
-                    sqliteHeader[18] = 0x01; // file format write version
-                    sqliteHeader[19] = 0x01; // file format read version
-                    sqliteHeader[24] = 0x00; // max embedded payload
-                    sqliteHeader[25] = 0x40;
-                    sqliteHeader[26] = 0x20; // min embedded payload
-                    sqliteHeader[27] = 0x20; // leaf payload
-                    fs.writeFileSync(dbPath, sqliteHeader);
-                    return [4 /*yield*/, activateControllerRegistry(dbPath, verbose)];
-                case 11:
-                    controllerResult = _e.sent();
-                    return [2 /*return*/, {
-                            success: true,
-                            backend: backend,
-                            dbPath: dbPath,
-                            schemaVersion: '3.0.0',
-                            tablesCreated: [
-                                'memory_entries (pending)',
-                                'patterns (pending)',
-                                'pattern_history (pending)',
-                                'trajectories (pending)',
-                                'trajectory_steps (pending)',
-                                'migration_state (pending)',
-                                'sessions (pending)',
-                                'vector_indexes (pending)',
-                                'metadata (pending)'
-                            ],
-                            indexesCreated: [],
-                            features: {
-                                vectorEmbeddings: true,
-                                patternLearning: true,
-                                temporalDecay: true,
-                                hnswIndexing: true,
-                                migrationTracking: true
-                            },
-                            controllers: controllerResult
-                        }];
-                case 12: return [3 /*break*/, 14];
-                case 13:
-                    error_2 = _e.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            backend: backend,
-                            dbPath: dbPath,
-                            schemaVersion: '3.0.0',
-                            tablesCreated: [],
-                            indexesCreated: [],
-                            features: {
-                                vectorEmbeddings: false,
-                                patternLearning: false,
-                                temporalDecay: false,
-                                hnswIndexing: false,
-                                migrationTracking: false
-                            },
-                            error: error_2 instanceof Error ? error_2.message : String(error_2)
-                        }];
-                case 14: return [2 /*return*/];
+export async function initializeMemoryDatabase(options) {
+    const { backend = 'hybrid', dbPath: customPath, force = false, verbose = false, migrate = true } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbDir = path.dirname(dbPath);
+    try {
+        // Create directory if needed
+        if (!fs.existsSync(dbDir)) {
+            fs.mkdirSync(dbDir, { recursive: true });
+        }
+        // Check for legacy installations
+        if (migrate) {
+            const legacyCheck = await checkAndMigrateLegacy({ dbPath, verbose });
+            if (legacyCheck.needsMigration && verbose) {
+                console.log(`Found legacy database (v${legacyCheck.legacyVersion}) with ${legacyCheck.legacyEntries} entries`);
             }
-        });
-    });
+        }
+        // Check existing database
+        if (fs.existsSync(dbPath) && !force) {
+            return {
+                success: false,
+                backend,
+                dbPath,
+                schemaVersion: '3.0.0',
+                tablesCreated: [],
+                indexesCreated: [],
+                features: {
+                    vectorEmbeddings: false,
+                    patternLearning: false,
+                    temporalDecay: false,
+                    hnswIndexing: false,
+                    migrationTracking: false
+                },
+                error: 'Database already exists. Use --force to reinitialize.'
+            };
+        }
+        // Try to use sql.js (WASM SQLite)
+        let db;
+        let usedSqlJs = false;
+        try {
+            // Dynamic import of sql.js
+            const initSqlJs = (await import('sql.js')).default;
+            const SQL = await initSqlJs();
+            // Load existing database or create new
+            if (fs.existsSync(dbPath) && force) {
+                fs.unlinkSync(dbPath);
+            }
+            db = new SQL.Database();
+            usedSqlJs = true;
+        }
+        catch (e) {
+            // sql.js not available, fall back to writing schema file
+            if (verbose) {
+                console.log('sql.js not available, writing schema file for later initialization');
+            }
+        }
+        if (usedSqlJs && db) {
+            // Execute schema
+            db.run(MEMORY_SCHEMA_V3);
+            // Insert initial metadata
+            db.run(getInitialMetadata(backend));
+            // Save to file
+            const data = db.export();
+            const buffer = Buffer.from(data);
+            fs.writeFileSync(dbPath, buffer);
+            // Close database
+            db.close();
+            // Also create schema file for reference
+            const schemaPath = path.join(dbDir, 'schema.sql');
+            fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
+            // ADR-053: Activate ControllerRegistry so controllers (ReasoningBank,
+            // SkillLibrary, ExplainableRecall, etc.) are instantiated during init
+            const controllerResult = await activateControllerRegistry(dbPath, verbose);
+            return {
+                success: true,
+                backend,
+                dbPath,
+                schemaVersion: '3.0.0',
+                tablesCreated: [
+                    'memory_entries',
+                    'patterns',
+                    'pattern_history',
+                    'trajectories',
+                    'trajectory_steps',
+                    'migration_state',
+                    'sessions',
+                    'vector_indexes',
+                    'metadata'
+                ],
+                indexesCreated: [
+                    'idx_memory_namespace',
+                    'idx_memory_key',
+                    'idx_memory_type',
+                    'idx_memory_status',
+                    'idx_memory_created',
+                    'idx_memory_accessed',
+                    'idx_memory_owner',
+                    'idx_patterns_type',
+                    'idx_patterns_confidence',
+                    'idx_patterns_status',
+                    'idx_patterns_last_matched',
+                    'idx_pattern_history_pattern',
+                    'idx_steps_trajectory'
+                ],
+                features: {
+                    vectorEmbeddings: true,
+                    patternLearning: true,
+                    temporalDecay: true,
+                    hnswIndexing: true,
+                    migrationTracking: true
+                },
+                controllers: controllerResult,
+            };
+        }
+        else {
+            // Fall back to schema file approach
+            const schemaPath = path.join(dbDir, 'schema.sql');
+            fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
+            // Create minimal valid SQLite file
+            const sqliteHeader = Buffer.alloc(4096, 0);
+            // SQLite format 3 header
+            Buffer.from('SQLite format 3\0').copy(sqliteHeader, 0);
+            sqliteHeader[16] = 0x10; // page size high byte (4096)
+            sqliteHeader[17] = 0x00; // page size low byte
+            sqliteHeader[18] = 0x01; // file format write version
+            sqliteHeader[19] = 0x01; // file format read version
+            sqliteHeader[24] = 0x00; // max embedded payload
+            sqliteHeader[25] = 0x40;
+            sqliteHeader[26] = 0x20; // min embedded payload
+            sqliteHeader[27] = 0x20; // leaf payload
+            fs.writeFileSync(dbPath, sqliteHeader);
+            // ADR-053: Activate ControllerRegistry even on fallback path
+            const controllerResult = await activateControllerRegistry(dbPath, verbose);
+            return {
+                success: true,
+                backend,
+                dbPath,
+                schemaVersion: '3.0.0',
+                tablesCreated: [
+                    'memory_entries (pending)',
+                    'patterns (pending)',
+                    'pattern_history (pending)',
+                    'trajectories (pending)',
+                    'trajectory_steps (pending)',
+                    'migration_state (pending)',
+                    'sessions (pending)',
+                    'vector_indexes (pending)',
+                    'metadata (pending)'
+                ],
+                indexesCreated: [],
+                features: {
+                    vectorEmbeddings: true,
+                    patternLearning: true,
+                    temporalDecay: true,
+                    hnswIndexing: true,
+                    migrationTracking: true
+                },
+                controllers: controllerResult,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            backend,
+            dbPath,
+            schemaVersion: '3.0.0',
+            tablesCreated: [],
+            indexesCreated: [],
+            features: {
+                vectorEmbeddings: false,
+                patternLearning: false,
+                temporalDecay: false,
+                hnswIndexing: false,
+                migrationTracking: false
+            },
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 /**
  * Check if memory database is properly initialized
  */
-export function checkMemoryInitialization(dbPath) {
-    var _a, _b, _c, _d, _e, _f;
-    return __awaiter(this, void 0, Promise, function () {
-        var swarmDir, path_, initSqlJs, SQL, fileBuffer, db, tables, tableNames, version, backend, versionResult, backendResult, _g;
-        return __generator(this, function (_h) {
-            switch (_h.label) {
-                case 0:
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    path_ = dbPath || path.join(swarmDir, 'memory.db');
-                    if (!fs.existsSync(path_)) {
-                        return [2 /*return*/, { initialized: false }];
-                    }
-                    _h.label = 1;
-                case 1:
-                    _h.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, import('sql.js')];
-                case 2:
-                    initSqlJs = (_h.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 3:
-                    SQL = _h.sent();
-                    fileBuffer = fs.readFileSync(path_);
-                    db = new SQL.Database(fileBuffer);
-                    tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
-                    tableNames = ((_b = (_a = tables[0]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b.map(function (v) { return v[0]; })) || [];
-                    version = 'unknown';
-                    backend = 'unknown';
-                    try {
-                        versionResult = db.exec("SELECT value FROM metadata WHERE key='schema_version'");
-                        version = ((_d = (_c = versionResult[0]) === null || _c === void 0 ? void 0 : _c.values[0]) === null || _d === void 0 ? void 0 : _d[0]) || 'unknown';
-                        backendResult = db.exec("SELECT value FROM metadata WHERE key='backend'");
-                        backend = ((_f = (_e = backendResult[0]) === null || _e === void 0 ? void 0 : _e.values[0]) === null || _f === void 0 ? void 0 : _f[0]) || 'unknown';
-                    }
-                    catch (_j) {
-                        // Metadata table might not exist
-                    }
-                    db.close();
-                    return [2 /*return*/, {
-                            initialized: true,
-                            version: version,
-                            backend: backend,
-                            features: {
-                                vectorEmbeddings: tableNames.includes('vector_indexes'),
-                                patternLearning: tableNames.includes('patterns'),
-                                temporalDecay: tableNames.includes('pattern_history')
-                            },
-                            tables: tableNames
-                        }];
-                case 4:
-                    _g = _h.sent();
-                    // Could not read database
-                    return [2 /*return*/, { initialized: false }];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function checkMemoryInitialization(dbPath) {
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const path_ = dbPath || path.join(swarmDir, 'memory.db');
+    if (!fs.existsSync(path_)) {
+        return { initialized: false };
+    }
+    try {
+        // Try to load with sql.js
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(path_);
+        const db = new SQL.Database(fileBuffer);
+        // Check for metadata table
+        const tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
+        const tableNames = tables[0]?.values?.map(v => v[0]) || [];
+        // Get version
+        let version = 'unknown';
+        let backend = 'unknown';
+        try {
+            const versionResult = db.exec("SELECT value FROM metadata WHERE key='schema_version'");
+            version = versionResult[0]?.values[0]?.[0] || 'unknown';
+            const backendResult = db.exec("SELECT value FROM metadata WHERE key='backend'");
+            backend = backendResult[0]?.values[0]?.[0] || 'unknown';
+        }
+        catch {
+            // Metadata table might not exist
+        }
+        db.close();
+        return {
+            initialized: true,
+            version,
+            backend,
+            features: {
+                vectorEmbeddings: tableNames.includes('vector_indexes'),
+                patternLearning: tableNames.includes('patterns'),
+                temporalDecay: tableNames.includes('pattern_history')
+            },
+            tables: tableNames
+        };
+    }
+    catch {
+        // Could not read database
+        return { initialized: false };
+    }
 }
 /**
  * Apply temporal decay to patterns
  * Reduces confidence of patterns that haven't been used recently
  */
-export function applyTemporalDecay(dbPath) {
-    return __awaiter(this, void 0, Promise, function () {
-        var swarmDir, path_, initSqlJs, SQL, fileBuffer, db, now, decayQuery, changes, data, error_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    path_ = dbPath || path.join(swarmDir, 'memory.db');
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, import('sql.js')];
-                case 2:
-                    initSqlJs = (_a.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 3:
-                    SQL = _a.sent();
-                    fileBuffer = fs.readFileSync(path_);
-                    db = new SQL.Database(fileBuffer);
-                    now = Date.now();
-                    decayQuery = "\n      UPDATE patterns\n      SET\n        confidence = confidence * (1.0 - decay_rate * ((? - COALESCE(last_matched_at, created_at)) / 86400000.0)),\n        updated_at = ?\n      WHERE status = 'active'\n        AND confidence > 0.1\n        AND (? - COALESCE(last_matched_at, created_at)) > 86400000\n    ";
-                    db.run(decayQuery, [now, now, now]);
-                    changes = db.getRowsModified();
-                    data = db["export"]();
-                    fs.writeFileSync(path_, Buffer.from(data));
-                    db.close();
-                    return [2 /*return*/, {
-                            success: true,
-                            patternsDecayed: changes
-                        }];
-                case 4:
-                    error_3 = _a.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            patternsDecayed: 0,
-                            error: error_3 instanceof Error ? error_3.message : String(error_3)
-                        }];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function applyTemporalDecay(dbPath) {
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const path_ = dbPath || path.join(swarmDir, 'memory.db');
+    try {
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(path_);
+        const db = new SQL.Database(fileBuffer);
+        // Apply decay: confidence *= exp(-decay_rate * days_since_last_use)
+        const now = Date.now();
+        const decayQuery = `
+      UPDATE patterns
+      SET
+        confidence = confidence * (1.0 - decay_rate * ((? - COALESCE(last_matched_at, created_at)) / 86400000.0)),
+        updated_at = ?
+      WHERE status = 'active'
+        AND confidence > 0.1
+        AND (? - COALESCE(last_matched_at, created_at)) > 86400000
+    `;
+        db.run(decayQuery, [now, now, now]);
+        const changes = db.getRowsModified();
+        // Save
+        const data = db.export();
+        fs.writeFileSync(path_, Buffer.from(data));
+        db.close();
+        return {
+            success: true,
+            patternsDecayed: changes
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            patternsDecayed: 0,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
-var embeddingModelState = null;
+let embeddingModelState = null;
 /**
  * Lazy load ONNX embedding model
  * Only loads when first embedding is requested
  */
-export function loadEmbeddingModel(options) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var _b, verbose, startTime, bridge, bridgeResult, transformers, pipeline, embedder, reasoningBank, ruvector, onnxEmb_1, probe, _c, agenticFlow, error_4;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    _b = (options || {}).verbose, verbose = _b === void 0 ? false : _b;
-                    startTime = Date.now();
-                    // Already loaded
-                    if (embeddingModelState === null || embeddingModelState === void 0 ? void 0 : embeddingModelState.loaded) {
-                        return [2 /*return*/, {
-                                success: true,
-                                dimensions: embeddingModelState.dimensions,
-                                modelName: 'cached',
-                                loadTime: 0
-                            }];
-                    }
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _d.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeLoadEmbeddingModel()];
-                case 2:
-                    bridgeResult = _d.sent();
-                    if (bridgeResult && bridgeResult.success) {
-                        // Mark local state as loaded too so subsequent calls use cache
-                        embeddingModelState = {
-                            loaded: true,
-                            model: null,
-                            tokenizer: null,
-                            dimensions: bridgeResult.dimensions
-                        };
-                        return [2 /*return*/, bridgeResult];
-                    }
-                    _d.label = 3;
-                case 3:
-                    _d.trys.push([3, 16, , 17]);
-                    return [4 /*yield*/, import('@xenova/transformers')["catch"](function () { return null; })];
-                case 4:
-                    transformers = _d.sent();
-                    if (!transformers) return [3 /*break*/, 6];
-                    if (verbose) {
-                        console.log('Loading ONNX embedding model (all-MiniLM-L6-v2)...');
-                    }
-                    pipeline = transformers.pipeline;
-                    return [4 /*yield*/, pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2')];
-                case 5:
-                    embedder = _d.sent();
-                    embeddingModelState = {
-                        loaded: true,
-                        model: embedder,
-                        tokenizer: null,
-                        dimensions: 384 // MiniLM-L6 produces 384-dim vectors
-                    };
-                    return [2 /*return*/, {
-                            success: true,
-                            dimensions: 384,
-                            modelName: 'all-MiniLM-L6-v2',
-                            loadTime: Date.now() - startTime
-                        }];
-                case 6: return [4 /*yield*/, import('agentic-flow/reasoningbank')["catch"](function () { return null; })];
-                case 7:
-                    reasoningBank = _d.sent();
-                    if (reasoningBank === null || reasoningBank === void 0 ? void 0 : reasoningBank.computeEmbedding) {
-                        if (verbose) {
-                            console.log('Loading agentic-flow ReasoningBank embedding model...');
-                        }
-                        embeddingModelState = {
-                            loaded: true,
-                            model: { embed: reasoningBank.computeEmbedding },
-                            tokenizer: null,
-                            dimensions: 768
-                        };
-                        return [2 /*return*/, {
-                                success: true,
-                                dimensions: 768,
-                                modelName: 'agentic-flow/reasoningbank',
-                                loadTime: Date.now() - startTime
-                            }];
-                    }
-                    return [4 /*yield*/, import('ruvector')["catch"](function () { return null; })];
-                case 8:
-                    ruvector = _d.sent();
-                    if (!(ruvector === null || ruvector === void 0 ? void 0 : ruvector.initOnnxEmbedder)) return [3 /*break*/, 14];
-                    _d.label = 9;
-                case 9:
-                    _d.trys.push([9, 13, , 14]);
-                    return [4 /*yield*/, ruvector.initOnnxEmbedder()];
-                case 10:
-                    _d.sent();
-                    onnxEmb_1 = (_a = ruvector.getOptimizedOnnxEmbedder) === null || _a === void 0 ? void 0 : _a.call(ruvector);
-                    if (!(onnxEmb_1 === null || onnxEmb_1 === void 0 ? void 0 : onnxEmb_1.embed)) return [3 /*break*/, 12];
-                    return [4 /*yield*/, onnxEmb_1.embed('test')];
-                case 11:
-                    probe = _d.sent();
-                    if (probe && probe.length > 0 && (Array.isArray(probe) ? probe.some(function (v) { return v !== 0; }) : true)) {
+export async function loadEmbeddingModel(options) {
+    const { verbose = false } = options || {};
+    const startTime = Date.now();
+    // Already loaded
+    if (embeddingModelState?.loaded) {
+        return {
+            success: true,
+            dimensions: embeddingModelState.dimensions,
+            modelName: 'cached',
+            loadTime: 0
+        };
+    }
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeLoadEmbeddingModel();
+        if (bridgeResult && bridgeResult.success) {
+            // Mark local state as loaded too so subsequent calls use cache
+            embeddingModelState = {
+                loaded: true,
+                model: null, // Bridge handles embedding
+                tokenizer: null,
+                dimensions: bridgeResult.dimensions
+            };
+            return bridgeResult;
+        }
+    }
+    try {
+        // Try to import @xenova/transformers for ONNX embeddings
+        const transformers = await import('@xenova/transformers').catch(() => null);
+        if (transformers) {
+            if (verbose) {
+                console.log('Loading ONNX embedding model (all-MiniLM-L6-v2)...');
+            }
+            // Use small, fast model for local embeddings
+            const { pipeline } = transformers;
+            const embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+            embeddingModelState = {
+                loaded: true,
+                model: embedder,
+                tokenizer: null,
+                dimensions: 384 // MiniLM-L6 produces 384-dim vectors
+            };
+            return {
+                success: true,
+                dimensions: 384,
+                modelName: 'all-MiniLM-L6-v2',
+                loadTime: Date.now() - startTime
+            };
+        }
+        // Fallback: Check for agentic-flow ReasoningBank embeddings (v3)
+        const reasoningBank = await import('agentic-flow/reasoningbank').catch(() => null);
+        if (reasoningBank?.computeEmbedding) {
+            if (verbose) {
+                console.log('Loading agentic-flow ReasoningBank embedding model...');
+            }
+            embeddingModelState = {
+                loaded: true,
+                model: { embed: reasoningBank.computeEmbedding },
+                tokenizer: null,
+                dimensions: 768
+            };
+            return {
+                success: true,
+                dimensions: 768,
+                modelName: 'agentic-flow/reasoningbank',
+                loadTime: Date.now() - startTime
+            };
+        }
+        // Fallback: Check for ruvector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
+        // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
+        // Note: isReady() returns false until first embed() call (lazy init), so we
+        // skip the isReady() gate and verify with a probe embed instead.
+        const ruvector = await import('ruvector').catch(() => null);
+        if (ruvector?.initOnnxEmbedder) {
+            try {
+                await ruvector.initOnnxEmbedder();
+                // Fallback: OptimizedOnnxEmbedder (raw ONNX, lazy-inits on first embed)
+                const onnxEmb = ruvector.getOptimizedOnnxEmbedder?.();
+                if (onnxEmb?.embed) {
+                    // Probe embed to trigger lazy ONNX init and verify it works
+                    const probe = await onnxEmb.embed('test');
+                    if (probe && probe.length > 0 && (Array.isArray(probe) ? probe.some((v) => v !== 0) : true)) {
                         if (verbose) {
-                            console.log("Loading ruvector ONNX embedder (all-MiniLM-L6-v2, " + probe.length + "d)...");
+                            console.log(`Loading ruvector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
                         }
                         embeddingModelState = {
                             loaded: true,
-                            model: function (text) { return onnxEmb_1.embed(text); },
+                            model: (text) => onnxEmb.embed(text),
                             tokenizer: null,
                             dimensions: probe.length || 384
                         };
-                        return [2 /*return*/, {
-                                success: true,
-                                dimensions: probe.length || 384,
-                                modelName: 'ruvector/onnx',
-                                loadTime: Date.now() - startTime
-                            }];
-                    }
-                    _d.label = 12;
-                case 12: return [3 /*break*/, 14];
-                case 13:
-                    _c = _d.sent();
-                    return [3 /*break*/, 14];
-                case 14: return [4 /*yield*/, import('agentic-flow')["catch"](function () { return null; })];
-                case 15:
-                    agenticFlow = _d.sent();
-                    if (agenticFlow && agenticFlow.embeddings) {
-                        if (verbose) {
-                            console.log('Loading agentic-flow embedding model...');
-                        }
-                        embeddingModelState = {
-                            loaded: true,
-                            model: agenticFlow.embeddings,
-                            tokenizer: null,
-                            dimensions: 768
-                        };
-                        return [2 /*return*/, {
-                                success: true,
-                                dimensions: 768,
-                                modelName: 'agentic-flow',
-                                loadTime: Date.now() - startTime
-                            }];
-                    }
-                    // No ONNX model available - use fallback
-                    embeddingModelState = {
-                        loaded: true,
-                        model: null,
-                        tokenizer: null,
-                        dimensions: 128 // Smaller fallback dimensions
-                    };
-                    return [2 /*return*/, {
+                        return {
                             success: true,
-                            dimensions: 128,
-                            modelName: 'hash-fallback',
+                            dimensions: probe.length || 384,
+                            modelName: 'ruvector/onnx',
                             loadTime: Date.now() - startTime
-                        }];
-                case 16:
-                    error_4 = _d.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            dimensions: 0,
-                            modelName: 'none',
-                            error: error_4 instanceof Error ? error_4.message : String(error_4)
-                        }];
-                case 17: return [2 /*return*/];
+                        };
+                    }
+                }
             }
-        });
-    });
+            catch {
+                // ruvector ONNX init failed, continue to next fallback
+            }
+        }
+        // Legacy fallback: Check for agentic-flow core embeddings
+        const agenticFlow = await import('agentic-flow').catch(() => null);
+        if (agenticFlow && agenticFlow.embeddings) {
+            if (verbose) {
+                console.log('Loading agentic-flow embedding model...');
+            }
+            embeddingModelState = {
+                loaded: true,
+                model: agenticFlow.embeddings,
+                tokenizer: null,
+                dimensions: 768
+            };
+            return {
+                success: true,
+                dimensions: 768,
+                modelName: 'agentic-flow',
+                loadTime: Date.now() - startTime
+            };
+        }
+        // No ONNX model available - use fallback
+        embeddingModelState = {
+            loaded: true,
+            model: null, // Will use simple hash-based fallback
+            tokenizer: null,
+            dimensions: 128 // Smaller fallback dimensions
+        };
+        return {
+            success: true,
+            dimensions: 128,
+            modelName: 'hash-fallback',
+            loadTime: Date.now() - startTime
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            dimensions: 0,
+            modelName: 'none',
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 /**
  * Generate real embedding for text
  * Uses ONNX model if available, falls back to deterministic hash
  */
-export function generateEmbedding(text) {
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, state, output, embedding_1, _a, embedding;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeGenerateEmbedding(text)];
-                case 2:
-                    bridgeResult = _b.sent();
-                    if (bridgeResult)
-                        return [2 /*return*/, bridgeResult];
-                    _b.label = 3;
-                case 3:
-                    if (!!(embeddingModelState === null || embeddingModelState === void 0 ? void 0 : embeddingModelState.loaded)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, loadEmbeddingModel()];
-                case 4:
-                    _b.sent();
-                    _b.label = 5;
-                case 5:
-                    state = embeddingModelState;
-                    if (!(state.model && typeof state.model === 'function')) return [3 /*break*/, 9];
-                    _b.label = 6;
-                case 6:
-                    _b.trys.push([6, 8, , 9]);
-                    return [4 /*yield*/, state.model(text, { pooling: 'mean', normalize: true })];
-                case 7:
-                    output = _b.sent();
-                    embedding_1 = (output === null || output === void 0 ? void 0 : output.data)
-                        ? Array.from(output.data)
-                        : Array.isArray(output) ? output : null;
-                    if (embedding_1) {
-                        return [2 /*return*/, {
-                                embedding: embedding_1,
-                                dimensions: embedding_1.length,
-                                model: 'onnx'
-                            }];
-                    }
-                    return [3 /*break*/, 9];
-                case 8:
-                    _a = _b.sent();
-                    return [3 /*break*/, 9];
-                case 9:
-                    embedding = generateHashEmbedding(text, state.dimensions);
-                    return [2 /*return*/, {
-                            embedding: embedding,
-                            dimensions: state.dimensions,
-                            model: 'hash-fallback'
-                        }];
+export async function generateEmbedding(text) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeGenerateEmbedding(text);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Ensure model is loaded
+    if (!embeddingModelState?.loaded) {
+        await loadEmbeddingModel();
+    }
+    const state = embeddingModelState;
+    // Use ONNX model if available
+    if (state.model && typeof state.model === 'function') {
+        try {
+            const output = await state.model(text, { pooling: 'mean', normalize: true });
+            // Handle both @xenova/transformers (output.data) and ruvector (plain array) formats
+            const embedding = output?.data
+                ? Array.from(output.data)
+                : Array.isArray(output) ? output : null;
+            if (embedding) {
+                return {
+                    embedding,
+                    dimensions: embedding.length,
+                    model: 'onnx'
+                };
             }
-        });
-    });
+        }
+        catch {
+            // Fall through to fallback
+        }
+    }
+    // Deterministic hash-based fallback (for testing/demo without ONNX)
+    const embedding = generateHashEmbedding(text, state.dimensions);
+    return {
+        embedding,
+        dimensions: state.dimensions,
+        model: 'hash-fallback'
+    };
 }
 /**
  * Generate embeddings for multiple texts
@@ -1362,510 +1447,437 @@ export function generateEmbedding(text) {
  * @param options - Batch options
  * @returns Array of embedding results with timing info
  */
-export function generateBatchEmbeddings(texts, options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var _a, _b, concurrency, onProgress, startTime, embeddings, totalTime_1, results, completed, i, chunk, chunkResults, totalTime;
-        var _this = this;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    _a = options || {}, _b = _a.concurrency, concurrency = _b === void 0 ? texts.length : _b, onProgress = _a.onProgress;
-                    startTime = Date.now();
-                    if (!!(embeddingModelState === null || embeddingModelState === void 0 ? void 0 : embeddingModelState.loaded)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, loadEmbeddingModel()];
-                case 1:
-                    _c.sent();
-                    _c.label = 2;
-                case 2:
-                    if (!(concurrency >= texts.length)) return [3 /*break*/, 4];
-                    return [4 /*yield*/, Promise.all(texts.map(function (text, i) { return __awaiter(_this, void 0, void 0, function () {
-                            var result;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, generateEmbedding(text)];
-                                    case 1:
-                                        result = _a.sent();
-                                        onProgress === null || onProgress === void 0 ? void 0 : onProgress(i + 1, texts.length);
-                                        return [2 /*return*/, __assign({ text: text }, result)];
-                                }
-                            });
-                        }); }))];
-                case 3:
-                    embeddings = _c.sent();
-                    totalTime_1 = Date.now() - startTime;
-                    return [2 /*return*/, {
-                            results: embeddings,
-                            totalTime: totalTime_1,
-                            avgTime: totalTime_1 / texts.length
-                        }];
-                case 4:
-                    results = [];
-                    completed = 0;
-                    i = 0;
-                    _c.label = 5;
-                case 5:
-                    if (!(i < texts.length)) return [3 /*break*/, 8];
-                    chunk = texts.slice(i, i + concurrency);
-                    return [4 /*yield*/, Promise.all(chunk.map(function (text) { return __awaiter(_this, void 0, void 0, function () {
-                            var result;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, generateEmbedding(text)];
-                                    case 1:
-                                        result = _a.sent();
-                                        completed++;
-                                        onProgress === null || onProgress === void 0 ? void 0 : onProgress(completed, texts.length);
-                                        return [2 /*return*/, __assign({ text: text }, result)];
-                                }
-                            });
-                        }); }))];
-                case 6:
-                    chunkResults = _c.sent();
-                    results.push.apply(results, chunkResults);
-                    _c.label = 7;
-                case 7:
-                    i += concurrency;
-                    return [3 /*break*/, 5];
-                case 8:
-                    totalTime = Date.now() - startTime;
-                    return [2 /*return*/, {
-                            results: results,
-                            totalTime: totalTime,
-                            avgTime: totalTime / texts.length
-                        }];
-            }
-        });
-    });
+export async function generateBatchEmbeddings(texts, options) {
+    const { concurrency = texts.length, onProgress } = options || {};
+    const startTime = Date.now();
+    // Ensure model is loaded first (prevents cold start in parallel)
+    if (!embeddingModelState?.loaded) {
+        await loadEmbeddingModel();
+    }
+    // Process in parallel with optional concurrency limit
+    if (concurrency >= texts.length) {
+        // Full parallelism
+        const embeddings = await Promise.all(texts.map(async (text, i) => {
+            const result = await generateEmbedding(text);
+            onProgress?.(i + 1, texts.length);
+            return { text, ...result };
+        }));
+        const totalTime = Date.now() - startTime;
+        return {
+            results: embeddings,
+            totalTime,
+            avgTime: totalTime / texts.length
+        };
+    }
+    // Limited concurrency using chunking
+    const results = [];
+    let completed = 0;
+    for (let i = 0; i < texts.length; i += concurrency) {
+        const chunk = texts.slice(i, i + concurrency);
+        const chunkResults = await Promise.all(chunk.map(async (text) => {
+            const result = await generateEmbedding(text);
+            completed++;
+            onProgress?.(completed, texts.length);
+            return { text, ...result };
+        }));
+        results.push(...chunkResults);
+    }
+    const totalTime = Date.now() - startTime;
+    return {
+        results,
+        totalTime,
+        avgTime: totalTime / texts.length
+    };
 }
 /**
  * Generate deterministic hash-based embedding
  * Not semantic, but deterministic and useful for testing
  */
 function generateHashEmbedding(text, dimensions) {
-    var embedding = new Array(dimensions).fill(0);
+    const embedding = new Array(dimensions).fill(0);
     // Simple hash-based approach for reproducibility
-    var words = text.toLowerCase().split(/\s+/);
-    for (var i = 0; i < words.length; i++) {
-        var word = words[i];
-        for (var j = 0; j < word.length; j++) {
-            var charCode = word.charCodeAt(j);
-            var idx = (charCode * (i + 1) * (j + 1)) % dimensions;
+    const words = text.toLowerCase().split(/\s+/);
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        for (let j = 0; j < word.length; j++) {
+            const charCode = word.charCodeAt(j);
+            const idx = (charCode * (i + 1) * (j + 1)) % dimensions;
             embedding[idx] += Math.sin(charCode * 0.1) * 0.1;
         }
     }
     // Normalize to unit vector
-    var magnitude = Math.sqrt(embedding.reduce(function (sum, v) { return sum + v * v; }, 0)) || 1;
-    return embedding.map(function (v) { return v / magnitude; });
+    const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0)) || 1;
+    return embedding.map(v => v / magnitude);
 }
 /**
  * Verify memory initialization works correctly
  * Tests: write, read, search, patterns
  */
-export function verifyMemoryInit(dbPath, options) {
-    var _a, _b, _c, _d, _e;
-    return __awaiter(this, void 0, Promise, function () {
-        var _f, verbose, tests, initSqlJs, SQL, fs_1, fileBuffer, db, schemaStart, tables, tableNames_1, expectedTables, missingTables, writeStart, testId, testKey, testValue, readStart, result, content, embeddingStart, _g, embedding, dimensions, model, embeddingJson, e_2, patternStart, patternId, indexStart, indexResult, indexes, data, passed, failed, error_5;
-        return __generator(this, function (_h) {
-            switch (_h.label) {
-                case 0:
-                    _f = (options || {}).verbose, verbose = _f === void 0 ? false : _f;
-                    tests = [];
-                    _h.label = 1;
-                case 1:
-                    _h.trys.push([1, 9, , 10]);
-                    return [4 /*yield*/, import('sql.js')];
-                case 2:
-                    initSqlJs = (_h.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 3:
-                    SQL = _h.sent();
-                    return [4 /*yield*/, import('fs')];
-                case 4:
-                    fs_1 = _h.sent();
-                    fileBuffer = fs_1.readFileSync(dbPath);
-                    db = new SQL.Database(fileBuffer);
-                    schemaStart = Date.now();
-                    tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
-                    tableNames_1 = ((_b = (_a = tables[0]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b.map(function (v) { return v[0]; })) || [];
-                    expectedTables = ['memory_entries', 'patterns', 'metadata', 'vector_indexes'];
-                    missingTables = expectedTables.filter(function (t) { return !tableNames_1.includes(t); });
-                    tests.push({
-                        name: 'Schema verification',
-                        passed: missingTables.length === 0,
-                        details: missingTables.length > 0 ? "Missing: " + missingTables.join(', ') : tableNames_1.length + " tables found",
-                        duration: Date.now() - schemaStart
-                    });
-                    writeStart = Date.now();
-                    testId = "test_" + Date.now();
-                    testKey = 'verification_test';
-                    testValue = 'This is a verification test entry for memory initialization';
-                    try {
-                        db.run("\n        INSERT INTO memory_entries (id, key, namespace, content, type, created_at, updated_at)\n        VALUES (?, ?, 'test', ?, 'semantic', ?, ?)\n      ", [testId, testKey, testValue, Date.now(), Date.now()]);
-                        tests.push({
-                            name: 'Write entry',
-                            passed: true,
-                            details: 'Entry written successfully',
-                            duration: Date.now() - writeStart
-                        });
-                    }
-                    catch (e) {
-                        tests.push({
-                            name: 'Write entry',
-                            passed: false,
-                            details: e instanceof Error ? e.message : 'Write failed',
-                            duration: Date.now() - writeStart
-                        });
-                    }
-                    readStart = Date.now();
-                    try {
-                        result = db.exec("SELECT content FROM memory_entries WHERE id = ?", [testId]);
-                        content = (_d = (_c = result[0]) === null || _c === void 0 ? void 0 : _c.values[0]) === null || _d === void 0 ? void 0 : _d[0];
-                        tests.push({
-                            name: 'Read entry',
-                            passed: content === testValue,
-                            details: content === testValue ? 'Content matches' : 'Content mismatch',
-                            duration: Date.now() - readStart
-                        });
-                    }
-                    catch (e) {
-                        tests.push({
-                            name: 'Read entry',
-                            passed: false,
-                            details: e instanceof Error ? e.message : 'Read failed',
-                            duration: Date.now() - readStart
-                        });
-                    }
-                    embeddingStart = Date.now();
-                    _h.label = 5;
-                case 5:
-                    _h.trys.push([5, 7, , 8]);
-                    return [4 /*yield*/, generateEmbedding(testValue)];
-                case 6:
-                    _g = _h.sent(), embedding = _g.embedding, dimensions = _g.dimensions, model = _g.model;
-                    embeddingJson = JSON.stringify(embedding);
-                    db.run("\n        UPDATE memory_entries\n        SET embedding = ?, embedding_dimensions = ?, embedding_model = ?\n        WHERE id = ?\n      ", [embeddingJson, dimensions, model, testId]);
-                    tests.push({
-                        name: 'Generate embedding',
-                        passed: true,
-                        details: dimensions + "-dim vector (" + model + ")",
-                        duration: Date.now() - embeddingStart
-                    });
-                    return [3 /*break*/, 8];
-                case 7:
-                    e_2 = _h.sent();
-                    tests.push({
-                        name: 'Generate embedding',
-                        passed: false,
-                        details: e_2 instanceof Error ? e_2.message : 'Embedding failed',
-                        duration: Date.now() - embeddingStart
-                    });
-                    return [3 /*break*/, 8];
-                case 8:
-                    patternStart = Date.now();
-                    try {
-                        patternId = "pattern_" + Date.now();
-                        db.run("\n        INSERT INTO patterns (id, name, pattern_type, condition, action, confidence, created_at, updated_at)\n        VALUES (?, 'test-pattern', 'task-routing', 'test condition', 'test action', 0.5, ?, ?)\n      ", [patternId, Date.now(), Date.now()]);
-                        tests.push({
-                            name: 'Pattern storage',
-                            passed: true,
-                            details: 'Pattern stored with confidence scoring',
-                            duration: Date.now() - patternStart
-                        });
-                        // Cleanup test pattern
-                        db.run("DELETE FROM patterns WHERE id = ?", [patternId]);
-                    }
-                    catch (e) {
-                        tests.push({
-                            name: 'Pattern storage',
-                            passed: false,
-                            details: e instanceof Error ? e.message : 'Pattern storage failed',
-                            duration: Date.now() - patternStart
-                        });
-                    }
-                    indexStart = Date.now();
-                    try {
-                        indexResult = db.exec("SELECT name, dimensions, hnsw_m, hnsw_ef_construction FROM vector_indexes");
-                        indexes = ((_e = indexResult[0]) === null || _e === void 0 ? void 0 : _e.values) || [];
-                        tests.push({
-                            name: 'Vector index config',
-                            passed: indexes.length > 0,
-                            details: indexes.length + " indexes configured (HNSW M=16, ef=200)",
-                            duration: Date.now() - indexStart
-                        });
-                    }
-                    catch (e) {
-                        tests.push({
-                            name: 'Vector index config',
-                            passed: false,
-                            details: e instanceof Error ? e.message : 'Index check failed',
-                            duration: Date.now() - indexStart
-                        });
-                    }
-                    // Cleanup test entry
-                    db.run("DELETE FROM memory_entries WHERE id = ?", [testId]);
-                    data = db["export"]();
-                    fs_1.writeFileSync(dbPath, Buffer.from(data));
-                    db.close();
-                    passed = tests.filter(function (t) { return t.passed; }).length;
-                    failed = tests.filter(function (t) { return !t.passed; }).length;
-                    return [2 /*return*/, {
-                            success: failed === 0,
-                            tests: tests,
-                            summary: {
-                                passed: passed,
-                                failed: failed,
-                                total: tests.length
-                            }
-                        }];
-                case 9:
-                    error_5 = _h.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            tests: [{
-                                    name: 'Database access',
-                                    passed: false,
-                                    details: error_5 instanceof Error ? error_5.message : 'Unknown error'
-                                }],
-                            summary: { passed: 0, failed: 1, total: 1 }
-                        }];
-                case 10: return [2 /*return*/];
-            }
+export async function verifyMemoryInit(dbPath, options) {
+    const { verbose = false } = options || {};
+    const tests = [];
+    try {
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fs = await import('fs');
+        // Load database
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        // Test 1: Schema verification
+        const schemaStart = Date.now();
+        const tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
+        const tableNames = tables[0]?.values?.map(v => v[0]) || [];
+        const expectedTables = ['memory_entries', 'patterns', 'metadata', 'vector_indexes'];
+        const missingTables = expectedTables.filter(t => !tableNames.includes(t));
+        tests.push({
+            name: 'Schema verification',
+            passed: missingTables.length === 0,
+            details: missingTables.length > 0 ? `Missing: ${missingTables.join(', ')}` : `${tableNames.length} tables found`,
+            duration: Date.now() - schemaStart
         });
-    });
+        // Test 2: Write entry
+        const writeStart = Date.now();
+        const testId = `test_${Date.now()}`;
+        const testKey = 'verification_test';
+        const testValue = 'This is a verification test entry for memory initialization';
+        try {
+            db.run(`
+        INSERT INTO memory_entries (id, key, namespace, content, type, created_at, updated_at)
+        VALUES (?, ?, 'test', ?, 'semantic', ?, ?)
+      `, [testId, testKey, testValue, Date.now(), Date.now()]);
+            tests.push({
+                name: 'Write entry',
+                passed: true,
+                details: 'Entry written successfully',
+                duration: Date.now() - writeStart
+            });
+        }
+        catch (e) {
+            tests.push({
+                name: 'Write entry',
+                passed: false,
+                details: e instanceof Error ? e.message : 'Write failed',
+                duration: Date.now() - writeStart
+            });
+        }
+        // Test 3: Read entry
+        const readStart = Date.now();
+        try {
+            const result = db.exec(`SELECT content FROM memory_entries WHERE id = ?`, [testId]);
+            const content = result[0]?.values[0]?.[0];
+            tests.push({
+                name: 'Read entry',
+                passed: content === testValue,
+                details: content === testValue ? 'Content matches' : 'Content mismatch',
+                duration: Date.now() - readStart
+            });
+        }
+        catch (e) {
+            tests.push({
+                name: 'Read entry',
+                passed: false,
+                details: e instanceof Error ? e.message : 'Read failed',
+                duration: Date.now() - readStart
+            });
+        }
+        // Test 4: Write with embedding
+        const embeddingStart = Date.now();
+        try {
+            const { embedding, dimensions, model } = await generateEmbedding(testValue);
+            const embeddingJson = JSON.stringify(embedding);
+            db.run(`
+        UPDATE memory_entries
+        SET embedding = ?, embedding_dimensions = ?, embedding_model = ?
+        WHERE id = ?
+      `, [embeddingJson, dimensions, model, testId]);
+            tests.push({
+                name: 'Generate embedding',
+                passed: true,
+                details: `${dimensions}-dim vector (${model})`,
+                duration: Date.now() - embeddingStart
+            });
+        }
+        catch (e) {
+            tests.push({
+                name: 'Generate embedding',
+                passed: false,
+                details: e instanceof Error ? e.message : 'Embedding failed',
+                duration: Date.now() - embeddingStart
+            });
+        }
+        // Test 5: Pattern storage
+        const patternStart = Date.now();
+        try {
+            const patternId = `pattern_${Date.now()}`;
+            db.run(`
+        INSERT INTO patterns (id, name, pattern_type, condition, action, confidence, created_at, updated_at)
+        VALUES (?, 'test-pattern', 'task-routing', 'test condition', 'test action', 0.5, ?, ?)
+      `, [patternId, Date.now(), Date.now()]);
+            tests.push({
+                name: 'Pattern storage',
+                passed: true,
+                details: 'Pattern stored with confidence scoring',
+                duration: Date.now() - patternStart
+            });
+            // Cleanup test pattern
+            db.run(`DELETE FROM patterns WHERE id = ?`, [patternId]);
+        }
+        catch (e) {
+            tests.push({
+                name: 'Pattern storage',
+                passed: false,
+                details: e instanceof Error ? e.message : 'Pattern storage failed',
+                duration: Date.now() - patternStart
+            });
+        }
+        // Test 6: Vector index configuration
+        const indexStart = Date.now();
+        try {
+            const indexResult = db.exec(`SELECT name, dimensions, hnsw_m, hnsw_ef_construction FROM vector_indexes`);
+            const indexes = indexResult[0]?.values || [];
+            tests.push({
+                name: 'Vector index config',
+                passed: indexes.length > 0,
+                details: `${indexes.length} indexes configured (HNSW M=16, ef=200)`,
+                duration: Date.now() - indexStart
+            });
+        }
+        catch (e) {
+            tests.push({
+                name: 'Vector index config',
+                passed: false,
+                details: e instanceof Error ? e.message : 'Index check failed',
+                duration: Date.now() - indexStart
+            });
+        }
+        // Cleanup test entry
+        db.run(`DELETE FROM memory_entries WHERE id = ?`, [testId]);
+        // Save changes
+        const data = db.export();
+        fs.writeFileSync(dbPath, Buffer.from(data));
+        db.close();
+        const passed = tests.filter(t => t.passed).length;
+        const failed = tests.filter(t => !t.passed).length;
+        return {
+            success: failed === 0,
+            tests,
+            summary: {
+                passed,
+                failed,
+                total: tests.length
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            tests: [{
+                    name: 'Database access',
+                    passed: false,
+                    details: error instanceof Error ? error.message : 'Unknown error'
+                }],
+            summary: { passed: 0, failed: 1, total: 1 }
+        };
+    }
 }
 /**
  * Store an entry directly using sql.js
  * This bypasses MCP and writes directly to the database
  */
-export function storeEntry(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, key, value, _a, namespace, _b, generateEmbeddingFlag, _c, tags, ttl, customPath, _d, upsert, swarmDir, dbPath, initSqlJs, SQL, fileBuffer, db, id, now, embeddingJson, embeddingDimensions, embeddingModel, embResult, insertSql, data, embResult, error_6;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _e.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeStoreEntry(options)];
-                case 2:
-                    bridgeResult = _e.sent();
-                    if (bridgeResult)
-                        return [2 /*return*/, bridgeResult];
-                    _e.label = 3;
-                case 3:
-                    key = options.key, value = options.value, _a = options.namespace, namespace = _a === void 0 ? 'default' : _a, _b = options.generateEmbeddingFlag, generateEmbeddingFlag = _b === void 0 ? true : _b, _c = options.tags, tags = _c === void 0 ? [] : _c, ttl = options.ttl, customPath = options.dbPath, _d = options.upsert, upsert = _d === void 0 ? false : _d;
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    dbPath = customPath || path.join(swarmDir, 'memory.db');
-                    _e.label = 4;
-                case 4:
-                    _e.trys.push([4, 12, , 13]);
-                    if (!fs.existsSync(dbPath)) {
-                        return [2 /*return*/, { success: false, id: '', error: 'Database not initialized. Run: claude-flow memory init' }];
-                    }
-                    // Ensure schema has all required columns (migration for older DBs)
-                    return [4 /*yield*/, ensureSchemaColumns(dbPath)];
-                case 5:
-                    // Ensure schema has all required columns (migration for older DBs)
-                    _e.sent();
-                    return [4 /*yield*/, import('sql.js')];
-                case 6:
-                    initSqlJs = (_e.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 7:
-                    SQL = _e.sent();
-                    fileBuffer = fs.readFileSync(dbPath);
-                    db = new SQL.Database(fileBuffer);
-                    id = "entry_" + Date.now() + "_" + Math.random().toString(36).substring(7);
-                    now = Date.now();
-                    embeddingJson = null;
-                    embeddingDimensions = null;
-                    embeddingModel = null;
-                    if (!(generateEmbeddingFlag && value.length > 0)) return [3 /*break*/, 9];
-                    return [4 /*yield*/, generateEmbedding(value)];
-                case 8:
-                    embResult = _e.sent();
-                    embeddingJson = JSON.stringify(embResult.embedding);
-                    embeddingDimensions = embResult.dimensions;
-                    embeddingModel = embResult.model;
-                    _e.label = 9;
-                case 9:
-                    insertSql = 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')";
-                    db.run(insertSql, [
-                        id,
-                        key,
-                        namespace,
-                        value,
-                        embeddingJson,
-                        embeddingDimensions,
-                        embeddingModel,
-                        tags.length > 0 ? JSON.stringify(tags) : null,
-                        '{}',
-                        now,
-                        now,
-                        ttl ? now + (ttl * 1000) : null
-                    ]);
-                    data = db["export"]();
-                    fs.writeFileSync(dbPath, Buffer.from(data));
-                    db.close();
-                    if (!embeddingJson) return [3 /*break*/, 11];
-                    embResult = JSON.parse(embeddingJson);
-                    return [4 /*yield*/, addToHNSWIndex(id, embResult, {
-                            id: id,
-                            key: key,
-                            namespace: namespace,
-                            content: value
-                        })];
-                case 10:
-                    _e.sent();
-                    _e.label = 11;
-                case 11: return [2 /*return*/, {
-                        success: true,
-                        id: id,
-                        embedding: embeddingJson ? { dimensions: embeddingDimensions, model: embeddingModel } : undefined
-                    }];
-                case 12:
-                    error_6 = _e.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            id: '',
-                            error: error_6 instanceof Error ? error_6.message : String(error_6)
-                        }];
-                case 13: return [2 /*return*/];
-            }
-        });
-    });
+export async function storeEntry(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeStoreEntry(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: false, id: '', error: 'Database not initialized. Run: claude-flow memory init' };
+        }
+        // Ensure schema has all required columns (migration for older DBs)
+        await ensureSchemaColumns(dbPath);
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        const id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        const now = Date.now();
+        // Generate embedding if requested
+        let embeddingJson = null;
+        let embeddingDimensions = null;
+        let embeddingModel = null;
+        if (generateEmbeddingFlag && value.length > 0) {
+            const embResult = await generateEmbedding(value);
+            embeddingJson = JSON.stringify(embResult.embedding);
+            embeddingDimensions = embResult.dimensions;
+            embeddingModel = embResult.model;
+        }
+        // Insert or update entry (upsert mode uses REPLACE)
+        const insertSql = upsert
+            ? `INSERT OR REPLACE INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          tags, metadata, created_at, updated_at, expires_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')`
+            : `INSERT INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          tags, metadata, created_at, updated_at, expires_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')`;
+        db.run(insertSql, [
+            id,
+            key,
+            namespace,
+            value,
+            embeddingJson,
+            embeddingDimensions,
+            embeddingModel,
+            tags.length > 0 ? JSON.stringify(tags) : null,
+            '{}',
+            now,
+            now,
+            ttl ? now + (ttl * 1000) : null
+        ]);
+        // Save
+        const data = db.export();
+        fs.writeFileSync(dbPath, Buffer.from(data));
+        db.close();
+        // Add to HNSW index for faster future searches
+        if (embeddingJson) {
+            const embResult = JSON.parse(embeddingJson);
+            await addToHNSWIndex(id, embResult, {
+                id,
+                key,
+                namespace,
+                content: value
+            });
+        }
+        return {
+            success: true,
+            id,
+            embedding: embeddingJson ? { dimensions: embeddingDimensions, model: embeddingModel } : undefined
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            id: '',
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 /**
  * Search entries using sql.js with vector similarity
  * Uses HNSW index for 150x faster search when available
  */
-export function searchEntries(options) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, query, _b, namespace, _c, limit, _d, threshold, customPath, swarmDir, dbPath, startTime, queryEmb, queryEmbedding, hnswResults, filtered, initSqlJs, SQL, fileBuffer, db, searchStmt, searchRows, entries, results, _loop_1, _i, _e, row, error_7;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _f.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeSearchEntries(options)];
-                case 2:
-                    bridgeResult = _f.sent();
-                    if (bridgeResult)
-                        return [2 /*return*/, bridgeResult];
-                    _f.label = 3;
-                case 3:
-                    query = options.query, _b = options.namespace, namespace = _b === void 0 ? 'default' : _b, _c = options.limit, limit = _c === void 0 ? 10 : _c, _d = options.threshold, threshold = _d === void 0 ? 0.3 : _d, customPath = options.dbPath;
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    dbPath = customPath || path.join(swarmDir, 'memory.db');
-                    startTime = Date.now();
-                    _f.label = 4;
-                case 4:
-                    _f.trys.push([4, 10, , 11]);
-                    if (!fs.existsSync(dbPath)) {
-                        return [2 /*return*/, { success: false, results: [], searchTime: 0, error: 'Database not found' }];
-                    }
-                    // Ensure schema has all required columns (migration for older DBs)
-                    return [4 /*yield*/, ensureSchemaColumns(dbPath)];
-                case 5:
-                    // Ensure schema has all required columns (migration for older DBs)
-                    _f.sent();
-                    return [4 /*yield*/, generateEmbedding(query)];
-                case 6:
-                    queryEmb = _f.sent();
-                    queryEmbedding = queryEmb.embedding;
-                    return [4 /*yield*/, searchHNSWIndex(queryEmbedding, { k: limit, namespace: namespace })];
-                case 7:
-                    hnswResults = _f.sent();
-                    if (hnswResults && hnswResults.length > 0) {
-                        filtered = hnswResults.filter(function (r) { return r.score >= threshold; });
-                        return [2 /*return*/, {
-                                success: true,
-                                results: filtered,
-                                searchTime: Date.now() - startTime
-                            }];
-                    }
-                    return [4 /*yield*/, import('sql.js')];
-                case 8:
-                    initSqlJs = (_f.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 9:
-                    SQL = _f.sent();
-                    fileBuffer = fs.readFileSync(dbPath);
-                    db = new SQL.Database(fileBuffer);
-                    searchStmt = db.prepare(namespace !== 'all'
-                        ? "SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' AND namespace = ? LIMIT 1000"
-                        : "SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' LIMIT 1000");
-                    if (namespace !== 'all') {
-                        searchStmt.bind([namespace]);
-                    }
-                    searchRows = [];
-                    while (searchStmt.step()) {
-                        searchRows.push(searchStmt.get());
+export async function searchEntries(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeSearchEntries(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { query, namespace = 'default', limit = 10, threshold = 0.3, dbPath: customPath } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const startTime = Date.now();
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: false, results: [], searchTime: 0, error: 'Database not found' };
+        }
+        // Ensure schema has all required columns (migration for older DBs)
+        await ensureSchemaColumns(dbPath);
+        // Generate query embedding
+        const queryEmb = await generateEmbedding(query);
+        const queryEmbedding = queryEmb.embedding;
+        // Try HNSW search first (150x faster)
+        const hnswResults = await searchHNSWIndex(queryEmbedding, { k: limit, namespace });
+        if (hnswResults && hnswResults.length > 0) {
+            // Filter by threshold
+            const filtered = hnswResults.filter(r => r.score >= threshold);
+            return {
+                success: true,
+                results: filtered,
+                searchTime: Date.now() - startTime
+            };
+        }
+        // Fall back to brute-force SQLite search
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        // Get entries with embeddings
+        const searchStmt = db.prepare(namespace !== 'all'
+            ? `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' AND namespace = ? LIMIT 1000`
+            : `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' LIMIT 1000`);
+        if (namespace !== 'all') {
+            searchStmt.bind([namespace]);
+        }
+        const searchRows = [];
+        while (searchStmt.step()) {
+            searchRows.push(searchStmt.get());
+        }
+        searchStmt.free();
+        const entries = searchRows.length > 0 ? [{ values: searchRows }] : [];
+        const results = [];
+        if (entries[0]?.values) {
+            for (const row of entries[0].values) {
+                const [id, key, ns, content, embeddingJson] = row;
+                let score = 0;
+                if (embeddingJson) {
+                    try {
+                        const embedding = JSON.parse(embeddingJson);
+                        score = cosineSim(queryEmbedding, embedding);
                     }
-                    searchStmt.free();
-                    entries = searchRows.length > 0 ? [{ values: searchRows }] : [];
-                    results = [];
-                    if ((_a = entries[0]) === null || _a === void 0 ? void 0 : _a.values) {
-                        _loop_1 = function (row) {
-                            var _g = row, id = _g[0], key = _g[1], ns = _g[2], content = _g[3], embeddingJson = _g[4];
-                            var score = 0;
-                            if (embeddingJson) {
-                                try {
-                                    var embedding = JSON.parse(embeddingJson);
-                                    score = cosineSim(queryEmbedding, embedding);
-                                }
-                                catch (_h) {
-                                    // Invalid embedding, use keyword score
-                                }
-                            }
-                            // Fallback to keyword matching
-                            if (score < threshold) {
-                                var lowerContent_1 = (content || '').toLowerCase();
-                                var lowerQuery = query.toLowerCase();
-                                var words = lowerQuery.split(/\s+/);
-                                var matchCount = words.filter(function (w) { return lowerContent_1.includes(w); }).length;
-                                var keywordScore = matchCount / words.length * 0.5;
-                                score = Math.max(score, keywordScore);
-                            }
-                            if (score >= threshold) {
-                                results.push({
-                                    id: id.substring(0, 12),
-                                    key: key || id.substring(0, 15),
-                                    content: (content || '').substring(0, 60) + ((content || '').length > 60 ? '...' : ''),
-                                    score: score,
-                                    namespace: ns || 'default'
-                                });
-                            }
-                        };
-                        for (_i = 0, _e = entries[0].values; _i < _e.length; _i++) {
-                            row = _e[_i];
-                            _loop_1(row);
-                        }
+                    catch {
+                        // Invalid embedding, use keyword score
                     }
-                    db.close();
-                    // Sort by score
-                    results.sort(function (a, b) { return b.score - a.score; });
-                    return [2 /*return*/, {
-                            success: true,
-                            results: results.slice(0, limit),
-                            searchTime: Date.now() - startTime
-                        }];
-                case 10:
-                    error_7 = _f.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            results: [],
-                            searchTime: Date.now() - startTime,
-                            error: error_7 instanceof Error ? error_7.message : String(error_7)
-                        }];
-                case 11: return [2 /*return*/];
+                }
+                // Fallback to keyword matching
+                if (score < threshold) {
+                    const lowerContent = (content || '').toLowerCase();
+                    const lowerQuery = query.toLowerCase();
+                    const words = lowerQuery.split(/\s+/);
+                    const matchCount = words.filter(w => lowerContent.includes(w)).length;
+                    const keywordScore = matchCount / words.length * 0.5;
+                    score = Math.max(score, keywordScore);
+                }
+                if (score >= threshold) {
+                    results.push({
+                        id: id.substring(0, 12),
+                        key: key || id.substring(0, 15),
+                        content: (content || '').substring(0, 60) + ((content || '').length > 60 ? '...' : ''),
+                        score,
+                        namespace: ns || 'default'
+                    });
+                }
             }
-        });
-    });
+        }
+        db.close();
+        // Sort by score
+        results.sort((a, b) => b.score - a.score);
+        return {
+            success: true,
+            results: results.slice(0, limit),
+            searchTime: Date.now() - startTime
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            results: [],
+            searchTime: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 /**
  * Optimized cosine similarity
@@ -1875,348 +1887,321 @@ export function searchEntries(options) {
 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;
+    const len = Math.min(a.length, b.length);
+    let dot = 0, normA = 0, normB = 0;
     // Simple loop - V8 optimizes this well
-    for (var i = 0; i < len; i++) {
-        var ai = a[i], bi = b[i];
+    for (let i = 0; i < len; i++) {
+        const ai = a[i], bi = b[i];
         dot += ai * bi;
         normA += ai * ai;
         normB += bi * bi;
     }
     // Combined sqrt for slightly better performance
-    var mag = Math.sqrt(normA * normB);
+    const mag = Math.sqrt(normA * normB);
     return mag === 0 ? 0 : dot / mag;
 }
 /**
  * List all entries from the memory database
  */
-export function listEntries(options) {
-    var _a, _b, _c, _d;
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, namespace, _e, limit, _f, offset, customPath, swarmDir, dbPath, initSqlJs, SQL, fileBuffer, db, countStmt, countRows, countResult, total, safeLimit, safeOffset, listStmt, listRows, result, entries, _i, _g, row, _h, id, key, ns, content, embedding, accessCount, createdAt, updatedAt, error_8;
-        return __generator(this, function (_j) {
-            switch (_j.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _j.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeListEntries(options)];
-                case 2:
-                    bridgeResult = _j.sent();
-                    if (bridgeResult)
-                        return [2 /*return*/, bridgeResult];
-                    _j.label = 3;
-                case 3:
-                    namespace = options.namespace, _e = options.limit, limit = _e === void 0 ? 20 : _e, _f = options.offset, offset = _f === void 0 ? 0 : _f, customPath = options.dbPath;
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    dbPath = customPath || path.join(swarmDir, 'memory.db');
-                    _j.label = 4;
-                case 4:
-                    _j.trys.push([4, 8, , 9]);
-                    if (!fs.existsSync(dbPath)) {
-                        return [2 /*return*/, { success: false, entries: [], total: 0, error: 'Database not found' }];
-                    }
-                    // Ensure schema has all required columns (migration for older DBs)
-                    return [4 /*yield*/, ensureSchemaColumns(dbPath)];
-                case 5:
-                    // Ensure schema has all required columns (migration for older DBs)
-                    _j.sent();
-                    return [4 /*yield*/, import('sql.js')];
-                case 6:
-                    initSqlJs = (_j.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 7:
-                    SQL = _j.sent();
-                    fileBuffer = fs.readFileSync(dbPath);
-                    db = new SQL.Database(fileBuffer);
-                    countStmt = namespace
-                        ? db.prepare("SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = ?")
-                        : db.prepare("SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'");
-                    if (namespace) {
-                        countStmt.bind([namespace]);
-                    }
-                    countRows = [];
-                    while (countStmt.step()) {
-                        countRows.push(countStmt.get());
-                    }
-                    countStmt.free();
-                    countResult = countRows.length > 0 ? [{ values: countRows }] : [];
-                    total = ((_c = (_b = (_a = countResult[0]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c[0]) || 0;
-                    safeLimit = parseInt(String(limit), 10) || 100;
-                    safeOffset = parseInt(String(offset), 10) || 0;
-                    listStmt = namespace
-                        ? db.prepare("SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' AND namespace = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?")
-                        : db.prepare("SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' ORDER BY updated_at DESC LIMIT ? OFFSET ?");
-                    if (namespace) {
-                        listStmt.bind([namespace, safeLimit, safeOffset]);
-                    }
-                    else {
-                        listStmt.bind([safeLimit, safeOffset]);
-                    }
-                    listRows = [];
-                    while (listStmt.step()) {
-                        listRows.push(listStmt.get());
-                    }
-                    listStmt.free();
-                    result = listRows.length > 0 ? [{ values: listRows }] : [];
-                    entries = [];
-                    if ((_d = result[0]) === null || _d === void 0 ? void 0 : _d.values) {
-                        for (_i = 0, _g = result[0].values; _i < _g.length; _i++) {
-                            row = _g[_i];
-                            _h = row, id = _h[0], key = _h[1], ns = _h[2], content = _h[3], embedding = _h[4], accessCount = _h[5], createdAt = _h[6], updatedAt = _h[7];
-                            entries.push({
-                                id: String(id).substring(0, 20),
-                                key: key || String(id).substring(0, 15),
-                                namespace: ns || 'default',
-                                size: (content || '').length,
-                                accessCount: accessCount || 0,
-                                createdAt: createdAt || new Date().toISOString(),
-                                updatedAt: updatedAt || new Date().toISOString(),
-                                hasEmbedding: !!embedding && embedding.length > 10
-                            });
-                        }
-                    }
-                    db.close();
-                    return [2 /*return*/, { success: true, entries: entries, total: total }];
-                case 8:
-                    error_8 = _j.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            entries: [],
-                            total: 0,
-                            error: error_8 instanceof Error ? error_8.message : String(error_8)
-                        }];
-                case 9: return [2 /*return*/];
+export async function listEntries(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeListEntries(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: false, entries: [], total: 0, error: 'Database not found' };
+        }
+        // Ensure schema has all required columns (migration for older DBs)
+        await ensureSchemaColumns(dbPath);
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        // Get total count
+        const countStmt = namespace
+            ? db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = ?`)
+            : db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
+        if (namespace) {
+            countStmt.bind([namespace]);
+        }
+        const countRows = [];
+        while (countStmt.step()) {
+            countRows.push(countStmt.get());
+        }
+        countStmt.free();
+        const countResult = countRows.length > 0 ? [{ values: countRows }] : [];
+        const total = countResult[0]?.values?.[0]?.[0] || 0;
+        // Get entries
+        const safeLimit = parseInt(String(limit), 10) || 100;
+        const safeOffset = parseInt(String(offset), 10) || 0;
+        const listStmt = namespace
+            ? db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' AND namespace = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?`)
+            : db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' ORDER BY updated_at DESC LIMIT ? OFFSET ?`);
+        if (namespace) {
+            listStmt.bind([namespace, safeLimit, safeOffset]);
+        }
+        else {
+            listStmt.bind([safeLimit, safeOffset]);
+        }
+        const listRows = [];
+        while (listStmt.step()) {
+            listRows.push(listStmt.get());
+        }
+        listStmt.free();
+        const result = listRows.length > 0 ? [{ values: listRows }] : [];
+        const entries = [];
+        if (result[0]?.values) {
+            for (const row of result[0].values) {
+                const [id, key, ns, content, embedding, accessCount, createdAt, updatedAt] = row;
+                entries.push({
+                    id: String(id).substring(0, 20),
+                    key: key || String(id).substring(0, 15),
+                    namespace: ns || 'default',
+                    size: (content || '').length,
+                    accessCount: accessCount || 0,
+                    createdAt: createdAt || new Date().toISOString(),
+                    updatedAt: updatedAt || new Date().toISOString(),
+                    hasEmbedding: !!embedding && embedding.length > 10
+                });
             }
-        });
-    });
+        }
+        db.close();
+        return { success: true, entries, total };
+    }
+    catch (error) {
+        return {
+            success: false,
+            entries: [],
+            total: 0,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 /**
  * Get a specific entry from the memory database
  */
-export function getEntry(options) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, key, _c, namespace, customPath, swarmDir, dbPath, initSqlJs, SQL, fileBuffer, db, getStmt, getRows, result, _d, id, entryKey, ns, content, embedding, accessCount, createdAt, updatedAt, tagsJson, data, tags, error_9;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _e.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeGetEntry(options)];
-                case 2:
-                    bridgeResult = _e.sent();
-                    if (bridgeResult)
-                        return [2 /*return*/, bridgeResult];
-                    _e.label = 3;
-                case 3:
-                    key = options.key, _c = options.namespace, namespace = _c === void 0 ? 'default' : _c, customPath = options.dbPath;
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    dbPath = customPath || path.join(swarmDir, 'memory.db');
-                    _e.label = 4;
-                case 4:
-                    _e.trys.push([4, 8, , 9]);
-                    if (!fs.existsSync(dbPath)) {
-                        return [2 /*return*/, { success: false, found: false, error: 'Database not found' }];
-                    }
-                    // Ensure schema has all required columns (migration for older DBs)
-                    return [4 /*yield*/, ensureSchemaColumns(dbPath)];
-                case 5:
-                    // Ensure schema has all required columns (migration for older DBs)
-                    _e.sent();
-                    return [4 /*yield*/, import('sql.js')];
-                case 6:
-                    initSqlJs = (_e.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 7:
-                    SQL = _e.sent();
-                    fileBuffer = fs.readFileSync(dbPath);
-                    db = new SQL.Database(fileBuffer);
-                    getStmt = db.prepare("\n      SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags\n      FROM memory_entries\n      WHERE status = 'active'\n        AND key = ?\n        AND namespace = ?\n      LIMIT 1\n    ");
-                    getStmt.bind([key, namespace]);
-                    getRows = [];
-                    while (getStmt.step()) {
-                        getRows.push(getStmt.get());
-                    }
-                    getStmt.free();
-                    result = getRows.length > 0 ? [{ values: getRows }] : [];
-                    if (!((_b = (_a = result[0]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b[0])) {
-                        db.close();
-                        return [2 /*return*/, { success: true, found: false }];
-                    }
-                    _d = result[0].values[0], id = _d[0], entryKey = _d[1], ns = _d[2], content = _d[3], embedding = _d[4], accessCount = _d[5], createdAt = _d[6], updatedAt = _d[7], tagsJson = _d[8];
-                    // Update access count
-                    db.run("\n      UPDATE memory_entries\n      SET access_count = access_count + 1, last_accessed_at = strftime('%s', 'now') * 1000\n      WHERE id = ?\n    ", [String(id)]);
-                    data = db["export"]();
-                    fs.writeFileSync(dbPath, Buffer.from(data));
-                    db.close();
-                    tags = [];
-                    if (tagsJson) {
-                        try {
-                            tags = JSON.parse(tagsJson);
-                        }
-                        catch (_f) {
-                            // Invalid JSON
-                        }
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            found: true,
-                            entry: {
-                                id: String(id),
-                                key: entryKey || String(id),
-                                namespace: ns || 'default',
-                                content: content || '',
-                                accessCount: (accessCount || 0) + 1,
-                                createdAt: createdAt || new Date().toISOString(),
-                                updatedAt: updatedAt || new Date().toISOString(),
-                                hasEmbedding: !!embedding && embedding.length > 10,
-                                tags: tags
-                            }
-                        }];
-                case 8:
-                    error_9 = _e.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            found: false,
-                            error: error_9 instanceof Error ? error_9.message : String(error_9)
-                        }];
-                case 9: return [2 /*return*/];
+export async function getEntry(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeGetEntry(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { key, namespace = 'default', dbPath: customPath } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return { success: false, found: false, error: 'Database not found' };
+        }
+        // Ensure schema has all required columns (migration for older DBs)
+        await ensureSchemaColumns(dbPath);
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        // Find entry by key
+        const getStmt = db.prepare(`
+      SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
+      FROM memory_entries
+      WHERE status = 'active'
+        AND key = ?
+        AND namespace = ?
+      LIMIT 1
+    `);
+        getStmt.bind([key, namespace]);
+        const getRows = [];
+        while (getStmt.step()) {
+            getRows.push(getStmt.get());
+        }
+        getStmt.free();
+        const result = getRows.length > 0 ? [{ values: getRows }] : [];
+        if (!result[0]?.values?.[0]) {
+            db.close();
+            return { success: true, found: false };
+        }
+        const [id, entryKey, ns, content, embedding, accessCount, createdAt, updatedAt, tagsJson] = result[0].values[0];
+        // Update access count
+        db.run(`
+      UPDATE memory_entries
+      SET access_count = access_count + 1, last_accessed_at = strftime('%s', 'now') * 1000
+      WHERE id = ?
+    `, [String(id)]);
+        // Save updated database
+        const data = db.export();
+        fs.writeFileSync(dbPath, Buffer.from(data));
+        db.close();
+        let tags = [];
+        if (tagsJson) {
+            try {
+                tags = JSON.parse(tagsJson);
             }
-        });
-    });
+            catch {
+                // Invalid JSON
+            }
+        }
+        return {
+            success: true,
+            found: true,
+            entry: {
+                id: String(id),
+                key: entryKey || String(id),
+                namespace: ns || 'default',
+                content: content || '',
+                accessCount: (accessCount || 0) + 1,
+                createdAt: createdAt || new Date().toISOString(),
+                updatedAt: updatedAt || new Date().toISOString(),
+                hasEmbedding: !!embedding && embedding.length > 10,
+                tags
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            found: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 /**
  * Delete a memory entry by key and namespace
  * Issue #980: Properly supports namespaced entries
  */
-export function deleteEntry(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    return __awaiter(this, void 0, Promise, function () {
-        var bridge, bridgeResult, key, _j, namespace, customPath, swarmDir, dbPath, initSqlJs, SQL, fileBuffer, db, checkStmt, checkRows, checkResult, countResult_1, remainingEntries_1, entryId, countResult, remainingEntries, data, error_10;
-        return __generator(this, function (_k) {
-            switch (_k.label) {
-                case 0: return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _k.sent();
-                    if (!bridge) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bridge.bridgeDeleteEntry(options)];
-                case 2:
-                    bridgeResult = _k.sent();
-                    if (bridgeResult)
-                        return [2 /*return*/, bridgeResult];
-                    _k.label = 3;
-                case 3:
-                    key = options.key, _j = options.namespace, namespace = _j === void 0 ? 'default' : _j, customPath = options.dbPath;
-                    swarmDir = path.join(process.cwd(), '.swarm');
-                    dbPath = customPath || path.join(swarmDir, 'memory.db');
-                    _k.label = 4;
-                case 4:
-                    _k.trys.push([4, 8, , 9]);
-                    if (!fs.existsSync(dbPath)) {
-                        return [2 /*return*/, {
-                                success: false,
-                                deleted: false,
-                                key: key,
-                                namespace: namespace,
-                                remainingEntries: 0,
-                                error: 'Database not found'
-                            }];
-                    }
-                    // Ensure schema has all required columns (migration for older DBs)
-                    return [4 /*yield*/, ensureSchemaColumns(dbPath)];
-                case 5:
-                    // Ensure schema has all required columns (migration for older DBs)
-                    _k.sent();
-                    return [4 /*yield*/, import('sql.js')];
-                case 6:
-                    initSqlJs = (_k.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 7:
-                    SQL = _k.sent();
-                    fileBuffer = fs.readFileSync(dbPath);
-                    db = new SQL.Database(fileBuffer);
-                    checkStmt = db.prepare("\n      SELECT id FROM memory_entries\n      WHERE status = 'active'\n        AND key = ?\n        AND namespace = ?\n      LIMIT 1\n    ");
-                    checkStmt.bind([key, namespace]);
-                    checkRows = [];
-                    while (checkStmt.step()) {
-                        checkRows.push(checkStmt.get());
-                    }
-                    checkStmt.free();
-                    checkResult = checkRows.length > 0 ? [{ values: checkRows }] : [];
-                    if (!((_b = (_a = checkResult[0]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b[0])) {
-                        countResult_1 = db.exec("SELECT COUNT(*) FROM memory_entries WHERE status = 'active'");
-                        remainingEntries_1 = ((_e = (_d = (_c = countResult_1[0]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e[0]) || 0;
-                        db.close();
-                        return [2 /*return*/, {
-                                success: true,
-                                deleted: false,
-                                key: key,
-                                namespace: namespace,
-                                remainingEntries: remainingEntries_1,
-                                error: "Key '" + key + "' not found in namespace '" + namespace + "'"
-                            }];
-                    }
-                    entryId = String(checkResult[0].values[0][0]);
-                    // Delete the entry (soft delete by setting status to 'deleted')
-                    // Also null out the embedding to clean up vector data from SQLite
-                    db.run("\n      UPDATE memory_entries\n      SET status = 'deleted',\n          embedding = NULL,\n          updated_at = strftime('%s', 'now') * 1000\n      WHERE key = ?\n        AND namespace = ?\n        AND status = 'active'\n    ", [key, namespace]);
-                    countResult = db.exec("SELECT COUNT(*) FROM memory_entries WHERE status = 'active'");
-                    remainingEntries = ((_h = (_g = (_f = countResult[0]) === null || _f === void 0 ? void 0 : _f.values) === null || _g === void 0 ? void 0 : _g[0]) === null || _h === void 0 ? void 0 : _h[0]) || 0;
-                    data = db["export"]();
-                    fs.writeFileSync(dbPath, Buffer.from(data));
-                    db.close();
-                    // Clean up in-memory HNSW index so ghost vectors don't appear in searches.
-                    // Remove the entry from the HNSW entries map and invalidate the index.
-                    // The next search will rebuild the HNSW index from the remaining DB rows.
-                    if (hnswIndex === null || hnswIndex === void 0 ? void 0 : hnswIndex.entries) {
-                        hnswIndex.entries["delete"](entryId);
-                        saveHNSWMetadata();
-                        // Invalidate the HNSW index so it rebuilds from DB on next search.
-                        // We can't surgically remove a vector from the HNSW graph, so we
-                        // clear the entire index; it will be lazily rebuilt from SQLite.
-                        rebuildSearchIndex();
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            deleted: true,
-                            key: key,
-                            namespace: namespace,
-                            remainingEntries: remainingEntries
-                        }];
-                case 8:
-                    error_10 = _k.sent();
-                    return [2 /*return*/, {
-                            success: false,
-                            deleted: false,
-                            key: key,
-                            namespace: namespace,
-                            remainingEntries: 0,
-                            error: error_10 instanceof Error ? error_10.message : String(error_10)
-                        }];
-                case 9: return [2 /*return*/];
-            }
-        });
-    });
+export async function deleteEntry(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeDeleteEntry(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
+    const { key, namespace = 'default', dbPath: customPath } = options;
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    try {
+        if (!fs.existsSync(dbPath)) {
+            return {
+                success: false,
+                deleted: false,
+                key,
+                namespace,
+                remainingEntries: 0,
+                error: 'Database not found'
+            };
+        }
+        // Ensure schema has all required columns (migration for older DBs)
+        await ensureSchemaColumns(dbPath);
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        // Check if entry exists first
+        const checkStmt = db.prepare(`
+      SELECT id FROM memory_entries
+      WHERE status = 'active'
+        AND key = ?
+        AND namespace = ?
+      LIMIT 1
+    `);
+        checkStmt.bind([key, namespace]);
+        const checkRows = [];
+        while (checkStmt.step()) {
+            checkRows.push(checkStmt.get());
+        }
+        checkStmt.free();
+        const checkResult = checkRows.length > 0 ? [{ values: checkRows }] : [];
+        if (!checkResult[0]?.values?.[0]) {
+            // Get remaining count before closing
+            const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
+            const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
+            db.close();
+            return {
+                success: true,
+                deleted: false,
+                key,
+                namespace,
+                remainingEntries,
+                error: `Key '${key}' not found in namespace '${namespace}'`
+            };
+        }
+        // Capture the entry ID for HNSW cleanup
+        const entryId = String(checkResult[0].values[0][0]);
+        // Delete the entry (soft delete by setting status to 'deleted')
+        // Also null out the embedding to clean up vector data from SQLite
+        db.run(`
+      UPDATE memory_entries
+      SET status = 'deleted',
+          embedding = NULL,
+          updated_at = strftime('%s', 'now') * 1000
+      WHERE key = ?
+        AND namespace = ?
+        AND status = 'active'
+    `, [key, namespace]);
+        // Get remaining count
+        const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
+        const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
+        // Save updated database
+        const data = db.export();
+        fs.writeFileSync(dbPath, Buffer.from(data));
+        db.close();
+        // Clean up in-memory HNSW index so ghost vectors don't appear in searches.
+        // Remove the entry from the HNSW entries map and invalidate the index.
+        // The next search will rebuild the HNSW index from the remaining DB rows.
+        if (hnswIndex?.entries) {
+            hnswIndex.entries.delete(entryId);
+            saveHNSWMetadata();
+            // Invalidate the HNSW index so it rebuilds from DB on next search.
+            // We can't surgically remove a vector from the HNSW graph, so we
+            // clear the entire index; it will be lazily rebuilt from SQLite.
+            rebuildSearchIndex();
+        }
+        return {
+            success: true,
+            deleted: true,
+            key,
+            namespace,
+            remainingEntries
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            deleted: false,
+            key,
+            namespace,
+            remainingEntries: 0,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
 }
 export default {
-    initializeMemoryDatabase: initializeMemoryDatabase,
-    checkMemoryInitialization: checkMemoryInitialization,
-    checkAndMigrateLegacy: checkAndMigrateLegacy,
-    ensureSchemaColumns: ensureSchemaColumns,
-    applyTemporalDecay: applyTemporalDecay,
-    loadEmbeddingModel: loadEmbeddingModel,
-    generateEmbedding: generateEmbedding,
-    verifyMemoryInit: verifyMemoryInit,
-    storeEntry: storeEntry,
-    searchEntries: searchEntries,
-    listEntries: listEntries,
-    getEntry: getEntry,
-    deleteEntry: deleteEntry,
-    rebuildSearchIndex: rebuildSearchIndex,
-    MEMORY_SCHEMA_V3: MEMORY_SCHEMA_V3,
-    getInitialMetadata: getInitialMetadata
+    initializeMemoryDatabase,
+    checkMemoryInitialization,
+    checkAndMigrateLegacy,
+    ensureSchemaColumns,
+    applyTemporalDecay,
+    loadEmbeddingModel,
+    generateEmbedding,
+    verifyMemoryInit,
+    storeEntry,
+    searchEntries,
+    listEntries,
+    getEntry,
+    deleteEntry,
+    rebuildSearchIndex,
+    MEMORY_SCHEMA_V3,
+    getInitialMetadata
 };
 //# sourceMappingURL=memory-initializer.js.map