agentic-qe 3.6.7 → 3.6.9

package/v3/dist/cli/commands/learning.js

@@ -14,238 +14,12 @@ 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 { createReadStream, createWriteStream } from 'node:fs';
+import { safeJsonParse } from '../../shared/safe-json.js';
 import { stat, unlink } from 'node:fs/promises';
-import { createGzip, createGunzip } from 'node:zlib';
-import { pipeline } from 'node:stream/promises';
-import { createQEReasoningBank, } from '../../learning/qe-reasoning-bank.js';
-import { HybridMemoryBackend } from '../../kernel/hybrid-backend.js';
 import { QE_DOMAIN_LIST } from '../../learning/qe-patterns.js';
 import { createLearningMetricsTracker, } from '../../learning/metrics-tracker.js';
-const state = {
-    reasoningBank: null,
-    initialized: false,
-};
-/**
- * Initialize the learning system
- */
-async function initializeLearningSystem() {
-    if (state.initialized && state.reasoningBank) {
-        return state.reasoningBank;
-    }
-    const projectRoot = findProjectRoot();
-    const dataDir = path.join(projectRoot, '.agentic-qe');
-    // Create hybrid backend
-    const backend = new HybridMemoryBackend({
-        sqlite: {
-            path: path.join(dataDir, 'memory.db'),
-            walMode: true,
-            poolSize: 3,
-            busyTimeout: 5000,
-        },
-        enableFallback: true,
-        defaultNamespace: 'qe-patterns',
-    });
-    await backend.initialize();
-    // Create reasoning bank
-    state.reasoningBank = createQEReasoningBank(backend, undefined, {
-        enableLearning: true,
-        enableGuidance: true,
-        enableRouting: true,
-        embeddingDimension: 768,
-        useONNXEmbeddings: false,
-    });
-    await state.reasoningBank.initialize();
-    state.initialized = true;
-    return state.reasoningBank;
-}
-// ============================================================================
-// Helper Functions
-// ============================================================================
-function printJson(data) {
-    console.log(JSON.stringify(data, null, 2));
-}
-function printSuccess(message) {
-    console.log(chalk.green('✓'), message);
-}
-function printError(message) {
-    console.error(chalk.red('✗'), message);
-}
-function printInfo(message) {
-    console.log(chalk.blue('ℹ'), message);
-}
-/**
- * Display the learning dashboard
- */
-function displayDashboard(dashboard) {
-    const { current, topDomains } = dashboard;
-    // Box drawing characters
-    const BOX = {
-        tl: '┌', tr: '┐', bl: '└', br: '┘',
-        h: '─', v: '│', ml: '├', mr: '┤',
-    };
-    const WIDTH = 55;
-    const HR = BOX.h.repeat(WIDTH - 2);
-    console.log('');
-    console.log(`${BOX.tl}${HR}${BOX.tr}`);
-    console.log(`${BOX.v}${centerText('AQE LEARNING DASHBOARD', WIDTH - 2)}${BOX.v}`);
-    console.log(`${BOX.ml}${HR}${BOX.mr}`);
-    // Pattern stats
-    const patternToday = current.patternsCreatedToday > 0
-        ? chalk.green(` (+${current.patternsCreatedToday} today)`)
-        : '';
-    console.log(`${BOX.v} Patterns:          ${padRight(String(current.totalPatterns) + patternToday, 32)}${BOX.v}`);
-    // Experience stats
-    const expToday = current.experiencesToday > 0
-        ? chalk.green(` (+${current.experiencesToday} today)`)
-        : '';
-    console.log(`${BOX.v} Experiences:       ${padRight(String(current.totalExperiences) + expToday, 32)}${BOX.v}`);
-    // Q-Values
-    console.log(`${BOX.v} Q-Values:          ${padRight(String(current.totalQValues), 32)}${BOX.v}`);
-    // Average Reward with trend
-    const rewardStr = current.avgReward.toFixed(2);
-    const rewardTrend = current.avgRewardDelta >= 0
-        ? chalk.green(`(↑ ${Math.abs(current.avgRewardDelta).toFixed(2)} from last week)`)
-        : chalk.red(`(↓ ${Math.abs(current.avgRewardDelta).toFixed(2)} from last week)`);
-    console.log(`${BOX.v} Avg Reward:        ${padRight(`${rewardStr} ${rewardTrend}`, 32)}${BOX.v}`);
-    // Success rate
-    const successPct = (current.successRate * 100).toFixed(1);
-    console.log(`${BOX.v} Success Rate:      ${padRight(`${successPct}%`, 32)}${BOX.v}`);
-    // Pattern tiers
-    console.log(`${BOX.v} Short-term:        ${padRight(String(current.shortTermPatterns), 32)}${BOX.v}`);
-    console.log(`${BOX.v} Long-term:         ${padRight(String(current.longTermPatterns), 32)}${BOX.v}`);
-    console.log(`${BOX.v}${' '.repeat(WIDTH - 2)}${BOX.v}`);
-    // Domain Coverage
-    console.log(`${BOX.v} ${chalk.bold('Domain Coverage:')}${' '.repeat(WIDTH - 19)}${BOX.v}`);
-    if (topDomains.length === 0) {
-        console.log(`${BOX.v}   ${chalk.dim('No patterns yet')}${' '.repeat(WIDTH - 19)}${BOX.v}`);
-    }
-    else {
-        const maxCount = Math.max(...topDomains.map(d => d.count), 1);
-        const barWidth = 14;
-        for (const { domain, count } of topDomains) {
-            const filledBars = Math.round((count / maxCount) * barWidth);
-            const emptyBars = barWidth - filledBars;
-            const bar = chalk.green('█'.repeat(filledBars)) + chalk.dim('░'.repeat(emptyBars));
-            const domainName = padRight(domain, 20);
-            const countStr = padLeft(String(count), 3);
-            console.log(`${BOX.v}   ${domainName} ${bar} ${countStr} patterns ${BOX.v}`);
-        }
-        // Show remaining domains with 0 patterns
-        const shownDomains = new Set(topDomains.map(d => d.domain));
-        const zeroDomains = QE_DOMAIN_LIST.filter(d => !shownDomains.has(d)).slice(0, 3);
-        for (const domain of zeroDomains) {
-            const bar = chalk.dim('░'.repeat(barWidth));
-            const domainName = padRight(domain, 20);
-            console.log(`${BOX.v}   ${domainName} ${bar}   0 patterns ${BOX.v}`);
-        }
-    }
-    console.log(`${BOX.bl}${HR}${BOX.br}`);
-    console.log('');
-}
-/**
- * Center text within a given width
- */
-function centerText(text, width) {
-    const stripped = stripAnsi(text);
-    const padding = Math.max(0, width - stripped.length);
-    const leftPad = Math.floor(padding / 2);
-    const rightPad = padding - leftPad;
-    return ' '.repeat(leftPad) + text + ' '.repeat(rightPad);
-}
-/**
- * Pad string to the right
- */
-function padRight(text, width) {
-    const stripped = stripAnsi(text);
-    const padding = Math.max(0, width - stripped.length);
-    return text + ' '.repeat(padding);
-}
-/**
- * Pad string to the left
- */
-function padLeft(text, width) {
-    const stripped = stripAnsi(text);
-    const padding = Math.max(0, width - stripped.length);
-    return ' '.repeat(padding) + text;
-}
-/**
- * Strip ANSI escape codes from a string
- */
-function stripAnsi(text) {
-    // eslint-disable-next-line no-control-regex
-    return text.replace(/\x1b\[[0-9;]*m/g, '');
-}
-/**
- * Get the learning database path
- */
-function getDbPath() {
-    const projectRoot = findProjectRoot();
-    return path.join(projectRoot, '.agentic-qe', 'memory.db');
-}
-/**
- * Compress a file using gzip
- */
-async function compressFile(inputPath, outputPath) {
-    const gzPath = outputPath || `${inputPath}.gz`;
-    await pipeline(createReadStream(inputPath), createGzip(), createWriteStream(gzPath));
-    return gzPath;
-}
-/**
- * Decompress a gzipped file
- */
-async function decompressFile(gzPath, outputPath) {
-    await pipeline(createReadStream(gzPath), createGunzip(), createWriteStream(outputPath));
-}
-/**
- * Verify database integrity using SQLite's built-in check
- */
-async function verifyDatabaseIntegrity(dbPath) {
-    try {
-        const Database = (await import('better-sqlite3')).default;
-        const db = new Database(dbPath, { readonly: true });
-        // Run SQLite integrity check
-        const result = db.prepare('PRAGMA integrity_check').get();
-        db.close();
-        if (result.integrity_check === 'ok') {
-            return { valid: true, message: 'Database integrity verified' };
-        }
-        else {
-            return { valid: false, message: `Integrity check failed: ${result.integrity_check}` };
-        }
-    }
-    catch (error) {
-        return {
-            valid: false,
-            message: `Failed to verify: ${error instanceof Error ? error.message : 'unknown error'}`
-        };
-    }
-}
-/**
- * Get database schema version
- */
-async function getSchemaVersion(dbPath) {
-    try {
-        const Database = (await import('better-sqlite3')).default;
-        const db = new Database(dbPath, { readonly: true });
-        // Check if schema_version table exists
-        const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
-        if (!tableExists) {
-            db.close();
-            return 0;
-        }
-        const result = db.prepare('SELECT version FROM schema_version WHERE id = 1').get();
-        db.close();
-        return result?.version ?? 0;
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * Export format version for compatibility tracking
- */
-const EXPORT_FORMAT_VERSION = '3.1.0';
+// 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';
 // ============================================================================
 // Learning Command
 // ============================================================================
@@ -272,9 +46,27 @@ Examples:
   # Run background learning consolidation
   aqe learning daemon --interval 3600
     `);
-    // -------------------------------------------------------------------------
-    // stats: Display learning statistics
-    // -------------------------------------------------------------------------
+    // Register all subcommands
+    registerStatsCommand(learning);
+    registerConsolidateCommand(learning);
+    registerExportCommand(learning);
+    registerImportCommand(learning);
+    registerResetCommand(learning);
+    registerExtractCommand(learning);
+    registerDashboardCommand(learning);
+    registerInfoCommand(learning);
+    registerBackupCommand(learning);
+    registerRestoreCommand(learning);
+    registerVerifyCommand(learning);
+    registerExportFullCommand(learning);
+    registerImportMergeCommand(learning);
+    registerDreamCommand(learning);
+    return learning;
+}
+// ============================================================================
+// Subcommand: stats
+// ============================================================================
+function registerStatsCommand(learning) {
     learning
         .command('stats')
         .description('Display learning system statistics')
@@ -289,14 +81,12 @@ Examples:
             }
             else {
                 console.log(chalk.bold('\n📊 AQE Learning System Statistics\n'));
-                // Overview
                 console.log(chalk.bold('Patterns:'));
                 console.log(`  Total: ${chalk.cyan(stats.totalPatterns)}`);
                 console.log(`  Short-term: ${stats.patternStoreStats.byTier.shortTerm}`);
                 console.log(`  Long-term: ${stats.patternStoreStats.byTier.longTerm}`);
                 console.log(`  Avg Confidence: ${(stats.patternStoreStats.avgConfidence * 100).toFixed(1)}%`);
                 console.log(`  Avg Quality: ${(stats.patternStoreStats.avgQualityScore * 100).toFixed(1)}%`);
-                // By Domain
                 console.log(chalk.bold('\nBy Domain:'));
                 const domainsWithPatterns = Object.entries(stats.byDomain)
                     .filter(([_, count]) => count > 0)
@@ -309,19 +99,16 @@ Examples:
                         console.log(`  ${domain}: ${count}`);
                     }
                 }
-                // Learning Metrics
                 console.log(chalk.bold('\nLearning:'));
                 console.log(`  Routing Requests: ${stats.routingRequests}`);
                 console.log(`  Avg Routing Confidence: ${(stats.avgRoutingConfidence * 100).toFixed(1)}%`);
                 console.log(`  Learning Outcomes: ${stats.learningOutcomes}`);
                 console.log(`  Pattern Success Rate: ${(stats.patternSuccessRate * 100).toFixed(1)}%`);
-                // Search Performance
                 console.log(chalk.bold('\nSearch Performance:'));
                 console.log(`  Operations: ${stats.patternStoreStats.searchOperations}`);
                 console.log(`  Avg Latency: ${stats.patternStoreStats.avgSearchLatencyMs.toFixed(2)}ms`);
                 console.log(`  HNSW Native: ${stats.patternStoreStats.hnswStats.nativeAvailable ? chalk.green('✓') : chalk.dim('○')}`);
                 console.log(`  Vector Count: ${stats.patternStoreStats.hnswStats.vectorCount}`);
-                // ADR-061: Asymmetric Learning Metrics
                 const asymmetricStats = stats.asymmetricLearning;
                 if (asymmetricStats) {
                     console.log(chalk.bold('\nAsymmetric Learning (ADR-061):'));
@@ -333,9 +120,8 @@ Examples:
                 if (options.detailed) {
                     console.log(chalk.bold('\nBy Pattern Type:'));
                     for (const [type, count] of Object.entries(stats.patternStoreStats.byType)) {
-                        if (count > 0) {
+                        if (count > 0)
                             console.log(`  ${type}: ${count}`);
-                        }
                     }
                 }
                 console.log('');
@@ -347,9 +133,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // consolidate: Promote successful patterns to long-term memory
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: consolidate
+// ============================================================================
+function registerConsolidateCommand(learning) {
     learning
         .command('consolidate')
         .description('Consolidate patterns - promote successful patterns to long-term memory')
@@ -360,49 +148,31 @@ Examples:
         .action(async (options) => {
         try {
             const reasoningBank = await initializeLearningSystem();
-            const stats = await reasoningBank.getStats();
             const threshold = parseInt(options.threshold, 10);
             const successRateMin = parseFloat(options.successRate);
-            // Get patterns eligible for promotion
             const eligiblePatterns = [];
-            // Search for patterns that meet promotion criteria
-            // This would be enhanced with actual pattern store access
             const searchResult = await reasoningBank.searchPatterns('*', { limit: 1000 });
             if (searchResult.success) {
                 for (const match of searchResult.value) {
                     const pattern = match.pattern;
-                    if (pattern.tier === 'short-term' &&
-                        pattern.successfulUses >= threshold &&
-                        pattern.successRate >= successRateMin) {
+                    if (pattern.tier === 'short-term' && pattern.successfulUses >= threshold && pattern.successRate >= successRateMin) {
                         eligiblePatterns.push({
-                            id: pattern.id,
-                            name: pattern.name,
-                            domain: pattern.qeDomain,
-                            successfulUses: pattern.successfulUses,
-                            successRate: pattern.successRate,
-                            currentTier: pattern.tier,
+                            id: pattern.id, name: pattern.name, domain: pattern.qeDomain,
+                            successfulUses: pattern.successfulUses, successRate: pattern.successRate, currentTier: pattern.tier,
                         });
                     }
                 }
             }
             if (options.json) {
-                printJson({
-                    dryRun: options.dryRun || false,
-                    eligibleCount: eligiblePatterns.length,
-                    threshold,
-                    successRateMin,
-                    patterns: eligiblePatterns,
-                });
+                printJson({ dryRun: options.dryRun || false, eligibleCount: eligiblePatterns.length, threshold, successRateMin, patterns: eligiblePatterns });
             }
             else {
                 console.log(chalk.bold('\n🔄 Pattern Consolidation\n'));
                 console.log(`  Promotion threshold: ${threshold} successful uses`);
                 console.log(`  Minimum success rate: ${(successRateMin * 100).toFixed(0)}%`);
-                console.log(`  Eligible patterns: ${eligiblePatterns.length}`);
-                console.log('');
+                console.log(`  Eligible patterns: ${eligiblePatterns.length}\n`);
                 if (eligiblePatterns.length === 0) {
                     console.log(chalk.dim('  No patterns eligible for promotion yet.'));
-                    console.log(chalk.dim('  Patterns need more successful uses to be promoted.'));
                 }
                 else {
                     console.log(chalk.bold('  Patterns to promote:'));
@@ -411,7 +181,6 @@ Examples:
                         console.log(chalk.dim(`      Domain: ${p.domain}, Uses: ${p.successfulUses}, Rate: ${(p.successRate * 100).toFixed(0)}%`));
                     }
                     if (!options.dryRun) {
-                        // TODO: Implement actual promotion via reasoningBank
                         console.log(chalk.yellow('\n  Promotion would happen here (not yet implemented)'));
                     }
                     else {
@@ -427,9 +196,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // export: Export learned patterns
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: export
+// ============================================================================
+function registerExportCommand(learning) {
     learning
         .command('export')
         .description('Export learned patterns for sharing')
@@ -440,35 +211,17 @@ Examples:
         .action(async (options) => {
         try {
             const reasoningBank = await initializeLearningSystem();
-            // Search all patterns
-            const searchResult = await reasoningBank.searchPatterns('*', {
-                limit: 10000,
-                domain: options.domain,
-            });
-            if (!searchResult.success) {
+            const searchResult = await reasoningBank.searchPatterns('*', { limit: 10000, domain: options.domain });
+            if (!searchResult.success)
                 throw new Error(searchResult.error.message);
-            }
-            const patterns = searchResult.value
-                .map(m => m.pattern)
-                .filter(p => !options.longTermOnly || p.tier === 'long-term');
+            const patterns = searchResult.value.map(m => m.pattern).filter(p => !options.longTermOnly || p.tier === 'long-term');
             const exportData = {
-                version: '3.0.0',
-                exportedAt: new Date().toISOString(),
-                source: process.cwd(),
+                version: '3.0.0', exportedAt: new Date().toISOString(), source: process.cwd(),
                 patternCount: patterns.length,
                 patterns: patterns.map(p => ({
-                    id: p.id,
-                    name: p.name,
-                    description: p.description,
-                    patternType: p.patternType,
-                    qeDomain: p.qeDomain,
-                    tier: p.tier,
-                    confidence: p.confidence,
-                    successRate: p.successRate,
-                    successfulUses: p.successfulUses,
-                    qualityScore: p.qualityScore,
-                    template: p.template,
-                    context: p.context,
+                    id: p.id, name: p.name, description: p.description, patternType: p.patternType,
+                    qeDomain: p.qeDomain, tier: p.tier, confidence: p.confidence, successRate: p.successRate,
+                    successfulUses: p.successfulUses, qualityScore: p.qualityScore, template: p.template, context: p.context,
                 })),
             };
             if (options.json) {
@@ -486,9 +239,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // import: Import patterns from file
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: import
+// ============================================================================
+function registerImportCommand(learning) {
     learning
         .command('import')
         .description('Import patterns from file')
@@ -498,14 +253,12 @@ Examples:
         .action(async (options) => {
         try {
             const inputPath = path.resolve(options.input);
-            if (!existsSync(inputPath)) {
+            if (!existsSync(inputPath))
                 throw new Error(`File not found: ${inputPath}`);
-            }
             const content = readFileSync(inputPath, 'utf-8');
-            const importData = JSON.parse(content);
-            if (!importData.patterns || !Array.isArray(importData.patterns)) {
+            const importData = safeJsonParse(content);
+            if (!importData.patterns || !Array.isArray(importData.patterns))
                 throw new Error('Invalid pattern file format');
-            }
             const reasoningBank = await initializeLearningSystem();
             let imported = 0;
             let skipped = 0;
@@ -514,15 +267,11 @@ Examples:
                 for (const pattern of importData.patterns) {
                     try {
                         const result = await reasoningBank.storePattern({
-                            patternType: pattern.patternType,
-                            name: pattern.name,
-                            description: pattern.description,
-                            template: pattern.template,
-                            context: pattern.context,
+                            patternType: pattern.patternType, name: pattern.name,
+                            description: pattern.description, template: pattern.template, context: pattern.context,
                         });
-                        if (result.success) {
+                        if (result.success)
                             imported++;
-                        }
                         else {
                             skipped++;
                             errors.push(`${pattern.name}: ${result.error.message}`);
@@ -535,13 +284,7 @@ Examples:
                 }
             }
             if (options.json) {
-                printJson({
-                    dryRun: options.dryRun || false,
-                    totalPatterns: importData.patterns.length,
-                    imported,
-                    skipped,
-                    errors,
-                });
+                printJson({ dryRun: options.dryRun || false, totalPatterns: importData.patterns.length, imported, skipped, errors });
             }
             else {
                 console.log(chalk.bold('\n📥 Pattern Import\n'));
@@ -553,9 +296,8 @@ Examples:
                 }
                 else {
                     console.log(chalk.green(`\n  Imported: ${imported}`));
-                    if (skipped > 0) {
+                    if (skipped > 0)
                         console.log(chalk.yellow(`  Skipped: ${skipped}`));
-                    }
                 }
                 console.log('');
             }
@@ -566,9 +308,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // reset: Reset learning data
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: reset
+// ============================================================================
+function registerResetCommand(learning) {
     learning
         .command('reset')
         .description('Reset learning data (patterns and metrics)')
@@ -578,29 +322,23 @@ Examples:
         try {
             if (!options.confirm) {
                 console.log(chalk.yellow('\n⚠️  This will reset your learning data.'));
-                console.log(chalk.gray('    Use --confirm to proceed'));
-                console.log('');
+                console.log(chalk.gray('    Use --confirm to proceed\n'));
                 process.exit(0);
             }
             const projectRoot = findProjectRoot();
             const dataDir = path.join(projectRoot, '.agentic-qe');
-            // List files that would be affected
             const filesToReset = [
                 path.join(dataDir, 'data', 'patterns'),
                 path.join(dataDir, 'data', 'hnsw'),
             ];
-            if (!options.patternsOnly) {
+            if (!options.patternsOnly)
                 filesToReset.push(path.join(dataDir, 'data', 'learning-config.json'));
-            }
             console.log(chalk.bold('\n🗑️  Resetting Learning Data\n'));
             for (const file of filesToReset) {
-                if (existsSync(file)) {
+                if (existsSync(file))
                     console.log(chalk.dim(`  Removing: ${path.relative(projectRoot, file)}`));
-                    // Actual deletion would happen here
-                }
             }
-            printSuccess('Learning data reset. Run "aqe init --auto" to reinitialize.');
-            console.log('');
+            printSuccess('Learning data reset. Run "aqe init --auto" to reinitialize.\n');
             process.exit(0);
         }
         catch (error) {
@@ -608,9 +346,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // extract: Extract patterns from learning experiences
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: extract
+// ============================================================================
+function registerExtractCommand(learning) {
     learning
         .command('extract')
         .description('Extract QE patterns from existing learning experiences')
@@ -622,133 +362,38 @@ Examples:
         try {
             const projectRoot = findProjectRoot();
             const dbPath = path.join(projectRoot, '.agentic-qe', 'memory.db');
-            if (!existsSync(dbPath)) {
+            if (!existsSync(dbPath))
                 throw new Error('No memory database found. Run "aqe init --auto" first.');
-            }
             const minReward = parseFloat(options.minReward);
             const minCount = parseInt(options.minCount, 10);
             console.log(chalk.bold('\n🔬 Pattern Extraction from Learning Experiences\n'));
             console.log(`  Min reward threshold: ${minReward}`);
-            console.log(`  Min occurrences: ${minCount}`);
-            console.log('');
-            // Dynamic import for better-sqlite3
+            console.log(`  Min occurrences: ${minCount}\n`);
             const Database = (await import('better-sqlite3')).default;
             const db = new Database(dbPath, { readonly: true });
-            // Query learning experiences grouped by task_type
             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 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
         `).all(minReward, minCount);
-            // Query memory entries for additional context
             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
+          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);
             db.close();
-            // Map task types to QE domains
-            const domainMapping = {
-                'generate': 'test-generation',
-                'test-generation': 'test-generation',
-                'analyze': 'coverage-analysis',
-                'coverage': 'coverage-analysis',
-                'coverage-analysis': 'coverage-analysis',
-                'run': 'test-execution',
-                'test-execution': 'test-execution',
-                'report': 'quality-assessment',
-                'quality': 'quality-assessment',
-                'quality-analysis': 'quality-assessment',
-                'security': 'security-compliance',
-                'sast': 'security-compliance',
-                'owasp': 'security-compliance',
-                'secrets': 'security-compliance',
-                'audit': 'security-compliance',
-                'recommend': 'defect-intelligence',
-                'predict': 'defect-intelligence',
-                'complexity-analysis': 'code-intelligence',
-                'code-analysis': 'code-intelligence',
-                'stabilize': 'chaos-resilience',
-                'flaky': 'chaos-resilience',
-                'quarantine': 'chaos-resilience',
-                'retry': 'chaos-resilience',
-                'stress': 'chaos-resilience',
-                'load': 'chaos-resilience',
-                'endurance': 'chaos-resilience',
-                'baseline': 'chaos-resilience',
-            };
-            // Map task types to valid QE pattern types
-            const patternTypeMapping = {
-                'generate': 'test-template',
-                'test-generation': 'test-template',
-                'analyze': 'coverage-strategy',
-                'coverage': 'coverage-strategy',
-                'coverage-analysis': 'coverage-strategy',
-                'run': 'test-template',
-                'test-execution': 'test-template',
-                'report': 'assertion-pattern',
-                'quality': 'assertion-pattern',
-                'quality-analysis': 'assertion-pattern',
-                'security': 'assertion-pattern',
-                'sast': 'assertion-pattern',
-                'owasp': 'assertion-pattern',
-                'secrets': 'assertion-pattern',
-                'audit': 'assertion-pattern',
-                'recommend': 'assertion-pattern',
-                'predict': 'assertion-pattern',
-                'complexity-analysis': 'assertion-pattern',
-                'code-analysis': 'assertion-pattern',
-                'stabilize': 'flaky-fix',
-                'flaky': 'flaky-fix',
-                'quarantine': 'flaky-fix',
-                'retry': 'flaky-fix',
-                'stress': 'perf-benchmark',
-                'load': 'perf-benchmark',
-                'endurance': 'perf-benchmark',
-                'baseline': 'perf-benchmark',
-                'mock': 'mock-pattern',
-                'dependency': 'mock-pattern',
-            };
-            // Extract patterns
             const extractedPatterns = [];
             for (const exp of experiences) {
-                const domain = domainMapping[exp.task_type] || 'code-intelligence';
-                const patternType = patternTypeMapping[exp.task_type] || 'test-template';
+                const domain = DOMAIN_MAPPING[exp.task_type] || 'code-intelligence';
+                const patternType = PATTERN_TYPE_MAPPING[exp.task_type] || 'test-template';
                 const actions = exp.actions ? exp.actions.split(',').slice(0, 5) : [];
                 extractedPatterns.push({
-                    name: `${exp.task_type}-success-pattern`,
-                    domain,
-                    patternType,
-                    confidence: Math.min(0.95, exp.avg_reward / 2),
-                    sourceCount: exp.count,
-                    avgReward: exp.avg_reward,
-                    actions,
+                    name: `${exp.task_type}-success-pattern`, domain, patternType,
+                    confidence: Math.min(0.95, exp.avg_reward / 2), sourceCount: exp.count, avgReward: exp.avg_reward, actions,
                 });
             }
             if (options.json) {
-                printJson({
-                    minReward,
-                    minCount,
-                    dryRun: options.dryRun || false,
-                    experienceGroups: experiences.length,
-                    memoryPatterns: memoryPatterns.length,
-                    extractedPatterns,
-                });
+                printJson({ minReward, minCount, dryRun: options.dryRun || false, experienceGroups: experiences.length, memoryPatterns: memoryPatterns.length, extractedPatterns });
             }
             else {
                 console.log(chalk.bold('Learning Experience Groups:'));
@@ -757,16 +402,14 @@ Examples:
                 }
                 else {
                     for (const exp of experiences) {
-                        const rewardColor = exp.avg_reward >= 1.0 ? chalk.green :
-                            exp.avg_reward >= 0.5 ? chalk.yellow : chalk.red;
+                        const rewardColor = exp.avg_reward >= 1.0 ? chalk.green : exp.avg_reward >= 0.5 ? chalk.yellow : chalk.red;
                         console.log(`  ${chalk.cyan(exp.task_type)}`);
                         console.log(`    Count: ${exp.count}, Avg Reward: ${rewardColor(exp.avg_reward.toFixed(2))}`);
                     }
                 }
                 console.log(chalk.bold('\nMemory Pattern Sources:'));
-                for (const mp of memoryPatterns.slice(0, 10)) {
+                for (const mp of memoryPatterns.slice(0, 10))
                     console.log(`  ${mp.key_prefix}... (${mp.count})`);
-                }
                 console.log(chalk.bold('\nExtracted Patterns:'));
                 if (extractedPatterns.length === 0) {
                     console.log(chalk.dim('  No patterns extracted'));
@@ -779,51 +422,32 @@ Examples:
                     }
                 }
                 if (!options.dryRun && extractedPatterns.length > 0) {
-                    // Store extracted patterns
                     const reasoningBank = await initializeLearningSystem();
                     let stored = 0;
                     const errors = [];
                     for (const p of extractedPatterns) {
                         try {
-                            // Build template content from actions
                             const templateContent = p.actions.length > 0
                                 ? `// ${p.name}\n// Steps: ${p.actions.join(' -> ')}\n\n{{implementation}}`
                                 : `// ${p.name}\n// Extracted pattern with ${p.sourceCount} successful uses\n\n{{implementation}}`;
                             const result = await reasoningBank.storePattern({
-                                patternType: p.patternType,
-                                name: p.name,
+                                patternType: p.patternType, name: p.name,
                                 description: `Extracted from ${p.sourceCount} learning experiences with avg reward ${p.avgReward.toFixed(2)}`,
-                                template: {
-                                    type: 'code',
-                                    content: templateContent,
-                                    variables: [
-                                        {
-                                            name: 'implementation',
-                                            type: 'code',
-                                            required: true,
-                                            description: 'Implementation code for this pattern',
-                                        },
-                                    ],
-                                },
-                                context: {
-                                    tags: [p.domain, p.patternType, `sources:${p.sourceCount}`, `reward:${p.avgReward.toFixed(2)}`],
-                                },
+                                template: { type: 'code', content: templateContent, variables: [{ name: 'implementation', type: 'code', required: true, description: 'Implementation code for this pattern' }] },
+                                context: { tags: [p.domain, p.patternType, `sources:${p.sourceCount}`, `reward:${p.avgReward.toFixed(2)}`] },
                             });
-                            if (result.success) {
+                            if (result.success)
                                 stored++;
-                            }
-                            else {
+                            else
                                 errors.push(`${p.name}: ${result.error.message}`);
-                            }
                         }
                         catch (e) {
                             errors.push(`${p.name}: ${e instanceof Error ? e.message : 'unknown'}`);
                         }
                     }
                     console.log(chalk.green(`\n✓ Stored ${stored} new patterns`));
-                    if (errors.length > 0 && errors.length <= 5) {
+                    if (errors.length > 0 && errors.length <= 5)
                         console.log(chalk.yellow(`  Errors: ${errors.slice(0, 3).join(', ')}${errors.length > 3 ? '...' : ''}`));
-                    }
                 }
                 else if (options.dryRun) {
                     console.log(chalk.yellow('\n  Dry run - no patterns stored'));
@@ -837,9 +461,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // dashboard: Display learning system dashboard
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: dashboard
+// ============================================================================
+function registerDashboardCommand(learning) {
     learning
         .command('dashboard')
         .description('Display learning system dashboard with metrics and trends')
@@ -856,12 +482,10 @@ Examples:
             }
             const dashboard = await tracker.getDashboardData();
             tracker.close();
-            if (options.json) {
+            if (options.json)
                 printJson(dashboard);
-            }
-            else {
+            else
                 displayDashboard(dashboard);
-            }
             process.exit(0);
         }
         catch (error) {
@@ -869,9 +493,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // info: Show learning system information
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: info
+// ============================================================================
+function registerInfoCommand(learning) {
     learning
         .command('info')
         .description('Show learning system configuration and paths')
@@ -894,8 +520,7 @@ Examples:
             console.log(`  ${QE_DOMAIN_LIST.join(', ')}`);
             console.log(chalk.bold('\nHooks:'));
             console.log('  Configure in .claude/settings.json');
-            console.log('  Events: pre-edit, post-edit, pre-task, post-task, route');
-            console.log('');
+            console.log('  Events: pre-edit, post-edit, pre-task, post-task, route\n');
             process.exit(0);
         }
         catch (error) {
@@ -903,9 +528,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // backup: Backup learning database
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: backup
+// ============================================================================
+function registerBackupCommand(learning) {
     learning
         .command('backup')
         .description('Backup learning database to a file')
@@ -916,60 +543,35 @@ Examples:
         .action(async (options) => {
         try {
             const dbPath = getDbPath();
-            if (!existsSync(dbPath)) {
+            if (!existsSync(dbPath))
                 throw new Error(`No learning database found at: ${dbPath}`);
-            }
-            // Generate default output path with timestamp
             const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
             const defaultOutput = path.join(process.cwd(), 'backups', `learning-${timestamp}.db`);
             let outputPath = options.output ? path.resolve(options.output) : defaultOutput;
-            // Ensure backup directory exists
             const backupDir = path.dirname(outputPath);
-            if (!existsSync(backupDir)) {
+            if (!existsSync(backupDir))
                 mkdirSync(backupDir, { recursive: true });
-            }
-            // Get source file size
             const sourceStats = await stat(dbPath);
             const sourceSizeKB = (sourceStats.size / 1024).toFixed(2);
-            // Copy the database file
             copyFileSync(dbPath, outputPath);
-            // Also copy WAL file if it exists (for consistency)
             const walPath = `${dbPath}-wal`;
-            if (existsSync(walPath)) {
+            if (existsSync(walPath))
                 copyFileSync(walPath, `${outputPath}-wal`);
-            }
-            // Compress if requested
             let finalPath = outputPath;
             if (options.compress) {
                 finalPath = await compressFile(outputPath);
-                // Remove uncompressed version
                 await unlink(outputPath);
-                if (existsSync(`${outputPath}-wal`)) {
+                if (existsSync(`${outputPath}-wal`))
                     await unlink(`${outputPath}-wal`);
-                }
             }
-            // Get final file size
             const finalStats = await stat(finalPath);
             const finalSizeKB = (finalStats.size / 1024).toFixed(2);
-            // Verify if requested
             let verificationResult;
-            if (options.verify && !options.compress) {
+            if (options.verify && !options.compress)
                 verificationResult = await verifyDatabaseIntegrity(outputPath);
-            }
-            // Get schema version
             const schemaVersion = await getSchemaVersion(dbPath);
             if (options.json) {
-                printJson({
-                    success: true,
-                    sourcePath: dbPath,
-                    backupPath: finalPath,
-                    sourceSizeKB: parseFloat(sourceSizeKB),
-                    backupSizeKB: parseFloat(finalSizeKB),
-                    compressed: options.compress || false,
-                    schemaVersion,
-                    verification: verificationResult,
-                    timestamp: new Date().toISOString(),
-                });
+                printJson({ success: true, sourcePath: dbPath, backupPath: finalPath, sourceSizeKB: parseFloat(sourceSizeKB), backupSizeKB: parseFloat(finalSizeKB), compressed: options.compress || false, schemaVersion, verification: verificationResult, timestamp: new Date().toISOString() });
             }
             else {
                 console.log(chalk.bold('\n💾 Learning Database Backup\n'));
@@ -983,15 +585,9 @@ Examples:
                     console.log(`  Compression: ${compressionRatio}% reduction`);
                 }
                 if (verificationResult) {
-                    if (verificationResult.valid) {
-                        console.log(chalk.green(`  Verification: ${verificationResult.message}`));
-                    }
-                    else {
-                        console.log(chalk.red(`  Verification: ${verificationResult.message}`));
-                    }
+                    console.log(verificationResult.valid ? chalk.green(`  Verification: ${verificationResult.message}`) : chalk.red(`  Verification: ${verificationResult.message}`));
                 }
-                printSuccess(`Backup saved to: ${finalPath}`);
-                console.log('');
+                printSuccess(`Backup saved to: ${finalPath}\n`);
             }
             process.exit(0);
         }
@@ -1000,9 +596,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // restore: Restore learning database from backup
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: restore
+// ============================================================================
+function registerRestoreCommand(learning) {
     learning
         .command('restore')
         .description('Restore learning database from backup')
@@ -1014,71 +612,46 @@ Examples:
         try {
             const inputPath = path.resolve(options.input);
             const dbPath = getDbPath();
-            if (!existsSync(inputPath)) {
+            if (!existsSync(inputPath))
                 throw new Error(`Backup file not found: ${inputPath}`);
-            }
-            // Determine if compressed
             const isCompressed = inputPath.endsWith('.gz');
             let restorePath = inputPath;
-            // Decompress if needed
             if (isCompressed) {
                 const tempPath = inputPath.replace('.gz', '.tmp');
                 await decompressFile(inputPath, tempPath);
                 restorePath = tempPath;
             }
-            // Verify if requested
             if (options.verify) {
                 const verificationResult = await verifyDatabaseIntegrity(restorePath);
                 if (!verificationResult.valid) {
-                    if (isCompressed && existsSync(restorePath)) {
+                    if (isCompressed && existsSync(restorePath))
                         await unlink(restorePath);
-                    }
                     throw new Error(`Backup verification failed: ${verificationResult.message}`);
                 }
             }
-            // Check if target exists
             if (existsSync(dbPath) && !options.force) {
                 printError(`Database already exists at: ${dbPath}`);
                 console.log(chalk.yellow('  Use --force to overwrite'));
-                if (isCompressed && existsSync(restorePath)) {
+                if (isCompressed && existsSync(restorePath))
                     await unlink(restorePath);
-                }
                 process.exit(1);
             }
-            // Ensure target directory exists
             const targetDir = path.dirname(dbPath);
-            if (!existsSync(targetDir)) {
+            if (!existsSync(targetDir))
                 mkdirSync(targetDir, { recursive: true });
-            }
-            // Remove existing database files
-            if (existsSync(dbPath)) {
+            if (existsSync(dbPath))
                 await unlink(dbPath);
-            }
-            if (existsSync(`${dbPath}-wal`)) {
+            if (existsSync(`${dbPath}-wal`))
                 await unlink(`${dbPath}-wal`);
-            }
-            if (existsSync(`${dbPath}-shm`)) {
+            if (existsSync(`${dbPath}-shm`))
                 await unlink(`${dbPath}-shm`);
-            }
-            // Copy restored file to target
             copyFileSync(restorePath, dbPath);
-            // Clean up temp file if we decompressed
-            if (isCompressed && existsSync(restorePath)) {
+            if (isCompressed && existsSync(restorePath))
                 await unlink(restorePath);
-            }
-            // Get restored database info
             const restoredStats = await stat(dbPath);
             const schemaVersion = await getSchemaVersion(dbPath);
             if (options.json) {
-                printJson({
-                    success: true,
-                    backupPath: inputPath,
-                    restoredPath: dbPath,
-                    sizeKB: parseFloat((restoredStats.size / 1024).toFixed(2)),
-                    schemaVersion,
-                    wasCompressed: isCompressed,
-                    timestamp: new Date().toISOString(),
-                });
+                printJson({ success: true, backupPath: inputPath, restoredPath: dbPath, sizeKB: parseFloat((restoredStats.size / 1024).toFixed(2)), schemaVersion, wasCompressed: isCompressed, timestamp: new Date().toISOString() });
             }
             else {
                 console.log(chalk.bold('\n🔄 Learning Database Restore\n'));
@@ -1086,8 +659,7 @@ Examples:
                 console.log(`  Restored to: ${dbPath}`);
                 console.log(`  Size: ${(restoredStats.size / 1024).toFixed(2)} KB`);
                 console.log(`  Schema version: ${schemaVersion}`);
-                printSuccess('Database restored successfully');
-                console.log('');
+                printSuccess('Database restored successfully\n');
             }
             process.exit(0);
         }
@@ -1096,9 +668,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // verify: Verify database integrity
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: verify
+// ============================================================================
+function registerVerifyCommand(learning) {
     learning
         .command('verify')
         .description('Verify learning database integrity')
@@ -1107,59 +681,38 @@ Examples:
         .action(async (options) => {
         try {
             const dbPath = options.file ? path.resolve(options.file) : getDbPath();
-            if (!existsSync(dbPath)) {
+            if (!existsSync(dbPath))
                 throw new Error(`Database file not found: ${dbPath}`);
-            }
             const verificationResult = await verifyDatabaseIntegrity(dbPath);
             const schemaVersion = await getSchemaVersion(dbPath);
             const fileStats = await stat(dbPath);
-            // Get table counts
             let tableCounts = {};
             try {
                 const Database = (await import('better-sqlite3')).default;
                 const db = new Database(dbPath, { readonly: true });
-                const tables = ['qe_patterns', 'qe_trajectories', 'learning_experiences', 'kv_store', 'vectors'];
-                for (const table of tables) {
+                for (const table of ['qe_patterns', 'qe_trajectories', 'learning_experiences', 'kv_store', 'vectors']) {
                     try {
-                        const result = db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
-                        tableCounts[table] = result.count;
-                    }
-                    catch {
-                        // Table may not exist
+                        const r = db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+                        tableCounts[table] = r.count;
                     }
+                    catch { /* table may not exist */ }
                 }
                 db.close();
             }
-            catch {
-                // Ignore table count errors
-            }
+            catch { /* ignore */ }
             if (options.json) {
-                printJson({
-                    valid: verificationResult.valid,
-                    message: verificationResult.message,
-                    path: dbPath,
-                    sizeKB: parseFloat((fileStats.size / 1024).toFixed(2)),
-                    schemaVersion,
-                    tableCounts,
-                    timestamp: new Date().toISOString(),
-                });
+                printJson({ valid: verificationResult.valid, message: verificationResult.message, path: dbPath, sizeKB: parseFloat((fileStats.size / 1024).toFixed(2)), schemaVersion, tableCounts, timestamp: new Date().toISOString() });
             }
             else {
                 console.log(chalk.bold('\n🔍 Database Verification\n'));
                 console.log(`  Path: ${dbPath}`);
                 console.log(`  Size: ${(fileStats.size / 1024).toFixed(2)} KB`);
                 console.log(`  Schema version: ${schemaVersion}`);
-                if (verificationResult.valid) {
-                    console.log(chalk.green(`  Status: ${verificationResult.message}`));
-                }
-                else {
-                    console.log(chalk.red(`  Status: ${verificationResult.message}`));
-                }
+                console.log(verificationResult.valid ? chalk.green(`  Status: ${verificationResult.message}`) : chalk.red(`  Status: ${verificationResult.message}`));
                 if (Object.keys(tableCounts).length > 0) {
                     console.log(chalk.bold('\nTable Counts:'));
-                    for (const [table, count] of Object.entries(tableCounts)) {
+                    for (const [table, count] of Object.entries(tableCounts))
                         console.log(`  ${table}: ${count}`);
-                    }
                 }
                 console.log('');
             }
@@ -1170,9 +723,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // export-full: Enhanced export with all learning data
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: export-full
+// ============================================================================
+function registerExportFullCommand(learning) {
     learning
         .command('export-full')
         .description('Export all learning data including patterns, trajectories, and experiences')
@@ -1184,100 +739,47 @@ Examples:
         .action(async (options) => {
         try {
             const dbPath = getDbPath();
-            if (!existsSync(dbPath)) {
+            if (!existsSync(dbPath))
                 throw new Error('No learning database found. Run "aqe init --auto" first.');
-            }
             const reasoningBank = await initializeLearningSystem();
             const schemaVersion = await getSchemaVersion(dbPath);
-            // Get all patterns
             const searchResult = await reasoningBank.searchPatterns('*', { limit: 10000 });
-            if (!searchResult.success) {
+            if (!searchResult.success)
                 throw new Error(searchResult.error.message);
-            }
             const patterns = searchResult.value.map(m => ({
-                id: m.pattern.id,
-                name: m.pattern.name,
-                description: m.pattern.description,
-                patternType: m.pattern.patternType,
-                qeDomain: m.pattern.qeDomain,
-                tier: m.pattern.tier,
-                confidence: m.pattern.confidence,
-                successRate: m.pattern.successRate,
-                successfulUses: m.pattern.successfulUses,
-                qualityScore: m.pattern.qualityScore,
-                template: m.pattern.template,
-                context: m.pattern.context,
-                createdAt: m.pattern.createdAt instanceof Date
-                    ? m.pattern.createdAt.toISOString()
-                    : m.pattern.createdAt || undefined,
-                lastUsedAt: m.pattern.lastUsedAt instanceof Date
-                    ? m.pattern.lastUsedAt.toISOString()
-                    : m.pattern.lastUsedAt || undefined,
+                id: m.pattern.id, name: m.pattern.name, description: m.pattern.description,
+                patternType: m.pattern.patternType, qeDomain: m.pattern.qeDomain, tier: m.pattern.tier,
+                confidence: m.pattern.confidence, successRate: m.pattern.successRate,
+                successfulUses: m.pattern.successfulUses, qualityScore: m.pattern.qualityScore,
+                template: m.pattern.template, context: m.pattern.context,
+                createdAt: m.pattern.createdAt instanceof Date ? m.pattern.createdAt.toISOString() : m.pattern.createdAt || undefined,
+                lastUsedAt: m.pattern.lastUsedAt instanceof Date ? m.pattern.lastUsedAt.toISOString() : m.pattern.lastUsedAt || undefined,
             }));
             const exportData = {
-                version: EXPORT_FORMAT_VERSION,
-                exportedAt: new Date().toISOString(),
-                source: process.cwd(),
-                schemaVersion,
-                patternCount: patterns.length,
-                patterns,
+                version: EXPORT_FORMAT_VERSION, exportedAt: new Date().toISOString(), source: process.cwd(),
+                schemaVersion, patternCount: patterns.length, patterns,
             };
-            // Include trajectories if requested
             if (options.includeTrajectories) {
                 try {
                     const Database = (await import('better-sqlite3')).default;
                     const db = new Database(dbPath, { readonly: true });
-                    const trajectories = db.prepare(`
-              SELECT id, task, agent, domain, success, steps_json
-              FROM qe_trajectories
-              ORDER BY started_at DESC
-              LIMIT 1000
-            `).all();
-                    exportData.trajectories = trajectories.map(t => ({
-                        id: t.id,
-                        task: t.task,
-                        agent: t.agent,
-                        domain: t.domain,
-                        success: t.success,
-                        stepsJson: t.steps_json,
-                    }));
+                    const trajectories = db.prepare(`SELECT id, task, agent, domain, success, steps_json FROM qe_trajectories ORDER BY started_at DESC LIMIT 1000`).all();
+                    exportData.trajectories = trajectories.map(t => ({ id: t.id, task: t.task, agent: t.agent, domain: t.domain, success: t.success, stepsJson: t.steps_json }));
                     db.close();
                 }
-                catch {
-                    // Trajectories table may not exist
-                }
+                catch { /* table may not exist */ }
             }
-            // Include experiences if requested
             if (options.includeExperiences) {
                 try {
                     const Database = (await import('better-sqlite3')).default;
                     const db = new Database(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();
-                    exportData.experiences = experiences.map(e => ({
-                        taskType: e.task_type,
-                        action: e.action,
-                        reward: e.avg_reward,
-                        count: e.count,
-                    }));
-                    // Add metadata
-                    const metaRow = db.prepare(`
-              SELECT COUNT(*) as total, AVG(reward) as avg_reward FROM learning_experiences
-            `).get();
-                    exportData.metadata = {
-                        totalExperiences: metaRow.total,
-                        avgReward: metaRow.avg_reward,
-                    };
+                    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();
+                    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();
+                    exportData.metadata = { totalExperiences: metaRow.total, avgReward: metaRow.avg_reward };
                     db.close();
                 }
-                catch {
-                    // Learning experiences table may not exist
-                }
+                catch { /* table may not exist */ }
             }
             if (options.json) {
                 printJson(exportData);
@@ -1292,16 +794,13 @@ Examples:
                 }
                 console.log(chalk.bold('\n📤 Learning Data Export\n'));
                 console.log(`  Patterns: ${patterns.length}`);
-                if (exportData.trajectories) {
+                if (exportData.trajectories)
                     console.log(`  Trajectories: ${exportData.trajectories.length}`);
-                }
-                if (exportData.experiences) {
+                if (exportData.experiences)
                     console.log(`  Experience groups: ${exportData.experiences.length}`);
-                }
                 console.log(`  Schema version: ${schemaVersion}`);
                 console.log(`  Export format: ${EXPORT_FORMAT_VERSION}`);
-                printSuccess(`Exported to: ${outputPath}`);
-                console.log('');
+                printSuccess(`Exported to: ${outputPath}\n`);
             }
             process.exit(0);
         }
@@ -1310,9 +809,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // import-merge: Import and merge patterns from export file
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: import-merge
+// ============================================================================
+function registerImportMergeCommand(learning) {
     learning
         .command('import-merge')
         .description('Import and merge patterns from export file (preserves existing data)')
@@ -1323,10 +824,8 @@ Examples:
         .action(async (options) => {
         try {
             let inputPath = path.resolve(options.input);
-            if (!existsSync(inputPath)) {
+            if (!existsSync(inputPath))
                 throw new Error(`File not found: ${inputPath}`);
-            }
-            // Handle compressed files
             let content;
             if (inputPath.endsWith('.gz')) {
                 const tempPath = inputPath.replace('.gz', '.tmp.json');
@@ -1337,23 +836,16 @@ Examples:
             else {
                 content = readFileSync(inputPath, 'utf-8');
             }
-            const importData = JSON.parse(content);
-            // Validate import data
-            if (!importData.patterns || !Array.isArray(importData.patterns)) {
+            const importData = safeJsonParse(content);
+            if (!importData.patterns || !Array.isArray(importData.patterns))
                 throw new Error('Invalid import file format: missing patterns array');
-            }
             const reasoningBank = await initializeLearningSystem();
-            // Get existing pattern names for duplicate detection
             const existingResult = await reasoningBank.searchPatterns('*', { limit: 10000 });
             const existingNames = new Set();
-            if (existingResult.success) {
-                for (const m of existingResult.value) {
+            if (existingResult.success)
+                for (const m of existingResult.value)
                     existingNames.add(m.pattern.name);
-                }
-            }
-            let imported = 0;
-            let skipped = 0;
-            let updated = 0;
+            let imported = 0, skipped = 0, updated = 0;
             const errors = [];
             if (!options.dryRun) {
                 for (const pattern of importData.patterns) {
@@ -1363,20 +855,12 @@ Examples:
                         continue;
                     }
                     try {
-                        const result = await reasoningBank.storePattern({
-                            patternType: pattern.patternType,
-                            name: pattern.name,
-                            description: pattern.description,
-                            template: pattern.template,
-                            context: pattern.context,
-                        });
+                        const result = await reasoningBank.storePattern({ patternType: pattern.patternType, name: pattern.name, description: pattern.description, template: pattern.template, context: pattern.context });
                         if (result.success) {
-                            if (isDuplicate) {
+                            if (isDuplicate)
                                 updated++;
-                            }
-                            else {
+                            else
                                 imported++;
-                            }
                         }
                         else {
                             skipped++;
@@ -1389,34 +873,20 @@ Examples:
                     }
                 }
             }
-            // Calculate what would happen in dry-run
-            let wouldImport = 0;
-            let wouldSkip = 0;
-            let wouldUpdate = 0;
+            let wouldImport = 0, wouldSkip = 0, wouldUpdate = 0;
             if (options.dryRun) {
                 for (const pattern of importData.patterns) {
                     const isDuplicate = existingNames.has(pattern.name);
-                    if (isDuplicate && options.skipDuplicates) {
+                    if (isDuplicate && options.skipDuplicates)
                         wouldSkip++;
-                    }
-                    else if (isDuplicate) {
+                    else if (isDuplicate)
                         wouldUpdate++;
-                    }
-                    else {
+                    else
                         wouldImport++;
-                    }
                 }
             }
             if (options.json) {
-                printJson({
-                    dryRun: options.dryRun || false,
-                    importVersion: importData.version,
-                    totalPatterns: importData.patterns.length,
-                    imported: options.dryRun ? wouldImport : imported,
-                    updated: options.dryRun ? wouldUpdate : updated,
-                    skipped: options.dryRun ? wouldSkip : skipped,
-                    errors: errors.slice(0, 10),
-                });
+                printJson({ dryRun: options.dryRun || false, importVersion: importData.version, totalPatterns: importData.patterns.length, imported: options.dryRun ? wouldImport : imported, updated: options.dryRun ? wouldUpdate : updated, skipped: options.dryRun ? wouldSkip : skipped, errors: errors.slice(0, 10) });
             }
             else {
                 console.log(chalk.bold('\n📥 Learning Data Import (Merge)\n'));
@@ -1426,19 +896,15 @@ Examples:
                 console.log(`  Existing patterns: ${existingNames.size}`);
                 if (options.dryRun) {
                     console.log(chalk.yellow('\n  Dry run - no changes made'));
-                    console.log(`  Would import: ${wouldImport}`);
-                    console.log(`  Would update: ${wouldUpdate}`);
-                    console.log(`  Would skip: ${wouldSkip}`);
+                    console.log(`  Would import: ${wouldImport}\n  Would update: ${wouldUpdate}\n  Would skip: ${wouldSkip}`);
                 }
                 else {
                     console.log(chalk.green(`\n  Imported: ${imported}`));
                     console.log(chalk.blue(`  Updated: ${updated}`));
-                    if (skipped > 0) {
+                    if (skipped > 0)
                         console.log(chalk.yellow(`  Skipped: ${skipped}`));
-                    }
-                    if (errors.length > 0) {
+                    if (errors.length > 0)
                         console.log(chalk.red(`  Errors: ${errors.length}`));
-                    }
                 }
                 console.log('');
             }
@@ -1449,9 +915,11 @@ Examples:
             process.exit(1);
         }
     });
-    // -------------------------------------------------------------------------
-    // dream: Run dream cycles for pattern discovery
-    // -------------------------------------------------------------------------
+}
+// ============================================================================
+// Subcommand: dream
+// ============================================================================
+function registerDreamCommand(learning) {
     learning
         .command('dream')
         .description('Run dream cycles for pattern discovery via spreading activation')
@@ -1467,10 +935,8 @@ Examples:
         .option('--json', 'Output as JSON')
         .action(async (options) => {
         try {
-            const { createDreamEngine, } = await import('../../learning/dream/index.js');
-            // Determine which action to run
+            const { createDreamEngine } = await import('../../learning/dream/index.js');
             if (options.status) {
-                // --- Status ---
                 const engine = createDreamEngine();
                 await engine.initialize();
                 const isDreaming = engine.isDreaming();
@@ -1479,13 +945,7 @@ Examples:
                 const totalInsights = history.reduce((sum, c) => sum + c.insightsGenerated, 0);
                 const lastCycle = history[0];
                 if (options.json) {
-                    printJson({
-                        isDreaming,
-                        totalCycles: history.length,
-                        totalInsights,
-                        pendingInsights: pending.length,
-                        lastDreamTime: lastCycle?.startTime.toISOString() || null,
-                    });
+                    printJson({ isDreaming, totalCycles: history.length, totalInsights, pendingInsights: pending.length, lastDreamTime: lastCycle?.startTime.toISOString() || null });
                 }
                 else {
                     console.log(chalk.bold('\n🌙 Dream System Status\n'));
@@ -1494,7 +954,6 @@ Examples:
                     console.log(`  Total insights generated: ${totalInsights}`);
                     console.log(`  Pending insights: ${pending.length}`);
                     console.log(`  Last dream: ${lastCycle ? lastCycle.startTime.toISOString() : chalk.dim('never')}`);
-                    // Show last 3 cycles summary
                     if (history.length > 0) {
                         console.log(chalk.bold('\n  Recent cycles:'));
                         for (const c of history.slice(0, 3)) {
@@ -1508,22 +967,12 @@ Examples:
                 process.exit(0);
             }
             if (options.history) {
-                // --- History ---
                 const limit = parseInt(options.limit, 10);
                 const engine = createDreamEngine();
                 await engine.initialize();
                 const cycles = await engine.getDreamHistory(limit);
                 if (options.json) {
-                    printJson(cycles.map(c => ({
-                        id: c.id,
-                        startTime: c.startTime.toISOString(),
-                        endTime: c.endTime?.toISOString(),
-                        durationMs: c.durationMs,
-                        status: c.status,
-                        conceptsProcessed: c.conceptsProcessed,
-                        associationsFound: c.associationsFound,
-                        insightsGenerated: c.insightsGenerated,
-                    })));
+                    printJson(cycles.map(c => ({ id: c.id, startTime: c.startTime.toISOString(), endTime: c.endTime?.toISOString(), durationMs: c.durationMs, status: c.status, conceptsProcessed: c.conceptsProcessed, associationsFound: c.associationsFound, insightsGenerated: c.insightsGenerated })));
                 }
                 else {
                     console.log(chalk.bold(`\n🌙 Dream Cycle History (${cycles.length} cycles)\n`));
@@ -1532,9 +981,7 @@ Examples:
                     }
                     else {
                         for (const c of cycles) {
-                            const status = c.status === 'completed' ? chalk.green('✓')
-                                : c.status === 'failed' ? chalk.red('✗')
-                                    : chalk.yellow('⋯');
+                            const status = c.status === 'completed' ? chalk.green('✓') : c.status === 'failed' ? chalk.red('✗') : chalk.yellow('⋯');
                             console.log(`  ${status} ${c.id.slice(0, 8)} | ${c.startTime.toISOString()}`);
                             console.log(chalk.dim(`    Duration: ${c.durationMs || 0}ms | Concepts: ${c.conceptsProcessed} | Associations: ${c.associationsFound} | Insights: ${c.insightsGenerated}`));
                         }
@@ -1545,23 +992,12 @@ Examples:
                 process.exit(0);
             }
             if (options.insights) {
-                // --- Pending Insights ---
                 const limit = parseInt(options.limit, 10);
                 const engine = createDreamEngine();
                 await engine.initialize();
                 const pending = await engine.getPendingInsights(limit);
                 if (options.json) {
-                    printJson(pending.map(i => ({
-                        id: i.id,
-                        type: i.type,
-                        description: i.description,
-                        noveltyScore: i.noveltyScore,
-                        confidenceScore: i.confidenceScore,
-                        actionable: i.actionable,
-                        applied: i.applied || false,
-                        suggestedAction: i.suggestedAction,
-                        createdAt: i.createdAt?.toISOString(),
-                    })));
+                    printJson(pending.map(i => ({ id: i.id, type: i.type, description: i.description, noveltyScore: i.noveltyScore, confidenceScore: i.confidenceScore, actionable: i.actionable, applied: i.applied || false, suggestedAction: i.suggestedAction, createdAt: i.createdAt?.toISOString() })));
                 }
                 else {
                     console.log(chalk.bold(`\n💡 Pending Dream Insights (${pending.length})\n`));
@@ -1570,16 +1006,13 @@ Examples:
                     }
                     else {
                         for (const i of pending) {
-                            const novelty = i.noveltyScore >= 0.7 ? chalk.green(`${(i.noveltyScore * 100).toFixed(0)}%`)
-                                : chalk.yellow(`${(i.noveltyScore * 100).toFixed(0)}%`);
-                            const confidence = i.confidenceScore >= 0.7 ? chalk.green(`${(i.confidenceScore * 100).toFixed(0)}%`)
-                                : chalk.yellow(`${(i.confidenceScore * 100).toFixed(0)}%`);
+                            const novelty = i.noveltyScore >= 0.7 ? chalk.green(`${(i.noveltyScore * 100).toFixed(0)}%`) : chalk.yellow(`${(i.noveltyScore * 100).toFixed(0)}%`);
+                            const confidence = i.confidenceScore >= 0.7 ? chalk.green(`${(i.confidenceScore * 100).toFixed(0)}%`) : chalk.yellow(`${(i.confidenceScore * 100).toFixed(0)}%`);
                             console.log(`  ${chalk.cyan(i.id.slice(0, 8))} [${i.type}] ${i.actionable ? '⚡' : '  '}`);
                             console.log(`    ${i.description}`);
                             console.log(chalk.dim(`    Novelty: ${novelty} | Confidence: ${confidence}`));
-                            if (i.suggestedAction) {
+                            if (i.suggestedAction)
                                 console.log(chalk.dim(`    Action: ${i.suggestedAction}`));
-                            }
                         }
                     }
                     console.log('');
@@ -1588,7 +1021,6 @@ Examples:
                 process.exit(0);
             }
             if (options.apply) {
-                // --- Apply Insight ---
                 const insightId = options.apply;
                 const engine = createDreamEngine();
                 await engine.initialize();
@@ -1604,42 +1036,25 @@ Examples:
                     await engine.close();
                     process.exit(1);
                 }
-                // Apply insight in engine
                 const result = await engine.applyInsight(insight.id);
-                // Also create a real pattern in ReasoningBank
                 const reasoningBank = await initializeLearningSystem();
                 const patternResult = await reasoningBank.storePattern({
-                    patternType: 'test-template',
-                    name: `Dream Insight: ${insight.type}`,
+                    patternType: 'test-template', name: `Dream Insight: ${insight.type}`,
                     description: `${insight.description} (confidence: ${insight.confidenceScore.toFixed(2)})`,
-                    template: {
-                        type: 'workflow',
-                        content: insight.suggestedAction || insight.description,
-                        variables: [],
-                    },
-                    context: {
-                        tags: ['dream-generated', insight.type, ...insight.sourceConcepts.slice(0, 3)],
-                        complexity: 'medium',
-                    },
+                    template: { type: 'workflow', content: insight.suggestedAction || insight.description, variables: [] },
+                    context: { tags: ['dream-generated', insight.type, ...insight.sourceConcepts.slice(0, 3)], complexity: 'medium' },
                 });
                 if (options.json) {
-                    printJson({
-                        insightId: insight.id,
-                        applied: result.success,
-                        patternId: patternResult.success ? patternResult.value.id : null,
-                        error: result.error || (patternResult.success ? null : patternResult.error?.message),
-                    });
+                    printJson({ insightId: insight.id, applied: result.success, patternId: patternResult.success ? patternResult.value.id : null, error: result.error || (patternResult.success ? null : patternResult.error?.message) });
                 }
                 else {
                     if (result.success) {
                         printSuccess(`Applied insight ${insight.id.slice(0, 8)}`);
-                        if (patternResult.success) {
+                        if (patternResult.success)
                             printSuccess(`Created pattern ${patternResult.value.id} in ReasoningBank`);
-                        }
                     }
-                    else {
+                    else
                         printError(`Failed to apply insight: ${result.error}`);
-                    }
                 }
                 await engine.close();
                 process.exit(result.success ? 0 : 1);
@@ -1650,29 +1065,20 @@ Examples:
                 durationMs = 5000;
             if (options.full)
                 durationMs = 30000;
-            durationMs = Math.min(durationMs, 60000); // Cap at 60s
+            durationMs = Math.min(durationMs, 60000);
             const minPatterns = parseInt(options.minPatterns, 10);
             printInfo(`Starting dream cycle (${durationMs}ms, min ${minPatterns} patterns)...`);
-            const engine = createDreamEngine({
-                maxDurationMs: durationMs,
-                minConceptsRequired: minPatterns,
-            });
+            const engine = createDreamEngine({ maxDurationMs: durationMs, minConceptsRequired: minPatterns });
             await engine.initialize();
-            // Load patterns from ReasoningBank
             const reasoningBank = await initializeLearningSystem();
-            const patternsResult = await reasoningBank.searchPatterns('', {
-                limit: 100,
-                minConfidence: 0.3,
-            });
+            const patternsResult = await reasoningBank.searchPatterns('', { limit: 100, minConfidence: 0.3 });
             let loaded = 0;
             if (patternsResult.success && patternsResult.value.length > 0) {
                 const importPatterns = patternsResult.value.map(result => ({
-                    id: result.pattern.id,
-                    name: result.pattern.name,
+                    id: result.pattern.id, name: result.pattern.name,
                     description: result.pattern.description || `${result.pattern.patternType} pattern`,
                     domain: result.pattern.qeDomain || 'learning-optimization',
-                    patternType: result.pattern.patternType,
-                    confidence: result.pattern.confidence,
+                    patternType: result.pattern.patternType, confidence: result.pattern.confidence,
                     successRate: result.pattern.successRate || 0.5,
                 }));
                 loaded = await engine.loadPatternsAsConcepts(importPatterns);
@@ -1681,26 +1087,14 @@ Examples:
             else {
                 printInfo('No patterns found in ReasoningBank — dreaming with existing concepts');
             }
-            // Run the dream
             const result = await engine.dream(durationMs);
             if (options.json) {
                 printJson({
-                    cycleId: result.cycle.id,
-                    status: result.cycle.status,
-                    durationMs: result.cycle.durationMs || 0,
-                    conceptsProcessed: result.cycle.conceptsProcessed,
-                    associationsFound: result.cycle.associationsFound,
-                    insightsGenerated: result.cycle.insightsGenerated,
-                    activationStats: result.activationStats,
+                    cycleId: result.cycle.id, status: result.cycle.status, durationMs: result.cycle.durationMs || 0,
+                    conceptsProcessed: result.cycle.conceptsProcessed, associationsFound: result.cycle.associationsFound,
+                    insightsGenerated: result.cycle.insightsGenerated, activationStats: result.activationStats,
                     patternsCreated: result.patternsCreated,
-                    insights: result.insights.map(i => ({
-                        id: i.id,
-                        type: i.type,
-                        description: i.description,
-                        noveltyScore: i.noveltyScore,
-                        confidenceScore: i.confidenceScore,
-                        actionable: i.actionable,
-                    })),
+                    insights: result.insights.map(i => ({ id: i.id, type: i.type, description: i.description, noveltyScore: i.noveltyScore, confidenceScore: i.confidenceScore, actionable: i.actionable })),
                 });
             }
             else {
@@ -1720,8 +1114,7 @@ Examples:
                 if (result.insights.length > 0) {
                     console.log(chalk.bold('\n  Generated Insights:'));
                     for (const i of result.insights) {
-                        const novelty = i.noveltyScore >= 0.7 ? chalk.green(`${(i.noveltyScore * 100).toFixed(0)}%`)
-                            : chalk.yellow(`${(i.noveltyScore * 100).toFixed(0)}%`);
+                        const novelty = i.noveltyScore >= 0.7 ? chalk.green(`${(i.noveltyScore * 100).toFixed(0)}%`) : chalk.yellow(`${(i.noveltyScore * 100).toFixed(0)}%`);
                         console.log(`    ${chalk.cyan(i.id.slice(0, 8))} [${i.type}] ${i.actionable ? '⚡ actionable' : ''}`);
                         console.log(`      ${i.description}`);
                         console.log(chalk.dim(`      Novelty: ${novelty} | Confidence: ${(i.confidenceScore * 100).toFixed(0)}%`));
@@ -1739,16 +1132,14 @@ Examples:
         }
         catch (error) {
             printError(`dream failed: ${error instanceof Error ? error.message : 'unknown'}`);
-            if (error instanceof Error && error.stack) {
+            if (error instanceof Error && error.stack)
                 console.error(chalk.dim(error.stack));
-            }
             process.exit(1);
         }
     });
-    return learning;
 }
 // ============================================================================
 // Exports
 // ============================================================================
-export { initializeLearningSystem };
+export { initializeLearningSystem } from './learning-helpers.js';
 //# sourceMappingURL=learning.js.map