agentic-qe 3.7.21 → 3.8.0

package/dist/cli/commands/learning.js

@@ -13,14 +13,15 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import path from 'node:path';
 import { findProjectRoot } from '../../kernel/unified-memory.js';
-import { existsSync, writeFileSync, readFileSync, mkdirSync, copyFileSync } from 'node:fs';
+import { existsSync, writeFileSync, readFileSync, mkdirSync, copyFileSync, renameSync } from 'node:fs';
 import { safeJsonParse } from '../../shared/safe-json.js';
 import { stat, unlink } from 'node:fs/promises';
 import { QE_DOMAIN_LIST } from '../../learning/qe-patterns.js';
 import { createLearningMetricsTracker, } from '../../learning/metrics-tracker.js';
+import { createRegretTracker, } from '../../learning/regret-tracker.js';
 import { openDatabase } from '../../shared/safe-db.js';
 // Extracted helpers
-import { initializeLearningSystem, printJson, printSuccess, printError, printInfo, displayDashboard, getDbPath, compressFile, decompressFile, verifyDatabaseIntegrity, getSchemaVersion, EXPORT_FORMAT_VERSION, DOMAIN_MAPPING, PATTERN_TYPE_MAPPING, } from './learning-helpers.js';
+import { initializeLearningSystem, printJson, printSuccess, printError, printInfo, displayDashboard, getDbPath, compressFile, decompressFile, verifyDatabaseIntegrity, getSchemaVersion, padRight, EXPORT_FORMAT_VERSION, DOMAIN_MAPPING, PATTERN_TYPE_MAPPING, } from './learning-helpers.js';
 // ============================================================================
 // Learning Command
 // ============================================================================
@@ -62,6 +63,8 @@ Examples:
     registerExportFullCommand(learning);
     registerImportMergeCommand(learning);
     registerDreamCommand(learning);
+    registerRepairCommand(learning);
+    registerHealthCommand(learning);
     return learning;
 }
 // ============================================================================
