agentdb 3.0.0-alpha.2 → 3.0.0-alpha.20

package/dist/src/mcp/agentdb-mcp-server.js

@@ -7,8 +7,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-// Database type - IDatabaseConnection from types
-// (type alias removed: was unused)
+import { createDatabase } from '../db-fallback.js';
 import { CausalMemoryGraph } from '../controllers/CausalMemoryGraph.js';
 import { CausalRecall } from '../controllers/CausalRecall.js';
 import { ReflexionMemory } from '../controllers/ReflexionMemory.js';
@@ -20,7 +19,19 @@ import { BatchOperations } from '../optimizations/BatchOperations.js';
 import { ReasoningBank } from '../controllers/ReasoningBank.js';
 import { MCPToolCaches } from '../optimizations/ToolCache.js';
 import { validateId, validateTimestamp, validateSessionId, validateTaskString, validateNumericRange, validateArrayLength, validateBoolean, validateEnum, ValidationError, handleSecurityError, } from '../security/input-validation.js';
+import * as path from 'path';
 import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { buildMcpToolPolicy, filterMcpTools, isMcpToolAllowed, } from '../security/mcp-policy.js';
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const toolPolicy = buildMcpToolPolicy();
+// stdout belongs exclusively to JSON-RPC when running over stdio. Route every
+// transitive diagnostic (including legacy controller console.log calls) to
+// stderr before database and embedding initialization begins.
+console.log = (...args) => console.error(...args);
 // ============================================================================
 // Helper Functions for Core Vector DB Operations
 // ============================================================================
