agentic-flow 2.0.2-alpha → 2.0.2

package/dist/reasoningbank/core/consolidate.js

@@ -0,0 +1,208 @@
+/**
+ * Memory Consolidation
+ * Algorithm 4 from ReasoningBank paper: Dedup, Contradict, Prune
+ */
+import { ulid } from 'ulid';
+import { loadConfig } from '../utils/config.js';
+import { cosineSimilarity } from '../utils/mmr.js';
+import * as db from '../db/queries.js';
+/**
+ * Run consolidation: deduplicate, detect contradictions, prune old memories
+ */
+export async function consolidate() {
+    const config = loadConfig();
+    const startTime = Date.now();
+    console.log('[INFO] Starting memory consolidation...');
+    const runId = ulid();
+    const memories = db.getAllActiveMemories();
+    console.log(`[INFO] Processing ${memories.length} active memories`);
+    let duplicatesFound = 0;
+    let contradictionsFound = 0;
+    let itemsPruned = 0;
+    // Step 1: Deduplicate similar memories
+    duplicatesFound = await deduplicateMemories(memories, config.consolidate.duplicate_threshold);
+    // Step 2: Detect contradictions
+    contradictionsFound = await detectContradictions(memories, config.consolidate.contradiction_threshold);
+    // Step 3: Prune old, unused memories
+    itemsPruned = db.pruneOldMemories({
+        maxAgeDays: config.consolidate.prune_age_days,
+        minConfidence: config.consolidate.min_confidence_keep
+    });
+    const durationMs = Date.now() - startTime;
+    // Store consolidation run
+    db.storeConsolidationRun({
+        run_id: runId,
+        items_processed: memories.length,
+        duplicates_found: duplicatesFound,
+        contradictions_found: contradictionsFound,
+        items_pruned: itemsPruned,
+        duration_ms: durationMs
+    });
+    console.log(`[INFO] Consolidation complete: ${duplicatesFound} dupes, ${contradictionsFound} contradictions, ${itemsPruned} pruned in ${durationMs}ms`);
+    db.logMetric('rb.consolidate.duration_ms', durationMs);
+    db.logMetric('rb.consolidate.duplicates', duplicatesFound);
+    db.logMetric('rb.consolidate.contradictions', contradictionsFound);
+    db.logMetric('rb.consolidate.pruned', itemsPruned);
+    return {
+        itemsProcessed: memories.length,
+        duplicatesFound,
+        contradictionsFound,
+        itemsPruned,
+        durationMs
+    };
+}
+/**
+ * Deduplicate highly similar memories
+ * PERFORMANCE FIX: Use bucketing/blocking to reduce O(n²) to ~O(n·k)
+ * by only comparing memories within the same semantic bucket
+ */
+async function deduplicateMemories(memories, threshold) {
+    let duplicatesFound = 0;
+    if (memories.length === 0)
+        return 0;
+    // Fetch all embeddings in a single batch query (instead of N queries)
+    const dbConn = db.getDb();
+    const ids = memories.map(m => m.id);
+    const placeholders = ids.map(() => '?').join(',');
+    const rows = dbConn.prepare(`SELECT id, vector FROM pattern_embeddings WHERE id IN (${placeholders})`).all(...ids);
+    const embeddingsMap = new Map();
+    for (const row of rows) {
+        embeddingsMap.set(row.id, new Float32Array(row.vector));
+    }
+    // PERFORMANCE: Use locality-sensitive hashing (LSH) bucketing
+    // Group memories by their dominant embedding dimension to reduce comparisons
+    const buckets = new Map();
+    const BUCKET_GRANULARITY = 10; // Number of buckets per dimension
+    for (const mem of memories) {
+        const emb = embeddingsMap.get(mem.id);
+        if (!emb)
+            continue;
+        // Find dominant dimension and bucket
+        let maxDim = 0;
+        let maxVal = -Infinity;
+        for (let i = 0; i < Math.min(emb.length, 32); i++) { // Check first 32 dims
+            if (Math.abs(emb[i]) > maxVal) {
+                maxVal = Math.abs(emb[i]);
+                maxDim = i;
+            }
+        }
+        const bucketKey = maxDim * BUCKET_GRANULARITY + Math.floor((emb[maxDim] + 1) * BUCKET_GRANULARITY / 2);
+        if (!buckets.has(bucketKey)) {
+            buckets.set(bucketKey, []);
+        }
+        buckets.get(bucketKey).push(mem);
+    }
+    // Compare only within buckets (and neighboring buckets for safety)
+    const deletedIds = new Set();
+    for (const [bucketKey, bucketMemories] of buckets) {
+        // Compare within bucket
+        for (let i = 0; i < bucketMemories.length; i++) {
+            const mem1 = bucketMemories[i];
+            if (deletedIds.has(mem1.id))
+                continue;
+            const emb1 = embeddingsMap.get(mem1.id);
+            if (!emb1)
+                continue;
+            for (let j = i + 1; j < bucketMemories.length; j++) {
+                const mem2 = bucketMemories[j];
+                if (deletedIds.has(mem2.id))
+                    continue;
+                const emb2 = embeddingsMap.get(mem2.id);
+                if (!emb2)
+                    continue;
+                const similarity = cosineSimilarity(emb1, emb2);
+                if (similarity >= threshold) {
+                    // Mark as duplicate
+                    db.storeLink(mem1.id, mem2.id, 'duplicate_of', similarity);
+                    duplicatesFound++;
+                    // Merge: keep the one with higher usage
+                    if (mem1.usage_count < mem2.usage_count) {
+                        deletedIds.add(mem1.id);
+                        console.log(`[INFO] Merged duplicate: ${mem1.pattern_data?.title || mem1.id} → ${mem2.pattern_data?.title || mem2.id}`);
+                    }
+                    else {
+                        deletedIds.add(mem2.id);
+                    }
+                }
+            }
+        }
+    }
+    // Batch delete all duplicates in a single transaction
+    if (deletedIds.size > 0) {
+        const deleteIds = Array.from(deletedIds);
+        const deletePlaceholders = deleteIds.map(() => '?').join(',');
+        dbConn.prepare(`DELETE FROM patterns WHERE id IN (${deletePlaceholders})`).run(...deleteIds);
+    }
+    return duplicatesFound;
+}
+/**
+ * Detect contradicting memories
+ * Uses embedding similarity + semantic analysis
+ * PERFORMANCE FIX: Reuses embeddings from deduplication phase and uses bucketing
+ */
+async function detectContradictions(memories, threshold, preloadedEmbeddings) {
+    let contradictionsFound = 0;
+    if (memories.length === 0)
+        return 0;
+    // Use preloaded embeddings if available, otherwise fetch in batch
+    let embeddingsMap;
+    if (preloadedEmbeddings) {
+        embeddingsMap = preloadedEmbeddings;
+    }
+    else {
+        const dbConn = db.getDb();
+        const ids = memories.map(m => m.id);
+        const placeholders = ids.map(() => '?').join(',');
+        const rows = dbConn.prepare(`SELECT id, vector FROM pattern_embeddings WHERE id IN (${placeholders})`).all(...ids);
+        embeddingsMap = new Map();
+        for (const row of rows) {
+            embeddingsMap.set(row.id, new Float32Array(row.vector));
+        }
+    }
+    // PERFORMANCE: Group by outcome first, only compare across different outcomes
+    const outcomeGroups = new Map();
+    for (const mem of memories) {
+        const outcome = mem.pattern_data?.source?.outcome ?? 'unknown';
+        if (!outcomeGroups.has(outcome)) {
+            outcomeGroups.set(outcome, []);
+        }
+        outcomeGroups.get(outcome).push(mem);
+    }
+    // Only compare memories with different outcomes
+    const outcomeKeys = Array.from(outcomeGroups.keys());
+    for (let o1 = 0; o1 < outcomeKeys.length; o1++) {
+        for (let o2 = o1 + 1; o2 < outcomeKeys.length; o2++) {
+            const group1 = outcomeGroups.get(outcomeKeys[o1]);
+            const group2 = outcomeGroups.get(outcomeKeys[o2]);
+            // Compare across groups (different outcomes)
+            for (const mem1 of group1) {
+                const emb1 = embeddingsMap.get(mem1.id);
+                if (!emb1)
+                    continue;
+                for (const mem2 of group2) {
+                    const emb2 = embeddingsMap.get(mem2.id);
+                    if (!emb2)
+                        continue;
+                    const similarity = cosineSimilarity(emb1, emb2);
+                    // High similarity but different outcomes = contradiction
+                    if (similarity >= threshold) {
+                        db.storeLink(mem1.id, mem2.id, 'contradicts', similarity);
+                        contradictionsFound++;
+                        console.log(`[WARN] Contradiction detected: ${mem1.pattern_data?.title || mem1.id} vs ${mem2.pattern_data?.title || mem2.id}`);
+                    }
+                }
+            }
+        }
+    }
+    return contradictionsFound;
+}
+/**
+ * Check if consolidation should run
+ * Returns true if threshold of new memories is reached
+ */
+export function shouldConsolidate() {
+    const config = loadConfig();
+    const newCount = db.countNewMemoriesSinceConsolidation();
+    return newCount >= config.consolidate.trigger_threshold;
+}
+//# sourceMappingURL=consolidate.js.map

