agentic-flow 3.0.0-alpha.2 → 3.1.0

package/dist/services/agentdb-service.js

@@ -1,12 +1,24 @@
 /**
  * AgentDB Integration Service
  *
- * Singleton service providing a unified interface to AgentDB controllers.
- * Detects backends (RuVector -> HNSWLib -> sql.js) with in-memory fallback.
+ * Singleton service providing a unified interface to the AgentDB controllers
+ * (ReflexionMemory, ReasoningBank, LearningSystem). AgentDB is loaded with a
+ * dynamic import; when it is missing or fails to initialize, the service keeps
+ * working on an in-memory store and reports `getBackendName() === 'in-memory'`.
+ *
+ * Ported from agentic-flow 3.0.0-alpha.2 and trimmed to the surface used by
+ * AutopilotLearning. The alpha line imported AgentDB through monorepo-relative
+ * paths (`../../../packages/agentdb/src/...`) that never resolved from an
+ * installed package, so it always ran on the in-memory fallback. This version
+ * resolves the published `agentdb` package instead.
+ *
+ * Nothing here writes to stdout: callers such as ruflo's MCP server use stdout
+ * as their JSON-RPC channel.
  */
 import * as path from 'path';
 import * as fs from 'fs';
-import { CostOptimizerService } from './cost-optimizer-service.js';
+/** Directory that holds agentdb.sqlite. Overridable for tests and embedders. */
+export const AGENTDB_DIR_ENV = 'AGENTIC_FLOW_AGENTDB_DIR';
 // -- In-memory fallback store -----------------------------------------------
 class InMemoryStore {
     items = new Map();
@@ -31,46 +43,16 @@ class InMemoryStore {
 // -- Service ----------------------------------------------------------------
 export class AgentDBService {
     static instance = null;
+    agentdb = null;
     db = null;
     reflexionMemory = null;
-    skillLibrary = null;
     reasoningBank = null;
-    causalGraph = null;
-    causalRecall = null;
     learningSystem = null;
     embeddingService = null;
-    vectorBackend = null;
-    // Phase 1: High-impact dormant controllers
-    attentionService = null;
-    wasmVectorSearch = null;
-    mmrRanker = null;
-    contextSynthesizer = null;
-    // Phase 2: RuVector package integrations
-    gnnLearning = null; // @ruvector/gnn
-    semanticRouter = null; // @ruvector/router
-    graphAdapter = null; // @ruvector/graph-node
-    sonaService = null; // @ruvector/sona
-    gnnEnabled = false;
-    routerEnabled = false;
-    graphEnabled = false;
-    sonaEnabled = false;
-    // Phase 4: Distributed controllers
-    syncCoordinator = null;
-    nightlyLearner = null;
-    explainableRecall = null;
-    quicClient = null;
-    quicServer = null;
-    // ADR-063: RVF Optimizer for 2-100x embedding optimization
-    rvfOptimizer = null;
-    // ADR-066 P2-3: Hierarchical Memory System
-    hierarchicalMemory = null;
-    memoryConsolidation = null;
-    // ADR-064: Cost Optimizer for 90% savings via intelligent model routing
-    costOptimizer = null;
+    learningSessionId = null;
+    exitHook = null;
     episodeStore = new InMemoryStore();
-    skillStore = new InMemoryStore();
     patternStore = new InMemoryStore();
-    causalEdges = [];
     trajectories = [];
     backendName = 'in-memory';
     startTime = Date.now();
@@ -84,431 +66,70 @@ export class AgentDBService {
         return AgentDBService.instance;
     }
     static resetInstance() { AgentDBService.instance = null; }
+    /** 'agentdb' when the real AgentDB backend is active, otherwise 'in-memory'. */
+    getBackendName() { return this.backendName; }
     // -- Init -----------------------------------------------------------------
     async initialize() {
         if (this.initialized)
             return;
-        const dbDir = path.join(process.cwd(), '.claude-flow', 'agentdb');
-        if (!fs.existsSync(dbDir))
-            fs.mkdirSync(dbDir, { recursive: true });
-        const dbPath = path.join(dbDir, 'agentdb.sqlite');
+        this.initialized = true;
+        let agentdb;
+        try {
+            agentdb = await import(/* webpackIgnore: true */ 'agentdb');
+        }
+        catch {
+            return; // AgentDB not installed — in-memory fallback
+        }
         try {
-            const agentdb = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/index.js');
+            const dbDir = process.env[AGENTDB_DIR_ENV] || path.join(process.cwd(), '.claude-flow', 'agentdb');
+            if (!fs.existsSync(dbDir))
+                fs.mkdirSync(dbDir, { recursive: true });
+            const dbPath = path.join(dbDir, 'agentdb.sqlite');
             const AgentDB = agentdb.AgentDB ?? agentdb.default;
             this.db = new AgentDB({ dbPath });
             await this.db.initialize();
-            const EmbeddingSvc = agentdb.EmbeddingService;
-            this.embeddingService = new EmbeddingSvc({
+            this.embeddingService = new agentdb.EmbeddingService({
                 model: 'Xenova/all-MiniLM-L6-v2', dimension: 384, provider: 'transformers',
             });
             await this.embeddingService.initialize();
-            // ADR-063: Initialize RVFOptimizer for 2-100x embedding optimization
-            try {
-                const { RVFOptimizer } = await import(
-                /* webpackIgnore: true */ '../../../packages/agentdb/src/optimizations/RVFOptimizer.js');
-                this.rvfOptimizer = new RVFOptimizer({
-                    compression: {
-                        enabled: true,
-                        quantizeBits: 8, // 4x memory reduction, minimal quality loss
-                        deduplicationThreshold: 0.98 // 98% similarity = duplicate
-                    },
-                    pruning: {
-                        enabled: true,
-                        minConfidence: 0.3, // Remove low-quality memories
-                        maxAge: 30 * 24 * 60 * 60 * 1000 // 30 days
-                    },
-                    batching: {
-                        enabled: true,
-                        batchSize: 32, // Optimal for most workloads
-                        maxWaitMs: 10 // 10ms max latency
-                    },
-                    caching: {
-                        enabled: true,
-                        maxSize: 10000, // 10K embeddings cached
-                        ttl: 60 * 60 * 1000 // 1 hour TTL
-                    }
-                });
-                console.log('[AgentDBService] RVFOptimizer initialized (2-100x performance improvement)');
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.warn(`[AgentDBService] RVFOptimizer unavailable (${msg}), using unoptimized embeddings`);
-            }
-            // Initialize VectorBackend for HNSW-accelerated search
-            let vectorBackend = null;
-            try {
-                const { createBackend } = await import(
-                /* webpackIgnore: true */ '../../../packages/agentdb/src/backends/factory.js');
-                vectorBackend = await createBackend('auto', {
-                    dimension: 384,
-                    metric: 'cosine',
-                    maxElements: 10000,
-                    efConstruction: 200,
-                    M: 16,
-                });
-                this.vectorBackend = vectorBackend;
-                console.log('[AgentDBService] VectorBackend initialized');
-            }
-            catch (err) {
-                console.warn('[AgentDBService] VectorBackend unavailable, using SQL fallback');
-            }
+            // AgentDB builds its own vector backend during initialize(); the
+            // controllers here use the SQL-backed embedding search so they need no
+            // separate backend (the alpha line's MutationGuard wrapper is gone).
             const database = this.db.database;
-            // ADR-060: Wrap vectorBackend with proof-gated MutationGuard.
-            // Proofs via @ruvector/graph-transformer prevent the root-cause errors
-            // (dimension mismatch, missing field `k`) before they reach the native addon.
-            let controllerVB = null;
-            if (vectorBackend) {
-                try {
-                    const { MutationGuard } = await import(
-                    /* webpackIgnore: true */ '../../../packages/agentdb/src/security/MutationGuard.js');
-                    const { GuardedVectorBackend } = await import(
-                    /* webpackIgnore: true */ '../../../packages/agentdb/src/backends/ruvector/GuardedVectorBackend.js');
-                    const { AttestationLog } = await import(
-                    /* webpackIgnore: true */ '../../../packages/agentdb/src/security/AttestationLog.js');
-                    const guard = new MutationGuard({
-                        dimension: 384,
-                        maxElements: 10000,
-                        enableWasmProofs: true,
-                        enableAttestationLog: true,
-                        defaultNamespace: 'agentdb',
-                    });
-                    await guard.initialize();
-                    const attestLog = new AttestationLog(database);
-                    controllerVB = new GuardedVectorBackend(vectorBackend, guard, attestLog);
-                    console.log(`[AgentDBService] VectorBackend guarded (${guard.getStats().engineType})`);
-                }
-                catch (guardErr) {
-                    const msg = guardErr instanceof Error ? guardErr.message : String(guardErr);
-                    console.warn(`[AgentDBService] MutationGuard unavailable (${msg}), vectorBackend disabled`);
-                }
-            }
-            this.reflexionMemory = new agentdb.ReflexionMemory(database, this.embeddingService, controllerVB);
-            this.skillLibrary = new agentdb.SkillLibrary(database, this.embeddingService, controllerVB);
-            this.reasoningBank = new agentdb.ReasoningBank(database, this.embeddingService, controllerVB);
-            this.causalGraph = new agentdb.CausalMemoryGraph(database);
-            this.causalRecall = new agentdb.CausalRecall(database, this.embeddingService);
+            this.reflexionMemory = new agentdb.ReflexionMemory(database, this.embeddingService);
+            this.reasoningBank = new agentdb.ReasoningBank(database, this.embeddingService);
             this.learningSystem = new agentdb.LearningSystem(database, this.embeddingService);
+            this.agentdb = agentdb;
             this.backendName = 'agentdb';
-            console.log('[AgentDBService] Initialized with real AgentDB backend');
-            // Phase 1: Initialize high-impact dormant controllers
-            await this.initializePhase1Controllers(database);
-            // Replace basic EmbeddingService with EnhancedEmbeddingService
-            await this.upgradeEmbeddingService();
-            // Phase 2: Initialize RuVector package integrations
-            await this.initializePhase2RuVectorPackages(database);
-            // Phase 4: Initialize distributed controllers
-            await this.initializePhase4Controllers(database);
-            // ADR-064: Initialize Cost Optimizer for intelligent model routing
-            try {
-                this.costOptimizer = CostOptimizerService.getInstance();
-                console.log('[AgentDBService] CostOptimizer initialized (90% savings via intelligent routing)');
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.warn(`[AgentDBService] CostOptimizer unavailable (${msg})`);
-            }
-            // ADR-066 P2-3: Initialize Hierarchical Memory System
-            try {
-                const { HierarchicalMemory } = await import(
-                /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/HierarchicalMemory.js');
-                const { MemoryConsolidation } = await import(
-                /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/MemoryConsolidation.js');
-                this.hierarchicalMemory = new HierarchicalMemory(database, this.embeddingService, vectorBackend, graphBackend, {
-                    workingMemoryLimit: 1024 * 1024, // 1MB
-                    episodicWindow: 7 * 24 * 60 * 60 * 1000, // 7 days
-                    autoConsolidate: true,
-                });
-                this.memoryConsolidation = new MemoryConsolidation(database, this.hierarchicalMemory, this.embeddingService, vectorBackend, graphBackend, {
-                    clusterThreshold: 0.75,
-                    importanceThreshold: 0.6,
-                    enableSpacedRepetition: true,
-                });
-                console.log('[AgentDBService] HierarchicalMemory + MemoryConsolidation initialized (3-tier memory system)');
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.warn(`[AgentDBService] HierarchicalMemory unavailable (${msg})`);
-            }
+            this.saveOnExit(database);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             console.warn(`[AgentDBService] AgentDB unavailable (${msg}), using in-memory fallback`);
+            this.reflexionMemory = null;
+            this.reasoningBank = null;
+            this.learningSystem = null;
             this.backendName = 'in-memory';
         }
-        this.initialized = true;
-    }
-    /**
-     * Initialize Phase 1 high-impact controllers
-     */
-    async initializePhase1Controllers(database) {
-        // 1. AttentionService - Advanced attention mechanisms with @ruvector/attention
-        try {
-            const { AttentionService } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/AttentionService.js');
-            this.attentionService = new AttentionService({
-                numHeads: 8,
-                headDim: 48,
-                embedDim: 384,
-                useFlash: true,
-                dropout: 0.1,
-            });
-            await this.attentionService.initialize();
-            console.log('[AgentDBService] AttentionService initialized');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] AttentionService unavailable (${msg})`);
-        }
-        // 2. WASMVectorSearch - High-performance vector operations with ReasoningBank WASM
-        try {
-            const { WASMVectorSearch } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/WASMVectorSearch.js');
-            this.wasmVectorSearch = new WASMVectorSearch(database, {
-                enableWASM: true,
-                enableSIMD: true,
-                batchSize: 100,
-                indexThreshold: 1000,
-            });
-            console.log('[AgentDBService] WASMVectorSearch initialized');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] WASMVectorSearch unavailable (${msg})`);
-        }
-        // 3. MMRDiversityRanker - Already loaded statically, store reference
-        try {
-            const { MMRDiversityRanker } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/MMRDiversityRanker.js');
-            this.mmrRanker = MMRDiversityRanker;
-            console.log('[AgentDBService] MMRDiversityRanker initialized');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] MMRDiversityRanker unavailable (${msg})`);
-        }
-        // 4. ContextSynthesizer - Context generation from multiple memories
-        try {
-            const { ContextSynthesizer } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/ContextSynthesizer.js');
-            this.contextSynthesizer = ContextSynthesizer;
-            console.log('[AgentDBService] ContextSynthesizer initialized');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] ContextSynthesizer unavailable (${msg})`);
-        }
     }
     /**
-     * Upgrade basic EmbeddingService to EnhancedEmbeddingService
+     * better-sqlite3 writes through to disk. The sql.js WASM fallback (used when
+     * the native module is not built) keeps everything in memory until save()
+     * or close(), and a long-lived host such as an MCP server never calls
+     * shutdown(). Saving after each write is not an option: in agentdb
+     * 3.0.0-alpha.20, save() frees the cached prepared statements and the next
+     * insert throws. So flush once, when the process exits.
      */
-    async upgradeEmbeddingService() {
-        if (!this.embeddingService)
+    saveOnExit(database) {
+        if (!database || typeof database.save !== 'function')
             return;
-        try {
-            const { EnhancedEmbeddingService } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/EnhancedEmbeddingService.js');
-            // Create enhanced version with same config
-            const enhanced = new EnhancedEmbeddingService({
-                model: 'Xenova/all-MiniLM-L6-v2',
-                dimension: 384,
-                provider: 'transformers',
-                enableWASM: true,
-                enableBatchProcessing: true,
-                batchSize: 100,
-            });
-            await enhanced.initialize();
-            // Replace basic service with enhanced version
-            this.embeddingService = enhanced;
-            console.log('[AgentDBService] Upgraded to EnhancedEmbeddingService with WASM acceleration');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] EnhancedEmbeddingService unavailable (${msg}), keeping basic service`);
-        }
-    }
-    /**
-     * Initialize Phase 2: Activate 4 dormant RuVector packages
-     * 1. @ruvector/gnn - Graph Neural Networks for enhanced embeddings
-     * 2. @ruvector/router - Semantic routing
-     * 3. @ruvector/graph-node - Native hypergraph database
-     * 4. @ruvector/sona - RL trajectory learning
-     */
-    async initializePhase2RuVectorPackages(database) {
-        // 1. @ruvector/gnn - GNN-enhanced learning
-        try {
-            const { RuVectorLearning } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/backends/ruvector/RuVectorLearning.js');
-            this.gnnLearning = new RuVectorLearning({
-                inputDim: 384,
-                hiddenDim: 256,
-                heads: 4,
-                dropout: 0.1
-            });
-            await this.gnnLearning.initialize();
-            this.gnnEnabled = true;
-            console.log('✅ [AgentDBService] Phase 2.1: GNN-enhanced learning active (@ruvector/gnn)');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] Phase 2.1: GNN unavailable (${msg})`);
-            this.gnnEnabled = false;
-        }
-        // 2. @ruvector/router - Semantic routing
-        try {
-            const { SemanticRouter } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/services/SemanticRouter.js');
-            this.semanticRouter = new SemanticRouter();
-            const initialized = await this.semanticRouter.initialize();
-            this.routerEnabled = initialized;
-            if (initialized) {
-                // Add default routes for tier routing
-                await this.semanticRouter.addRoute('tier1', 'Simple transforms and basic operations', ['transform', 'convert', 'format']);
-                await this.semanticRouter.addRoute('tier2', 'Moderate complexity tasks', ['implement', 'create', 'build']);
-                await this.semanticRouter.addRoute('tier3', 'Complex reasoning and architecture', ['design', 'architect', 'optimize']);
-                console.log('✅ [AgentDBService] Phase 2.2: Semantic routing active (@ruvector/router)');
-            }
-            else {
-                console.warn('[AgentDBService] Phase 2.2: Router using keyword fallback');
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] Phase 2.2: Router unavailable (${msg})`);
-            this.routerEnabled = false;
-        }
-        // 3. @ruvector/graph-node - Native hypergraph database
-        try {
-            const { GraphDatabaseAdapter } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/backends/graph/GraphDatabaseAdapter.js');
-            const graphPath = path.join(process.cwd(), '.claude-flow', 'agentdb', 'graph.db');
-            this.graphAdapter = new GraphDatabaseAdapter({
-                storagePath: graphPath,
-                dimensions: 384,
-                distanceMetric: 'Cosine'
-            }, this.embeddingService);
-            await this.graphAdapter.initialize();
-            this.graphEnabled = true;
-            console.log('✅ [AgentDBService] Phase 2.3: Native hypergraph DB active (@ruvector/graph-node)');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] Phase 2.3: Graph DB unavailable (${msg})`);
-            this.graphEnabled = false;
-        }
-        // 4. @ruvector/sona - RL trajectory learning
-        try {
-            const { SonaTrajectoryService } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/services/SonaTrajectoryService.js');
-            this.sonaService = new SonaTrajectoryService();
-            const initialized = await this.sonaService.initialize();
-            this.sonaEnabled = initialized;
-            if (initialized) {
-                console.log('✅ [AgentDBService] Phase 2.4: Sona RL trajectory learning active (@ruvector/sona)');
-            }
-            else {
-                console.warn('[AgentDBService] Phase 2.4: Sona using in-memory fallback');
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] Phase 2.4: Sona unavailable (${msg})`);
-            this.sonaEnabled = false;
-        }
-        console.log(`[AgentDBService] Phase 2 complete: GNN=${this.gnnEnabled}, Router=${this.routerEnabled}, Graph=${this.graphEnabled}, Sona=${this.sonaEnabled}`);
-    }
-    /**
-     * Initialize Phase 4 distributed controllers (WASM + Distributed Features)
-     */
-    async initializePhase4Controllers(database) {
-        // 1. SyncCoordinator - Multi-instance sync with conflict resolution
-        try {
-            const { SyncCoordinator } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/SyncCoordinator.js');
-            // Initialize QUIC client if enabled
-            const quicEnabled = process.env.ENABLE_QUIC_SYNC === 'true';
-            if (quicEnabled && process.env.QUIC_SERVER_HOST) {
-                try {
-                    const { QUICClient } = await import(
-                    /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/QUICClient.js');
-                    this.quicClient = new QUICClient({
-                        serverHost: process.env.QUIC_SERVER_HOST || 'localhost',
-                        serverPort: parseInt(process.env.QUIC_SERVER_PORT || '4433'),
-                        authToken: process.env.QUIC_AUTH_TOKEN,
-                    });
-                    console.log('[AgentDBService] QUICClient initialized');
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.warn(`[AgentDBService] QUICClient unavailable (${msg})`);
-                }
-            }
-            this.syncCoordinator = new SyncCoordinator({
-                db: database,
-                client: this.quicClient,
-                conflictStrategy: 'latest-wins',
-                batchSize: 100,
-                autoSync: false,
-            });
-            console.log('[AgentDBService] SyncCoordinator initialized');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] SyncCoordinator unavailable (${msg})`);
-        }
-        // 2. NightlyLearner - Automated causal discovery
-        try {
-            const { NightlyLearner } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/NightlyLearner.js');
-            this.nightlyLearner = new NightlyLearner(database, this.embeddingService, {
-                minSimilarity: 0.7,
-                minSampleSize: 30,
-                confidenceThreshold: 0.6,
-                upliftThreshold: 0.05,
-                pruneOldEdges: true,
-                edgeMaxAgeDays: 90,
-                autoExperiments: true,
-                experimentBudget: 10,
-                ENABLE_FLASH_CONSOLIDATION: false,
-            });
-            console.log('[AgentDBService] NightlyLearner initialized');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] NightlyLearner unavailable (${msg})`);
-        }
-        // 3. ExplainableRecall - Merkle provenance chains
-        try {
-            const { ExplainableRecall } = await import(
-            /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/ExplainableRecall.js');
-            this.explainableRecall = new ExplainableRecall(database, this.embeddingService, {
-                ENABLE_GRAPH_ROPE: false,
-            });
-            console.log('[AgentDBService] ExplainableRecall initialized');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[AgentDBService] ExplainableRecall unavailable (${msg})`);
-        }
-        // 4. QUIC Server (optional, for distributed deployments)
-        const quicServerEnabled = process.env.ENABLE_QUIC_SERVER === 'true';
-        if (quicServerEnabled) {
+        this.exitHook = () => {
             try {
-                const { QUICServer } = await import(
-                /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/QUICServer.js');
-                this.quicServer = new QUICServer(database, {
-                    host: process.env.QUIC_SERVER_HOST || '0.0.0.0',
-                    port: parseInt(process.env.QUIC_SERVER_PORT || '4433'),
-                    authToken: process.env.QUIC_AUTH_TOKEN,
-                    maxConnections: 100,
-                });
-                console.log('[AgentDBService] QUICServer initialized');
+                database.save();
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.warn(`[AgentDBService] QUICServer unavailable (${msg})`);
-            }
-        }
+            catch { /* nothing left to do at exit */ }
+        };
+        process.once('exit', this.exitHook);
     }
     // -- Episodes -------------------------------------------------------------
     async storeEpisode(episode) {
@@ -523,24 +144,22 @@ export class AgentDBService {
         return String(this.episodeStore.add({ ...episode, ts: Date.now(), id: 0 }));
     }
     async recallEpisodes(query, limit = 5, filters) {
+        const hasFilters = !!filters && Object.keys(filters).length > 0;
         if (this.reflexionMemory) {
             try {
-                const fetchCount = filters && Object.keys(filters).length > 0 ? limit * 2 : limit;
+                const fetchCount = hasFilters ? limit * 2 : limit;
                 const results = await this.reflexionMemory.retrieveRelevant({ task: query, k: fetchCount });
                 let episodes = (results ?? []).map((r) => ({
                     id: r.id ?? 0, ts: r.ts ?? 0, sessionId: r.sessionId ?? '',
                     task: r.task ?? '', input: r.input, output: r.output, critique: r.critique,
                     reward: r.reward ?? 0, success: r.success ?? false, similarity: r.similarity,
-                    metadata: r.metadata,
+                    tags: r.tags, metadata: r.metadata,
                 }));
-                // Apply metadata filters if provided
-                if (filters && Object.keys(filters).length > 0) {
+                if (hasFilters && this.agentdb?.MetadataFilter) {
                     try {
-                        const { MetadataFilter } = await import(
-                        /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/MetadataFilter.js');
-                        episodes = MetadataFilter.apply(episodes, filters);
+                        episodes = this.agentdb.MetadataFilter.apply(episodes, filters);
                     }
-                    catch { /* MetadataFilter unavailable */ }
+                    catch { /* invalid filter — return unfiltered */ }
                 }
                 return episodes.slice(0, limit);
             }
@@ -551,89 +170,6 @@ export class AgentDBService {
         const q = query.toLowerCase();
         return this.episodeStore.search((ep) => ep.task.toLowerCase().includes(q), limit);
     }
-    /**
-     * Recall diverse episodes using MMR ranking to prevent near-duplicate results.
-     * Now wired to use initialized MMRDiversityRanker controller.
-     */
-    async recallDiverseEpisodes(query, limit = 5, lambda = 0.5) {
-        if (!this.reflexionMemory || !this.embeddingService) {
-            return this.recallEpisodes(query, limit);
-        }
-        try {
-            // Get extra candidates for diversity selection
-            const candidates = await this.reflexionMemory.retrieveRelevant({ task: query, k: limit * 3 });
-            if (!candidates || candidates.length <= limit) {
-                return this.recallEpisodes(query, limit);
-            }
-            // Get query embedding
-            const queryEmbedding = await this.embeddingService.embed(query);
-            // Build MMR candidates
-            const mmrCandidates = candidates.map((r) => ({
-                id: r.id ?? 0,
-                embedding: r.embedding ? Array.from(r.embedding) : [],
-                similarity: r.similarity ?? 0,
-                ...r,
-            }));
-            // Only apply MMR if we have embeddings and MMRRanker is initialized
-            if (this.mmrRanker && mmrCandidates.some((c) => c.embedding.length > 0)) {
-                try {
-                    const diverse = this.mmrRanker.selectDiverse(mmrCandidates, Array.from(queryEmbedding), { lambda, k: limit });
-                    return diverse.map((r) => ({
-                        id: r.id ?? 0, ts: r.ts ?? 0, sessionId: r.sessionId ?? '',
-                        task: r.task ?? '', input: r.input, output: r.output, critique: r.critique,
-                        reward: r.reward ?? 0, success: r.success ?? false, similarity: r.similarity,
-                        metadata: r.metadata,
-                    }));
-                }
-                catch { /* MMR unavailable, fall through */ }
-            }
-        }
-        catch { /* fall through */ }
-        return this.recallEpisodes(query, limit);
-    }
-    // -- Skills ---------------------------------------------------------------
-    async publishSkill(skill) {
-        if (this.skillLibrary) {
-            try {
-                return String(await this.skillLibrary.createSkill({
-                    name: skill.name, description: skill.description,
-                    code: skill.code, successRate: skill.successRate, metadata: skill.metadata,
-                }));
-            }
-            catch {
-                this.skillLibrary = null;
-            }
-        }
-        return String(this.skillStore.add({ ...skill, id: 0, uses: 0, avgReward: 0 }));
-    }
-    async findSkills(description, limit = 5, filters) {
-        if (this.skillLibrary) {
-            try {
-                const fetchCount = filters && Object.keys(filters).length > 0 ? limit * 2 : limit;
-                const results = await this.skillLibrary.retrieveSkills({ task: description, k: fetchCount });
-                let skills = (results ?? []).map((r) => ({
-                    id: r.id ?? 0, name: r.name ?? '', description: r.description, code: r.code,
-                    successRate: r.successRate ?? 0, uses: r.uses ?? 0, avgReward: r.avgReward ?? 0,
-                    similarity: r.similarity, metadata: r.metadata,
-                }));
-                // Apply metadata filters if provided
-                if (filters && Object.keys(filters).length > 0) {
-                    try {
-                        const { MetadataFilter } = await import(
-                        /* webpackIgnore: true */ '../../../packages/agentdb/src/controllers/MetadataFilter.js');
-                        skills = MetadataFilter.apply(skills, filters);
-                    }
-                    catch { /* MetadataFilter unavailable */ }
-                }
-                return skills.slice(0, limit);
-            }
-            catch {
-                this.skillLibrary = null;
-            }
-        }
-        const q = description.toLowerCase();
-        return this.skillStore.search((s) => s.name.toLowerCase().includes(q) || (s.description ?? '').toLowerCase().includes(q), limit);
-    }
     // -- Patterns -------------------------------------------------------------
     async storePattern(pattern) {
         if (this.reasoningBank) {
@@ -649,30 +185,15 @@ export class AgentDBService {
         }
         return String(this.patternStore.add({ ...pattern, id: 0, uses: 0 }));
     }
-    async searchPatterns(query, limit = 5, diverse = false) {
+    async searchPatterns(query, limit = 5) {
         if (this.reasoningBank) {
             try {
-                const fetchCount = diverse ? limit * 3 : limit;
-                const results = await this.reasoningBank.searchPatterns({ task: query, k: fetchCount });
-                let patterns = (results ?? []).map((r) => ({
+                const results = await this.reasoningBank.searchPatterns({ task: query, k: limit });
+                return (results ?? []).slice(0, limit).map((r) => ({
                     id: r.id ?? 0, taskType: r.taskType ?? '', approach: r.approach ?? '',
                     successRate: r.successRate ?? 0, uses: r.uses ?? 0,
                     tags: r.tags, metadata: r.metadata, similarity: r.similarity,
-                    embedding: r.embedding ? Array.from(r.embedding) : [],
                 }));
-                // Apply MMR diversity ranking if requested and embeddings available
-                if (diverse && this.embeddingService && this.mmrRanker && patterns.length > limit) {
-                    const hasEmbeddings = patterns.some((p) => p.embedding && p.embedding.length > 0);
-                    if (hasEmbeddings) {
-                        try {
-                            const queryEmbedding = await this.embeddingService.embed(query);
-                            patterns = this.mmrRanker.selectDiverse(patterns.map((p) => ({ ...p, id: p.id, similarity: p.similarity ?? 0 })), Array.from(queryEmbedding), { lambda: 0.5, k: limit });
-                        }
-                        catch { /* MMR unavailable, fall through to slice */ }
-                    }
-                }
-                // Strip internal embedding field before returning
-                return patterns.slice(0, limit).map(({ embedding, ...rest }) => rest);
             }
             catch {
                 this.reasoningBank = null;
@@ -681,728 +202,114 @@ export class AgentDBService {
         const q = query.toLowerCase();
         return this.patternStore.search((p) => p.taskType.toLowerCase().includes(q) || p.approach.toLowerCase().includes(q), limit);
     }
-    // -- Causal ---------------------------------------------------------------
-    async recordCausalEdge(from, to, metadata) {
-        if (this.causalGraph) {
-            try {
-                await this.causalGraph.addCausalEdge({
-                    fromMemoryId: Number(from) || 0, fromMemoryType: 'episode',
-                    toMemoryId: Number(to) || 0, toMemoryType: 'episode',
-                    similarity: 1.0, confidence: 1.0, metadata,
-                });
-            }
-            catch {
-                this.causalGraph = null;
-                this.causalEdges.push({ from, to, metadata });
-            }
-            return;
-        }
-        this.causalEdges.push({ from, to, metadata });
-    }
-    async queryCausalPath(from, to) {
-        if (this.causalGraph) {
-            try {
-                const edges = this.causalGraph.queryCausalEffects({
-                    interventionMemoryId: Number(from), interventionMemoryType: 'episode',
-                    outcomeMemoryId: Number(to),
-                });
-                if (edges && edges.length > 0) {
-                    return [{
-                            from, to,
-                            edges: edges.map((e) => ({
-                                fromId: String(e.fromMemoryId ?? from), toId: String(e.toMemoryId ?? to),
-                                similarity: e.similarity ?? 0, uplift: e.uplift, confidence: e.confidence ?? 0,
-                            })),
-                        }];
-                }
-            }
-            catch {
-                // Fall through to in-memory lookup
-            }
-        }
-        const direct = this.causalEdges.filter((e) => e.from === from && e.to === to);
-        if (direct.length === 0)
-            return [];
-        return [{
-                from, to,
-                edges: direct.map((e) => ({ fromId: e.from, toId: e.to, similarity: 1.0, confidence: 1.0 })),
-            }];
-    }
     // -- Learning -------------------------------------------------------------
     /**
-     * Record agent trajectory (Phase 2: @ruvector/sona integration)
+     * Record an agent trajectory into one long-lived Q-learning session, which
+     * predictAction() then queries.
      */
     async recordTrajectory(steps, reward) {
-        // Phase 2: Record to Sona if available
-        if (this.sonaEnabled && this.sonaService) {
-            try {
-                const sonaSteps = steps.map(step => ({
-                    state: { description: step.state },
-                    action: step.action,
-                    reward: step.reward
-                }));
-                await this.sonaService.recordTrajectory('agent', sonaSteps);
-            }
-            catch (error) {
-                console.warn('[AgentDBService] Sona trajectory recording failed:', error);
-            }
-        }
-        // Original LearningSystem integration
         if (this.learningSystem) {
             try {
-                const sessionId = await this.learningSystem.startSession('default', 'q-learning', { learningRate: 0.01, discountFactor: 0.99 });
+                if (!this.learningSessionId) {
+                    this.learningSessionId = await this.learningSystem.startSession('default', 'q-learning', { learningRate: 0.01, discountFactor: 0.99 });
+                }
                 for (const step of steps) {
                     await this.learningSystem.submitFeedback({
-                        sessionId, action: step.action, state: step.state, reward: step.reward,
-                        nextState: step.nextState, success: step.reward > 0, timestamp: Date.now(),
+                        sessionId: this.learningSessionId, action: step.action, state: step.state,
+                        reward: step.reward, nextState: step.nextState, success: step.reward > 0,
+                        timestamp: Date.now(),
                     });
                 }
+                return;
             }
             catch {
                 this.learningSystem = null;
-                this.trajectories.push({ steps, reward });
+                this.learningSessionId = null;
             }
-            return;
         }
         this.trajectories.push({ steps, reward });
     }
     /**
-     * Predict next action (Phase 2: @ruvector/sona integration)
+     * Predict the next action for a state. AgentDB 3 exposes
+     * `LearningSystem.predict(sessionId, state)`; the alpha line called a
+     * `predictAction()` method that no longer exists and always fell through.
      */
     async predictAction(state) {
-        // Phase 2: Try Sona prediction first
-        if (this.sonaEnabled && this.sonaService) {
+        if (this.learningSystem && this.learningSessionId) {
             try {
-                const prediction = await this.sonaService.predict(state);
-                if (prediction.confidence > 0.6) {
+                const stateStr = typeof state === 'string' ? state : JSON.stringify(state);
+                const p = await this.learningSystem.predict(this.learningSessionId, stateStr);
+                if (p?.action) {
                     return {
-                        action: prediction.action,
-                        confidence: prediction.confidence,
-                        alternatives: []
+                        action: p.action,
+                        confidence: p.confidence ?? 0,
+                        alternatives: (p.alternatives ?? []).map((a) => ({ action: a.action, confidence: a.confidence ?? 0 })),
                     };
                 }
             }
-            catch (error) {
-                console.warn('[AgentDBService] Sona prediction failed:', error);
-            }
-        }
-        // Fallback to LearningSystem
-        if (this.learningSystem) {
-            try {
-                const p = await this.learningSystem.predictAction?.(String(state));
-                if (p)
-                    return { action: p.action ?? 'noop', confidence: p.confidence ?? 0, alternatives: p.alternatives ?? [] };
-            }
-            catch {
-                this.learningSystem = null;
-            }
-        }
-        return { action: 'noop', confidence: 0, alternatives: [] };
-    }
-    // -- Graph ----------------------------------------------------------------
-    /**
-     * Store graph state (Phase 2: @ruvector/graph-node integration)
-     */
-    async storeGraphState(nodes, edges) {
-        // Phase 2: Try graph database first
-        if (this.graphEnabled && this.graphAdapter) {
-            try {
-                // Store nodes
-                for (const node of nodes) {
-                    const embedding = await this.embeddingService.embed(JSON.stringify(node));
-                    await this.graphAdapter.createNode({
-                        id: node.id || `node-${Date.now()}-${Math.random()}`,
-                        embedding,
-                        labels: [node.type || 'Node'],
-                        properties: node
-                    });
-                }
-                // Store edges
-                for (const edge of edges) {
-                    const edgeEmbedding = await this.embeddingService.embed(`${edge.from} -> ${edge.to}: ${edge.description || ''}`);
-                    await this.graphAdapter.createEdge({
-                        from: String(edge.from),
-                        to: String(edge.to),
-                        description: edge.description || 'edge',
-                        embedding: edgeEmbedding,
-                        confidence: edge.confidence,
-                        metadata: edge
-                    });
-                }
-                console.log(`[AgentDBService] Stored ${nodes.length} nodes and ${edges.length} edges in graph DB`);
-                return;
-            }
-            catch (error) {
-                console.warn('[AgentDBService] Graph DB storage failed:', error);
-            }
-        }
-        // Fallback: CausalGraph
-        if (this.causalGraph) {
-            try {
-                for (const edge of edges) {
-                    await this.causalGraph.addCausalEdge({
-                        fromMemoryId: edge.from ?? 0, fromMemoryType: edge.fromType ?? 'episode',
-                        toMemoryId: edge.to ?? 0, toMemoryType: edge.toType ?? 'episode',
-                        similarity: edge.similarity ?? 1.0, confidence: edge.confidence ?? 1.0,
-                        metadata: { nodes, edgeData: edge },
-                    });
-                }
-                return;
-            }
-            catch {
-                this.causalGraph = null;
-            }
-        }
-        // Final fallback: in-memory
-        for (const edge of edges) {
-            this.causalEdges.push({ from: String(edge.from), to: String(edge.to), metadata: { nodes, edgeData: edge } });
-        }
-    }
-    async queryGraph(query) {
-        if (this.causalRecall) {
-            try {
-                const result = await this.causalRecall.recall?.({ task: query, k: 10 });
-                return result?.candidates ?? [];
-            }
             catch { /* fall through */ }
         }
-        return [];
+        return { action: 'noop', confidence: 0, alternatives: [] };
     }
-    // -- Routing --------------------------------------------------------------
+    // -- Metrics --------------------------------------------------------------
     /**
-     * Route task using semantic understanding (Phase 2: @ruvector/router integration)
+     * Counts come from the persistent store. AgentDB 3 has no
+     * getEpisodeCount()/getPatternCount(), so episodes are counted in SQL and
+     * patterns through ReasoningBank.getPatternStats().
      */
-    async routeSemantic(taskDescription) {
-        // Phase 2: Try semantic router first
-        if (this.routerEnabled && this.semanticRouter) {
-            try {
-                const routeResult = await this.semanticRouter.route(taskDescription);
-                // Map route names to tiers
-                const tierMap = {
-                    'tier1': { tier: 1, handler: 'agent-booster' },
-                    'tier2': { tier: 2, handler: 'haiku' },
-                    'tier3': { tier: 3, handler: 'sonnet' }
-                };
-                const mapping = tierMap[routeResult.route] || { tier: 2, handler: 'haiku' };
-                return {
-                    tier: mapping.tier,
-                    handler: mapping.handler,
-                    confidence: routeResult.confidence,
-                    reasoning: `Semantic router (${this.semanticRouter.isAvailable() ? 'embedding-based' : 'keyword-based'}): ${routeResult.route}`
-                };
-            }
-            catch (error) {
-                console.warn('[AgentDBService] Semantic router failed, using keyword fallback');
-            }
-        }
-        // Fallback: keyword-based routing
-        const lower = taskDescription.toLowerCase();
-        const complex = ['architecture', 'security', 'refactor', 'design', 'complex', 'optimize', 'performance', 'migration'];
-        const simple = ['rename', 'format', 'lint', 'const', 'type', 'typo', 'fix import'];
-        if (simple.some((kw) => lower.includes(kw)))
-            return { tier: 1, handler: 'agent-booster', confidence: 0.85, reasoning: 'Simple transform detected' };
-        if (complex.some((kw) => lower.includes(kw)))
-            return { tier: 3, handler: 'sonnet', confidence: 0.8, reasoning: 'Complex reasoning required' };
-        return { tier: 2, handler: 'haiku', confidence: 0.7, reasoning: 'Standard task complexity' };
-    }
-    // -- Explain --------------------------------------------------------------
-    async explainDecision(decisionId) {
-        if (this.causalRecall?.explain) {
-            const r = await this.causalRecall.explain(decisionId);
-            return { decisionId, chunks: r?.chunkIds ?? [], minimalWhy: r?.minimalWhy ?? [], completenessScore: r?.completenessScore ?? 0 };
-        }
-        return { decisionId, chunks: [], minimalWhy: ['No explanation backend available'], completenessScore: 0 };
-    }
-    // -- Metrics --------------------------------------------------------------
     async getMetrics() {
         let episodes = this.episodeStore.size;
-        let skills = this.skillStore.size;
         let patterns = this.patternStore.size;
-        try {
-            if (this.reflexionMemory)
-                episodes = (await this.reflexionMemory.getEpisodeCount?.()) ?? episodes;
-        }
-        catch { /* use in-memory count */ }
-        try {
-            if (this.skillLibrary)
-                skills = (await this.skillLibrary.getSkillCount?.()) ?? skills;
-        }
-        catch { /* use in-memory count */ }
-        try {
-            if (this.reasoningBank)
-                patterns = (await this.reasoningBank.getPatternCount?.()) ?? patterns;
-        }
-        catch { /* use in-memory count */ }
-        return { backend: this.backendName, episodes, skills, patterns, uptime: Date.now() - this.startTime };
-    }
-    // -- Phase 1 Controller Methods -------------------------------------------
-    /**
-     * Get AttentionService instance
-     */
-    getAttentionService() {
-        return this.attentionService;
-    }
-    /**
-     * Search using WASM-accelerated vector operations
-     */
-    async searchWithWASM(query, k, options) {
-        if (!this.wasmVectorSearch) {
-            throw new Error('WASMVectorSearch not available');
-        }
-        return this.wasmVectorSearch.findKNN(query, k, 'pattern_embeddings', options);
-    }
-    /**
-     * Synthesize context from multiple episodes
-     */
-    async synthesizeContext(episodes, options) {
-        if (!this.contextSynthesizer) {
-            return {
-                summary: 'Context synthesis unavailable',
-                patterns: [],
-                successRate: 0,
-                averageReward: 0,
-                recommendations: [],
-                keyInsights: [],
-                totalMemories: 0,
-            };
-        }
-        // Map episodes to memory pattern format
-        const memories = episodes.map(ep => ({
-            task: ep.task,
-            reward: ep.reward,
-            success: ep.success,
-            critique: ep.critique,
-            input: ep.input,
-            output: ep.output,
-            similarity: ep.similarity,
-        }));
-        return this.contextSynthesizer.synthesize(memories, options);
-    }
-    /**
-     * Get WASM vector search statistics
-     */
-    getWASMStats() {
-        if (!this.wasmVectorSearch) {
-            return {
-                wasmAvailable: false,
-                simdAvailable: false,
-                indexBuilt: false,
-                indexSize: 0,
-                lastIndexUpdate: null,
-            };
-        }
-        return this.wasmVectorSearch.getStats();
-    }
-    /**
-     * Get attention service statistics
-     */
-    getAttentionStats() {
-        if (!this.attentionService) {
-            return {
-                totalOps: 0,
-                avgExecutionTimeMs: 0,
-                peakMemoryBytes: 0,
-                mechanismCounts: {},
-                runtimeCounts: {},
-            };
-        }
-        return this.attentionService.getStats();
-    }
-    // -- Phase 4 Controller Methods -------------------------------------------
-    /**
-     * Run nightly learner for automated causal discovery
-     */
-    async runNightlyLearner() {
-        if (!this.nightlyLearner) {
-            throw new Error('NightlyLearner not available');
-        }
-        // Run learning consolidation
-        const learningResults = await this.nightlyLearner.run();
-        // ADR-063: Auto-prune stale memories (confidence <0.3, age >30d)
-        let pruningResults = null;
-        if (this.rvfOptimizer) {
+        if (this.reflexionMemory && this.db) {
             try {
-                pruningResults = await this.pruneStaleMemories();
-                console.log(`[NightlyLearner] Pruned ${pruningResults.pruned} stale memories`);
+                const row = this.db.database.prepare('SELECT COUNT(*) AS c FROM episodes').get();
+                if (row && typeof row.c === 'number')
+                    episodes = row.c;
             }
-            catch (err) {
-                console.warn('[NightlyLearner] Pruning failed:', err);
-            }
-        }
-        return {
-            learning: learningResults,
-            pruning: pruningResults,
-            timestamp: Date.now()
-        };
-    }
-    /**
-     * Consolidate episodes using FlashAttention
-     */
-    async consolidateEpisodes(sessionId) {
-        if (!this.nightlyLearner) {
-            throw new Error('NightlyLearner not available');
-        }
-        return this.nightlyLearner.consolidateEpisodes(sessionId);
-    }
-    /**
-     * Synchronize with remote AgentDB instance
-     */
-    async syncWithRemote(onProgress) {
-        if (!this.syncCoordinator) {
-            throw new Error('SyncCoordinator not available');
-        }
-        return this.syncCoordinator.sync(onProgress);
-    }
-    /**
-     * Get synchronization status
-     */
-    getSyncStatus() {
-        if (!this.syncCoordinator) {
-            return {
-                isSyncing: false,
-                autoSyncEnabled: false,
-                state: {
-                    lastSyncAt: 0,
-                    lastEpisodeSync: 0,
-                    lastSkillSync: 0,
-                    lastEdgeSync: 0,
-                    totalItemsSynced: 0,
-                    totalBytesSynced: 0,
-                    syncCount: 0,
-                },
-            };
-        }
-        return this.syncCoordinator.getStatus();
-    }
-    /**
-     * Create explainable recall certificate for a retrieval
-     */
-    async createRecallCertificate(params) {
-        if (!this.explainableRecall) {
-            throw new Error('ExplainableRecall not available');
-        }
-        return this.explainableRecall.createCertificate(params);
-    }
-    /**
-     * Verify a recall certificate
-     */
-    verifyRecallCertificate(certificateId) {
-        if (!this.explainableRecall) {
-            throw new Error('ExplainableRecall not available');
-        }
-        return this.explainableRecall.verifyCertificate(certificateId);
-    }
-    /**
-     * Get justification for a chunk in a recall certificate
-     */
-    getRecallJustification(certificateId, chunkId) {
-        if (!this.explainableRecall) {
-            throw new Error('ExplainableRecall not available');
-        }
-        return this.explainableRecall.getJustification(certificateId, chunkId);
-    }
-    /**
-     * Trace provenance lineage for a certificate
-     */
-    traceProvenance(certificateId) {
-        if (!this.explainableRecall) {
-            throw new Error('ExplainableRecall not available');
-        }
-        return this.explainableRecall.traceProvenance(certificateId);
-    }
-    /**
-     * Audit a recall certificate
-     */
-    auditCertificate(certificateId) {
-        if (!this.explainableRecall) {
-            throw new Error('ExplainableRecall not available');
-        }
-        return this.explainableRecall.auditCertificate(certificateId);
-    }
-    /**
-     * Start QUIC server for distributed sync
-     */
-    async startQUICServer() {
-        if (!this.quicServer) {
-            throw new Error('QUICServer not available');
-        }
-        return this.quicServer.start();
-    }
-    /**
-     * Stop QUIC server
-     */
-    async stopQUICServer() {
-        if (!this.quicServer) {
-            throw new Error('QUICServer not available');
-        }
-        return this.quicServer.stop();
-    }
-    /**
-     * Get Phase 4 controller availability status
-     */
-    getPhase4Status() {
-        return {
-            syncCoordinator: this.syncCoordinator !== null,
-            nightlyLearner: this.nightlyLearner !== null,
-            explainableRecall: this.explainableRecall !== null,
-            quicClient: this.quicClient !== null,
-            quicServer: this.quicServer !== null,
-        };
-    }
-    // -- ADR-063: RVF Optimizer Methods --------------------------------------
-    /**
-     * Generate optimized embedding (compressed, cached, batched)
-     * ADR-063: 2-100x performance improvement over raw embeddings
-     */
-    async generateEmbedding(text) {
-        if (!this.embeddingService) {
-            throw new Error('EmbeddingService not initialized');
-        }
-        // If RVFOptimizer unavailable, use raw embeddings
-        if (!this.rvfOptimizer) {
-            return await this.embeddingService.embed(text);
-        }
-        // Use batched + compressed embeddings
-        const embedFn = async (t) => {
-            const result = await this.embeddingService.embed(t);
-            return result;
-        };
-        const embedding = await this.rvfOptimizer.batchEmbed(text, embedFn);
-        return this.rvfOptimizer.compressEmbedding(embedding);
-    }
-    /**
-     * Generate multiple embeddings in batch (10-100x faster than sequential)
-     * ADR-063: Batch size 32, max latency 10ms
-     */
-    async generateEmbeddings(texts) {
-        if (!this.embeddingService) {
-            throw new Error('EmbeddingService not initialized');
-        }
-        // If RVFOptimizer unavailable, use raw embeddings
-        if (!this.rvfOptimizer) {
-            return await Promise.all(texts.map(t => this.embeddingService.embed(t)));
-        }
-        const embedFn = async (t) => {
-            const result = await this.embeddingService.embed(t);
-            return result;
-        };
-        const embeddings = await Promise.all(texts.map(text => this.rvfOptimizer.batchEmbed(text, embedFn)));
-        return embeddings.map(e => this.rvfOptimizer.compressEmbedding(e));
-    }
-    /**
-     * Store episodes with automatic deduplication (20-50% storage reduction)
-     * ADR-063: 98% similarity threshold
-     */
-    async storeEpisodesWithDedup(episodes) {
-        if (!this.rvfOptimizer) {
-            // Fallback: store all without deduplication
-            return await Promise.all(episodes.map(ep => this.storeEpisode(ep)));
-        }
-        // Generate embeddings for all episodes
-        const texts = episodes.map(ep => JSON.stringify(ep));
-        const embeddings = await this.generateEmbeddings(texts);
-        // Create items for deduplication
-        const items = episodes.map((ep, i) => ({
-            id: `ep-${Date.now()}-${i}`,
-            embedding: embeddings[i],
-            confidence: ep.reward || 0.5
-        }));
-        // Deduplicate (removes 20-50% typically)
-        const unique = this.rvfOptimizer.deduplicate(items);
-        // Store only unique episodes
-        const ids = await Promise.all(unique.map(item => {
-            const idx = items.findIndex(it => it.id === item.id);
-            return this.storeEpisode(episodes[idx]);
-        }));
-        return ids;
-    }
-    /**
-     * Prune stale memories (confidence <0.3, age >30d)
-     * ADR-063: Automatic cleanup to prevent memory bloat
-     */
-    async pruneStaleMemories() {
-        if (!this.rvfOptimizer) {
-            return { pruned: 0, remaining: this.episodeStore.size };
-        }
-        // Get all episodes
-        const episodes = await this.recallEpisodes('*', 10000);
-        // Convert to format expected by RVFOptimizer
-        const items = episodes.map(ep => ({
-            id: String(ep.id),
-            embedding: [], // Not needed for pruning
-            confidence: ep.reward,
-            timestamp: ep.ts
-        }));
-        // Get IDs to prune
-        const toPrune = this.rvfOptimizer.pruneMemories(items);
-        // Delete episodes (in-memory store)
-        let pruned = 0;
-        for (const id of toPrune) {
-            // For real AgentDB backend, would use this.reflexionMemory.delete(id)
-            // For in-memory store, we can't delete directly, so just count
-            pruned++;
-        }
-        return {
-            pruned,
-            remaining: this.episodeStore.size - pruned
-        };
-    }
-    /**
-     * Preview what would be pruned without deleting
-     * ADR-063: Dry-run mode for safety
-     */
-    async previewPruning() {
-        if (!this.rvfOptimizer) {
-            return { pruned: 0, remaining: this.episodeStore.size };
-        }
-        const episodes = await this.recallEpisodes('*', 10000);
-        const items = episodes.map(ep => ({
-            id: String(ep.id),
-            embedding: [],
-            confidence: ep.reward,
-            timestamp: ep.ts
-        }));
-        const toPrune = this.rvfOptimizer.pruneMemories(items);
-        return {
-            pruned: toPrune.length,
-            remaining: episodes.length - toPrune.length
-        };
-    }
-    /**
-     * Get RVF optimizer statistics
-     * ADR-063: Monitor compression ratio, cache hit rate, batch queue size
-     */
-    getRVFStats() {
-        if (!this.rvfOptimizer) {
-            return {
-                available: false,
-                message: 'RVFOptimizer not initialized'
-            };
-        }
-        return {
-            available: true,
-            ...this.rvfOptimizer.getStats()
-        };
-    }
-    /**
-     * Clear embedding cache (forces fresh embeddings)
-     * ADR-063: Useful when model or data changes
-     */
-    clearEmbeddingCache() {
-        if (this.rvfOptimizer) {
-            this.rvfOptimizer.clearCache();
-        }
-    }
-    // -- ADR-064: Cost Optimizer Integration ----------------------------------
-    /**
-     * Auto-select optimal model before an LLM call.
-     * Returns the model ID and estimated cost.
-     */
-    selectModelForTask(task) {
-        if (!this.costOptimizer) {
-            return { modelId: 'claude-sonnet-4', estimatedCost: 0, reasoning: 'CostOptimizer unavailable, using default' };
+            catch { /* use in-memory count */ }
         }
-        return this.costOptimizer.selectOptimalModel(task);
-    }
-    /**
-     * Auto-record spend after an LLM call completes.
-     */
-    recordModelSpend(modelId, inputTokens, outputTokens) {
-        if (this.costOptimizer) {
-            this.costOptimizer.recordSpend(modelId, inputTokens, outputTokens);
+        if (this.reasoningBank) {
+            try {
+                const stats = this.reasoningBank.getPatternStats();
+                if (stats && typeof stats.totalPatterns === 'number')
+                    patterns = stats.totalPatterns;
+            }
+            catch { /* use in-memory count */ }
         }
-    }
-    /**
-     * Get the CostOptimizerService instance for direct access.
-     */
-    getCostOptimizer() {
-        return this.costOptimizer;
+        return { backend: this.backendName, episodes, patterns, uptime: Date.now() - this.startTime };
     }
     // -- Cleanup --------------------------------------------------------------
     async shutdown() {
-        // Cleanup Phase 1 controllers
-        if (this.wasmVectorSearch) {
-            try {
-                this.wasmVectorSearch.clearIndex();
-            }
-            catch { /* ignore cleanup errors */ }
-            this.wasmVectorSearch = null;
+        if (this.exitHook) {
+            process.removeListener('exit', this.exitHook);
+            this.exitHook = null;
         }
-        if (this.attentionService) {
+        if (this.learningSystem && this.learningSessionId) {
             try {
-                this.attentionService.resetStats();
+                await this.learningSystem.endSession(this.learningSessionId);
             }
-            catch { /* ignore cleanup errors */ }
-            this.attentionService = null;
+            catch { /* ignore */ }
         }
-        this.mmrRanker = null;
-        this.contextSynthesizer = null;
-        // Cleanup Phase 2 RuVector packages
-        if (this.graphAdapter) {
+        if (this.db && typeof this.db.close === 'function') {
             try {
-                this.graphAdapter.close?.();
+                await this.db.close();
             }
             catch { /* ignore cleanup errors */ }
-            this.graphAdapter = null;
         }
-        if (this.sonaService) {
-            try {
-                this.sonaService.clear?.();
-            }
-            catch { /* ignore cleanup errors */ }
-            this.sonaService = null;
-        }
-        this.gnnLearning = null;
-        this.semanticRouter = null;
-        // Cleanup Phase 4 controllers
-        if (this.syncCoordinator) {
-            try {
-                this.syncCoordinator.stopAutoSync?.();
-            }
-            catch { /* ignore cleanup errors */ }
-            this.syncCoordinator = null;
-        }
-        if (this.quicServer) {
-            try {
-                await this.quicServer.stop?.();
-            }
-            catch { /* ignore cleanup errors */ }
-            this.quicServer = null;
-        }
-        if (this.quicClient) {
-            try {
-                await this.quicClient.disconnect?.();
-            }
-            catch { /* ignore cleanup errors */ }
-            this.quicClient = null;
-        }
-        this.nightlyLearner = null;
-        this.explainableRecall = null;
-        // ADR-063: Cleanup RVFOptimizer
-        if (this.rvfOptimizer) {
-            try {
-                this.rvfOptimizer.clearCache();
-            }
-            catch { /* ignore cleanup errors */ }
-            this.rvfOptimizer = null;
-        }
-        // ADR-064: Cleanup CostOptimizer
-        this.costOptimizer = null;
-        // Existing cleanup
-        if (this.vectorBackend) {
-            try {
-                if (typeof this.vectorBackend.close === 'function')
-                    this.vectorBackend.close();
-                else if (typeof this.vectorBackend.dispose === 'function')
-                    this.vectorBackend.dispose();
-            }
-            catch { /* ignore cleanup errors */ }
-            this.vectorBackend = null;
-        }
-        if (this.db && typeof this.db.close === 'function')
-            await this.db.close();
+        this.db = null;
+        this.reflexionMemory = null;
+        this.reasoningBank = null;
+        this.learningSystem = null;
+        this.learningSessionId = null;
         this.initialized = false;
-        AgentDBService.instance = null;
+        if (AgentDBService.instance === this)
+            AgentDBService.instance = null;
     }
 }
+/**
+ * Get or create the singleton AgentDBService instance
+ */
+export async function getAgentDBService() {
+    return await AgentDBService.getInstance();
+}
 //# sourceMappingURL=agentdb-service.js.map