@@ -154,19 +165,19 @@ function initializeSchema(database) {
 /**
  * Serialize embedding to BLOB
  */
-function _serializeEmbedding(embedding) {
+function serializeEmbedding(embedding) {
     return Buffer.from(embedding.buffer);
 }
 /**
  * Deserialize embedding from BLOB
  */
-function _deserializeEmbedding(blob) {
+function deserializeEmbedding(blob) {
     return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
 }
 /**
  * Calculate cosine similarity between two vectors
  */
-function _cosineSimilarity(a, b) {
+function cosineSimilarity(a, b) {
     if (a.length !== b.length) {
         throw new Error('Vectors must have same length');
     }
@@ -180,39 +191,51 @@ function _cosineSimilarity(a, b) {
     }
     return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
 }
-// Keep references to suppress unused warnings (functions may be needed later)
-void _serializeEmbedding;
-void _deserializeEmbedding;
-void _cosineSimilarity;
 // ============================================================================
-// Initialize Database and Controllers via unified AgentDB
+// Initialize Database and Controllers
 // ============================================================================
-import { AgentDB } from '../core/AgentDB.js';
-const dbPath = process.env.AGENTDB_PATH || './agentdb.rvf';
-const agentdb = new AgentDB({
-    dbPath,
-    vectorBackend: 'rvf',
-    vectorDimension: 384,
-});
-await agentdb.initialize();
-const db = agentdb.database;
-console.error(`✅ Unified AgentDB initialized (${agentdb.isUnifiedMode ? 'single .rvf file' : 'legacy'} mode)`);
-// Initialize embedding service (shared by MCP-local helpers)
+const dbPath = process.env.AGENTDB_PATH || './agentdb.db';
+const db = await createDatabase(dbPath);
+// Configure for performance
+db.pragma('journal_mode = WAL');
+db.pragma('synchronous = NORMAL');
+db.pragma('cache_size = -64000');
+// Initialize schema automatically on server start using SQL files
+const schemaPath = path.join(__dirname, '../schemas/schema.sql');
+const frontierSchemaPath = path.join(__dirname, '../schemas/frontier-schema.sql');
+try {
+    if (fs.existsSync(schemaPath)) {
+        const schemaSQL = fs.readFileSync(schemaPath, 'utf-8');
+        db.exec(schemaSQL);
+        console.error('✅ Main schema loaded');
+    }
+    if (fs.existsSync(frontierSchemaPath)) {
+        const frontierSQL = fs.readFileSync(frontierSchemaPath, 'utf-8');
+        db.exec(frontierSQL);
+        console.error('✅ Frontier schema loaded');
+    }
+    console.error('✅ Database schema initialized');
+}
+catch (error) {
+    console.error('⚠️  Schema initialization failed, using fallback:', error.message);
+    // Fallback to initializeSchema function if SQL files not found
+    initializeSchema(db);
+}
+// Initialize embedding service
 const embeddingService = new EmbeddingService({
     model: 'Xenova/all-MiniLM-L6-v2',
     dimension: 384,
     provider: 'transformers'
 });
 await embeddingService.initialize();
-// Initialize all controllers using the shared db
+// Initialize all controllers
 const causalGraph = new CausalMemoryGraph(db);
 const reflexion = new ReflexionMemory(db, embeddingService);
 const skills = new SkillLibrary(db, embeddingService);
 const causalRecall = new CausalRecall(db, embeddingService);
 const learner = new NightlyLearner(db, embeddingService);
 const learningSystem = new LearningSystem(db, embeddingService);
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const _batchOps = new BatchOperations(db, embeddingService);
+const batchOps = new BatchOperations(db, embeddingService);
 const reasoningBank = new ReasoningBank(db, embeddingService);
 const caches = new MCPToolCaches();
 // ============================================================================
@@ -220,7 +243,7 @@ const caches = new MCPToolCaches();
 // ============================================================================
 const server = new Server({
     name: 'agentdb',
-    version: '3.0.0',
+    version: '1.3.0',
 }, {
     capabilities: {
         tools: {},
@@ -239,7 +262,7 @@ const tools = [
         inputSchema: {
             type: 'object',
             properties: {
-                db_path: { type: 'string', description: 'Database file path (optional, defaults to ./agentdb.rvf)', default: './agentdb.rvf' },
+                db_path: { type: 'string', description: 'Database file path (optional, defaults to ./agentdb.db)', default: './agentdb.db' },
                 reset: { type: 'boolean', description: 'Reset database (delete existing)', default: false },
             },
         },
@@ -812,86 +835,57 @@ const tools = [
             required: ['patterns'],
         },
     },
-];
-// ============================================================================
-// Solver MCP Tools (ADR-010 — gated behind WASM availability)
-// ============================================================================
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let solverInstance = null;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function getSolver() {
-    if (solverInstance)
-        return solverInstance;
-    try {
-        const { AgentDBSolver } = await import('../backends/rvf/RvfSolver.js');
-        if (await AgentDBSolver.isAvailable()) {
-            solverInstance = await AgentDBSolver.create();
-            return solverInstance;
-        }
-    }
-    catch { /* skip */ }
-    return null;
-}
-// Register solver tools at startup if WASM is available
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const solverTools = [
+    // ==========================================================================
+    // ADR-073 — SOTA roadmap additions (causal traversal · batch delete · on-demand consolidation)
+    // ==========================================================================
     {
-        name: 'solver_train',
-        description: 'Train the RVF self-learning solver on generated puzzles. Uses three-loop architecture: fast (constraint propagation), medium (PolicyKernel skip-mode), slow (KnowledgeCompiler pattern distillation).',
+        name: 'causal_traverse',
+        description: 'Walk the causal graph between two memories. Returns the chain of causal links (with confidence and uplift) up to max_depth hops. Use this to answer "WHY does this memory matter?" / "what chain of causes led here?" — the primary explainability surface beyond a single recall. Wraps CausalMemoryGraph.getCausalChain().',
         inputSchema: {
             type: 'object',
             properties: {
-                count: { type: 'number', description: 'Number of puzzles to generate and solve (1-100000)' },
-                min_difficulty: { type: 'number', description: 'Minimum puzzle difficulty 1-10' },
-                max_difficulty: { type: 'number', description: 'Maximum puzzle difficulty 1-10' },
-                seed: { type: 'number', description: 'RNG seed for reproducibility' },
+                from_memory_id: { type: 'number', description: 'Starting memory id (the cause / earlier node)' },
+                to_memory_id: { type: 'number', description: 'Ending memory id (the effect / target node)' },
+                max_depth: { type: 'number', description: 'Maximum hops along the causal chain', default: 5, minimum: 1, maximum: 20 },
             },
+            required: ['from_memory_id', 'to_memory_id'],
         },
     },
     {
-        name: 'solver_acceptance',
-        description: 'Run the A/B/C ablation acceptance test. Mode A: fixed heuristic baseline, Mode B: compiler-suggested policy, Mode C: learned Thompson Sampling policy. Returns multi-dimensional pass/fail with accuracy, cost, robustness, and violation metrics.',
+        name: 'agentdb_delete_batch',
+        description: 'Delete many episode/pattern rows by ID list in a single transaction. Faster and safer than looping `agentdb_delete` (one transaction, validated IDs, atomic). Use for bulk cleanup of old sessions / failed experiments.',
         inputSchema: {
             type: 'object',
             properties: {
-                cycles: { type: 'number', description: 'Number of acceptance cycles (1-50)' },
-                holdout_size: { type: 'number', description: 'Holdout set size' },
-                training_per_cycle: { type: 'number', description: 'Training puzzles per cycle' },
-                step_budget: { type: 'number', description: 'Max steps per solve' },
-                seed: { type: 'number', description: 'RNG seed for reproducibility' },
+                ids: { type: 'array', items: { type: 'number' }, description: 'Episode IDs to delete (1–1000 per call)', minItems: 1, maxItems: 1000 },
+                table: { type: 'string', enum: ['episodes', 'reasoning_patterns'], default: 'episodes', description: 'Target table (whitelist-validated)' },
             },
+            required: ['ids'],
         },
     },
     {
-        name: 'solver_policy',
-        description: 'Get the current Thompson Sampling policy state: 18 context-bucketed bandits (3 range x 3 distractor x 2 noise), per-arm stats, KnowledgeCompiler cache, and speculative execution metrics.',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'solver_witness',
-        description: 'Get the SHAKE-256 tamper-evident witness chain summary. Each entry is 73 bytes. Provides cryptographic audit trail of all solver state transitions.',
-        inputSchema: { type: 'object', properties: {} },
+        name: 'consolidate_now',
+        description: 'Run the NightlyLearner consolidation pass on demand — discovers new causal edges, prunes low-confidence edges, and promotes high-reward episodes into skills. Use after a batch of new episodes or when you want consolidated memories available immediately (instead of waiting for a scheduled run). Returns a summary report.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Optional: limit consolidation to this session' },
+            },
+        },
     },
 ];
-(async () => {
-    try {
-        const { AgentDBSolver } = await import('../backends/rvf/RvfSolver.js');
-        if (await AgentDBSolver.isAvailable()) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            tools.push(...solverTools);
-        }
-    }
-    catch { /* solver not available — tools not registered */ }
-})();
 // ============================================================================
 // Tool Handlers
 // ============================================================================
 server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return { tools };
+    return { tools: filterMcpTools(tools, toolPolicy) };
 });
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
+        if (!isMcpToolAllowed(name, toolPolicy)) {
+            throw new Error(`MCP tool "${name}" is not permitted by the active AgentDB capability policy`);
+        }
         switch (name) {
             // ======================================================================
             // CORE VECTOR DB OPERATIONS
@@ -910,7 +904,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             type: 'text',
                             text: `✅ AgentDB initialized successfully!\n` +
                                 `📍 Database: ${targetDbPath}\n` +
-                                `📊 Tables created: ${stats?.count ?? 0}\n` +
+                                `📊 Tables created: ${stats.count}\n` +
                                 `⚙️  Optimizations: WAL mode, cache_size=64MB\n` +
                                 `🧠 Embedding service: ${embeddingService.constructor.name} ready`,
                         },