package/dist/reasoningbank/core/consolidate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidate.js","sourceRoot":"","sources":["../../../src/reasoningbank/core/consolidate.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Memory Consolidation\n * Algorithm 4 from ReasoningBank paper: Dedup, Contradict, Prune\n */\n\nimport { ulid } from 'ulid';\nimport { loadConfig } from '../utils/config.js';\nimport { cosineSimilarity } from '../utils/mmr.js';\nimport * as db from '../db/queries.js';\n\nexport interface ConsolidationResult {\n  itemsProcessed: number;\n  duplicatesFound: number;\n  contradictionsFound: number;\n  itemsPruned: number;\n  durationMs: number;\n}\n\n/**\n * Run consolidation: deduplicate, detect contradictions, prune old memories\n */\nexport async function consolidate(): Promise<ConsolidationResult> {\n  const config = loadConfig();\n  const startTime = Date.now();\n\n  console.log('[INFO] Starting memory consolidation...');\n\n  const runId = ulid();\n  const memories = db.getAllActiveMemories();\n\n  console.log(`[INFO] Processing ${memories.length} active memories`);\n\n  let duplicatesFound = 0;\n  let contradictionsFound = 0;\n  let itemsPruned = 0;\n\n  // Step 1: Deduplicate similar memories\n  duplicatesFound = await deduplicateMemories(memories, config.consolidate.duplicate_threshold);\n\n  // Step 2: Detect contradictions\n  contradictionsFound = await detectContradictions(memories, config.consolidate.contradiction_threshold);\n\n  // Step 3: Prune old, unused memories\n  itemsPruned = db.pruneOldMemories({\n    maxAgeDays: config.consolidate.prune_age_days,\n    minConfidence: config.consolidate.min_confidence_keep\n  });\n\n  const durationMs = Date.now() - startTime;\n\n  // Store consolidation run\n  db.storeConsolidationRun({\n    run_id: runId,\n    items_processed: memories.length,\n    duplicates_found: duplicatesFound,\n    contradictions_found: contradictionsFound,\n    items_pruned: itemsPruned,\n    duration_ms: durationMs\n  });\n\n  console.log(`[INFO] Consolidation complete: ${duplicatesFound} dupes, ${contradictionsFound} contradictions, ${itemsPruned} pruned in ${durationMs}ms`);\n\n  db.logMetric('rb.consolidate.duration_ms', durationMs);\n  db.logMetric('rb.consolidate.duplicates', duplicatesFound);\n  db.logMetric('rb.consolidate.contradictions', contradictionsFound);\n  db.logMetric('rb.consolidate.pruned', itemsPruned);\n\n  return {\n    itemsProcessed: memories.length,\n    duplicatesFound,\n    contradictionsFound,\n    itemsPruned,\n    durationMs\n  };\n}\n\n/**\n * Deduplicate highly similar memories\n * PERFORMANCE FIX: Use bucketing/blocking to reduce O(n²) to ~O(n·k)\n * by only comparing memories within the same semantic bucket\n */\nasync function deduplicateMemories(\n  memories: any[],\n  threshold: number\n): Promise<number> {\n  let duplicatesFound = 0;\n\n  if (memories.length === 0) return 0;\n\n  // Fetch all embeddings in a single batch query (instead of N queries)\n  const dbConn = db.getDb();\n  const ids = memories.map(m => m.id);\n  const placeholders = ids.map(() => '?').join(',');\n  const rows = dbConn.prepare(`SELECT id, vector FROM pattern_embeddings WHERE id IN (${placeholders})`).all(...ids) as Array<{ id: string; vector: Buffer }>;\n\n  const embeddingsMap = new Map<string, Float32Array>();\n  for (const row of rows) {\n    embeddingsMap.set(row.id, new Float32Array(row.vector));\n  }\n\n  // PERFORMANCE: Use locality-sensitive hashing (LSH) bucketing\n  // Group memories by their dominant embedding dimension to reduce comparisons\n  const buckets = new Map<number, any[]>();\n  const BUCKET_GRANULARITY = 10; // Number of buckets per dimension\n\n  for (const mem of memories) {\n    const emb = embeddingsMap.get(mem.id);\n    if (!emb) continue;\n\n    // Find dominant dimension and bucket\n    let maxDim = 0;\n    let maxVal = -Infinity;\n    for (let i = 0; i < Math.min(emb.length, 32); i++) { // Check first 32 dims\n      if (Math.abs(emb[i]) > maxVal) {\n        maxVal = Math.abs(emb[i]);\n        maxDim = i;\n      }\n    }\n    const bucketKey = maxDim * BUCKET_GRANULARITY + Math.floor((emb[maxDim] + 1) * BUCKET_GRANULARITY / 2);\n\n    if (!buckets.has(bucketKey)) {\n      buckets.set(bucketKey, []);\n    }\n    buckets.get(bucketKey)!.push(mem);\n  }\n\n  // Compare only within buckets (and neighboring buckets for safety)\n  const deletedIds = new Set<string>();\n\n  for (const [bucketKey, bucketMemories] of buckets) {\n    // Compare within bucket\n    for (let i = 0; i < bucketMemories.length; i++) {\n      const mem1 = bucketMemories[i];\n      if (deletedIds.has(mem1.id)) continue;\n\n      const emb1 = embeddingsMap.get(mem1.id);\n      if (!emb1) continue;\n\n      for (let j = i + 1; j < bucketMemories.length; j++) {\n        const mem2 = bucketMemories[j];\n        if (deletedIds.has(mem2.id)) continue;\n\n        const emb2 = embeddingsMap.get(mem2.id);\n        if (!emb2) continue;\n\n        const similarity = cosineSimilarity(emb1, emb2);\n\n        if (similarity >= threshold) {\n          // Mark as duplicate\n          db.storeLink(mem1.id, mem2.id, 'duplicate_of', similarity);\n          duplicatesFound++;\n\n          // Merge: keep the one with higher usage\n          if (mem1.usage_count < mem2.usage_count) {\n            deletedIds.add(mem1.id);\n            console.log(`[INFO] Merged duplicate: ${mem1.pattern_data?.title || mem1.id} → ${mem2.pattern_data?.title || mem2.id}`);\n          } else {\n            deletedIds.add(mem2.id);\n          }\n        }\n      }\n    }\n  }\n\n  // Batch delete all duplicates in a single transaction\n  if (deletedIds.size > 0) {\n    const deleteIds = Array.from(deletedIds);\n    const deletePlaceholders = deleteIds.map(() => '?').join(',');\n    dbConn.prepare(`DELETE FROM patterns WHERE id IN (${deletePlaceholders})`).run(...deleteIds);\n  }\n\n  return duplicatesFound;\n}\n\n/**\n * Detect contradicting memories\n * Uses embedding similarity + semantic analysis\n * PERFORMANCE FIX: Reuses embeddings from deduplication phase and uses bucketing\n */\nasync function detectContradictions(\n  memories: any[],\n  threshold: number,\n  preloadedEmbeddings?: Map<string, Float32Array>\n): Promise<number> {\n  let contradictionsFound = 0;\n\n  if (memories.length === 0) return 0;\n\n  // Use preloaded embeddings if available, otherwise fetch in batch\n  let embeddingsMap: Map<string, Float32Array>;\n\n  if (preloadedEmbeddings) {\n    embeddingsMap = preloadedEmbeddings;\n  } else {\n    const dbConn = db.getDb();\n    const ids = memories.map(m => m.id);\n    const placeholders = ids.map(() => '?').join(',');\n    const rows = dbConn.prepare(`SELECT id, vector FROM pattern_embeddings WHERE id IN (${placeholders})`).all(...ids) as Array<{ id: string; vector: Buffer }>;\n\n    embeddingsMap = new Map<string, Float32Array>();\n    for (const row of rows) {\n      embeddingsMap.set(row.id, new Float32Array(row.vector));\n    }\n  }\n\n  // PERFORMANCE: Group by outcome first, only compare across different outcomes\n  const outcomeGroups = new Map<string, any[]>();\n\n  for (const mem of memories) {\n    const outcome = mem.pattern_data?.source?.outcome ?? 'unknown';\n    if (!outcomeGroups.has(outcome)) {\n      outcomeGroups.set(outcome, []);\n    }\n    outcomeGroups.get(outcome)!.push(mem);\n  }\n\n  // Only compare memories with different outcomes\n  const outcomeKeys = Array.from(outcomeGroups.keys());\n\n  for (let o1 = 0; o1 < outcomeKeys.length; o1++) {\n    for (let o2 = o1 + 1; o2 < outcomeKeys.length; o2++) {\n      const group1 = outcomeGroups.get(outcomeKeys[o1])!;\n      const group2 = outcomeGroups.get(outcomeKeys[o2])!;\n\n      // Compare across groups (different outcomes)\n      for (const mem1 of group1) {\n        const emb1 = embeddingsMap.get(mem1.id);\n        if (!emb1) continue;\n\n        for (const mem2 of group2) {\n          const emb2 = embeddingsMap.get(mem2.id);\n          if (!emb2) continue;\n\n          const similarity = cosineSimilarity(emb1, emb2);\n\n          // High similarity but different outcomes = contradiction\n          if (similarity >= threshold) {\n            db.storeLink(mem1.id, mem2.id, 'contradicts', similarity);\n            contradictionsFound++;\n            console.log(`[WARN] Contradiction detected: ${mem1.pattern_data?.title || mem1.id} vs ${mem2.pattern_data?.title || mem2.id}`);\n          }\n        }\n      }\n    }\n  }\n\n  return contradictionsFound;\n}\n\n/**\n * Check if consolidation should run\n * Returns true if threshold of new memories is reached\n */\nexport function shouldConsolidate(): boolean {\n  const config = loadConfig();\n  const newCount = db.countNewMemoriesSinceConsolidation();\n  return newCount >= config.consolidate.trigger_threshold;\n}\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/distill.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Memory Distillation from trajectories
+ * Algorithm 3 from ReasoningBank paper
+ */
+import type { Trajectory } from '../db/schema.js';
+import type { Verdict } from './judge.js';
+export interface DistilledMemory {
+    title: string;
+    description: string;
+    content: string;
+    tags: string[];
+    domain?: string;
+}
+/**
+ * Distill memories from a trajectory
+ */
+export declare function distillMemories(trajectory: Trajectory, verdict: Verdict, query: string, options?: {
+    taskId?: string;
+    agentId?: string;
+    domain?: string;
+}): Promise<string[]>;
+//# sourceMappingURL=distill.d.ts.map

package/dist/reasoningbank/core/judge.d.ts

@@ -0,0 +1,17 @@
+/**
+ * LLM-as-Judge for trajectory evaluation
+ * Algorithm 2 from ReasoningBank paper
+ */
+import type { Trajectory } from '../db/schema.js';
+export interface Verdict {
+    label: 'Success' | 'Failure';
+    confidence: number;
+    reasons: string[];
+}
+/**
+ * Judge a task trajectory using LLM evaluation
+ */
+export declare function judgeTrajectory(trajectory: Trajectory, query: string, options?: {
+    useCache?: boolean;
+}): Promise<Verdict>;
+//# sourceMappingURL=judge.d.ts.map

package/dist/reasoningbank/core/matts.d.ts

@@ -0,0 +1,46 @@
+/**
+ * MaTTS: Memory-aware Test-Time Scaling
+ * Algorithm 5 from ReasoningBank paper
+ *
+ * Two modes:
+ * - Parallel: k independent rollouts with self-contrast aggregation
+ * - Sequential: r iterative refinements with check-and-correct
+ */
+import type { Trajectory } from '../db/schema.js';
+export interface MattsResult {
+    runId: string;
+    mode: 'parallel' | 'sequential';
+    k: number;
+    trajectories: Array<{
+        id: string;
+        verdict: {
+            label: string;
+            confidence: number;
+        };
+        trajectory: Trajectory;
+    }>;
+    aggregatedMemories: string[];
+    successRate: number;
+    duration: number;
+}
+/**
+ * Run MaTTS in parallel mode
+ * Execute k independent rollouts and aggregate via self-contrast
+ */
+export declare function mattsParallel(taskFn: () => Promise<Trajectory>, query: string, options?: {
+    k?: number;
+    taskId?: string;
+    agentId?: string;
+    domain?: string;
+}): Promise<MattsResult>;
+/**
+ * Run MaTTS in sequential mode
+ * Iterative refinement with check-and-correct
+ */
+export declare function mattsSequential(taskFn: (memories: any[]) => Promise<Trajectory>, query: string, options?: {
+    r?: number;
+    taskId?: string;
+    agentId?: string;
+    domain?: string;
+}): Promise<MattsResult>;
+//# sourceMappingURL=matts.d.ts.map