@@ -372,15 +375,19 @@ function registerExtractCommand(learning) {
             console.log(`  Min occurrences: ${minCount}\n`);
             const db = openDatabase(dbPath, { readonly: true });
             const experiences = db.prepare(`
-          SELECT task_type, COUNT(*) as count, AVG(reward) as avg_reward, MAX(reward) as max_reward,
-                 MIN(reward) as min_reward, GROUP_CONCAT(DISTINCT action) as actions
-          FROM learning_experiences WHERE reward >= ? GROUP BY task_type HAVING COUNT(*) >= ? ORDER BY avg_reward DESC
+          SELECT domain as task_type, COUNT(*) as count, AVG(quality) as avg_reward, MAX(quality) as max_reward,
+                 MIN(quality) as min_reward, GROUP_CONCAT(DISTINCT agent) as actions
+          FROM captured_experiences WHERE quality >= ? AND agent != 'cli-hook' GROUP BY domain HAVING COUNT(*) >= ? ORDER BY avg_reward DESC
         `).all(minReward, minCount);
-            const memoryPatterns = db.prepare(`
-          SELECT substr(key, 1, 40) as key_prefix, COUNT(*) as count
-          FROM memory_entries WHERE key LIKE 'phase2/learning/%'
-          GROUP BY substr(key, 1, 40) HAVING COUNT(*) >= ? ORDER BY COUNT(*) DESC LIMIT 20
-        `).all(minCount);
+            let memoryPatterns = [];
+            try {
+                memoryPatterns = db.prepare(`
+            SELECT substr(key, 1, 40) as key_prefix, COUNT(*) as count
+            FROM memory_entries WHERE key LIKE 'phase2/learning/%'
+            GROUP BY substr(key, 1, 40) HAVING COUNT(*) >= ? ORDER BY COUNT(*) DESC LIMIT 20
+          `).all(minCount);
+            }
+            catch { /* memory_entries table may not exist */ }
             db.close();
             const extractedPatterns = [];
             for (const exp of experiences) {
@@ -689,7 +696,7 @@ function registerVerifyCommand(learning) {
             let tableCounts = {};
             try {
                 const db = openDatabase(dbPath, { readonly: true });
-                for (const table of ['qe_patterns', 'qe_trajectories', 'learning_experiences', 'kv_store', 'vectors']) {
+                for (const table of ['qe_patterns', 'qe_trajectories', 'captured_experiences', 'kv_store', 'vectors']) {
                     try {
                         const r = db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
                         tableCounts[table] = r.count;
@@ -770,9 +777,9 @@ function registerExportFullCommand(learning) {
             if (options.includeExperiences) {
                 try {
                     const db = openDatabase(dbPath, { readonly: true });
-                    const experiences = db.prepare(`SELECT task_type, action, AVG(reward) as avg_reward, COUNT(*) as count FROM learning_experiences GROUP BY task_type, action ORDER BY count DESC LIMIT 500`).all();
+                    const experiences = db.prepare(`SELECT domain as task_type, agent as action, AVG(quality) as avg_reward, COUNT(*) as count FROM captured_experiences WHERE agent != 'cli-hook' GROUP BY domain, agent ORDER BY count DESC LIMIT 500`).all();
                     exportData.experiences = experiences.map(e => ({ taskType: e.task_type, action: e.action, reward: e.avg_reward, count: e.count }));
-                    const metaRow = db.prepare(`SELECT COUNT(*) as total, AVG(reward) as avg_reward FROM learning_experiences`).get();
+                    const metaRow = db.prepare(`SELECT COUNT(*) as total, AVG(quality) as avg_reward FROM captured_experiences WHERE agent != 'cli-hook'`).get();
                     exportData.metadata = { totalExperiences: metaRow.total, avgReward: metaRow.avg_reward };
                     db.close();
                 }
@@ -1136,6 +1143,256 @@ function registerDreamCommand(learning) {
     });
 }
 // ============================================================================
+// Subcommand: repair
+// ============================================================================
+function registerRepairCommand(learning) {
+    learning
+        .command('repair')
+        .description('Repair a corrupted learning database (dump + reimport to rebuild indexes)')
+        .option('-f, --file <path>', 'Database file to repair (defaults to current project)')
+        .option('--dry-run', 'Show what would be done without modifying files')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const dbPath = options.file ? path.resolve(options.file) : getDbPath();
+            if (!existsSync(dbPath))
+                throw new Error(`Database file not found: ${dbPath}`);
+            // Step 1: Check integrity first
+            const integrityResult = await verifyDatabaseIntegrity(dbPath);
+            if (integrityResult.valid) {
+                if (options.json) {
+                    printJson({ status: 'healthy', message: 'Database is already healthy, no repair needed', path: dbPath });
+                }
+                else {
+                    printSuccess('Database integrity check passed — no repair needed.');
+                }
+                process.exit(0);
+            }
+            printInfo(`Corruption detected: ${integrityResult.message}`);
+            // Step 2: Count rows before repair
+            let rowCountsBefore = {};
+            try {
+                const db = openDatabase(dbPath, { readonly: true });
+                const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+                for (const t of tables) {
+                    try {
+                        const r = db.prepare(`SELECT COUNT(*) as count FROM "${t.name}"`).get();
+                        rowCountsBefore[t.name] = r.count;
+                    }
+                    catch { /* corrupted table, count what we can */ }
+                }
+                db.close();
+            }
+            catch { /* ignore count failures */ }
+            const totalBefore = Object.values(rowCountsBefore).reduce((a, b) => a + b, 0);
+            printInfo(`Found ${Object.keys(rowCountsBefore).length} tables, ~${totalBefore} total rows`);
+            if (options.dryRun) {
+                if (options.json) {
+                    printJson({ status: 'dry-run', corruptionDetected: true, message: integrityResult.message, tables: rowCountsBefore, totalRows: totalBefore });
+                }
+                else {
+                    console.log(chalk.bold('\nDry run — would perform these steps:'));
+                    console.log('  1. Backup corrupted DB');
+                    console.log('  2. Dump all data via .dump');
+                    console.log('  3. Reimport into fresh DB (rebuilds all indexes)');
+                    console.log('  4. Verify integrity of repaired DB');
+                    console.log('  5. Verify row counts match');
+                    console.log('  6. Swap repaired DB into place');
+                    console.log('');
+                }
+                process.exit(0);
+            }
+            // Step 3: Backup
+            const backupPath = `${dbPath}.bak-${Date.now()}`;
+            copyFileSync(dbPath, backupPath);
+            printInfo(`Backup created: ${backupPath}`);
+            // Step 4: Remove stale WAL/SHM
+            for (const suffix of ['-wal', '-shm']) {
+                const walFile = dbPath + suffix;
+                if (existsSync(walFile)) {
+                    await unlink(walFile);
+                }
+            }
+            // Step 5: Dump and reimport using sqlite3 CLI
+            const { execSync } = await import('node:child_process');
+            const repairedPath = `${dbPath}.repaired`;
+            const dumpPath = `${dbPath}.dump.sql`;
+            try {
+                // Dump all data
+                execSync(`sqlite3 "${dbPath}" ".dump" > "${dumpPath}"`, { stdio: 'pipe', timeout: 120000 });
+                // Reimport into fresh DB
+                execSync(`sqlite3 "${repairedPath}" < "${dumpPath}"`, { stdio: 'pipe', timeout: 120000 });
+                // Enable WAL on repaired DB
+                execSync(`sqlite3 "${repairedPath}" "PRAGMA journal_mode=WAL;"`, { stdio: 'pipe' });
+            }
+            catch (dumpError) {
+                // Clean up partial files
+                if (existsSync(repairedPath))
+                    await unlink(repairedPath);
+                if (existsSync(dumpPath))
+                    await unlink(dumpPath);
+                throw new Error(`sqlite3 dump/reimport failed: ${dumpError instanceof Error ? dumpError.message : 'unknown'}. Is sqlite3 installed?`);
+            }
+            // Step 6: Verify repaired DB
+            const repairedIntegrity = await verifyDatabaseIntegrity(repairedPath);
+            if (!repairedIntegrity.valid) {
+                if (existsSync(dumpPath))
+                    await unlink(dumpPath);
+                throw new Error(`Repaired DB still has integrity issues: ${repairedIntegrity.message}. Backup preserved at ${backupPath}`);
+            }
+            // Step 7: Verify row counts
+            let rowCountsAfter = {};
+            const repairedDb = openDatabase(repairedPath, { readonly: true });
+            const repairedTables = repairedDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+            for (const t of repairedTables) {
+                try {
+                    const r = repairedDb.prepare(`SELECT COUNT(*) as count FROM "${t.name}"`).get();
+                    rowCountsAfter[t.name] = r.count;
+                }
+                catch { /* skip */ }
+            }
+            repairedDb.close();
+            const totalAfter = Object.values(rowCountsAfter).reduce((a, b) => a + b, 0);
+            // Step 8: Swap
+            renameSync(dbPath, `${dbPath}.pre-repair`);
+            renameSync(repairedPath, dbPath);
+            // Clean up dump file
+            if (existsSync(dumpPath))
+                await unlink(dumpPath);
+            if (options.json) {
+                printJson({
+                    status: 'repaired',
+                    backupPath,
+                    rowsBefore: totalBefore,
+                    rowsAfter: totalAfter,
+                    tablesRepaired: Object.keys(rowCountsAfter).length,
+                    rowCounts: rowCountsAfter,
+                });
+            }
+            else {
+                printSuccess('Database repaired successfully!');
+                console.log(`  Backup:       ${backupPath}`);
+                console.log(`  Rows before:  ${totalBefore}`);
+                console.log(`  Rows after:   ${totalAfter}`);
+                if (totalAfter < totalBefore) {
+                    console.log(chalk.yellow(`  Warning: ${totalBefore - totalAfter} rows may have been lost due to data page corruption`));
+                }
+                console.log(`  Tables:       ${Object.keys(rowCountsAfter).length}`);
+                console.log(`  Integrity:    ${chalk.green('OK')}`);
+                console.log('');
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            printError(`repair failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            process.exit(1);
+        }
+    });
+}
+// ============================================================================
+// Subcommand: health (Task 2.4 - Regret Tracking & Learning Health)
+// ============================================================================
+/**
+ * Get trend arrow and label for a growth rate classification
+ */
+function growthRateDisplay(rate) {
+    switch (rate) {
+        case 'sublinear':
+            return { arrow: '\u25B2', label: 'Sublinear (learning)', color: chalk.green };
+        case 'linear':
+            return { arrow: '\u2192', label: 'Linear (stagnating)', color: chalk.yellow };
+        case 'superlinear':
+            return { arrow: '\u25BC', label: 'Superlinear (degrading)', color: chalk.red };
+        case 'insufficient_data':
+        default:
+            return { arrow: '?', label: 'Insufficient data', color: chalk.dim };
+    }
+}
+function registerHealthCommand(learning) {
+    learning
+        .command('health')
+        .description('Display per-domain learning health based on regret tracking')
+        .option('--json', 'Output as JSON')
+        .option('--domain <domain>', 'Filter to a specific domain')
+        .action(async (options) => {
+        try {
+            const projectRoot = findProjectRoot();
+            const dbPath = path.join(projectRoot, '.agentic-qe', 'memory.db');
+            if (!existsSync(dbPath)) {
+                printError('Database not found. Run "aqe init --auto" first.');
+                process.exit(1);
+            }
+            // Build regret data from captured experiences per domain
+            const tracker = createRegretTracker();
+            const db = openDatabase(dbPath, { readonly: true });
+            // Check for captured_experiences table
+            const tableExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='captured_experiences'`).get();
+            if (tableExists) {
+                // Query experiences grouped by domain, ordered by time
+                const domainFilter = options.domain
+                    ? `AND domain = ?` : '';
+                const params = [];
+                if (options.domain)
+                    params.push(options.domain);
+                const rows = db.prepare(`
+            SELECT domain, quality, success, started_at
+            FROM captured_experiences
+            WHERE agent != 'cli-hook'
+              AND domain IS NOT NULL
+              AND domain != ''
+              ${domainFilter}
+            ORDER BY started_at ASC
+          `).all(...params);
+                for (const row of rows) {
+                    const reward = row.quality ?? (row.success ? 1.0 : 0.0);
+                    const optimalReward = 1.0;
+                    tracker.recordDecision(row.domain, reward, optimalReward);
+                }
+            }
+            db.close();
+            const healthSummary = tracker.getHealthSummary();
+            if (options.json) {
+                printJson(healthSummary);
+                process.exit(0);
+            }
+            // Display health dashboard
+            console.log('');
+            console.log(chalk.bold('Learning Health Dashboard:'));
+            if (healthSummary.length === 0) {
+                console.log(chalk.dim('  No domain data available. Run some QE tasks to generate learning data.'));
+                console.log('');
+                process.exit(0);
+            }
+            // Find the longest domain name for alignment
+            const maxDomainLen = Math.max(...healthSummary.map(s => s.domain.length), 20);
+            for (const summary of healthSummary) {
+                const { arrow, label, color } = growthRateDisplay(summary.growthRate);
+                const domainName = padRight(summary.domain + ':', maxDomainLen + 1);
+                const statusStr = color(`${arrow} ${padRight(label, 26)}`);
+                const regretStr = `regret: ${summary.cumulativeRegret.toFixed(1)}`;
+                const decisionsStr = `decisions: ${summary.totalDecisions}`;
+                console.log(`  ${domainName} ${statusStr} ${regretStr}   ${decisionsStr}`);
+            }
+            // Show summary line
+            const stagnating = healthSummary.filter(s => s.stagnating);
+            if (stagnating.length > 0) {
+                console.log('');
+                console.log(chalk.yellow(`  Warning: ${stagnating.length} domain(s) showing stagnation: ${stagnating.map(s => s.domain).join(', ')}`));
+            }
+            const learning = healthSummary.filter(s => s.growthRate === 'sublinear');
+            if (learning.length > 0) {
+                console.log(chalk.green(`  ${learning.length} domain(s) actively learning`));
+            }
+            console.log('');
+            process.exit(0);
+        }
+        catch (error) {
+            printError(`health check failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            process.exit(1);
+        }
+    });
+}
+// ============================================================================
 // Exports
 // ============================================================================
 export { initializeLearningSystem } from './learning-helpers.js';

package/dist/cli/commands/ruvector-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Agentic QE v3 - RuVector CLI Commands
+ * Manage RuVector feature flags and native package status.
+ *
+ * Subcommands:
+ *   status - Show native package availability and flag status
+ *   flags  - List, set, or apply profiles to feature flags
+ */
+import { Command } from 'commander';
+/**
+ * Create the ruvector command group
+ */
+export declare function createRuVectorCommand(): Command;
+export default createRuVectorCommand;
+//# sourceMappingURL=ruvector-commands.d.ts.map

package/dist/cli/commands/ruvector-commands.js

@@ -0,0 +1,271 @@
+/**
+ * Agentic QE v3 - RuVector CLI Commands
+ * Manage RuVector feature flags and native package status.
+ *
+ * Subcommands:
+ *   status - Show native package availability and flag status
+ *   flags  - List, set, or apply profiles to feature flags
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getRuVectorFeatureFlags, setRuVectorFeatureFlags, DEFAULT_FEATURE_FLAGS, } from '../../integrations/ruvector/feature-flags.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const NATIVE_PACKAGES = [
+    {
+        name: '@ruvector/router',
+        flag: 'useNativeHNSW',
+        fallback: 'ProgressiveHnswBackend',
+    },
+    {
+        name: 'prime-radiant-advanced-wasm',
+        flag: 'useCoherenceGate',
+        fallback: 'Word-frequency heuristics',
+    },
+    {
+        name: '@ruvector/sona',
+        flag: 'useSONAThreeLoop',
+        fallback: 'TypeScript MicroLoRA/EWC++',
+    },
+];
+const FLAG_DESCRIPTIONS = {
+    useQESONA: 'Self-Optimizing Neural Architecture',
+    useQEFlashAttention: 'SIMD-accelerated attention computation',
+    useQEGNNIndex: 'Differentiable search and HNSW indexing',
+    logMigrationMetrics: 'Log migration metrics during rollout',
+    useNativeHNSW: 'Rust-based HNSW backend (@ruvector/router VectorDb)',
+    useTemporalCompression: 'Temporal tensor compression (ADR-085)',
+    useMetadataFiltering: 'SIMD-accelerated metadata filtering',
+    useDeterministicDither: 'Cross-platform deterministic dithering',
+    useNeuralRouting: 'Neural model routing via FastGRNN (ADR-082)',
+    useSONAThreeLoop: 'SONA Three-Loop Engine (Task 2.2)',
+    useCrossDomainTransfer: 'Cross-domain transfer learning (ADR-084)',
+    useHnswHealthMonitor: 'HNSW health monitor (Task 3.4)',
+    useRegretTracking: 'Regret tracking & learning health (Task 2.4)',
+    useCoherenceGate: 'Sheaf-gated coherence validation (ADR-083, Task 3.1)',
+    useWitnessChain: 'Blake3 hash-chained witness records (Task 3.1)',
+    useCNNVisualRegression: 'CNN visual regression testing (Task 4.3)',
+    useDAGAttention: 'DAG attention for test scheduling (Task 4.2)',
+    useCoherenceActionGate: 'Coherence-gated agent actions (ADR-083, Task 3.2)',
+    useReasoningQEC: 'Reasoning QEC error correction (Task 4.5)',
+};
+const PROFILES = {
+    performance: {
+        useNativeHNSW: true,
+        useTemporalCompression: true,
+        useDeterministicDither: true,
+    },
+    experimental: {
+        useQESONA: true,
+        useQEFlashAttention: true,
+        useQEGNNIndex: true,
+        logMigrationMetrics: true,
+        useNativeHNSW: true,
+        useTemporalCompression: true,
+        useMetadataFiltering: true,
+        useDeterministicDither: true,
+        useNeuralRouting: true,
+    },
+    safe: {
+        useQESONA: true,
+        useQEFlashAttention: true,
+        useQEGNNIndex: true,
+        logMigrationMetrics: true,
+        useNativeHNSW: false,
+        useTemporalCompression: false,
+        useMetadataFiltering: false,
+        useDeterministicDither: false,
+        useNeuralRouting: false,
+    },
+};
+const VALID_FLAG_NAMES = Object.keys(DEFAULT_FEATURE_FLAGS);
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Check whether a native package is installed.
+ * Returns true if the package can be resolved, false otherwise.
+ */
+function isNativePackageInstalled(packageName) {
+    try {
+        require.resolve(packageName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isDefaultValue(flag, value) {
+    return DEFAULT_FEATURE_FLAGS[flag] === value;
+}
+function padRight(str, length) {
+    return str.padEnd(length);
+}
+function isValidFlagName(name) {
+    return VALID_FLAG_NAMES.includes(name);
+}
+function isValidProfile(name) {
+    return name in PROFILES;
+}
+// ============================================================================
+// Command: ruvector status
+// ============================================================================
+function executeStatus() {
+    const flags = getRuVectorFeatureFlags();
+    console.log('');
+    console.log(chalk.bold.blue('RuVector Integration Status:'));
+    // Native packages section
+    console.log(chalk.cyan('  Native Packages:'));
+    for (const pkg of NATIVE_PACKAGES) {
+        const installed = isNativePackageInstalled(pkg.name);
+        const statusText = installed
+            ? chalk.green('installed')
+            : chalk.gray(`not installed (fallback: ${pkg.fallback})`);
+        console.log(`    ${padRight(pkg.name + ':', 30)} ${statusText}`);
+    }
+    // Feature flags section
+    console.log('');
+    console.log(chalk.cyan('  Feature Flags:'));
+    for (const flagName of VALID_FLAG_NAMES) {
+        const value = flags[flagName];
+        const isDefault = isDefaultValue(flagName, value);
+        const valueText = value ? chalk.green('true') : chalk.gray('false');
+        const suffix = isDefault ? chalk.gray(' (default)') : chalk.yellow(' (modified)');
+        console.log(`    ${padRight(flagName + ':', 30)} ${valueText}${suffix}`);
+    }
+    // Memory info when compression is enabled
+    if (flags.useTemporalCompression) {
+        console.log('');
+        console.log(chalk.cyan('  Temporal Compression:'));
+        console.log(chalk.gray('    Hot tier:  8-bit quantization (frequently accessed patterns)'));
+        console.log(chalk.gray('    Warm tier: 5-bit quantization (moderately accessed patterns)'));
+        console.log(chalk.gray('    Cold tier: 3-bit quantization (rarely accessed patterns)'));
+        console.log(chalk.gray('    Estimated memory savings: 40-60% for cold patterns'));
+    }
+    console.log('');
+}
+// ============================================================================
+// Command: ruvector flags
+// ============================================================================
+function executeFlags(options) {
+    // Handle --profile
+    if (options.profile) {
+        if (!isValidProfile(options.profile)) {
+            console.log('');
+            console.log(chalk.red(`  Unknown profile: ${options.profile}`));
+            console.log(chalk.gray(`  Valid profiles: ${Object.keys(PROFILES).join(', ')}`));
+            console.log('');
+            process.exit(1);
+            return;
+        }
+        const profileFlags = PROFILES[options.profile];
+        setRuVectorFeatureFlags(profileFlags);
+        console.log('');
+        console.log(chalk.bold.blue(`Setting ${options.profile} profile:`));
+        for (const [key, value] of Object.entries(profileFlags)) {
+            const valueText = value ? chalk.green('true') : chalk.gray('false');
+            console.log(`  ${padRight(key + ':', 30)} ${valueText}`);
+        }
+        console.log('');
+        return;
+    }
+    // Handle --set
+    if (options.set) {
+        const eqIdx = options.set.indexOf('=');
+        if (eqIdx <= 0) {
+            console.log('');
+            console.log(chalk.red('  Invalid format. Use: --set flagName=true|false'));
+            console.log('');
+            process.exit(1);
+            return;
+        }
+        const flagName = options.set.substring(0, eqIdx);
+        const flagValue = options.set.substring(eqIdx + 1);
+        if (!isValidFlagName(flagName)) {
+            console.log('');
+            console.log(chalk.red(`  Unknown flag: ${flagName}`));
+            console.log(chalk.gray(`  Valid flags: ${VALID_FLAG_NAMES.join(', ')}`));
+            console.log('');
+            process.exit(1);
+            return;
+        }
+        if (flagValue !== 'true' && flagValue !== 'false') {
+            console.log('');
+            console.log(chalk.red(`  Invalid value: ${flagValue}. Use true or false.`));
+            console.log('');
+            process.exit(1);
+            return;
+        }
+        const boolValue = flagValue === 'true';
+        setRuVectorFeatureFlags({ [flagName]: boolValue });
+        const valueText = boolValue ? chalk.green('true') : chalk.gray('false');
+        console.log('');
+        console.log(chalk.green(`  Set ${flagName} = ${valueText}`));
+        console.log('');
+        return;
+    }
+    // Default: list all flags
+    const flags = getRuVectorFeatureFlags();
+    console.log('');
+    console.log(chalk.bold.blue('RuVector Feature Flags:'));
+    console.log('');
+    console.log(chalk.bold('  ' + padRight('Flag', 28) + padRight('Value', 10) + 'Description'));
+    console.log(chalk.gray('  ' + '-'.repeat(78)));
+    for (const flagName of VALID_FLAG_NAMES) {
+        const value = flags[flagName];
+        const isDefault = isDefaultValue(flagName, value);
+        const valueText = value ? chalk.green('true') : chalk.gray('false');
+        const suffix = isDefault ? '' : chalk.yellow(' *');
+        const description = FLAG_DESCRIPTIONS[flagName];
+        console.log('  ' +
+            padRight(flagName, 28) +
+            padRight(String(value), 10) +
+            chalk.gray(description) +
+            suffix);
+    }
+    console.log('');
+    console.log(chalk.gray('  * = modified from default'));
+    console.log('');
+    console.log(chalk.gray('  Profiles: performance, experimental, safe'));
+    console.log(chalk.gray('  Usage:'));
+    console.log(chalk.gray('    aqe ruvector flags --set useNativeHNSW=true'));
+    console.log(chalk.gray('    aqe ruvector flags --profile=performance'));
+    console.log('');
+}
+// ============================================================================
+// Command Factory
+// ============================================================================
+/**
+ * Create the ruvector command group
+ */
+export function createRuVectorCommand() {
+    const ruvectorCmd = new Command('ruvector')
+        .description('RuVector integration management')
+        .addHelpText('after', `
+Examples:
+  $ aqe ruvector status                     Show native packages and flags
+  $ aqe ruvector flags                      List all feature flags
+  $ aqe ruvector flags --set useNativeHNSW=true   Toggle a flag
+  $ aqe ruvector flags --profile=performance      Apply a preset profile
+`);
+    // ruvector status
+    ruvectorCmd
+        .command('status')
+        .description('Show native package availability and feature flag status')
+        .action(() => {
+        executeStatus();
+    });
+    // ruvector flags
+    ruvectorCmd
+        .command('flags')
+        .description('List, set, or apply profiles to feature flags')
+        .option('-s, --set <flag=value>', 'Set a feature flag (e.g., useNativeHNSW=true)')
+        .option('-p, --profile <name>', 'Apply a preset profile (performance|experimental|safe)')
+        .action((options) => {
+        executeFlags(options);
+    });
+    return ruvectorCmd;
+}
+export default createRuVectorCommand;
+//# sourceMappingURL=ruvector-commands.js.map

package/dist/cli/handlers/init-handler.d.ts

@@ -40,7 +40,6 @@ interface InitOptions {
     withWindsurf?: boolean;
     withContinuedev?: boolean;
     withAllPlatforms?: boolean;
-    autoMigrate?: boolean;
     withClaudeFlow?: boolean;
     skipClaudeFlow?: boolean;
     noGovernance?: boolean;

package/dist/cli/handlers/init-handler.js

@@ -72,10 +72,6 @@ export class InitHandler {
                 options.withWindsurf = true;
                 options.withContinuedev = true;
             }
-            // --auto-migrate implies --auto (must use orchestrator for migration)
-            if (options.autoMigrate && !options.auto && !options.wizard) {
-                options.auto = true;
-            }
             // --upgrade implies --auto (must use modular orchestrator to overwrite files)
             if (options.upgrade && !options.auto && !options.wizard) {
                 options.auto = true;
@@ -118,7 +114,6 @@ export class InitHandler {
             withCodex: options.withCodex,
             withWindsurf: options.withWindsurf,
             withContinueDev: options.withContinuedev,
-            autoMigrate: options.autoMigrate,
             noGovernance: options.noGovernance,
         });
         console.log(chalk.white('  Analyzing project...\n'));
@@ -192,7 +187,6 @@ export class InitHandler {
             minimal: options.minimal,
             skipPatterns: options.skipPatterns,
             withN8n: options.withN8n,
-            autoMigrate: options.autoMigrate,
         };
         const orchestrator = new InitOrchestrator(orchestratorOptions);
         if (options.wizard) {