@@ -1247,12 +1241,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case 'db_stats': {
                 const stats = {
-                    causal_edges: (db.prepare('SELECT COUNT(*) as count FROM causal_edges').get())?.count || 0,
-                    causal_experiments: (db.prepare('SELECT COUNT(*) as count FROM causal_experiments').get())?.count || 0,
-                    causal_observations: (db.prepare('SELECT COUNT(*) as count FROM causal_observations').get())?.count || 0,
-                    episodes: (db.prepare('SELECT COUNT(*) as count FROM episodes').get())?.count || 0,
-                    episode_embeddings: (db.prepare('SELECT COUNT(*) as count FROM episode_embeddings').get())?.count || 0,
-                    skills: (db.prepare('SELECT COUNT(*) as count FROM skills').get())?.count || 0,
+                    causal_edges: db.prepare('SELECT COUNT(*) as count FROM causal_edges').get()?.count || 0,
+                    causal_experiments: db.prepare('SELECT COUNT(*) as count FROM causal_experiments').get()?.count || 0,
+                    causal_observations: db.prepare('SELECT COUNT(*) as count FROM causal_observations').get()?.count || 0,
+                    episodes: db.prepare('SELECT COUNT(*) as count FROM episodes').get()?.count || 0,
+                    episode_embeddings: db.prepare('SELECT COUNT(*) as count FROM episode_embeddings').get()?.count || 0,
+                    skills: db.prepare('SELECT COUNT(*) as count FROM skills').get()?.count || 0,
                 };
                 return {
                     content: [
@@ -1290,7 +1284,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 // Helper to safely query table count
                 const safeCount = (tableName) => {
                     try {
-                        return (db.prepare(`SELECT COUNT(*) as count FROM ${tableName}`).get())?.count || 0;
+                        return db.prepare(`SELECT COUNT(*) as count FROM ${tableName}`).get()?.count || 0;
                     }
                     catch {
                         return 0; // Table doesn't exist
@@ -1327,7 +1321,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             SELECT page_count * page_size as total_bytes
             FROM pragma_page_count(), pragma_page_size()
           `).get();
-                    const totalMB = ((dbStats?.total_bytes ?? 0) / (1024 * 1024)).toFixed(2);
+                    const totalMB = (dbStats.total_bytes / (1024 * 1024)).toFixed(2);
                     // Add recent activity stats
                     const recentActivity = db.prepare(`
             SELECT COUNT(*) as count
@@ -1336,7 +1330,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           `).get();
                     output += `\n📦 Storage:\n` +
                         `   Database Size: ${totalMB} MB\n` +
-                        `   Recent Activity (7d): ${recentActivity?.count ?? 0} episodes\n`;
+                        `   Recent Activity (7d): ${recentActivity.count} episodes\n`;
                 }
                 // Cache the result (60s TTL)
                 caches.stats.set(cacheKey, output);
@@ -1489,7 +1483,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const batchSize = args?.batch_size ? validateNumericRange(args.batch_size, 'batch_size', 1, 100) : 32;
                     const format = args?.format ? validateEnum(args.format, 'format', ['concise', 'detailed', 'json']) : 'concise';
                     // Validate each skill
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const validatedSkills = skillsArray.map((skill, index) => {
                         const name = validateTaskString(skill.name, `skills[${index}].name`);
                         const description = validateTaskString(skill.description, `skills[${index}].description`);
@@ -1592,7 +1585,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const batchSize = args?.batch_size ? validateNumericRange(args.batch_size, 'batch_size', 1, 1000) : 100;
                     const format = args?.format ? validateEnum(args.format, 'format', ['concise', 'detailed', 'json']) : 'concise';
                     // Validate each episode
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const validatedEpisodes = episodesArray.map((ep, index) => {
                         const sessionId = validateSessionId(ep.session_id);
                         const task = validateTaskString(ep.task, `episodes[${index}].task`);
@@ -1695,7 +1687,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const batchSize = args?.batch_size ? validateNumericRange(args.batch_size, 'batch_size', 1, 500) : 50;
                     const format = args?.format ? validateEnum(args.format, 'format', ['concise', 'detailed', 'json']) : 'concise';
                     // Validate each pattern
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const validatedPatterns = patternsArray.map((pattern, index) => {
                         const taskType = validateTaskString(pattern.taskType, `patterns[${index}].taskType`);
                         const approach = validateTaskString(pattern.approach, `patterns[${index}].approach`);
@@ -1889,7 +1880,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const epochs = args?.epochs || 50;
                 const batchSize = args?.batch_size || 32;
                 const learningRate = args?.learning_rate || 0.01;
-                console.error(`🎓 Training session ${sessionId}...`);
+                console.log(`🎓 Training session ${sessionId}...`);
                 const result = await learningSystem.train(sessionId, epochs, batchSize, learningRate);
                 return {
                     content: [
@@ -1969,7 +1960,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const sourceTask = args?.source_task;
                 const targetTask = args?.target_task;
                 const minSimilarity = args?.min_similarity || 0.7;
-                const transferType = (args?.transfer_type || 'all');
+                const transferType = args?.transfer_type || 'all';
                 const maxTransfers = args?.max_transfers || 10;
                 const result = await learningSystem.transferLearning({
                     sourceSession,
@@ -2003,7 +1994,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'learning_explain': {
                 const query = args?.query;
                 const k = args?.k || 5;
-                const explainDepth = (args?.explain_depth || 'detailed');
+                const explainDepth = args?.explain_depth || 'detailed';
                 const includeConfidence = args?.include_confidence !== false;
                 const includeEvidence = args?.include_evidence !== false;
                 const includeCausal = args?.include_causal !== false;
@@ -2034,7 +2025,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     `   • Avg Similarity: ${(explanation.reasoning.avgSimilarity * 100).toFixed(1)}%\n` +
                                     `   • Unique Actions Considered: ${explanation.reasoning.uniqueActions}` : '') +
                                 (includeCausal && explanation.causalChains && explanation.causalChains.length > 0 ? `\n\n🔗 Causal Reasoning Chains:\n` +
-                                    explanation.causalChains.slice(0, 3).map((chain, i) => `   ${i + 1}. ${chain.from_memory_id} → ${chain.to_memory_id} (uplift: ${(chain.uplift || 0).toFixed(3)})`).join('\n') : ''),
+                                    explanation.causalChains.slice(0, 3).map((chain, i) => `   ${i + 1}. ${chain.fromMemoryType} → ${chain.toMemoryType} (uplift: ${(chain.uplift || 0).toFixed(3)})`).join('\n') : ''),
                         },
                     ],
                 };
@@ -2089,7 +2080,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const timeTakenMs = args?.time_taken_ms;
                 const expectedTimeMs = args?.expected_time_ms;
                 const includeCausal = args?.include_causal !== false;
-                const rewardFunction = (args?.reward_function || 'standard');
+                const rewardFunction = args?.reward_function || 'standard';
                 const reward = learningSystem.calculateReward({
                     episodeId,
                     success,
@@ -2121,69 +2112,64 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             // ======================================================================
-            // SOLVER TOOLS (ADR-010)
+            // ADR-073 — SOTA roadmap handlers
             // ======================================================================
-            case 'solver_train': {
-                const solver = await getSolver();
-                if (!solver)
-                    throw new Error('RVF Solver not available. Install @ruvector/rvf-solver.');
-                const count = validateNumericRange(args?.count ?? 50, 'count', 1, 100000);
-                const minDifficulty = validateNumericRange(args?.min_difficulty ?? 1, 'min_difficulty', 1, 10);
-                const maxDifficulty = validateNumericRange(args?.max_difficulty ?? 10, 'max_difficulty', 1, 10);
-                const result = solver.train({ count, minDifficulty, maxDifficulty, seed: args?.seed });
+            case 'causal_traverse': {
+                const fromId = args?.from_memory_id;
+                const toId = args?.to_memory_id;
+                const maxDepth = args?.max_depth || 5;
+                const chain = await causalGraph.getCausalChain(fromId, toId, maxDepth);
+                const found = chain && Array.isArray(chain.edges) ? chain.edges.length > 0 : false;
                 return {
                     content: [{
                             type: 'text',
-                            text: JSON.stringify(result, null, 2),
+                            text: found
+                                ? `🔗 Causal chain ${fromId} → ${toId} (max ${maxDepth} hops):\n${JSON.stringify(chain, null, 2)}`
+                                : `❌ No causal chain found between memory #${fromId} and #${toId} within ${maxDepth} hops.`,
                         }],
                 };
             }
-            case 'solver_acceptance': {
-                const solver = await getSolver();
-                if (!solver)
-                    throw new Error('RVF Solver not available. Install @ruvector/rvf-solver.');
-                const manifest = solver.acceptance({
-                    cycles: args?.cycles,
-                    holdoutSize: args?.holdout_size,
-                    trainingPerCycle: args?.training_per_cycle,
-                    stepBudget: args?.step_budget,
-                    seed: args?.seed,
+            case 'agentdb_delete_batch': {
+                const ids = args?.ids || [];
+                const requestedTable = args?.table || 'episodes';
+                const allowedTables = new Set(['episodes', 'reasoning_patterns']);
+                if (!allowedTables.has(requestedTable)) {
+                    throw new Error(`Invalid table: ${requestedTable}`);
+                }
+                if (ids.length === 0) {
+                    return { content: [{ type: 'text', text: '⚠️  No IDs supplied — nothing to delete.' }] };
+                }
+                // Validate each id is a positive integer (defense in depth)
+                const safeIds = ids.map((raw) => {
+                    const n = Number(raw);
+                    if (!Number.isInteger(n) || n <= 0)
+                        throw new Error(`Invalid id: ${raw}`);
+                    return n;
                 });
+                const placeholders = safeIds.map(() => '?').join(',');
+                // requestedTable is whitelist-checked above; parameterising values via ?.
+                const stmt = db.prepare(`DELETE FROM ${requestedTable} WHERE id IN (${placeholders})`);
+                const result = stmt.run(...safeIds);
                 return {
                     content: [{
                             type: 'text',
-                            text: JSON.stringify(manifest, null, 2),
+                            text: `🗑️  Batch delete from \`${requestedTable}\`: ${result.changes}/${safeIds.length} rows removed (atomic).`,
                         }],
                 };
             }
-            case 'solver_policy': {
-                const solver = await getSolver();
-                if (!solver)
-                    throw new Error('RVF Solver not available. Install @ruvector/rvf-solver.');
-                const policy = solver.policy();
-                return {
-                    content: [{
-                            type: 'text',
-                            text: policy ? JSON.stringify(policy, null, 2) : 'No policy state available (no training yet).',
-                        }],
-                };
-            }
-            case 'solver_witness': {
-                const solver = await getSolver();
-                if (!solver)
-                    throw new Error('RVF Solver not available. Install @ruvector/rvf-solver.');
-                const chain = solver.witnessChain();
-                if (!chain || chain.length === 0) {
-                    return { content: [{ type: 'text', text: JSON.stringify({ entries: 0, bytes: 0, hex: '' }) }] };
-                }
-                const entries = Math.floor(chain.length / 73);
-                const slice = new Uint8Array(chain.buffer, chain.byteOffset, Math.min(chain.length, 73 * 3));
-                const hex = Array.from(slice)
-                    .map(b => b.toString(16).padStart(2, '0')).join('');
+            case 'consolidate_now': {
+                const sessionId = args?.session_id;
+                const t0 = Date.now();
+                // Prefer the session-scoped path when sessionId is given.
+                const report = sessionId
+                    ? await learner.consolidateEpisodes(sessionId)
+                    : await learner.run();
+                const ms = Date.now() - t0;
                 return {
                     content: [{
                             type: 'text',
-                            text: JSON.stringify({ entries, bytes: chain.length, hex: hex.length > 438 ? hex.slice(0, 438) + '...' : hex }, null, 2),
+                            text: `🌙 Consolidation complete${sessionId ? ` (session=${sessionId})` : ''} in ${ms}ms\n` +
+                                JSON.stringify(report, null, 2),
                         }],
                 };
             }
@@ -2196,7 +2182,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             content: [
                 {
                     type: 'text',
-                    text: `❌ Error: ${error.message}`,
+                    text: `❌ Error: ${error.message}\n${error.stack || ''}`,
                 },
             ],
             isError: true,
@@ -2209,8 +2195,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('🚀 AgentDB MCP Server v3.0.0 running on stdio');
-    console.error('📦 33 tools available (5 core + 9 frontier + 10 learning + 5 AgentDB + 4 batch ops)');
+    console.error('🚀 AgentDB MCP Server v2.0.0 running on stdio');
+    console.error('📦 32 tools available (5 core + 9 frontier + 10 learning + 5 AgentDB + 3 batch ops)');
     console.error('🧠 Embedding service initialized');
     console.error('🎓 Learning system ready (9 RL algorithms)');
     console.error('⚡ NEW v2.0: Batch operations (3-4x faster), format parameters, enhanced validation');
@@ -2223,10 +2209,12 @@ async function main() {
         // Empty interval just to keep event loop alive
     }, 1000 * 60 * 60); // Every hour (basically forever)
     // Periodic auto-save: Save database every 5 minutes to prevent data loss
-    const autoSaveInterval = setInterval(async () => {
+    const autoSaveInterval = setInterval(() => {
         try {
-            await agentdb.save();
-            console.error('💾 Auto-saved database to', dbPath);
+            if (db && typeof db.save === 'function') {
+                db.save();
+                console.error('💾 Auto-saved database to', dbPath);
+            }
         }
         catch (error) {
             console.error('❌ Auto-save failed:', error.message);
@@ -2238,18 +2226,33 @@ async function main() {
         // Clear intervals
         clearInterval(keepAlive);
         clearInterval(autoSaveInterval);
-        // Save and close via unified AgentDB (handles both vectors + relational)
+        let persistenceFailed = false;
+        // Save database before exit
+        try {
+            if (db && typeof db.save === 'function') {
+                console.error('💾 Saving database to', dbPath);
+                await db.save();
+                console.error('✅ Database saved successfully');
+            }
+        }
+        catch (error) {
+            persistenceFailed = true;
+            console.error('❌ Error saving database:', error.message);
+        }
+        // Close database connection. close() persists sql.js itself, so only call
+        // it after save when save succeeded; a failed optimistic save must not be
+        // retried against the same stale snapshot.
         try {
-            console.error('💾 Saving database to', dbPath);
-            await agentdb.save();
-            console.error('✅ Database saved successfully');
-            await agentdb.close();
-            console.error('✅ Database connection closed');
+            if (!persistenceFailed && db && typeof db.close === 'function') {
+                db.close();
+                console.error('✅ Database connection closed');
+            }
         }
         catch (error) {
-            console.error('❌ Error during shutdown:', error.message);
+            persistenceFailed = true;
+            console.error('❌ Error closing database:', error.message);
         }
-        process.exit(0);
+        process.exit(persistenceFailed ? 1 : 0);
     };
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);