agentdb 3.0.0-alpha.2 → 3.0.0-alpha.4

package/dist/src/cli/agentdb-cli.js

@@ -19,19 +19,11 @@ import { EmbeddingService } from '../controllers/EmbeddingService.js';
 import { MMRDiversityRanker } from '../controllers/MMRDiversityRanker.js';
 import { ContextSynthesizer } from '../controllers/ContextSynthesizer.js';
 import { MetadataFilter } from '../controllers/MetadataFilter.js';
-import { QUICServer } from '../controllers/QUICServer.js';
-import { QUICClient } from '../controllers/QUICClient.js';
-import { SyncCoordinator } from '../controllers/SyncCoordinator.js';
 import { initCommand } from './commands/init.js';
 import { statusCommand } from './commands/status.js';
 import { installEmbeddingsCommand } from './commands/install-embeddings.js';
 import { migrateCommand } from './commands/migrate.js';
 import { doctorCommand } from './commands/doctor.js';
-import { attentionCommand } from './commands/attention.js';
-import { learnCommand } from './commands/learn.js';
-import { routeCommand } from './commands/route.js';
-import { hyperbolicCommand } from './commands/hyperbolic.js';
-import { rvfCommand } from './commands/rvf.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as zlib from 'zlib';
@@ -56,65 +48,7 @@ const log = {
     warning: (msg) => console.log(`${colors.yellow}⚠ ${msg}${colors.reset}`),
     header: (msg) => console.log(`${colors.bright}${colors.cyan}${msg}${colors.reset}`)
 };
