agentic-flow 2.0.7 → 3.0.0-alpha.2

package/dist/reasoningbank/backend-selector.js.map

@@ -1 +1 @@
-{"version":3,"file":"backend-selector.js","sourceRoot":"","sources":["../../src/reasoningbank/backend-selector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,MAAM,UAAU,qBAAqB;IACnC,gCAAgC;IAChC,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;QACrE,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,yBAAyB;IACzB,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;QAC7D,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,sEAAsE;IACtE,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY;IAC1B,OAAO,OAAO,SAAS,KAAK,WAAW,CAAC;AAC1C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,SAAS;IACvB,IAAI,CAAC;QACH,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,SAAiB,eAAe,EAChC,UAOI,EAAE;IAEN,MAAM,OAAO,GAAG,OAAO,CAAC,YAAY,IAAI,qBAAqB,EAAE,CAAC;IAEhE,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,OAAO,CAAC,GAAG,CAAC,gCAAgC,OAAO,EAAE,CAAC,CAAC;QACvD,OAAO,CAAC,GAAG,CAAC,6BAA6B,MAAM,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,IAAI,OAAO,KAAK,QAAQ,EAAE,CAAC;QACzB,kCAAkC;QAClC,MAAM,mBAAmB,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,CAAC;QAEvD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,UAAU,MAAM,KAAK,CAAC;QAEvD,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,OAAO,CAAC,GAAG,CAAC,mDAAmD,CAAC,CAAC;YACjE,OAAO,CAAC,GAAG,CAAC,kCAAkC,MAAM,EAAE,CAAC,CAAC;QAC1D,CAAC;QAED,6DAA6D;QAC7D,0BAA0B;QAC1B,MAAM,mBAAmB,CAAC,UAAU,EAAE,CAAC;QAEvC,0DAA0D;QAC1D,+DAA+D;QAC/D,+DAA+D;QAC/D,OAAO,mBAAmB,CAAC;IAC7B,CAAC;SAAM,CAAC;QACN,gEAAgE;QAChE,MAAM,EAAE,mBAAmB,EAAE,GAAG,MAAM,MAAM,CAAC,mBAAmB,CAAC,CAAC;QAElE,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,WAAW,GAAG,YAAY,EAAE,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,oBAAoB,CAAC;YACrF,OAAO,CAAC,GAAG,CAAC,2CAA2C,WAAW,EAAE,CAAC,CAAC;YACtE,OAAO,CAAC,GAAG,CAAC,kCAAkC,MAAM,EAAE,CAAC,CAAC;QAC1D,CAAC;QAED,OAAO,MAAM,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc;IAC5B,MAAM,OAAO,GAAG,qBAAqB,EAAE,CAAC;IAExC,OAAO;QACL,OAAO;QACP,WAAW,EAAE,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ;QACjE,QAAQ,EAAE;YACR,UAAU,EAAE,OAAO,KAAK,QAAQ,IAAI,YAAY,EAAE;YAClD,MAAM,EAAE,OAAO,KAAK,QAAQ,IAAI,SAAS,EAAE;YAC3C,SAAS,EAAE,OAAO,KAAK,MAAM,IAAI,YAAY,EAAE;YAC/C,IAAI,EAAE,OAAO,KAAK,MAAM;SACzB;QACD,OAAO,EAAE,OAAO,KAAK,QAAQ;YAC3B,CAAC,CAAC,eAAe;YACjB,CAAC,CAAC,YAAY,EAAE;gBACd,CAAC,CAAC,qBAAqB;gBACvB,CAAC,CAAC,oBAAoB;KAC3B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB;IAKjC,MAAM,OAAO,GAAG,qBAAqB,EAAE,CAAC;IACxC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,IAAI,KAAK,GAAG,IAAI,CAAC;IAEjB,IAAI,OAAO,KAAK,QAAQ,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;QACzC,QAAQ,CAAC,IAAI,CAAC,0DAA0D,CAAC,CAAC;QAC1E,KAAK,GAAG,KAAK,CAAC;IAChB,CAAC;IAED,IAAI,OAAO,KAAK,MAAM,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;QAC3E,QAAQ,CAAC,IAAI,CAAC,0DAA0D,CAAC,CAAC;QAC1E,QAAQ,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;IAC7D,CAAC;IAED,IAAI,OAAO,KAAK,MAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QACxD,QAAQ,CAAC,IAAI,CAAC,oDAAoD,CAAC,CAAC;QACpE,QAAQ,CAAC,IAAI,CAAC,gDAAgD,CAAC,CAAC;IAClE,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AACtC,CAAC;AAED,qDAAqD;AACrD,OAAO,EAAE,mBAAmB,IAAI,gBAAgB,EAAE,CAAC","sourcesContent":["/**\n * Backend Selection Helper for ReasoningBank\n *\n * Automatically selects the optimal ReasoningBank backend based on runtime environment.\n *\n * Usage:\n * ```typescript\n * import { createOptimalReasoningBank, getRecommendedBackend } from 'agentic-flow/reasoningbank/backend-selector';\n *\n * // Automatic backend selection\n * const rb = await createOptimalReasoningBank('my-db');\n *\n * // Manual check\n * const backend = getRecommendedBackend();\n * console.log(`Using ${backend} backend`);\n * ```\n */\n\n/**\n * Detect runtime environment and recommend optimal backend\n *\n * @returns 'nodejs' for Node.js/Deno environments, 'wasm' for browsers\n */\nexport function getRecommendedBackend(): 'nodejs' | 'wasm' {\n  // Check for browser environment\n  if (typeof window !== 'undefined' && typeof document !== 'undefined') {\n    return 'wasm';\n  }\n\n  // Check for Node.js/Deno\n  if (typeof process !== 'undefined' && process.versions?.node) {\n    return 'nodejs';\n  }\n\n  // Default to WASM for unknown environments (likely web workers, etc.)\n  return 'wasm';\n}\n\n/**\n * Check if IndexedDB is available (browser environment)\n */\nexport function hasIndexedDB(): boolean {\n  return typeof indexedDB !== 'undefined';\n}\n\n/**\n * Check if SQLite native module is available (Node.js)\n */\nexport function hasSQLite(): boolean {\n  try {\n    require.resolve('better-sqlite3');\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Create ReasoningBank instance with optimal backend for current environment\n *\n * @param dbName - Database name (used differently by each backend)\n * @param options - Additional configuration options\n * @returns ReasoningBank instance using optimal backend\n *\n * @example\n * ```typescript\n * // Node.js: Creates SQLite database at .swarm/my-app.db\n * const rb = await createOptimalReasoningBank('my-app');\n *\n * // Browser: Creates IndexedDB database named 'my-app'\n * const rb = await createOptimalReasoningBank('my-app');\n * ```\n */\nexport async function createOptimalReasoningBank(\n  dbName: string = 'reasoningbank',\n  options: {\n    /** Force specific backend (overrides auto-detection) */\n    forceBackend?: 'nodejs' | 'wasm';\n    /** Custom database path (Node.js only) */\n    dbPath?: string;\n    /** Enable verbose logging */\n    verbose?: boolean;\n  } = {}\n): Promise<any> {\n  const backend = options.forceBackend || getRecommendedBackend();\n\n  if (options.verbose) {\n    console.log(`[ReasoningBank] Environment: ${backend}`);\n    console.log(`[ReasoningBank] Database: ${dbName}`);\n  }\n\n  if (backend === 'nodejs') {\n    // Import Node.js backend (SQLite)\n    const reasoningBankModule = await import('./index.js');\n\n    const dbPath = options.dbPath || `.swarm/${dbName}.db`;\n\n    if (options.verbose) {\n      console.log(`[ReasoningBank] Using Node.js backend with SQLite`);\n      console.log(`[ReasoningBank] Database path: ${dbPath}`);\n    }\n\n    // The Node.js backend uses the db module and core algorithms\n    // Initialize the database\n    await reasoningBankModule.initialize();\n\n    // Note: The Node.js backend has a different API than WASM\n    // It uses the functions from db/queries.ts and core algorithms\n    // We return the full module for direct access to all functions\n    return reasoningBankModule;\n  } else {\n    // Import WASM backend (IndexedDB in browser, Memory in Node.js)\n    const { createReasoningBank } = await import('./wasm-adapter.js');\n\n    if (options.verbose) {\n      const storageType = hasIndexedDB() ? 'IndexedDB (persistent)' : 'Memory (ephemeral)';\n      console.log(`[ReasoningBank] Using WASM backend with ${storageType}`);\n      console.log(`[ReasoningBank] Database name: ${dbName}`);\n    }\n\n    return await createReasoningBank(dbName);\n  }\n}\n\n/**\n * Get backend information and capabilities\n */\nexport function getBackendInfo() {\n  const backend = getRecommendedBackend();\n\n  return {\n    backend,\n    environment: typeof window !== 'undefined' ? 'browser' : 'nodejs',\n    features: {\n      persistent: backend === 'nodejs' || hasIndexedDB(),\n      sqlite: backend === 'nodejs' && hasSQLite(),\n      indexeddb: backend === 'wasm' && hasIndexedDB(),\n      wasm: backend === 'wasm',\n    },\n    storage: backend === 'nodejs'\n      ? 'SQLite (disk)'\n      : hasIndexedDB()\n        ? 'IndexedDB (browser)'\n        : 'Memory (ephemeral)',\n  };\n}\n\n/**\n * Validate environment and warn about limitations\n */\nexport function validateEnvironment(): {\n  valid: boolean;\n  warnings: string[];\n  backend: 'nodejs' | 'wasm';\n} {\n  const backend = getRecommendedBackend();\n  const warnings: string[] = [];\n  let valid = true;\n\n  if (backend === 'nodejs' && !hasSQLite()) {\n    warnings.push('better-sqlite3 not found - database operations will fail');\n    valid = false;\n  }\n\n  if (backend === 'wasm' && typeof window !== 'undefined' && !hasIndexedDB()) {\n    warnings.push('IndexedDB not available - using ephemeral memory storage');\n    warnings.push('Data will be lost when page/process exits');\n  }\n\n  if (backend === 'wasm' && typeof window === 'undefined') {\n    warnings.push('WASM in Node.js uses in-memory storage (ephemeral)');\n    warnings.push('Consider using Node.js backend for persistence');\n  }\n\n  return { valid, warnings, backend };\n}\n\n// Export validation helper for use in initialization\nexport { validateEnvironment as checkEnvironment };\n"]}
+{"version":3,"file":"backend-selector.js","sourceRoot":"","sources":["../../src/reasoningbank/backend-selector.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Backend Selection Helper for ReasoningBank\n *\n * Automatically selects the optimal ReasoningBank backend based on runtime environment.\n *\n * Usage:\n * ```typescript\n * import { createOptimalReasoningBank, getRecommendedBackend } from 'agentic-flow/reasoningbank/backend-selector';\n *\n * // Automatic backend selection\n * const rb = await createOptimalReasoningBank('my-db');\n *\n * // Manual check\n * const backend = getRecommendedBackend();\n * console.log(`Using ${backend} backend`);\n * ```\n */\n\n/**\n * Detect runtime environment and recommend optimal backend\n *\n * @returns 'nodejs' for Node.js/Deno environments, 'wasm' for browsers\n */\nexport function getRecommendedBackend(): 'nodejs' | 'wasm' {\n  // Check for browser environment\n  if (typeof window !== 'undefined' && typeof document !== 'undefined') {\n    return 'wasm';\n  }\n\n  // Check for Node.js/Deno\n  if (typeof process !== 'undefined' && process.versions?.node) {\n    return 'nodejs';\n  }\n\n  // Default to WASM for unknown environments (likely web workers, etc.)\n  return 'wasm';\n}\n\n/**\n * Check if IndexedDB is available (browser environment)\n */\nexport function hasIndexedDB(): boolean {\n  return typeof indexedDB !== 'undefined';\n}\n\n/**\n * Check if SQLite adapter is available (Node.js)\n * Uses sql.js pure JavaScript implementation (always available)\n */\nexport function hasSQLite(): boolean {\n  try {\n    require.resolve('./db/sql-adapter.js');\n    return true;\n  } catch {\n    // sql.js adapter should always be available\n    return true;\n  }\n}\n\n/**\n * Create ReasoningBank instance with optimal backend for current environment\n *\n * @param dbName - Database name (used differently by each backend)\n * @param options - Additional configuration options\n * @returns ReasoningBank instance using optimal backend\n *\n * @example\n * ```typescript\n * // Node.js: Creates SQLite database at .swarm/my-app.db\n * const rb = await createOptimalReasoningBank('my-app');\n *\n * // Browser: Creates IndexedDB database named 'my-app'\n * const rb = await createOptimalReasoningBank('my-app');\n * ```\n */\nexport async function createOptimalReasoningBank(\n  dbName: string = 'reasoningbank',\n  options: {\n    /** Force specific backend (overrides auto-detection) */\n    forceBackend?: 'nodejs' | 'wasm';\n    /** Custom database path (Node.js only) */\n    dbPath?: string;\n    /** Enable verbose logging */\n    verbose?: boolean;\n  } = {}\n): Promise<any> {\n  const backend = options.forceBackend || getRecommendedBackend();\n\n  if (options.verbose) {\n    console.log(`[ReasoningBank] Environment: ${backend}`);\n    console.log(`[ReasoningBank] Database: ${dbName}`);\n  }\n\n  if (backend === 'nodejs') {\n    // Import Node.js backend (SQLite)\n    const reasoningBankModule = await import('./index.js');\n\n    const dbPath = options.dbPath || `.swarm/${dbName}.db`;\n\n    if (options.verbose) {\n      console.log(`[ReasoningBank] Using Node.js backend with SQLite`);\n      console.log(`[ReasoningBank] Database path: ${dbPath}`);\n    }\n\n    // The Node.js backend uses the db module and core algorithms\n    // Initialize the database\n    await reasoningBankModule.initialize();\n\n    // Note: The Node.js backend has a different API than WASM\n    // It uses the functions from db/queries.ts and core algorithms\n    // We return the full module for direct access to all functions\n    return reasoningBankModule;\n  } else {\n    // Import WASM backend (IndexedDB in browser, Memory in Node.js)\n    const { createReasoningBank } = await import('./wasm-adapter.js');\n\n    if (options.verbose) {\n      const storageType = hasIndexedDB() ? 'IndexedDB (persistent)' : 'Memory (ephemeral)';\n      console.log(`[ReasoningBank] Using WASM backend with ${storageType}`);\n      console.log(`[ReasoningBank] Database name: ${dbName}`);\n    }\n\n    return await createReasoningBank(dbName);\n  }\n}\n\n/**\n * Get backend information and capabilities\n */\nexport function getBackendInfo() {\n  const backend = getRecommendedBackend();\n\n  return {\n    backend,\n    environment: typeof window !== 'undefined' ? 'browser' : 'nodejs',\n    features: {\n      persistent: backend === 'nodejs' || hasIndexedDB(),\n      sqlite: backend === 'nodejs' && hasSQLite(),\n      indexeddb: backend === 'wasm' && hasIndexedDB(),\n      wasm: backend === 'wasm',\n    },\n    storage: backend === 'nodejs'\n      ? 'SQLite (disk)'\n      : hasIndexedDB()\n        ? 'IndexedDB (browser)'\n        : 'Memory (ephemeral)',\n  };\n}\n\n/**\n * Validate environment and warn about limitations\n */\nexport function validateEnvironment(): {\n  valid: boolean;\n  warnings: string[];\n  backend: 'nodejs' | 'wasm';\n} {\n  const backend = getRecommendedBackend();\n  const warnings: string[] = [];\n  let valid = true;\n\n  if (backend === 'nodejs' && !hasSQLite()) {\n    warnings.push('sql-adapter not found - database operations will fail');\n    valid = false;\n  }\n\n  if (backend === 'wasm' && typeof window !== 'undefined' && !hasIndexedDB()) {\n    warnings.push('IndexedDB not available - using ephemeral memory storage');\n    warnings.push('Data will be lost when page/process exits');\n  }\n\n  if (backend === 'wasm' && typeof window === 'undefined') {\n    warnings.push('WASM in Node.js uses in-memory storage (ephemeral)');\n    warnings.push('Consider using Node.js backend for persistence');\n  }\n\n  return { valid, warnings, backend };\n}\n\n// Export validation helper for use in initialization\nexport { validateEnvironment as checkEnvironment };\n"]}

package/dist/reasoningbank/core/database.js

@@ -0,0 +1,250 @@
+/**
+ * SQLite Database Layer for ReasoningBank
+ * Handles memory storage, retrieval, and consolidation
+ */
+import Database from 'better-sqlite3';
+import { ulid } from 'ulid';
+export class ReasoningBankDB {
+    db;
+    constructor(dbPath) {
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL'); // Enable Write-Ahead Logging for concurrency
+        this.initSchema();
+    }
+    initSchema() {
+        // Main memory table
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS reasoning_memory (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        description TEXT NOT NULL,
+        content TEXT NOT NULL,
+        confidence REAL DEFAULT 0.5,
+        usage_count INTEGER DEFAULT 0,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        pattern_data JSON NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_confidence ON reasoning_memory(confidence);
+      CREATE INDEX IF NOT EXISTS idx_memory_created_at ON reasoning_memory(created_at);
+      CREATE INDEX IF NOT EXISTS idx_memory_domain ON reasoning_memory(json_extract(pattern_data, '$.domain'));
+    `);
+        // Pattern embeddings table
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pattern_embeddings (
+        pattern_id TEXT PRIMARY KEY,
+        embedding BLOB NOT NULL,
+        FOREIGN KEY (pattern_id) REFERENCES reasoning_memory(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_embeddings_pattern ON pattern_embeddings(pattern_id);
+    `);
+        // Task trajectory table
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS task_trajectory (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        trajectory TEXT NOT NULL,
+        verdict TEXT NOT NULL CHECK(verdict IN ('Success', 'Failure')),
+        confidence REAL NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_trajectory_task ON task_trajectory(task_id);
+      CREATE INDEX IF NOT EXISTS idx_trajectory_verdict ON task_trajectory(verdict);
+    `);
+        // MaTTS runs table
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS matts_runs (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        run_index INTEGER NOT NULL,
+        result TEXT NOT NULL,
+        verdict TEXT NOT NULL CHECK(verdict IN ('Success', 'Failure')),
+        confidence REAL NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_matts_task ON matts_runs(task_id);
+    `);
+    }
+    // Memory operations
+    insertMemory(memory) {
+        const id = ulid();
+        const stmt = this.db.prepare(`
+      INSERT INTO reasoning_memory (id, title, description, content, confidence, usage_count, pattern_data)
+      VALUES (?, ?, ?, ?, ?, ?, json(?))
+    `);
+        stmt.run(id, memory.title, memory.description, memory.content, memory.confidence, memory.usage_count, JSON.stringify(memory.pattern_data));
+        return id;
+    }
+    getMemory(id) {
+        const stmt = this.db.prepare(`
+      SELECT id, title, description, content, confidence, usage_count,
+             datetime(created_at) as created_at, pattern_data
+      FROM reasoning_memory
+      WHERE id = ?
+    `);
+        const row = stmt.get(id);
+        if (!row)
+            return null;
+        return {
+            ...row,
+            pattern_data: JSON.parse(row.pattern_data)
+        };
+    }
+    getAllMemories() {
+        const stmt = this.db.prepare(`
+      SELECT id, title, description, content, confidence, usage_count,
+             datetime(created_at) as created_at, pattern_data
+      FROM reasoning_memory
+      ORDER BY created_at DESC
+    `);
+        const rows = stmt.all();
+        return rows.map(row => ({
+            ...row,
+            pattern_data: JSON.parse(row.pattern_data)
+        }));
+    }
+    updateMemoryUsage(id) {
+        const stmt = this.db.prepare(`
+      UPDATE reasoning_memory
+      SET usage_count = usage_count + 1
+      WHERE id = ?
+    `);
+        stmt.run(id);
+    }
+    updateMemoryConfidence(id, confidence) {
+        const stmt = this.db.prepare(`
+      UPDATE reasoning_memory
+      SET confidence = ?
+      WHERE id = ?
+    `);
+        stmt.run(confidence, id);
+    }
+    deleteMemory(id) {
+        const stmt = this.db.prepare('DELETE FROM reasoning_memory WHERE id = ?');
+        stmt.run(id);
+    }
+    // Embedding operations
+    insertEmbedding(patternId, embedding) {
+        const buffer = Buffer.from(new Float64Array(embedding).buffer);
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO pattern_embeddings (pattern_id, embedding)
+      VALUES (?, ?)
+    `);
+        stmt.run(patternId, buffer);
+    }
+    getEmbedding(patternId) {
+        const stmt = this.db.prepare('SELECT embedding FROM pattern_embeddings WHERE pattern_id = ?');
+        const row = stmt.get(patternId);
+        if (!row)
+            return null;
+        const buffer = row.embedding;
+        return Array.from(new Float64Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 8));
+    }
+    getAllEmbeddings() {
+        const stmt = this.db.prepare('SELECT pattern_id, embedding FROM pattern_embeddings');
+        const rows = stmt.all();
+        const embeddings = new Map();
+        for (const row of rows) {
+            const buffer = row.embedding;
+            const embedding = Array.from(new Float64Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 8));
+            embeddings.set(row.pattern_id, embedding);
+        }
+        return embeddings;
+    }
+    // Trajectory operations
+    insertTrajectory(trajectory) {
+        const id = ulid();
+        const stmt = this.db.prepare(`
+      INSERT INTO task_trajectory (id, task_id, trajectory, verdict, confidence)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, trajectory.task_id, trajectory.trajectory, trajectory.verdict, trajectory.confidence);
+        return id;
+    }
+    getTrajectories(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT id, task_id, trajectory, verdict, confidence, datetime(created_at) as created_at
+      FROM task_trajectory
+      WHERE task_id = ?
+      ORDER BY created_at DESC
+    `);
+        return stmt.all(taskId);
+    }
+    // MaTTS operations
+    insertMattsRun(run) {
+        const id = ulid();
+        const stmt = this.db.prepare(`
+      INSERT INTO matts_runs (id, task_id, run_index, result, verdict, confidence)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, run.task_id, run.run_index, run.result, run.verdict, run.confidence);
+        return id;
+    }
+    getMattsRuns(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT id, task_id, run_index, result, verdict, confidence, datetime(created_at) as created_at
+      FROM matts_runs
+      WHERE task_id = ?
+      ORDER BY run_index ASC
+    `);
+        return stmt.all(taskId);
+    }
+    // Statistics
+    getStats() {
+        const memoryStats = this.db.prepare(`
+      SELECT COUNT(*) as total, AVG(confidence) as avg_conf, SUM(usage_count) as total_usage
+      FROM reasoning_memory
+    `).get();
+        const trajectoryStats = this.db.prepare(`
+      SELECT
+        SUM(CASE WHEN verdict = 'Success' THEN 1 ELSE 0 END) as successes,
+        COUNT(*) as total
+      FROM task_trajectory
+    `).get();
+        return {
+            totalMemories: memoryStats.total || 0,
+            avgConfidence: memoryStats.avg_conf || 0,
+            totalUsage: memoryStats.total_usage || 0,
+            successRate: trajectoryStats.total > 0
+                ? trajectoryStats.successes / trajectoryStats.total
+                : 0
+        };
+    }
+    // Consolidation helpers
+    findDuplicates(threshold = 0.95) {
+        // Returns pairs of memory IDs that are likely duplicates
+        const memories = this.getAllMemories();
+        const embeddings = this.getAllEmbeddings();
+        const duplicates = [];
+        for (let i = 0; i < memories.length; i++) {
+            for (let j = i + 1; j < memories.length; j++) {
+                const emb1 = embeddings.get(memories[i].id);
+                const emb2 = embeddings.get(memories[j].id);
+                if (emb1 && emb2) {
+                    const similarity = this.cosineSimilarity(emb1, emb2);
+                    if (similarity >= threshold) {
+                        duplicates.push([memories[i].id, memories[j].id]);
+                    }
+                }
+            }
+        }
+        return duplicates;
+    }
+    cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/reasoningbank/core/memory-engine.js

@@ -0,0 +1,335 @@
+/**
+ * ReasoningBank Memory Engine
+ * Implements the 4-phase learning loop: RETRIEVE → JUDGE → DISTILL → CONSOLIDATE
+ */
+import { ReasoningBankDB } from './database.js';
+import { createEmbeddingProvider, cosineSimilarity } from '../utils/embeddings.js';
+import { piiScrubber } from '../utils/pii-scrubber.js';
+export class ReasoningBankEngine {
+    db;
+    embeddings;
+    piiEnabled;
+    weights;
+    defaultK;
+    minConfidence;
+    consolidationThreshold;
+    memoriesSinceConsolidation = 0;
+    constructor(config) {
+        this.db = new ReasoningBankDB(config.dbPath);
+        this.embeddings = createEmbeddingProvider(config.embeddings?.provider || 'hash', {
+            apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY,
+            model: config.embeddings?.model
+        });
+        this.piiEnabled = config.piiScrub?.enabled !== false;
+        this.weights = {
+            alpha: config.retrieval?.weights?.alpha || 0.65, // Similarity
+            beta: config.retrieval?.weights?.beta || 0.15, // Recency
+            gamma: config.retrieval?.weights?.gamma || 0.20, // Reliability
+            delta: config.retrieval?.weights?.delta || 0.10 // Diversity penalty
+        };
+        this.defaultK = config.retrieval?.k || 3;
+        this.minConfidence = config.retrieval?.minConfidence || 0.3;
+        this.consolidationThreshold = config.consolidation?.scheduleEvery || 20;
+    }
+    /**
+     * Phase 1: RETRIEVE - Get relevant memories using 4-factor scoring
+     */
+    async retrieve(options) {
+        const k = options.k || this.defaultK;
+        const lambda = options.lambda || 0.9;
+        // Generate query embedding
+        const queryEmbedding = await this.embeddings.generate(options.query);
+        // Get all memories
+        const allMemories = this.db.getAllMemories();
+        const embeddings = this.db.getAllEmbeddings();
+        // Filter by domain if specified
+        let candidates = allMemories;
+        if (options.domain) {
+            candidates = candidates.filter(m => m.pattern_data.domain === options.domain ||
+                m.pattern_data.domain?.startsWith(options.domain + '.'));
+        }
+        // Calculate scores for each candidate
+        const scoredCandidates = [];
+        for (const memory of candidates) {
+            const embedding = embeddings.get(memory.id);
+            if (!embedding)
+                continue;
+            // 1. Similarity score (cosine similarity)
+            const similarity = cosineSimilarity(queryEmbedding, embedding);
+            // 2. Recency score (exponential decay, 30-day half-life)
+            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
+            const recency = Math.exp(-ageDays / 30);
+            // 3. Reliability score (confidence × sqrt(usage/10))
+            const reliability = Math.min(memory.confidence * Math.sqrt(memory.usage_count / 10), 1.0);
+            // Combined score (before diversity penalty)
+            const score = this.weights.alpha * similarity +
+                this.weights.beta * recency +
+                this.weights.gamma * reliability;
+            scoredCandidates.push({
+                ...memory,
+                score,
+                similarity,
+                recency,
+                reliability,
+                diversityPenalty: 0 // Will be calculated in MMR
+            });
+        }
+        // Sort by score
+        scoredCandidates.sort((a, b) => b.score - a.score);
+        // Apply MMR for diversity
+        const selected = this.selectWithMMR(scoredCandidates, queryEmbedding, k, lambda);
+        // Update usage counts
+        for (const memory of selected) {
+            this.db.updateMemoryUsage(memory.id);
+        }
+        // Filter by minimum confidence
+        return selected.filter(m => m.confidence >= this.minConfidence);
+    }
+    /**
+     * MMR (Maximal Marginal Relevance) Selection
+     * Balances relevance and diversity
+     */
+    selectWithMMR(candidates, queryEmbedding, k, lambda) {
+        const selected = [];
+        const remaining = [...candidates];
+        const embeddings = this.db.getAllEmbeddings();
+        while (selected.length < k && remaining.length > 0) {
+            let bestScore = -Infinity;
+            let bestIndex = -1;
+            for (let i = 0; i < remaining.length; i++) {
+                const candidate = remaining[i];
+                const candidateEmbedding = embeddings.get(candidate.id);
+                if (!candidateEmbedding)
+                    continue;
+                // Relevance to query
+                const relevance = candidate.score;
+                // Maximum similarity to already selected
+                let maxSimilarity = 0;
+                if (selected.length > 0) {
+                    for (const selectedMemory of selected) {
+                        const selectedEmbedding = embeddings.get(selectedMemory.id);
+                        if (selectedEmbedding) {
+                            const sim = cosineSimilarity(candidateEmbedding, selectedEmbedding);
+                            maxSimilarity = Math.max(maxSimilarity, sim);
+                        }
+                    }
+                }
+                // MMR score
+                const mmrScore = lambda * relevance - (1 - lambda) * maxSimilarity;
+                if (mmrScore > bestScore) {
+                    bestScore = mmrScore;
+                    bestIndex = i;
+                }
+            }
+            if (bestIndex >= 0) {
+                selected.push(remaining[bestIndex]);
+                remaining.splice(bestIndex, 1);
+            }
+            else {
+                break;
+            }
+        }
+        return selected;
+    }
+    /**
+     * Phase 2: JUDGE - Evaluate task outcome
+     */
+    async judge(trajectory) {
+        // Simple heuristic judge (can be upgraded to LLM)
+        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
+        // Heuristics for success/failure
+        const errorKeywords = ['error', 'failed', 'exception', 'timeout', 'unauthorized', 'forbidden'];
+        const successKeywords = ['success', 'completed', 'ok', '200', 'done'];
+        const lowerTrajectory = scrubbed.toLowerCase();
+        const hasError = errorKeywords.some(kw => lowerTrajectory.includes(kw));
+        const hasSuccess = successKeywords.some(kw => lowerTrajectory.includes(kw));
+        if (hasSuccess && !hasError) {
+            return { label: 'Success', confidence: 0.8, rationale: 'Success keywords found' };
+        }
+        else if (hasError && !hasSuccess) {
+            return { label: 'Failure', confidence: 0.8, rationale: 'Error keywords found' };
+        }
+        else if (hasSuccess && hasError) {
+            return { label: 'Success', confidence: 0.5, rationale: 'Mixed signals' };
+        }
+        else {
+            return { label: 'Failure', confidence: 0.5, rationale: 'No clear indicators' };
+        }
+    }
+    /**
+     * Phase 3: DISTILL - Extract patterns from trajectory
+     */
+    async distill(taskId, trajectory, verdict, domain) {
+        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
+        // Store trajectory
+        this.db.insertTrajectory({
+            task_id: taskId,
+            trajectory: scrubbed,
+            verdict: verdict.label,
+            confidence: verdict.confidence
+        });
+        // Extract pattern based on verdict
+        const pattern = verdict.label === 'Success'
+            ? this.extractSuccessPattern(scrubbed, domain)
+            : this.extractFailureGuardrail(scrubbed, domain);
+        // Store as memory
+        const memoryId = this.db.insertMemory({
+            title: pattern.title,
+            description: pattern.description,
+            content: pattern.content,
+            confidence: verdict.confidence,
+            usage_count: 0,
+            pattern_data: {
+                domain,
+                success_pattern: verdict.label === 'Success',
+                failure_guardrail: verdict.label === 'Failure'
+            }
+        });
+        // Generate and store embedding
+        const embedding = await this.embeddings.generate(pattern.content);
+        this.db.insertEmbedding(memoryId, embedding);
+        this.memoriesSinceConsolidation++;
+        return memoryId;
+    }
+    extractSuccessPattern(trajectory, domain) {
+        // Extract key steps from successful execution
+        const lines = trajectory.split('\n').filter(l => l.trim());
+        const keySteps = lines.slice(0, 5).join('\n');
+        return {
+            title: `Success pattern for ${domain}`,
+            description: `Successful execution strategy`,
+            content: `Successful approach:\n${keySteps}`
+        };
+    }
+    extractFailureGuardrail(trajectory, domain) {
+        // Extract error information
+        const lines = trajectory.split('\n').filter(l => l.trim());
+        const errorInfo = lines.find(l => l.toLowerCase().includes('error') ||
+            l.toLowerCase().includes('failed')) || 'Unknown error';
+        return {
+            title: `Failure guardrail for ${domain}`,
+            description: `Prevention strategy for common failures`,
+            content: `Avoid: ${errorInfo}\nRecommend: Check prerequisites and retry with backoff`
+        };
+    }
+    /**
+     * Phase 4: CONSOLIDATE - Deduplicate and prune
+     */
+    async consolidate(options) {
+        const startTime = Date.now();
+        const dedupeThreshold = options?.dedupeThreshold || 0.95;
+        const maxAgeDays = options?.prune?.maxAgeDays || 90;
+        const minConfidence = options?.prune?.minConfidence || 0.3;
+        const unusedDays = options?.prune?.unusedDays || 30;
+        // Find and merge duplicates
+        const duplicates = this.db.findDuplicates(dedupeThreshold);
+        for (const [id1, id2] of duplicates) {
+            const mem1 = this.db.getMemory(id1);
+            const mem2 = this.db.getMemory(id2);
+            if (mem1 && mem2) {
+                // Keep the one with higher confidence and usage
+                const keepId = mem1.confidence > mem2.confidence ||
+                    (mem1.confidence === mem2.confidence && mem1.usage_count > mem2.usage_count)
+                    ? id1 : id2;
+                const deleteId = keepId === id1 ? id2 : id1;
+                this.db.deleteMemory(deleteId);
+            }
+        }
+        // Prune old or low-quality memories
+        const allMemories = this.db.getAllMemories();
+        let pruned = 0;
+        for (const memory of allMemories) {
+            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
+            const lastUsedDays = ageDays; // Simplified: assume last used = created
+            const shouldPrune = ageDays > maxAgeDays ||
+                memory.confidence < minConfidence ||
+                (memory.usage_count === 0 && lastUsedDays > unusedDays);
+            if (shouldPrune) {
+                this.db.deleteMemory(memory.id);
+                pruned++;
+            }
+        }
+        // Detect contradictions (simplified)
+        const contradictions = 0; // TODO: Implement semantic contradiction detection
+        this.memoriesSinceConsolidation = 0;
+        return {
+            processed: allMemories.length,
+            duplicates: duplicates.length,
+            contradictions,
+            pruned,
+            durationMs: Date.now() - startTime
+        };
+    }
+    /**
+     * High-level task execution with full learning loop
+     */
+    async runTask(options) {
+        // Phase 1: RETRIEVE
+        const memories = await this.retrieve({
+            query: options.query,
+            domain: options.domain
+        });
+        // EXECUTE
+        const result = await options.executeFn(memories);
+        // Phase 2: JUDGE
+        const verdict = await this.judge(result.log);
+        // Phase 3: DISTILL
+        await this.distill(options.taskId, result.log, verdict, options.domain);
+        // Phase 4: CONSOLIDATE (if threshold reached)
+        if (this.memoriesSinceConsolidation >= this.consolidationThreshold) {
+            await this.consolidate();
+        }
+        return {
+            success: result.success,
+            summary: `Task ${options.taskId}: ${verdict.label} (confidence: ${verdict.confidence})`,
+            memories,
+            verdict
+        };
+    }
+    /**
+     * MaTTS: Memory-aware Test-Time Scaling (Parallel)
+     */
+    async mattsParallel(options) {
+        const runs = await Promise.all(Array.from({ length: options.k }, async (_, i) => {
+            const memories = await this.retrieve({
+                query: options.query,
+                domain: options.domain
+            });
+            const result = await options.executeFn(memories);
+            const verdict = await this.judge(result.log);
+            this.db.insertMattsRun({
+                task_id: options.taskId,
+                run_index: i,
+                result: result.log,
+                verdict: verdict.label,
+                confidence: verdict.confidence
+            });
+            return { result, verdict };
+        }));
+        // Calculate consensus
+        const successes = runs.filter(r => r.verdict.label === 'Success').length;
+        const avgConfidence = runs.reduce((sum, r) => sum + r.verdict.confidence, 0) / runs.length;
+        const consensusVerdict = {
+            label: successes > runs.length / 2 ? 'Success' : 'Failure',
+            confidence: avgConfidence
+        };
+        return {
+            success: consensusVerdict.label === 'Success',
+            summary: `MaTTS Parallel: ${successes}/${runs.length} successes, consensus: ${consensusVerdict.label}`,
+            memories: [],
+            verdict: consensusVerdict
+        };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return this.db.getStats();
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        this.db.close();
+    }
+}

package/dist/reasoningbank/db/queries.d.ts

@@ -2,7 +2,6 @@
  * Database queries for ReasoningBank
  * Operates on Claude Flow's memory.db at .swarm/memory.db
  */
-import Database from 'better-sqlite3';
 import type { ReasoningMemory, PatternEmbedding, TaskTrajectory, MattsRun } from './schema.js';
 /**
  * Run database migrations (create tables)

package/dist/reasoningbank/db/queries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/reasoningbank/db/queries.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AAGtC,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAU/F;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAmGnD;AAED;;GAEG;AACH,wBAAgB,KAAK,IAAI,QAAQ,CAAC,QAAQ,CAgBzC;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,KAAK,CAAC,eAAe,GAAG;IAAE,SAAS,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAqCzE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,WAAW,CAAC,GAAG,MAAM,CAmB9F;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAWjE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CASrD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG,IAAI,CAoBpF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC,GAAG,IAAI,CAOrE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAa3D;AAED;;GAEG;AACH,wBAAgB,kCAAkC,IAAI,MAAM,CA4B3D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,eAAe,EAAE,CAexD;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS,GAAG,cAAc,EAChE,MAAM,EAAE,MAAM,GACb,IAAI,CAON;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAU5D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,IAAI,CAeP;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAYT;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAM9B"}
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/reasoningbank/db/queries.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAU/F;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAmGnD;AAED;;GAEG;AACH,wBAAgB,KAAK,IAAI,QAAQ,CAAC,QAAQ,CAgBzC;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,KAAK,CAAC,eAAe,GAAG;IAAE,SAAS,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAqCzE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,WAAW,CAAC,GAAG,MAAM,CAmB9F;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAWjE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CASrD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG,IAAI,CAoBpF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC,GAAG,IAAI,CAOrE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAa3D;AAED;;GAEG;AACH,wBAAgB,kCAAkC,IAAI,MAAM,CA4B3D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,eAAe,EAAE,CAexD;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS,GAAG,cAAc,EAChE,MAAM,EAAE,MAAM,GACb,IAAI,CAON;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAU5D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,IAAI,CAeP;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAYT;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAM9B"}

package/dist/reasoningbank/db/queries.js

@@ -2,7 +2,7 @@
  * Database queries for ReasoningBank
  * Operates on Claude Flow's memory.db at .swarm/memory.db
  */
-import Database from 'better-sqlite3';
+import Database from '../../db/sql-adapter.js';
 import { existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 // Simple logger for database operations