-// Spinner utility for progress indication
-class Spinner {
-    frames = ['|', '/', '-', '\\'];
-    current = 0;
-    interval = null;
-    message = '';
-    start(message) {
-        this.message = message;
-        this.current = 0;
-        process.stdout.write(`\r${this.frames[0]} ${message}`);
-        this.interval = setInterval(() => {
-            this.current = (this.current + 1) % this.frames.length;
-            process.stdout.write(`\r${this.frames[this.current]} ${this.message}`);
-        }, 100);
-    }
-    update(message) {
-        this.message = message;
-        process.stdout.write(`\r${this.frames[this.current]} ${this.message}`);
-    }
-    succeed(message) {
-        this.stop();
-        console.log(`\r${colors.green}v${colors.reset} ${message}`);
-    }
-    fail(message) {
-        this.stop();
-        console.log(`\r${colors.red}x${colors.reset} ${message}`);
-    }
-    stop() {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = null;
-        }
-        process.stdout.write('\r' + ' '.repeat(this.message.length + 10) + '\r');
-    }
-}
-// Progress bar utility
-class ProgressBar {
-    width = 40;
-    current = 0;
-    total = 100;
-    message = '';
-    update(current, total, message) {
-        this.current = current;
-        this.total = total;
-        if (message)
-            this.message = message;
-        const percent = Math.round((current / total) * 100);
-        const filled = Math.round((current / total) * this.width);
-        const empty = this.width - filled;
-        const bar = `${colors.green}${'='.repeat(filled)}${colors.reset}${'-'.repeat(empty)}`;
-        process.stdout.write(`\r[${bar}] ${percent}% ${this.message}`);
-    }
-    complete(message) {
-        const bar = `${colors.green}${'='.repeat(this.width)}${colors.reset}`;
-        console.log(`\r[${bar}] 100% ${message}`);
-    }
-}
 class AgentDBCLI {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     db; // Database instance from createDatabase (public for init command)
     causalGraph;
     causalRecall;
@@ -123,10 +57,6 @@ class AgentDBCLI {
     reflexion;
     skills;
     embedder;
-    // QUIC sync controllers
-    quicServer;
-    quicClient;
-    syncCoordinator;
     async initialize(dbPath = './agentdb.db') {
         // Initialize database
         this.db = await createDatabase(dbPath);
@@ -281,8 +211,8 @@ class AgentDBCLI {
             throw new Error(`Experiment ${experimentId} not found`);
         }
         log.info(`Experiment: ${experiment.hypothesis || 'Unknown'}`);
-        log.info(`Treatment Mean: ${typeof experiment.treatment_mean === 'number' ? experiment.treatment_mean.toFixed(3) : 'N/A'}`);
-        log.info(`Control Mean: ${typeof experiment.control_mean === 'number' ? experiment.control_mean.toFixed(3) : 'N/A'}`);
+        log.info(`Treatment Mean: ${experiment.treatment_mean?.toFixed(3) || 'N/A'}`);
+        log.info(`Control Mean: ${experiment.control_mean?.toFixed(3) || 'N/A'}`);
         log.success(`Uplift: ${result?.uplift?.toFixed(3) || 'N/A'}`);
         if (result?.confidenceInterval && result.confidenceInterval.length === 2) {
             log.info(`95% CI: [${result.confidenceInterval[0]?.toFixed(3) || 'N/A'}, ${result.confidenceInterval[1]?.toFixed(3) || 'N/A'}]`);
@@ -295,9 +225,7 @@ class AgentDBCLI {
         if (!counts) {
             throw new Error(`Failed to get observation counts for experiment ${experimentId}`);
         }
-        const totalCount = counts.total || 0;
-        const treatmentCount = counts.treatment || 0;
-        log.info(`Sample Sizes: ${treatmentCount} treatment, ${totalCount - treatmentCount} control`);
+        log.info(`Sample Sizes: ${counts.treatment || 0} treatment, ${(counts.total || 0) - (counts.treatment || 0)} control`);
         if (result && result.pValue !== undefined && result.pValue < 0.05) {
             log.success('Result is statistically significant (p < 0.05)');
         }
@@ -379,10 +307,9 @@ class AgentDBCLI {
         if (discovered.length > 0) {
             console.log('\n' + '═'.repeat(80));
             discovered.slice(0, 10).forEach((edge, i) => {
-                const e = edge;
-                console.log(`${colors.bright}#${i + 1}: ${e.cause} → ${e.effect}${colors.reset}`);
-                console.log(`  Uplift: ${colors.green}${e.uplift?.toFixed(3)}${colors.reset} (CI: ${e.confidence?.toFixed(2)})`);
-                console.log(`  Sample size: ${e.sampleSize}`);
+                console.log(`${colors.bright}#${i + 1}: ${edge.cause} → ${edge.effect}${colors.reset}`);
+                console.log(`  Uplift: ${colors.green}${edge.uplift.toFixed(3)}${colors.reset} (CI: ${edge.confidence.toFixed(2)})`);
+                console.log(`  Sample size: ${edge.sampleSize}`);
                 console.log('─'.repeat(80));
             });
         }
@@ -574,8 +501,8 @@ class AgentDBCLI {
             console.log(`  Description: ${skill.description}`);
             console.log(`  Success Rate: ${colors.green}${(skill.successRate * 100).toFixed(1)}%${colors.reset}`);
             console.log(`  Uses: ${skill.uses}`);
-            console.log(`  Avg Reward: ${(skill.avgReward ?? 0).toFixed(2)}`);
-            console.log(`  Avg Latency: ${(skill.avgLatencyMs ?? 0).toFixed(0)}ms`);
+            console.log(`  Avg Reward: ${skill.avgReward.toFixed(2)}`);
+            console.log(`  Avg Latency: ${skill.avgLatencyMs.toFixed(0)}ms`);
             console.log('─'.repeat(80));
         });
         log.success(`Found ${skills.length} matching skills`);
@@ -638,658 +565,134 @@ class AgentDBCLI {
     // QUIC Synchronization Commands
     // ============================================================================
     async quicStartServer(params) {
-        if (!this.db)
-            throw new Error('Not initialized');
-        log.header('\n[QUIC] Starting QUIC Sync Server');
-        const spinner = new Spinner();
+        log.header('\n🚀 Starting QUIC Sync Server');
         const port = params.port || 4433;
         const authToken = params.authToken || this.generateAuthToken();
-        console.log('\n' + '='.repeat(80));
-        console.log(`${colors.bright}Server Configuration${colors.reset}`);
-        console.log('='.repeat(80));
-        console.log(`  Host: ${colors.cyan}0.0.0.0${colors.reset}`);
-        console.log(`  Port: ${colors.cyan}${port}${colors.reset}`);
-        console.log(`  Auth Token: ${colors.cyan}${authToken.substring(0, 8)}...${colors.reset}`);
-        console.log(`  Max Connections: ${colors.cyan}${params.maxConnections || 100}${colors.reset}`);
+        log.info(`Port: ${port}`);
+        log.info(`Auth Token: ${authToken}`);
         if (params.cert && params.key) {
-            console.log(`  TLS Certificate: ${colors.green}${params.cert}${colors.reset}`);
-            console.log(`  TLS Key: ${colors.green}${params.key}${colors.reset}`);
+            log.info(`TLS Certificate: ${params.cert}`);
+            log.info(`TLS Key: ${params.key}`);
         }
         else {
-            console.log(`  TLS: ${colors.yellow}Self-signed (development mode)${colors.reset}`);
-        }
-        console.log('='.repeat(80));
-        try {
-            spinner.start('Initializing QUIC server...');
-            // Create QUIC server configuration
-            const serverConfig = {
-                host: '0.0.0.0',
-                port,
-                maxConnections: params.maxConnections || 100,
-                authToken,
-                tlsConfig: {
-                    cert: params.cert,
-                    key: params.key,
-                },
-                rateLimit: {
-                    maxRequestsPerMinute: 60,
-                    maxBytesPerMinute: 10 * 1024 * 1024, // 10MB
-                },
-            };
-            // Initialize the QUIC server with database
-            this.quicServer = new QUICServer(this.db, serverConfig);
-            spinner.update('Starting server...');
-            await this.quicServer.start();
-            spinner.succeed('QUIC server started successfully');
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Server Status${colors.reset}`);
-            console.log('-'.repeat(80));
-            const status = this.quicServer.getStatus();
-            console.log(`  Status: ${colors.green}Running${colors.reset}`);
-            console.log(`  Active Connections: ${colors.cyan}${status.activeConnections}${colors.reset}`);
-            console.log(`  Rate Limit: ${colors.cyan}${status.config.rateLimit?.maxRequestsPerMinute} req/min${colors.reset}`);
-            console.log('-'.repeat(80));
-            log.info('\nServer is ready to accept connections.');
-            log.info(`Clients can connect using: agentdb sync connect <host> ${port} --auth-token ${authToken}`);
-            log.info('\nPress Ctrl+C to stop the server');
-            // Handle graceful shutdown
-            const shutdown = async () => {
-                console.log('\n');
-                log.info('Shutting down server...');
-                const shutdownSpinner = new Spinner();
-                shutdownSpinner.start('Closing connections...');
-                try {
-                    if (this.quicServer) {
-                        await this.quicServer.stop();
-                    }
-                    shutdownSpinner.succeed('Server stopped gracefully');
-                }
-                catch (error) {
-                    shutdownSpinner.fail(`Error during shutdown: ${error.message}`);
-                }
-                process.exit(0);
-            };
-            process.on('SIGINT', shutdown);
-            process.on('SIGTERM', shutdown);
-            // Monitor server status periodically
-            const monitorInterval = setInterval(() => {
-                if (this.quicServer) {
-                    const currentStatus = this.quicServer.getStatus();
-                    if (currentStatus.activeConnections > 0) {
-                        process.stdout.write(`\r${colors.cyan}[${new Date().toLocaleTimeString()}]${colors.reset} Active connections: ${currentStatus.activeConnections} | Total requests: ${currentStatus.totalRequests}  `);
-                    }
-                }
-            }, 5000);
-            // Keep process alive
-            await new Promise((resolve) => {
-                process.on('SIGINT', () => {
-                    clearInterval(monitorInterval);
-                    resolve();
-                });
-                process.on('SIGTERM', () => {
-                    clearInterval(monitorInterval);
-                    resolve();
-                });
-            });
-        }
-        catch (error) {
-            spinner.fail(`Failed to start server: ${error.message}`);
-            throw error;
+            log.warning('No TLS certificate provided - using self-signed certificate');
         }
+        // TODO: Implement QUIC server using existing QUICSync controller
+        log.info('\nServer started. Waiting for connections...');
+        log.info('Press Ctrl+C to stop');
+        // Keep process alive
+        await new Promise(() => { });
     }
     async quicConnect(params) {
-        log.header('\n[QUIC] Connecting to QUIC Sync Server');
-        const spinner = new Spinner();
-        console.log('\n' + '='.repeat(80));
-        console.log(`${colors.bright}Connection Details${colors.reset}`);
-        console.log('='.repeat(80));
-        console.log(`  Server: ${colors.cyan}${params.host}:${params.port}${colors.reset}`);
-        console.log(`  Authentication: ${params.authToken ? colors.green + 'Enabled' : colors.yellow + 'Disabled'}${colors.reset}`);
-        console.log(`  Timeout: ${colors.cyan}${params.timeout || 30000}ms${colors.reset}`);
+        log.header('\n🔌 Connecting to QUIC Sync Server');
+        log.info(`Host: ${params.host}`);
+        log.info(`Port: ${params.port}`);
+        if (params.authToken) {
+            log.info('Authentication: Enabled');
+        }
         if (params.cert) {
-            console.log(`  TLS Certificate: ${colors.green}${params.cert}${colors.reset}`);
+            log.info(`TLS Certificate: ${params.cert}`);
         }
         else {
-            console.log(`  TLS: ${colors.yellow}Insecure (no certificate provided)${colors.reset}`);
-        }
-        console.log('='.repeat(80));
-        try {
-            spinner.start('Initializing QUIC client...');
-            // Create QUIC client configuration
-            const clientConfig = {
-                serverHost: params.host,
-                serverPort: params.port,
-                authToken: params.authToken,
-                maxRetries: 3,
-                retryDelayMs: 1000,
-                timeoutMs: params.timeout || 30000,
-                poolSize: 5,
-                tlsConfig: {
-                    cert: params.cert,
-                    rejectUnauthorized: !!params.cert,
-                },
-            };
-            // Initialize the QUIC client
-            this.quicClient = new QUICClient(clientConfig);
-            spinner.update('Establishing connection...');
-            await this.quicClient.connect();
-            spinner.update('Testing connection (ping)...');
-            const pingResult = await this.quicClient.ping();
-            if (!pingResult.success) {
-                throw new Error(pingResult.error || 'Ping failed');
-            }
-            spinner.succeed('Connected to remote server successfully');
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Connection Status${colors.reset}`);
-            console.log('-'.repeat(80));
-            const status = this.quicClient.getStatus();
-            console.log(`  Status: ${colors.green}Connected${colors.reset}`);
-            console.log(`  Latency: ${colors.cyan}${pingResult.latencyMs}ms${colors.reset}`);
-            console.log(`  Pool Size: ${colors.cyan}${status.poolSize}${colors.reset}`);
-            console.log(`  Active Connections: ${colors.cyan}${status.activeConnections}${colors.reset}`);
-            console.log('-'.repeat(80));
-            // Initialize the SyncCoordinator for subsequent push/pull operations
-            if (this.db) {
-                this.syncCoordinator = new SyncCoordinator({
-                    db: this.db,
-                    client: this.quicClient,
-                });
-                log.info('\nSync coordinator initialized. Ready for push/pull operations.');
-            }
-            log.success('\nConnection established.');
-            log.info('Use "agentdb sync push" or "agentdb sync pull" to sync data.');
-        }
-        catch (error) {
-            spinner.fail(`Connection failed: ${error.message}`);
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Troubleshooting${colors.reset}`);
-            console.log('-'.repeat(80));
-            console.log('  1. Verify the server is running and accessible');
-            console.log('  2. Check firewall settings allow traffic on the specified port');
-            console.log('  3. Ensure the auth token matches the server configuration');
-            console.log('  4. For TLS connections, verify the certificate is valid');
-            console.log('-'.repeat(80));
-            throw error;
+            log.warning('No TLS certificate provided - using insecure connection');
         }
+        // TODO: Implement QUIC client connection
+        log.success('Connected to remote server');
+        log.info('Server info: AgentDB QUIC Sync v1.0');
     }
     async quicPush(params) {
         if (!this.db)
             throw new Error('Not initialized');
-        log.header('\n[QUIC] Pushing Changes to Remote');
-        const spinner = new Spinner();
-        const progressBar = new ProgressBar();
-        // Parse server address
-        const [host, portStr] = params.server.split(':');
-        const port = parseInt(portStr) || 4433;
-        console.log('\n' + '='.repeat(80));
-        console.log(`${colors.bright}Push Configuration${colors.reset}`);
-        console.log('='.repeat(80));
-        console.log(`  Server: ${colors.cyan}${host}:${port}${colors.reset}`);
-        console.log(`  Mode: ${colors.cyan}${params.incremental ? 'Incremental' : 'Full Sync'}${colors.reset}`);
-        console.log(`  Batch Size: ${colors.cyan}${params.batchSize || 100}${colors.reset}`);
+        log.header('\n⬆️  Pushing Changes to Remote');
+        log.info(`Server: ${params.server}`);
+        log.info(`Mode: ${params.incremental ? 'Incremental' : 'Full'}`);
         if (params.filter) {
-            console.log(`  Filter: ${colors.cyan}${params.filter}${colors.reset}`);
-        }
-        console.log('='.repeat(80));
-        try {
-            // Step 1: Analyze pending changes
-            spinner.start('Analyzing local changes...');
-            const pendingChanges = this.getPendingChangesDetailed(params.incremental, params.filter);
-            spinner.succeed(`Found ${pendingChanges.totalItems} items to push`);
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Pending Changes${colors.reset}`);
-            console.log('-'.repeat(80));
-            console.log(`  Episodes: ${colors.cyan}${pendingChanges.episodes.length}${colors.reset}`);
-            console.log(`  Skills: ${colors.cyan}${pendingChanges.skills.length}${colors.reset}`);
-            console.log(`  Edges: ${colors.cyan}${pendingChanges.edges.length}${colors.reset}`);
-            console.log(`  Total Size: ${colors.cyan}${(pendingChanges.totalSize / 1024).toFixed(2)} KB${colors.reset}`);
-            console.log('-'.repeat(80));
-            if (pendingChanges.totalItems === 0) {
-                log.info('\nNo changes to push. Database is up to date.');
-                return;
-            }
-            // Step 2: Establish connection if not already connected
-            spinner.start('Connecting to server...');
-            if (!this.quicClient) {
-                const clientConfig = {
-                    serverHost: host,
-                    serverPort: port,
-                    authToken: params.authToken,
-                    maxRetries: 3,
-                    retryDelayMs: 1000,
-                    timeoutMs: 30000,
-                    poolSize: 5,
-                };
-                this.quicClient = new QUICClient(clientConfig);
-                await this.quicClient.connect();
-            }
-            spinner.succeed('Connected to server');
-            // Step 3: Initialize sync coordinator if not exists
-            if (!this.syncCoordinator) {
-                this.syncCoordinator = new SyncCoordinator({
-                    db: this.db,
-                    client: this.quicClient,
-                    batchSize: params.batchSize || 100,
-                });
-            }
-            // Step 4: Push changes with progress tracking
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Push Progress${colors.reset}`);
-            console.log('-'.repeat(80));
-            const startTime = Date.now();
-            // Perform sync with progress callback
-            const syncReport = await this.syncCoordinator.sync((progress) => {
-                if (progress.phase === 'pushing') {
-                    progressBar.update(progress.current, progress.total, progress.itemType || 'items');
-                }
-                else if (progress.phase === 'completed') {
-                    progressBar.complete('Push completed');
-                }
-                else if (progress.phase === 'error') {
-                    console.log(`\n${colors.red}Error: ${progress.error}${colors.reset}`);
-                }
-            });
-            const duration = Date.now() - startTime;
-            console.log('\n' + '='.repeat(80));
-            console.log(`${colors.bright}Push Summary${colors.reset}`);
-            console.log('='.repeat(80));
-            console.log(`  Status: ${syncReport.success ? colors.green + 'Success' : colors.red + 'Failed'}${colors.reset}`);
-            console.log(`  Items Pushed: ${colors.cyan}${syncReport.itemsPushed}${colors.reset}`);
-            console.log(`  Bytes Transferred: ${colors.cyan}${(syncReport.bytesTransferred / 1024).toFixed(2)} KB${colors.reset}`);
-            console.log(`  Duration: ${colors.cyan}${duration}ms${colors.reset}`);
-            console.log(`  Throughput: ${colors.cyan}${((syncReport.bytesTransferred / 1024) / (duration / 1000)).toFixed(2)} KB/s${colors.reset}`);
-            if (syncReport.errors.length > 0) {
-                console.log(`  Errors: ${colors.red}${syncReport.errors.length}${colors.reset}`);
-                syncReport.errors.forEach((err, i) => {
-                    console.log(`    ${i + 1}. ${err}`);
-                });
-            }
-            console.log('='.repeat(80));
-            if (syncReport.success) {
-                log.success('\nChanges pushed successfully');
-            }
-            else {
-                log.error('\nPush completed with errors');
-            }
-        }
-        catch (error) {
-            spinner.fail(`Push failed: ${error.message}`);
-            throw error;
-        }
-    }
-    // Helper to get detailed pending changes with actual data
-    getPendingChangesDetailed(incremental, _filter) {
-        if (!this.db) {
-            return { episodes: [], skills: [], edges: [], totalItems: 0, totalSize: 0 };
-        }
-        try {
-            // Get last sync time
-            let lastSyncTime = 0;
-            if (incremental) {
-                try {
-                    const syncState = this.db.prepare('SELECT last_sync_at FROM sync_state WHERE id = 1').get();
-                    if (syncState) {
-                        lastSyncTime = syncState.last_sync_at || 0;
-                    }
-                }
-                catch {
-                    // Table might not exist
-                }
-            }
-            // Query episodes
-            let episodesQuery = 'SELECT * FROM episodes WHERE 1=1';
-            const episodeParams = [];
-            if (incremental && lastSyncTime > 0) {
-                episodesQuery += ' AND ts > ?';
-                episodeParams.push(lastSyncTime);
-            }
-            const episodes = this.db.prepare(episodesQuery).all(...episodeParams) || [];
-            // Query skills
-            let skillsQuery = 'SELECT * FROM skills WHERE 1=1';
-            const skillParams = [];
-            if (incremental && lastSyncTime > 0) {
-                skillsQuery += ' AND ts > ?';
-                skillParams.push(lastSyncTime);
-            }
-            let skills = [];
-            try {
-                skills = this.db.prepare(skillsQuery).all(...skillParams) || [];
-            }
-            catch {
-                // Skills table might not exist
-            }
-            // Query edges
-            let edgesQuery = 'SELECT * FROM skill_edges WHERE 1=1';
-            const edgeParams = [];
-            if (incremental && lastSyncTime > 0) {
-                edgesQuery += ' AND ts > ?';
-                edgeParams.push(lastSyncTime);
-            }
-            let edges = [];
-            try {
-                edges = this.db.prepare(edgesQuery).all(...edgeParams) || [];
-            }
-            catch {
-                // Edges table might not exist
-            }
-            // Calculate total size
-            const totalSize = JSON.stringify(episodes).length +
-                JSON.stringify(skills).length +
-                JSON.stringify(edges).length;
-            return {
-                episodes,
-                skills,
-                edges,
-                totalItems: episodes.length + skills.length + edges.length,
-                totalSize,
-            };
-        }
-        catch (error) {
-            log.warning(`Error analyzing changes: ${error.message}`);
-            return { episodes: [], skills: [], edges: [], totalItems: 0, totalSize: 0 };
+            log.info(`Filter: ${params.filter}`);
         }
+        // Get pending changes
+        const changes = this.getPendingChanges(params.incremental, params.filter);
+        console.log('\n' + '═'.repeat(80));
+        console.log(`${colors.bright}Pending Changes${colors.reset}`);
+        console.log('═'.repeat(80));
+        console.log(`  Episodes: ${changes.episodes}`);
+        console.log(`  Skills: ${changes.skills}`);
+        console.log(`  Causal Edges: ${changes.causalEdges}`);
+        console.log(`  Total Size: ${(changes.totalSize / 1024).toFixed(2)} KB`);
+        console.log('═'.repeat(80));
+        // TODO: Implement QUIC push
+        log.success('Changes pushed successfully');
+        log.info(`Transferred: ${(changes.totalSize / 1024).toFixed(2)} KB`);
     }
     async quicPull(params) {
         if (!this.db)
             throw new Error('Not initialized');
-        log.header('\n[QUIC] Pulling Changes from Remote');
-        const spinner = new Spinner();
-        const progressBar = new ProgressBar();
-        // Parse server address
-        const [host, portStr] = params.server.split(':');
-        const port = parseInt(portStr) || 4433;
-        console.log('\n' + '='.repeat(80));
-        console.log(`${colors.bright}Pull Configuration${colors.reset}`);
-        console.log('='.repeat(80));
-        console.log(`  Server: ${colors.cyan}${host}:${port}${colors.reset}`);
-        console.log(`  Mode: ${colors.cyan}${params.incremental ? 'Incremental' : 'Full Sync'}${colors.reset}`);
-        console.log(`  Conflict Strategy: ${colors.cyan}${params.conflictStrategy || 'latest-wins'}${colors.reset}`);
-        console.log(`  Batch Size: ${colors.cyan}${params.batchSize || 100}${colors.reset}`);
+        log.header('\n⬇️  Pulling Changes from Remote');
+        log.info(`Server: ${params.server}`);
+        log.info(`Mode: ${params.incremental ? 'Incremental' : 'Full'}`);
         if (params.filter) {
-            console.log(`  Filter: ${colors.cyan}${params.filter}${colors.reset}`);
-        }
-        console.log('='.repeat(80));
-        try {
-            // Step 1: Establish connection if not already connected
-            spinner.start('Connecting to server...');
-            if (!this.quicClient) {
-                const clientConfig = {
-                    serverHost: host,
-                    serverPort: port,
-                    authToken: params.authToken,
-                    maxRetries: 3,
-                    retryDelayMs: 1000,
-                    timeoutMs: 30000,
-                    poolSize: 5,
-                };
-                this.quicClient = new QUICClient(clientConfig);
-                await this.quicClient.connect();
-            }
-            spinner.succeed('Connected to server');
-            // Step 2: Initialize sync coordinator if not exists
-            if (!this.syncCoordinator) {
-                this.syncCoordinator = new SyncCoordinator({
-                    db: this.db,
-                    client: this.quicClient,
-                    batchSize: params.batchSize || 100,
-                    conflictStrategy: params.conflictStrategy || 'latest-wins',
-                });
-            }
-            // Step 3: Pull changes with progress tracking
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Pull Progress${colors.reset}`);
-            console.log('-'.repeat(80));
-            const startTime = Date.now();
-            let currentPhase = '';
-            let episodesReceived = 0;
-            let skillsReceived = 0;
-            let edgesReceived = 0;
-            // Perform sync with progress callback
-            const syncReport = await this.syncCoordinator.sync((progress) => {
-                if (progress.phase === 'pulling') {
-                    currentPhase = progress.itemType || 'items';
-                    progressBar.update(progress.current, progress.total, `Pulling ${currentPhase}...`);
-                    // Track received items
-                    if (progress.itemType === 'episodes')
-                        episodesReceived = progress.current;
-                    if (progress.itemType === 'skills')
-                        skillsReceived = progress.current;
-                    if (progress.itemType === 'edges')
-                        edgesReceived = progress.current;
-                }
-                else if (progress.phase === 'resolving') {
-                    progressBar.update(progress.current, progress.total, 'Resolving conflicts...');
-                }
-                else if (progress.phase === 'applying') {
-                    progressBar.update(progress.current, progress.total, 'Applying changes...');
-                }
-                else if (progress.phase === 'completed') {
-                    progressBar.complete('Pull completed');
-                }
-                else if (progress.phase === 'error') {
-                    console.log(`\n${colors.red}Error: ${progress.error}${colors.reset}`);
-                }
-            });
-            const duration = Date.now() - startTime;
-            console.log('\n' + '='.repeat(80));
-            console.log(`${colors.bright}Pull Summary${colors.reset}`);
-            console.log('='.repeat(80));
-            console.log(`  Status: ${syncReport.success ? colors.green + 'Success' : colors.red + 'Failed'}${colors.reset}`);
-            console.log(`  Items Pulled: ${colors.cyan}${syncReport.itemsPulled}${colors.reset}`);
-            console.log(`  Conflicts Resolved: ${colors.cyan}${syncReport.conflictsResolved}${colors.reset}`);
-            console.log(`  Bytes Transferred: ${colors.cyan}${(syncReport.bytesTransferred / 1024).toFixed(2)} KB${colors.reset}`);
-            console.log(`  Duration: ${colors.cyan}${duration}ms${colors.reset}`);
-            console.log(`  Throughput: ${colors.cyan}${((syncReport.bytesTransferred / 1024) / (duration / 1000)).toFixed(2)} KB/s${colors.reset}`);
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Received Data${colors.reset}`);
-            console.log('-'.repeat(80));
-            console.log(`  Episodes: ${colors.cyan}${episodesReceived}${colors.reset}`);
-            console.log(`  Skills: ${colors.cyan}${skillsReceived}${colors.reset}`);
-            console.log(`  Edges: ${colors.cyan}${edgesReceived}${colors.reset}`);
-            console.log('-'.repeat(80));
-            if (syncReport.errors.length > 0) {
-                console.log(`\n${colors.bright}Errors${colors.reset}`);
-                console.log('-'.repeat(80));
-                syncReport.errors.forEach((err, i) => {
-                    console.log(`  ${colors.red}${i + 1}. ${err}${colors.reset}`);
-                });
-                console.log('-'.repeat(80));
-            }
-            console.log('='.repeat(80));
-            if (syncReport.success) {
-                log.success('\nChanges pulled and merged successfully');
-            }
-            else {
-                log.error('\nPull completed with errors');
-            }
-            // Display local database status after pull
-            spinner.start('Verifying local database...');
-            const localStatus = this.getLocalDatabaseStatus();
-            spinner.succeed('Local database verified');
-            console.log('\n' + '-'.repeat(80));
-            console.log(`${colors.bright}Local Database Status${colors.reset}`);
-            console.log('-'.repeat(80));
-            console.log(`  Total Episodes: ${colors.cyan}${localStatus.episodes}${colors.reset}`);
-            console.log(`  Total Skills: ${colors.cyan}${localStatus.skills}${colors.reset}`);
-            console.log(`  Total Edges: ${colors.cyan}${localStatus.edges}${colors.reset}`);
-            console.log('-'.repeat(80));
-        }
-        catch (error) {
-            spinner.fail(`Pull failed: ${error.message}`);
-            throw error;
-        }
-    }
-    // Helper to get local database status
-    getLocalDatabaseStatus() {
-        if (!this.db) {
-            return { episodes: 0, skills: 0, edges: 0 };
-        }
-        let episodes = 0;
-        let skills = 0;
-        let edges = 0;
-        try {
-            const episodeCount = this.db.prepare('SELECT COUNT(*) as count FROM episodes').get();
-            episodes = episodeCount?.count || 0;
-        }
-        catch {
-            // Table might not exist
-        }
-        try {
-            const skillCount = this.db.prepare('SELECT COUNT(*) as count FROM skills').get();
-            skills = skillCount?.count || 0;
-        }
-        catch {
-            // Table might not exist
-        }
-        try {
-            const edgeCount = this.db.prepare('SELECT COUNT(*) as count FROM skill_edges').get();
-            edges = edgeCount?.count || 0;
-        }
-        catch {
-            // Table might not exist
-        }
-        return { episodes, skills, edges };
+            log.info(`Filter: ${params.filter}`);
+        }
+        // TODO: Implement QUIC pull
+        const changes = {
+            episodes: 5,
+            skills: 2,
+            causalEdges: 3,
+            totalSize: 12800
+        };
+        console.log('\n' + '═'.repeat(80));
+        console.log(`${colors.bright}Received Changes${colors.reset}`);
+        console.log('═'.repeat(80));
+        console.log(`  Episodes: ${changes.episodes}`);
+        console.log(`  Skills: ${changes.skills}`);
+        console.log(`  Causal Edges: ${changes.causalEdges}`);
+        console.log(`  Total Size: ${(changes.totalSize / 1024).toFixed(2)} KB`);
+        console.log('═'.repeat(80));
+        log.success('Changes pulled and merged successfully');
+        log.info(`Downloaded: ${(changes.totalSize / 1024).toFixed(2)} KB`);
     }
     async quicStatus() {
         if (!this.db)
             throw new Error('Not initialized');
-        log.header('\n[QUIC] Sync Status');
-        const spinner = new Spinner();
-        spinner.start('Loading sync status...');
-        // Get sync metadata from database
-        const syncMeta = this.getSyncMetadataFromDb();
-        // Get pending changes
-        const pendingChanges = this.getPendingChangesDetailed(true);
-        spinner.succeed('Status loaded');
-        console.log('\n' + '='.repeat(80));
-        console.log(`${colors.bright}Sync Overview${colors.reset}`);
-        console.log('='.repeat(80));
-        // Last sync information
-        if (syncMeta.lastSyncAt > 0) {
-            const lastSync = new Date(syncMeta.lastSyncAt);
+        log.header('\n📊 QUIC Sync Status');
+        // Get sync metadata
+        const syncMeta = this.getSyncMetadata();
+        console.log('\n' + '═'.repeat(80));
+        console.log(`${colors.bright}Sync Status${colors.reset}`);
+        console.log('═'.repeat(80));
+        if (syncMeta.lastSyncTime) {
+            const lastSync = new Date(syncMeta.lastSyncTime * 1000);
             console.log(`  Last Sync: ${colors.cyan}${lastSync.toLocaleString()}${colors.reset}`);
-            console.log(`  Time Ago: ${colors.cyan}${this.timeAgo(Math.floor(syncMeta.lastSyncAt / 1000))}${colors.reset}`);
+            console.log(`  Time Ago: ${this.timeAgo(syncMeta.lastSyncTime)}`);
         }
         else {
             console.log(`  Last Sync: ${colors.yellow}Never${colors.reset}`);
         }
-        console.log(`  Total Syncs: ${colors.cyan}${syncMeta.syncCount}${colors.reset}`);
-        console.log(`  Total Items Synced: ${colors.cyan}${syncMeta.totalItemsSynced}${colors.reset}`);
-        console.log(`  Total Data Synced: ${colors.cyan}${(syncMeta.totalBytesSynced / 1024).toFixed(2)} KB${colors.reset}`);
-        if (syncMeta.lastError) {
-            console.log(`  Last Error: ${colors.red}${syncMeta.lastError}${colors.reset}`);
-        }
-        console.log('\n' + '-'.repeat(80));
-        console.log(`${colors.bright}Pending Changes (Unsynced)${colors.reset}`);
-        console.log('-'.repeat(80));
-        console.log(`  Episodes: ${colors.cyan}${pendingChanges.episodes.length}${colors.reset}`);
-        console.log(`  Skills: ${colors.cyan}${pendingChanges.skills.length}${colors.reset}`);
-        console.log(`  Edges: ${colors.cyan}${pendingChanges.edges.length}${colors.reset}`);
-        console.log(`  Total Size: ${colors.cyan}${(pendingChanges.totalSize / 1024).toFixed(2)} KB${colors.reset}`);
-        console.log('\n' + '-'.repeat(80));
-        console.log(`${colors.bright}Local Database${colors.reset}`);
-        console.log('-'.repeat(80));
-        const localStatus = this.getLocalDatabaseStatus();
-        console.log(`  Episodes: ${colors.cyan}${localStatus.episodes}${colors.reset}`);
-        console.log(`  Skills: ${colors.cyan}${localStatus.skills}${colors.reset}`);
-        console.log(`  Edges: ${colors.cyan}${localStatus.edges}${colors.reset}`);
-        console.log('\n' + '-'.repeat(80));
-        console.log(`${colors.bright}Controller Status${colors.reset}`);
-        console.log('-'.repeat(80));
-        // Server status
-        if (this.quicServer) {
-            const serverStatus = this.quicServer.getStatus();
-            console.log(`  QUIC Server: ${serverStatus.isRunning ? colors.green + 'Running' : colors.yellow + 'Stopped'}${colors.reset}`);
-            if (serverStatus.isRunning) {
-                console.log(`    Active Connections: ${colors.cyan}${serverStatus.activeConnections}${colors.reset}`);
-                console.log(`    Total Requests: ${colors.cyan}${serverStatus.totalRequests}${colors.reset}`);
-            }
-        }
-        else {
-            console.log(`  QUIC Server: ${colors.yellow}Not initialized${colors.reset}`);
-        }
-        // Client status
-        if (this.quicClient) {
-            const clientStatus = this.quicClient.getStatus();
-            console.log(`  QUIC Client: ${clientStatus.isConnected ? colors.green + 'Connected' : colors.yellow + 'Disconnected'}${colors.reset}`);
-            if (clientStatus.isConnected) {
-                console.log(`    Server: ${colors.cyan}${clientStatus.config.serverHost}:${clientStatus.config.serverPort}${colors.reset}`);
-                console.log(`    Pool Size: ${colors.cyan}${clientStatus.poolSize}${colors.reset}`);
-                console.log(`    Total Requests: ${colors.cyan}${clientStatus.totalRequests}${colors.reset}`);
-            }
-        }
-        else {
-            console.log(`  QUIC Client: ${colors.yellow}Not initialized${colors.reset}`);
-        }
-        // Sync coordinator status
-        if (this.syncCoordinator) {
-            const coordStatus = this.syncCoordinator.getStatus();
-            console.log(`  Sync Coordinator: ${colors.green}Ready${colors.reset}`);
-            console.log(`    Auto-Sync: ${coordStatus.autoSyncEnabled ? colors.green + 'Enabled' : colors.yellow + 'Disabled'}${colors.reset}`);
-            console.log(`    Currently Syncing: ${coordStatus.isSyncing ? colors.yellow + 'Yes' : colors.cyan + 'No'}${colors.reset}`);
+        console.log('\n' + '─'.repeat(80));
+        console.log(`${colors.bright}Pending Changes${colors.reset}`);
+        console.log('─'.repeat(80));
+        console.log(`  Episodes: ${colors.green}${syncMeta.pendingEpisodes}${colors.reset}`);
+        console.log(`  Skills: ${colors.green}${syncMeta.pendingSkills}${colors.reset}`);
+        console.log(`  Causal Edges: ${colors.green}${syncMeta.pendingCausalEdges}${colors.reset}`);
+        console.log('\n' + '─'.repeat(80));
+        console.log(`${colors.bright}Connected Servers${colors.reset}`);
+        console.log('─'.repeat(80));
+        if (syncMeta.servers.length === 0) {
+            console.log(`  ${colors.yellow}No servers connected${colors.reset}`);
         }
         else {
-            console.log(`  Sync Coordinator: ${colors.yellow}Not initialized${colors.reset}`);
-        }
-        console.log('='.repeat(80));
-        // Recommendations
-        if (pendingChanges.totalItems > 0) {
-            log.info(`\nTip: You have ${pendingChanges.totalItems} unsynced items. Use "agentdb sync push" to sync them.`);
-        }
-        if (!this.quicClient && !this.quicServer) {
-            log.info('\nTo start syncing:');
-            log.info('  - Start a server: agentdb sync start-server --port 4433');
-            log.info('  - Or connect to one: agentdb sync connect <host> <port>');
-        }
-    }
-    // Get sync metadata from database
-    getSyncMetadataFromDb() {
-        if (!this.db) {
-            return {
-                lastSyncAt: 0,
-                lastEpisodeSync: 0,
-                lastSkillSync: 0,
-                lastEdgeSync: 0,
-                totalItemsSynced: 0,
-                totalBytesSynced: 0,
-                syncCount: 0,
-            };
-        }
-        try {
-            const row = this.db
-                .prepare('SELECT * FROM sync_state WHERE id = 1')
-                .get();
-            if (row) {
-                return {
-                    lastSyncAt: row.last_sync_at || 0,
-                    lastEpisodeSync: row.last_episode_sync || 0,
-                    lastSkillSync: row.last_skill_sync || 0,
-                    lastEdgeSync: row.last_edge_sync || 0,
-                    totalItemsSynced: row.total_items_synced || 0,
-                    totalBytesSynced: row.total_bytes_synced || 0,
-                    syncCount: row.sync_count || 0,
-                    lastError: row.last_error || undefined,
-                };
-            }
-        }
-        catch {
-            // Table might not exist
+            syncMeta.servers.forEach((server) => {
+                console.log(`  ${colors.cyan}${server.host}:${server.port}${colors.reset}`);
+                console.log(`    Status: ${server.connected ? colors.green + 'Connected' : colors.red + 'Disconnected'}${colors.reset}`);
+                console.log(`    Last Seen: ${new Date(server.lastSeen * 1000).toLocaleString()}`);
+            });
         }
-        return {
-            lastSyncAt: 0,
-            lastEpisodeSync: 0,
-            lastSkillSync: 0,
-            lastEdgeSync: 0,
-            totalItemsSynced: 0,
-            totalBytesSynced: 0,
-            syncCount: 0,
-        };
+        console.log('═'.repeat(80));
     }
     generateAuthToken() {
         // Generate a random 32-character token
         return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
     }
-    getPendingChanges(_incremental, _filter) {
+    getPendingChanges(incremental, filter) {
         // Mock implementation - would query sync metadata table
         return {
             episodes: 10,
@@ -1344,14 +747,6 @@ class AgentDBCLI {
 // ============================================================================
 // CLI Entry Point
 // ============================================================================
-/**
- * Helper function to execute Commander-based commands
- */
-async function handleCommanderCommand(command, args) {
-    // Parse directly using the command instance without wrapping in a parent program
-    // This avoids issues with subcommand routing
-    await command.parseAsync(['node', command.name(), ...args], { from: 'user' });
-}
 async function main() {
     const args = process.argv.slice(2);
     // Handle version flag
@@ -1418,9 +813,6 @@ async function main() {
             else if (arg === '--db' && i + 1 < args.length) {
                 options.dbPath = args[++i];
             }
-            else if (arg === '--rvf-path' && i + 1 < args.length) {
-                options.rvfPath = args[++i];
-            }
             else if (!arg.startsWith('--')) {
                 options.dbPath = arg;
             }
@@ -1469,12 +861,6 @@ async function main() {
             else if (arg === '--target' && i + 1 < args.length) {
                 options.targetDb = args[++i];
             }
-            else if (arg === '--to' && i + 1 < args.length) {
-                options.to = args[++i];
-            }
-            else if (arg === '--rvf-path' && i + 1 < args.length) {
-                options.rvfPath = args[++i];
-            }
             else if (arg === '--no-optimize') {
                 options.optimize = false;
             }
@@ -1490,7 +876,7 @@ async function main() {
         }
         if (!options.sourceDb) {
             log.error('Source database path required');
-            console.log('Usage: agentdb migrate <source-db> [--to v2|v3|rvf] [--target <target-db>] [--rvf-path <path>] [--no-optimize] [--dry-run] [--verbose]');
+            console.log('Usage: agentdb migrate <source-db> [--target <target-db>] [--no-optimize] [--dry-run] [--verbose]');
             process.exit(1);
         }
         await migrateCommand(options);
@@ -1504,15 +890,9 @@ async function main() {
             if (arg === '--db' && i + 1 < args.length) {
                 options.dbPath = args[++i];
             }
-            else if (arg === '--rvf-path' && i + 1 < args.length) {
-                options.rvfPath = args[++i];
-            }
             else if (arg === '--verbose' || arg === '-v') {
                 options.verbose = true;
             }
-            else if (arg === '--fix') {
-                options.fix = true;
-            }
             else if (!arg.startsWith('--')) {
                 options.dbPath = arg;
             }
@@ -1537,28 +917,6 @@ async function main() {
         await handleStatsCommand(args.slice(1));
         return;
     }
-    // Handle advanced neural commands (WASM-accelerated when available)
-    if (command === 'attention') {
-        await handleCommanderCommand(attentionCommand, args.slice(1));
-        return;
-    }
-    if (command === 'learn') {
-        await handleCommanderCommand(learnCommand, args.slice(1));
-        return;
-    }
-    if (command === 'route') {
-        await handleCommanderCommand(routeCommand, args.slice(1));
-        return;
-    }
-    if (command === 'hyperbolic') {
-        await handleCommanderCommand(hyperbolicCommand, args.slice(1));
-        return;
-    }
-    // Handle RVF store management commands
-    if (command === 'rvf') {
-        await handleCommanderCommand(rvfCommand, args.slice(1));
-        return;
-    }
     // Handle simulate command - run simulation CLI
     if (command === 'simulate') {
         // Use pathToFileURL for proper ESM module resolution
@@ -1687,6 +1045,110 @@ async function main() {
     }
 }
 // Command handlers
+// Init command handler
+async function handleInitCommand(args) {
+    // Parse arguments
+    let dbPath = './agentdb.db';
+    let dimension = 1536; // Default OpenAI ada-002
+    let preset = null;
+    let inMemory = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--dimension' && i + 1 < args.length) {
+            dimension = parseInt(args[++i]);
+        }
+        else if (arg === '--preset' && i + 1 < args.length) {
+            preset = args[++i];
+        }
+        else if (arg === '--in-memory') {
+            inMemory = true;
+            dbPath = ':memory:';
+        }
+        else if (!arg.startsWith('--')) {
+            dbPath = arg;
+        }
+    }
+    // Apply preset configurations
+    if (preset) {
+        if (preset === 'small') {
+            log.info('Using SMALL preset (<10K vectors)');
+        }
+        else if (preset === 'medium') {
+            log.info('Using MEDIUM preset (10K-100K vectors)');
+        }
+        else if (preset === 'large') {
+            log.info('Using LARGE preset (>100K vectors)');
+        }
+    }
+    log.info(`Initializing AgentDB at: ${dbPath}`);
+    log.info(`Embedding dimension: ${dimension}`);
+    if (inMemory) {
+        log.info('Using in-memory database (data will not persist)');
+    }
+    // Check if database already exists
+    if (!inMemory && fs.existsSync(dbPath)) {
+        log.warning(`Database already exists at ${dbPath}`);
+        log.info('Use a different path or remove the existing file to reinitialize');
+        return;
+    }
+    // Create parent directories if needed
+    if (!inMemory) {
+        const parentDir = path.dirname(dbPath);
+        if (parentDir !== '.' && !fs.existsSync(parentDir)) {
+            log.info(`Creating directory: ${parentDir}`);
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+    }
+    // Create new database with schemas
+    const cli = new AgentDBCLI();
+    await cli.initialize(dbPath);
+    // CRITICAL: Save the database to disk (unless in-memory)
+    // sql.js keeps everything in memory until explicitly saved
+    if (!inMemory) {
+        if (cli.db && typeof cli.db.save === 'function') {
+            cli.db.save();
+        }
+        else if (cli.db && typeof cli.db.close === 'function') {
+            // close() calls save() internally
+            cli.db.close();
+        }
+        // Verify database file was created
+        if (!fs.existsSync(dbPath)) {
+            log.error(`Failed to create database file at ${dbPath}`);
+            log.error('The database may be in memory only');
+            process.exit(1);
+        }
+    }
+    // Verify database has tables
+    try {
+        const db = await createDatabase(dbPath);
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+        db.close();
+        if (tables.length === 0) {
+            log.warning('Database file created but no tables found');
+            log.warning('Schemas may not have been loaded correctly');
+        }
+        else {
+            log.success(`Database created with ${tables.length} tables`);
+        }
+    }
+    catch (error) {
+        log.warning(`Could not verify database tables: ${error.message}`);
+    }
+    log.success(`✅ AgentDB initialized successfully at ${dbPath}`);
+    log.info('Database includes:');
+    log.info('  - Core vector tables (episodes, embeddings)');
+    log.info('  - Causal memory graph');
+    log.info('  - Reflexion memory');
+    log.info('  - Skill library');
+    log.info('  - Learning system');
+    log.info('');
+    log.info('Next steps:');
+    log.info('  - Use "agentdb mcp start" to start MCP server');
+    log.info('  - Use "agentdb causal add" to add causal edges');
+    log.info('  - Use "agentdb reflexion add" to store episodes');
+    log.info('  - See "agentdb help" for all commands');
+}
 async function handleMcpCommand(args) {
     const subcommand = args[0];
     if (subcommand === 'start' || !subcommand) {
@@ -1820,7 +1282,7 @@ async function handleReflexionCommands(cli, subcommand, args) {
     }
     else if (subcommand === 'retrieve') {
         // Parse retrieve command with new flags
-        const task = args[0];
+        let task = args[0];
         let k = undefined;
         let minReward = undefined;
         let onlyFailures = undefined;
@@ -1930,7 +1392,7 @@ async function handleSkillCommands(cli, subcommand, args) {
         printHelp();
     }
 }
-async function handleDbCommands(cli, subcommand, _args) {
+async function handleDbCommands(cli, subcommand, args) {
     if (subcommand === 'stats') {
         await cli.dbStats();
     }
@@ -1946,7 +1408,6 @@ async function handleSyncCommands(cli, subcommand, args) {
         let cert;
         let key;
         let authToken;
-        let maxConnections;
         for (let i = 0; i < args.length; i++) {
             if (args[i] === '--port' && i + 1 < args.length) {
                 port = parseInt(args[++i]);
@@ -1960,11 +1421,8 @@ async function handleSyncCommands(cli, subcommand, args) {
             else if (args[i] === '--auth-token' && i + 1 < args.length) {
                 authToken = args[++i];
             }
-            else if (args[i] === '--max-connections' && i + 1 < args.length) {
-                maxConnections = parseInt(args[++i]);
-            }
         }
-        await cli.quicStartServer({ port, cert, key, authToken, maxConnections });
+        await cli.quicStartServer({ port, cert, key, authToken });
     }
     else if (subcommand === 'connect') {
         // Parse host and port
@@ -1972,12 +1430,11 @@ async function handleSyncCommands(cli, subcommand, args) {
         const port = parseInt(args[1]);
         if (!host || !port) {
             log.error('Missing required arguments: host and port');
-            log.info('Usage: agentdb sync connect <host> <port> [--auth-token <token>] [--cert <path>] [--timeout <ms>]');
+            log.info('Usage: agentdb sync connect <host> <port> [--auth-token <token>] [--cert <path>]');
             process.exit(1);
         }
         let authToken;
         let cert;
-        let timeout;
         for (let i = 2; i < args.length; i++) {
             if (args[i] === '--auth-token' && i + 1 < args.length) {
                 authToken = args[++i];
@@ -1985,19 +1442,14 @@ async function handleSyncCommands(cli, subcommand, args) {
             else if (args[i] === '--cert' && i + 1 < args.length) {
                 cert = args[++i];
             }
-            else if (args[i] === '--timeout' && i + 1 < args.length) {
-                timeout = parseInt(args[++i]);
-            }
         }
-        await cli.quicConnect({ host, port, authToken, cert, timeout });
+        await cli.quicConnect({ host, port, authToken, cert });
     }
     else if (subcommand === 'push') {
         // Parse options
         let server;
         let incremental = false;
         let filter;
-        let authToken;
-        let batchSize;
         for (let i = 0; i < args.length; i++) {
             if (args[i] === '--server' && i + 1 < args.length) {
                 server = args[++i];
@@ -2008,31 +1460,22 @@ async function handleSyncCommands(cli, subcommand, args) {
             else if (args[i] === '--filter' && i + 1 < args.length) {
                 filter = args[++i];
             }
-            else if (args[i] === '--auth-token' && i + 1 < args.length) {
-                authToken = args[++i];
-            }
-            else if (args[i] === '--batch-size' && i + 1 < args.length) {
-                batchSize = parseInt(args[++i]);
-            }
             else if (!args[i].startsWith('--') && !server) {
                 server = args[i];
             }
         }
         if (!server) {
             log.error('Missing required --server parameter');
-            log.info('Usage: agentdb sync push --server <host:port> [--incremental] [--filter <pattern>] [--auth-token <token>] [--batch-size <n>]');
+            log.info('Usage: agentdb sync push --server <host:port> [--incremental] [--filter <pattern>]');
             process.exit(1);
         }
-        await cli.quicPush({ server, incremental, filter, authToken, batchSize });
+        await cli.quicPush({ server, incremental, filter });
     }
     else if (subcommand === 'pull') {
         // Parse options
         let server;
         let incremental = false;
         let filter;
-        let authToken;
-        let batchSize;
-        let conflictStrategy;
         for (let i = 0; i < args.length; i++) {
             if (args[i] === '--server' && i + 1 < args.length) {
                 server = args[++i];
@@ -2043,31 +1486,16 @@ async function handleSyncCommands(cli, subcommand, args) {
             else if (args[i] === '--filter' && i + 1 < args.length) {
                 filter = args[++i];
             }
-            else if (args[i] === '--auth-token' && i + 1 < args.length) {
-                authToken = args[++i];
-            }
-            else if (args[i] === '--batch-size' && i + 1 < args.length) {
-                batchSize = parseInt(args[++i]);
-            }
-            else if (args[i] === '--conflict-strategy' && i + 1 < args.length) {
-                const strategy = args[++i];
-                if (strategy === 'local-wins' || strategy === 'remote-wins' || strategy === 'latest-wins') {
-                    conflictStrategy = strategy;
-                }
-                else {
-                    log.warning(`Unknown conflict strategy: ${strategy}. Using default: latest-wins`);
-                }
-            }
             else if (!args[i].startsWith('--') && !server) {
                 server = args[i];
             }
         }
         if (!server) {
             log.error('Missing required --server parameter');
-            log.info('Usage: agentdb sync pull --server <host:port> [--incremental] [--filter <pattern>] [--auth-token <token>] [--batch-size <n>] [--conflict-strategy <local-wins|remote-wins|latest-wins>]');
+            log.info('Usage: agentdb sync pull --server <host:port> [--incremental] [--filter <pattern>]');
             process.exit(1);
         }
-        await cli.quicPull({ server, incremental, filter, authToken, batchSize, conflictStrategy });
+        await cli.quicPull({ server, incremental, filter });
     }
     else if (subcommand === 'status') {
         await cli.quicStatus();
@@ -2075,13 +1503,6 @@ async function handleSyncCommands(cli, subcommand, args) {
     else {
         log.error(`Unknown sync subcommand: ${subcommand}`);
         log.info('Available subcommands: start-server, connect, push, pull, status');
-        log.info('');
-        log.info('Examples:');
-        log.info('  agentdb sync start-server --port 4433 --auth-token secret123');
-        log.info('  agentdb sync connect localhost 4433 --auth-token secret123');
-        log.info('  agentdb sync push --server localhost:4433 --incremental');
-        log.info('  agentdb sync pull --server localhost:4433 --conflict-strategy latest-wins');
-        log.info('  agentdb sync status');
         printHelp();
     }
 }
@@ -2432,7 +1853,7 @@ async function handleVectorSearchCommand(args) {
         scored = scored.slice(0, k);
     }
     // Remove embedding from output
-    const output = scored.map(({ embedding: _embedding, ...rest }) => rest);
+    const output = scored.map(({ embedding, ...rest }) => rest);
     if (format === 'json') {
         console.log(JSON.stringify(output, null, 2));
     }
@@ -2598,9 +2019,8 @@ async function handleImportCommand(args) {
     const cli = new AgentDBCLI();
     await cli.initialize(dbPath);
     let imported = 0;
-    for (const rawItem of data) {
+    for (const item of data) {
         try {
-            const item = rawItem;
             // Import episode
             const episodeQuery = `
         INSERT INTO episodes (session_id, task, input, output, critique, reward, success, latency_ms, tokens_used, tags, metadata)
@@ -2687,14 +2107,15 @@ function printHelp() {
 ${colors.bright}${colors.cyan}█▀█ █▀▀ █▀▀ █▄░█ ▀█▀ █▀▄ █▄▄
 █▀█ █▄█ ██▄ █░▀█ ░█░ █▄▀ █▄█${colors.reset}
 
-${colors.bright}${colors.cyan}AgentDB v3 CLI - Intelligent Vector Database for AI Agents${colors.reset}
+${colors.bright}${colors.cyan}AgentDB v2 CLI - Vector Intelligence with Auto Backend Detection${colors.reset}
 
 ${colors.bright}CORE COMMANDS:${colors.reset}
   ${colors.cyan}init${colors.reset} [options]              Initialize database with backend detection
-    --backend <type>           Backend: auto (default), ruvector, rvf, hnswlib
+    --backend <type>           Backend: auto (default), ruvector, hnswlib
     --dimension <n>            Vector dimension (default: 384)
     --model <name>             Embedding model (default: Xenova/all-MiniLM-L6-v2)
-    --rvf-path <path>          RVF store path (default: ./agentdb.rvf)
+                               Popular: Xenova/bge-base-en-v1.5 (768d production)
+                                        Xenova/bge-small-en-v1.5 (384d best quality)
     --dry-run                  Show detection info without initializing
     --db <path>                Database path (default: ./agentdb.db)
 
@@ -2704,17 +2125,8 @@ ${colors.bright}CORE COMMANDS:${colors.reset}
 
   ${colors.cyan}doctor${colors.reset} [options]            System diagnostics and health check
     --db <path>                Database path to check (optional)
-    --rvf-path <path>          RVF store to check (default: ./agentdb.rvf)
-    --fix                      Auto-fix issues (compact RVF, repair DB)
     --verbose, -v              Show detailed system information
 
-  ${colors.cyan}rvf${colors.reset} <subcommand>            RVF store management
-    status <store>             Show RVF store status and statistics
-    compact <store>            Compact store to reclaim dead space
-    derive <parent> <child>    Create a COW branch
-    segments <store>           List store segments
-    detect                     Detect RVF SDK availability
-
 ${colors.bright}USAGE:${colors.reset}
   agentdb <command> <subcommand> [options]
 
@@ -2831,55 +2243,6 @@ ${colors.bright}QUIC SYNC COMMANDS:${colors.reset}
     Show synchronization status, pending changes, and connected servers
     Example: agentdb sync status
 
-${colors.bright}ADVANCED NEURAL COMMANDS (WASM-ACCELERATED):${colors.reset}
-  agentdb attention <subcommand> [options]
-    Attention mechanism operations: flash, hyperbolic, sparse, MoE
-    Subcommands:
-      init --mechanism <type>         Initialize attention configuration
-      compute --query <text>          Compute attention for query-key-value
-      benchmark --all                 Benchmark all mechanisms
-      optimize --mechanism <type>     Optimize parameters
-    Example: agentdb attention benchmark --all --iterations 100
-
-  agentdb learn --mode <type> --data <file> [options]
-    Advanced learning: curriculum, contrastive loss, hard negative mining
-    Modes:
-      curriculum    Progressive difficulty training with cosine/linear schedules
-      contrastive   InfoNCE and local contrastive loss training
-      hard-negatives Hard negative mining for contrastive learning
-    Options:
-      --schedule <type>        Difficulty schedule: linear|cosine|exponential
-      --temperature <n>        InfoNCE temperature (default: 0.07)
-      --strategy <type>        Mining strategy: hard|semi-hard|distance-based
-    Example: agentdb learn --mode curriculum --data train.json --schedule cosine
-    Example: agentdb learn --mode contrastive --data pairs.json --epochs 15
-
-  agentdb route --prompt <text> [options]
-    LLM routing with FastGRNN model selection (haiku/sonnet/opus)
-    Options:
-      --prompt <text>          Prompt to route
-      --prompt-file <path>     File containing prompt
-      --context <json>         Conversation context (JSON)
-      --explain                Explain routing decision
-    Subcommands:
-      feedback --model <type> --outcome <result>    Record feedback for learning
-      stats                                          View routing statistics
-    Example: agentdb route --prompt "Explain quantum computing" --explain
-    Example: agentdb route feedback --model sonnet --outcome success
-
-  agentdb hyperbolic --op <type> [options]
-    Hyperbolic space operations: Poincaré ball geometry
-    Operations:
-      expmap       Exponential map (tangent -> manifold)
-      logmap       Logarithmic map (manifold -> tangent)
-      mobius-add   Möbius addition (hyperbolic addition)
-      distance     Poincaré distance between points
-      project      Project point to Poincaré ball
-      centroid     Compute hyperbolic centroid
-      dual-search  Hybrid Euclidean + Hyperbolic search
-    Example: agentdb hyperbolic --op distance --point-a "[0.3,0.4]" --point-b "[0.6,0.2]"
-    Example: agentdb hyperbolic --op dual-search --query "[0.5,0.5]" --points vectors.json
-
 ${colors.bright}CAUSAL COMMANDS:${colors.reset}
   agentdb causal add-edge <cause> <effect> <uplift> [confidence] [sample-size]
     Add a causal edge manually