agentic-qe 3.2.3 → 3.3.1

package/v3/dist/cli/index.js

@@ -4,6 +4,10 @@
  *
  * Provides CLI access to the v3 DDD architecture through the Queen Coordinator.
  * All commands delegate to domain services via the coordination layer.
+ *
+ * Refactored to use CommandRegistry and handlers for better maintainability.
+ * See: cli/handlers/ for command implementations
+ * See: cli/commands/ for additional command modules
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
@@ -14,17 +18,16 @@ import { CrossDomainEventRouter } from '../coordination/cross-domain-router';
 import { DefaultProtocolExecutor } from '../coordination/protocol-executor';
 import { WorkflowOrchestrator } from '../coordination/workflow-orchestrator';
 import { ALL_DOMAINS } from '../shared/types';
-import { InitOrchestrator } from '../init/init-wizard';
-import { integrateCodeIntelligence } from '../init/fleet-integration';
-import { generateCompletion, detectShell, getInstallInstructions, DOMAINS as COMPLETION_DOMAINS, QE_AGENTS, OTHER_AGENTS, } from './completions/index.js';
-import { FleetProgressManager, createTimedSpinner, } from './utils/progress';
 import { bootstrapTokenTracking, shutdownTokenTracking } from '../init/token-bootstrap.js';
 import { parsePipelineFile, validatePipeline, describeCronSchedule, } from './utils/workflow-parser.js';
-import { runCoverageAnalysisWizard, } from './wizards/coverage-wizard.js';
-import { parseJsonOption, parseJsonFile } from './helpers/safe-json.js';
-import { runFleetInitWizard, } from './wizards/fleet-wizard.js';
+import { parseJsonOption } from './helpers/safe-json.js';
 import { createPersistentScheduler, createScheduleEntry, } from './scheduler/index.js';
-import { v2AgentMapping, resolveAgentName, isDeprecatedAgent, v3Agents, } from '../migration/agent-compat.js';
+// Import handlers and registry
+import { createCommandRegistry } from './command-registry.js';
+import { formatDuration } from './handlers/interfaces.js';
+// ============================================================================
+// CLI State
+// ============================================================================
 const context = {
     kernel: null,
     queen: null,
@@ -34,63 +37,42 @@ const context = {
     persistentScheduler: null,
     initialized: false,
 };
+/**
+ * Register domain workflow actions with the WorkflowOrchestrator (Issue #206)
+ */
+function registerDomainWorkflowActions(kernel, orchestrator) {
+    const visualAccessibilityAPI = kernel.getDomainAPI('visual-accessibility');
+    if (visualAccessibilityAPI?.registerWorkflowActions) {
+        try {
+            visualAccessibilityAPI.registerWorkflowActions(orchestrator);
+        }
+        catch (error) {
+            console.error(chalk.yellow(`  Warning: Could not register visual-accessibility workflow actions: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}
 // ============================================================================
 // Helper Functions
 // ============================================================================
-function getStatusColor(status) {
-    switch (status) {
-        case 'healthy':
-        case 'completed':
-            return chalk.green(status);
-        case 'degraded':
-        case 'running':
-            return chalk.yellow(status);
-        case 'unhealthy':
-        case 'failed':
-            return chalk.red(status);
-        default:
-            return chalk.gray(status);
-    }
-}
-function formatDuration(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    if (ms < 60000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    if (ms < 3600000)
-        return `${(ms / 60000).toFixed(1)}m`;
-    return `${(ms / 3600000).toFixed(1)}h`;
-}
-function formatUptime(ms) {
-    const hours = Math.floor(ms / 3600000);
-    const minutes = Math.floor((ms % 3600000) / 60000);
-    const seconds = Math.floor((ms % 60000) / 1000);
-    return `${hours}h ${minutes}m ${seconds}s`;
-}
 async function autoInitialize() {
-    // Create kernel with defaults
     context.kernel = new QEKernelImpl({
         maxConcurrentAgents: 15,
         memoryBackend: 'sqlite',
         hnswEnabled: true,
-        lazyLoading: true, // ADR-046: Enable lazy loading to reduce memory footprint (was causing OOM)
+        lazyLoading: true,
         enabledDomains: [...ALL_DOMAINS],
     });
     await context.kernel.initialize();
-    // Create cross-domain router
     context.router = new CrossDomainEventRouter(context.kernel.eventBus);
     await context.router.initialize();
-    // Create protocol executor
     const getDomainAPI = (domain) => {
         return context.kernel.getDomainAPI(domain);
     };
     const protocolExecutor = new DefaultProtocolExecutor(context.kernel.eventBus, context.kernel.memory, getDomainAPI);
-    // Create workflow orchestrator
     context.workflowOrchestrator = new WorkflowOrchestrator(context.kernel.eventBus, context.kernel.memory, context.kernel.coordinator);
     await context.workflowOrchestrator.initialize();
-    // Create persistent scheduler for workflow scheduling (ADR-041)
+    registerDomainWorkflowActions(context.kernel, context.workflowOrchestrator);
     context.persistentScheduler = createPersistentScheduler();
-    // Create Queen Coordinator
     context.queen = createQueenCoordinator(context.kernel, context.router, protocolExecutor, undefined);
     await context.queen.initialize();
     context.initialized = true;
@@ -99,18 +81,14 @@ async function ensureInitialized() {
     if (context.initialized && context.kernel && context.queen) {
         return true;
     }
-    // Auto-initialize with defaults and timeout
     console.log(chalk.gray('Auto-initializing v3 system...'));
-    const timeout = 30000; // 30 seconds
+    const timeout = 30000;
     const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => reject(new Error('Initialization timeout after 30 seconds')), timeout);
     });
     try {
-        await Promise.race([
-            autoInitialize(),
-            timeoutPromise
-        ]);
-        console.log(chalk.green('✓ System ready\n'));
+        await Promise.race([autoInitialize(), timeoutPromise]);
+        console.log(chalk.green('System ready\n'));
         return true;
     }
     catch (err) {
@@ -131,7 +109,6 @@ async function ensureInitialized() {
  */
 async function cleanupAndExit(code = 0) {
     try {
-        // ADR-042: Save token metrics before shutdown
         await shutdownTokenTracking();
         if (context.workflowOrchestrator) {
             await context.workflowOrchestrator.dispose();
@@ -145,8 +122,6 @@ async function cleanupAndExit(code = 0) {
         if (context.kernel) {
             await context.kernel.dispose();
         }
-        // Close the UnifiedMemoryManager singleton to release database connection
-        // This is critical for CLI commands to exit properly
         UnifiedMemoryManager.resetInstance();
     }
     catch {
@@ -158,655 +133,16 @@ async function cleanupAndExit(code = 0) {
 // CLI Program
 // ============================================================================
 const program = new Command();
-// Version injected at build time from root package.json
 const VERSION = typeof __CLI_VERSION__ !== 'undefined' ? __CLI_VERSION__ : '0.0.0-dev';
 program
     .name('aqe')
     .description('Agentic QE - Domain-Driven Quality Engineering')
     .version(VERSION);
 // ============================================================================
-// Init Command
-// ============================================================================
-program
-    .command('init')
-    .description('Initialize the AQE v3 system')
-    .option('-d, --domains <domains>', 'Comma-separated list of domains to enable', 'all')
-    .option('-m, --max-agents <number>', 'Maximum concurrent agents', '15')
-    .option('--memory <backend>', 'Memory backend (sqlite|agentdb|hybrid)', 'hybrid')
-    .option('--lazy', 'Enable lazy loading of domains')
-    .option('--wizard', 'Run interactive setup wizard')
-    .option('--auto', 'Auto-configure based on project analysis')
-    .option('--minimal', 'Minimal configuration (skip optional features)')
-    .option('--skip-patterns', 'Skip loading pre-trained patterns')
-    .option('--with-n8n', 'Install n8n workflow testing agents and skills')
-    .option('--auto-migrate', 'Automatically migrate from v2 if detected')
-    .action(async (options) => {
-    try {
-        // --auto-migrate implies --auto (must use orchestrator for migration)
-        if (options.autoMigrate && !options.auto && !options.wizard) {
-            options.auto = true;
-        }
-        // Check if wizard mode requested
-        if (options.wizard || options.auto) {
-            console.log(chalk.blue('\n🚀 Agentic QE v3 Initialization\n'));
-            const orchestratorOptions = {
-                projectRoot: process.cwd(),
-                autoMode: options.auto,
-                minimal: options.minimal,
-                skipPatterns: options.skipPatterns,
-                withN8n: options.withN8n,
-                autoMigrate: options.autoMigrate,
-            };
-            const orchestrator = new InitOrchestrator(orchestratorOptions);
-            if (options.wizard) {
-                // Show wizard steps
-                console.log(chalk.white('📋 Setup Wizard Steps:\n'));
-                const steps = orchestrator.getWizardSteps();
-                for (let i = 0; i < steps.length; i++) {
-                    console.log(chalk.gray(`  ${i + 1}. ${steps[i].title}`));
-                    console.log(chalk.gray(`     ${steps[i].description}\n`));
-                }
-            }
-            console.log(chalk.white('🔍 Analyzing project...\n'));
-            const result = await orchestrator.initialize();
-            // Display step results
-            for (const step of result.steps) {
-                const statusIcon = step.status === 'success' ? '✓' : step.status === 'error' ? '✗' : '⚠';
-                const statusColor = step.status === 'success' ? chalk.green : step.status === 'error' ? chalk.red : chalk.yellow;
-                console.log(statusColor(`  ${statusIcon} ${step.step} (${step.durationMs}ms)`));
-            }
-            console.log('');
-            if (result.success) {
-                console.log(chalk.green('✅ AQE v3 initialized successfully!\n'));
-                // Show summary
-                console.log(chalk.blue('📊 Summary:'));
-                console.log(chalk.gray(`  • Patterns loaded: ${result.summary.patternsLoaded}`));
-                console.log(chalk.gray(`  • Hooks configured: ${result.summary.hooksConfigured ? 'Yes' : 'No'}`));
-                console.log(chalk.gray(`  • Workers started: ${result.summary.workersStarted}`));
-                if (result.summary.n8nInstalled) {
-                    console.log(chalk.gray(`  • N8n agents: ${result.summary.n8nInstalled.agents}`));
-                    console.log(chalk.gray(`  • N8n skills: ${result.summary.n8nInstalled.skills}`));
-                }
-                console.log(chalk.gray(`  • Total time: ${result.totalDurationMs}ms\n`));
-                console.log(chalk.white('Next steps:'));
-                console.log(chalk.gray('  1. Add MCP: claude mcp add aqe -- aqe-mcp'));
-                console.log(chalk.gray('  2. Run tests: aqe test <path>'));
-                console.log(chalk.gray('  3. Check status: aqe status\n'));
-            }
-            else {
-                console.log(chalk.red('❌ Initialization failed. Check errors above.\n'));
-                await cleanupAndExit(1);
-            }
-            await cleanupAndExit(0);
-        }
-        // Standard init without wizard
-        console.log(chalk.blue('\n🚀 Initializing Agentic QE v3...\n'));
-        // Determine enabled domains
-        const enabledDomains = options.domains === 'all'
-            ? [...ALL_DOMAINS]
-            : options.domains.split(',').filter((d) => ALL_DOMAINS.includes(d));
-        console.log(chalk.gray(`  Domains: ${enabledDomains.length}`));
-        console.log(chalk.gray(`  Max Agents: ${options.maxAgents}`));
-        console.log(chalk.gray(`  Memory: ${options.memory}`));
-        console.log(chalk.gray(`  Lazy Loading: ${options.lazy ? 'enabled' : 'disabled'}\n`));
-        // Create kernel
-        context.kernel = new QEKernelImpl({
-            maxConcurrentAgents: parseInt(options.maxAgents, 10),
-            memoryBackend: options.memory,
-            hnswEnabled: true,
-            lazyLoading: options.lazy || false,
-            enabledDomains,
-        });
-        await context.kernel.initialize();
-        console.log(chalk.green('  ✓ Kernel initialized'));
-        // Create cross-domain router
-        context.router = new CrossDomainEventRouter(context.kernel.eventBus);
-        await context.router.initialize();
-        console.log(chalk.green('  ✓ Cross-domain router initialized'));
-        // Create protocol executor
-        const getDomainAPI = (domain) => {
-            return context.kernel.getDomainAPI(domain);
-        };
-        const protocolExecutor = new DefaultProtocolExecutor(context.kernel.eventBus, context.kernel.memory, getDomainAPI);
-        console.log(chalk.green('  ✓ Protocol executor initialized'));
-        // Create workflow orchestrator
-        context.workflowOrchestrator = new WorkflowOrchestrator(context.kernel.eventBus, context.kernel.memory, context.kernel.coordinator);
-        await context.workflowOrchestrator.initialize();
-        console.log(chalk.green('  ✓ Workflow orchestrator initialized'));
-        // Create Queen Coordinator
-        // Note: workflowExecutor is omitted as WorkflowOrchestrator uses different interface
-        context.queen = createQueenCoordinator(context.kernel, context.router, protocolExecutor, undefined // WorkflowExecutor - optional, can be added later
-        );
-        await context.queen.initialize();
-        console.log(chalk.green('  ✓ Queen Coordinator initialized'));
-        context.initialized = true;
-        console.log(chalk.green('\n✅ AQE v3 initialized successfully!\n'));
-        // Show enabled domains
-        console.log(chalk.blue('📦 Enabled Domains:'));
-        for (const domain of enabledDomains) {
-            console.log(chalk.gray(`  • ${domain}`));
-        }
-        console.log('');
-        await cleanupAndExit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to initialize:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Status Command
-// ============================================================================
-program
-    .command('status')
-    .description('Show system status')
-    .option('-v, --verbose', 'Show detailed status')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const health = context.queen.getHealth();
-        const metrics = context.queen.getMetrics();
-        console.log(chalk.blue('\n📊 AQE v3 Status\n'));
-        // Overall health
-        console.log(`  Status: ${getStatusColor(health.status)}`);
-        console.log(`  Uptime: ${chalk.cyan(formatUptime(metrics.uptime))}`);
-        console.log(`  Work Stealing: ${health.workStealingActive ? chalk.green('active') : chalk.gray('inactive')}`);
-        // Agents
-        console.log(chalk.blue('\n👥 Agents:'));
-        console.log(`  Total: ${chalk.cyan(health.totalAgents)}`);
-        console.log(`  Active: ${chalk.yellow(health.activeAgents)}`);
-        console.log(`  Utilization: ${chalk.cyan((metrics.agentUtilization * 100).toFixed(1))}%`);
-        // Tasks
-        console.log(chalk.blue('\n📋 Tasks:'));
-        console.log(`  Received: ${chalk.cyan(metrics.tasksReceived)}`);
-        console.log(`  Completed: ${chalk.green(metrics.tasksCompleted)}`);
-        console.log(`  Failed: ${chalk.red(metrics.tasksFailed)}`);
-        console.log(`  Pending: ${chalk.yellow(health.pendingTasks)}`);
-        console.log(`  Running: ${chalk.yellow(health.runningTasks)}`);
-        if (metrics.tasksStolen > 0) {
-            console.log(`  Stolen (work stealing): ${chalk.cyan(metrics.tasksStolen)}`);
-        }
-        // Protocols & Workflows
-        if (metrics.protocolsExecuted > 0 || metrics.workflowsExecuted > 0) {
-            console.log(chalk.blue('\n🔄 Coordination:'));
-            console.log(`  Protocols Executed: ${chalk.cyan(metrics.protocolsExecuted)}`);
-            console.log(`  Workflows Executed: ${chalk.cyan(metrics.workflowsExecuted)}`);
-        }
-        // Verbose domain status
-        if (options.verbose) {
-            console.log(chalk.blue('\n📦 Domain Status:'));
-            for (const [domain, domainHealth] of health.domainHealth) {
-                console.log(`  ${domain}: ${getStatusColor(domainHealth.status)}`);
-                console.log(chalk.gray(`    Agents: ${domainHealth.agents.active}/${domainHealth.agents.total} active`));
-                if (domainHealth.errors.length > 0) {
-                    console.log(chalk.red(`    Errors: ${domainHealth.errors.length}`));
-                }
-            }
-            // Domain utilization
-            console.log(chalk.blue('\n📈 Domain Load:'));
-            for (const [domain, load] of metrics.domainUtilization) {
-                const bar = '█'.repeat(Math.min(load, 20)) + '░'.repeat(Math.max(0, 20 - load));
-                console.log(`  ${domain.padEnd(25)} ${bar} ${load}`);
-            }
-        }
-        // Health issues
-        if (health.issues.length > 0) {
-            console.log(chalk.red('\n⚠️ Issues:'));
-            for (const issue of health.issues) {
-                const color = issue.severity === 'high' ? chalk.red :
-                    issue.severity === 'medium' ? chalk.yellow : chalk.gray;
-                console.log(`  ${color(`[${issue.severity}]`)} ${issue.message}`);
-            }
-        }
-        console.log('');
-        await cleanupAndExit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to get status:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Health Command
-// ============================================================================
-program
-    .command('health')
-    .description('Check system health')
-    .option('-d, --domain <domain>', 'Check specific domain health')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        if (options.domain) {
-            const domain = options.domain;
-            const health = context.queen.getDomainHealth(domain);
-            if (!health) {
-                console.log(chalk.red(`\n❌ Domain not found: ${domain}\n`));
-                return;
-            }
-            console.log(chalk.blue(`\n🏥 Health: ${domain}\n`));
-            console.log(`  Status: ${getStatusColor(health.status)}`);
-            console.log(`  Agents: ${health.agents.active}/${health.agents.total} active`);
-            console.log(`  Idle: ${health.agents.idle}`);
-            console.log(`  Failed: ${health.agents.failed}`);
-            if (health.lastActivity) {
-                console.log(`  Last Activity: ${health.lastActivity.toISOString()}`);
-            }
-            if (health.errors.length > 0) {
-                console.log(chalk.red(`\n  Errors:`));
-                health.errors.forEach(err => console.log(chalk.red(`    • ${err}`)));
-            }
-        }
-        else {
-            const health = context.queen.getHealth();
-            console.log(chalk.blue('\n🏥 System Health\n'));
-            console.log(`  Overall: ${getStatusColor(health.status)}`);
-            console.log(`  Last Check: ${health.lastHealthCheck.toISOString()}`);
-            // Summary by status
-            let healthy = 0, degraded = 0, unhealthy = 0;
-            for (const [, domainHealth] of health.domainHealth) {
-                if (domainHealth.status === 'healthy')
-                    healthy++;
-                else if (domainHealth.status === 'degraded')
-                    degraded++;
-                else
-                    unhealthy++;
-            }
-            console.log(chalk.blue('\n📦 Domains:'));
-            console.log(`  ${chalk.green('●')} Healthy: ${healthy}`);
-            console.log(`  ${chalk.yellow('●')} Degraded: ${degraded}`);
-            console.log(`  ${chalk.red('●')} Unhealthy: ${unhealthy}`);
-        }
-        console.log('');
-        await cleanupAndExit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Health check failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Task Command Group
-// ============================================================================
-const taskCmd = program
-    .command('task')
-    .description('Manage QE tasks');
-taskCmd
-    .command('submit <type>')
-    .description('Submit a task to the Queen Coordinator')
-    .option('-p, --priority <priority>', 'Task priority (p0|p1|p2|p3)', 'p1')
-    .option('-d, --domain <domain>', 'Target domain')
-    .option('-t, --timeout <ms>', 'Task timeout in ms', '300000')
-    .option('--payload <json>', 'Task payload as JSON', '{}')
-    .option('--wait', 'Wait for task completion with progress')
-    .option('--no-progress', 'Disable progress indicator')
-    .action(async (type, options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const taskType = type;
-        const payload = parseJsonOption(options.payload, 'payload');
-        const targetDomains = options.domain ? [options.domain] : [];
-        console.log(chalk.blue(`\n Submitting task: ${taskType}\n`));
-        // Use spinner for submit operation
-        const spinner = options.progress !== false
-            ? createTimedSpinner(`Submitting ${taskType} task`)
-            : null;
-        const result = await context.queen.submitTask({
-            type: taskType,
-            priority: options.priority,
-            targetDomains,
-            payload,
-            timeout: parseInt(options.timeout, 10),
-        });
-        if (spinner) {
-            if (result.success) {
-                spinner.succeed(`Task submitted successfully`);
-            }
-            else {
-                spinner.fail(`Failed to submit task`);
-            }
-        }
-        if (result.success) {
-            console.log(chalk.cyan(`   ID: ${result.value}`));
-            console.log(chalk.gray(`   Type: ${taskType}`));
-            console.log(chalk.gray(`   Priority: ${options.priority}`));
-            // If --wait flag is provided, poll for task completion with progress
-            if (options.wait) {
-                console.log('');
-                const taskId = result.value;
-                const waitSpinner = createTimedSpinner('Waiting for task completion');
-                const timeout = parseInt(options.timeout, 10);
-                const startTime = Date.now();
-                let completed = false;
-                while (!completed && (Date.now() - startTime) < timeout) {
-                    const taskStatus = context.queen.getTaskStatus(taskId);
-                    if (taskStatus) {
-                        if (taskStatus.status === 'completed') {
-                            waitSpinner.succeed('Task completed successfully');
-                            completed = true;
-                        }
-                        else if (taskStatus.status === 'failed') {
-                            waitSpinner.fail(`Task failed: ${taskStatus.error || 'Unknown error'}`);
-                            completed = true;
-                        }
-                        else {
-                            // Update spinner with progress info
-                            waitSpinner.spinner.text = `Task ${taskStatus.status}... (${Math.round((Date.now() - startTime) / 1000)}s)`;
-                        }
-                    }
-                    if (!completed) {
-                        await new Promise(resolve => setTimeout(resolve, 500));
-                    }
-                }
-                if (!completed) {
-                    waitSpinner.fail('Task timed out');
-                }
-            }
-        }
-        else {
-            console.log(chalk.red(`   Error: ${result.error.message}`));
-        }
-        console.log('');
-    }
-    catch (error) {
-        console.error(chalk.red('\n Failed to submit task:'), error);
-        await cleanupAndExit(1);
-    }
-});
-taskCmd
-    .command('list')
-    .description('List all tasks')
-    .option('-s, --status <status>', 'Filter by status')
-    .option('-p, --priority <priority>', 'Filter by priority')
-    .option('-d, --domain <domain>', 'Filter by domain')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const tasks = context.queen.listTasks({
-            status: options.status,
-            priority: options.priority,
-            domain: options.domain,
-        });
-        console.log(chalk.blue(`\n📋 Tasks (${tasks.length})\n`));
-        if (tasks.length === 0) {
-            console.log(chalk.gray('  No tasks found'));
-        }
-        else {
-            for (const task of tasks) {
-                console.log(`  ${chalk.cyan(task.taskId)}`);
-                console.log(`    Type: ${task.task.type}`);
-                console.log(`    Status: ${getStatusColor(task.status)}`);
-                console.log(`    Priority: ${task.task.priority}`);
-                if (task.assignedDomain) {
-                    console.log(`    Domain: ${task.assignedDomain}`);
-                }
-                if (task.startedAt) {
-                    console.log(chalk.gray(`    Started: ${task.startedAt.toISOString()}`));
-                }
-                console.log('');
-            }
-        }
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to list tasks:'), error);
-        await cleanupAndExit(1);
-    }
-});
-taskCmd
-    .command('cancel <taskId>')
-    .description('Cancel a task')
-    .action(async (taskId) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const result = await context.queen.cancelTask(taskId);
-        if (result.success) {
-            console.log(chalk.green(`\n✅ Task cancelled: ${taskId}\n`));
-        }
-        else {
-            console.log(chalk.red(`\n❌ Failed to cancel task: ${result.error.message}\n`));
-        }
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to cancel task:'), error);
-        await cleanupAndExit(1);
-    }
-});
-taskCmd
-    .command('status <taskId>')
-    .description('Get task status')
-    .action(async (taskId) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const task = context.queen.getTaskStatus(taskId);
-        if (!task) {
-            console.log(chalk.red(`\n❌ Task not found: ${taskId}\n`));
-            return;
-        }
-        console.log(chalk.blue(`\n📋 Task: ${taskId}\n`));
-        console.log(`  Type: ${task.task.type}`);
-        console.log(`  Status: ${getStatusColor(task.status)}`);
-        console.log(`  Priority: ${task.task.priority}`);
-        if (task.assignedDomain) {
-            console.log(`  Domain: ${task.assignedDomain}`);
-        }
-        if (task.assignedAgents.length > 0) {
-            console.log(`  Agents: ${task.assignedAgents.join(', ')}`);
-        }
-        console.log(`  Created: ${task.task.createdAt.toISOString()}`);
-        if (task.startedAt) {
-            console.log(`  Started: ${task.startedAt.toISOString()}`);
-        }
-        if (task.completedAt) {
-            console.log(`  Completed: ${task.completedAt.toISOString()}`);
-            const duration = task.completedAt.getTime() - task.startedAt.getTime();
-            console.log(`  Duration: ${formatDuration(duration)}`);
-        }
-        if (task.error) {
-            console.log(chalk.red(`  Error: ${task.error}`));
-        }
-        if (task.retryCount > 0) {
-            console.log(chalk.yellow(`  Retries: ${task.retryCount}`));
-        }
-        console.log('');
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to get task status:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Agent Command Group
-// ============================================================================
-const agentCmd = program
-    .command('agent')
-    .description('Manage QE agents');
-agentCmd
-    .command('list')
-    .description('List all agents')
-    .option('-d, --domain <domain>', 'Filter by domain')
-    .option('-s, --status <status>', 'Filter by status')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        let agents = options.domain
-            ? context.queen.getAgentsByDomain(options.domain)
-            : context.queen.listAllAgents();
-        if (options.status) {
-            agents = agents.filter(a => a.status === options.status);
-        }
-        console.log(chalk.blue(`\n👥 Agents (${agents.length})\n`));
-        if (agents.length === 0) {
-            console.log(chalk.gray('  No agents found'));
-        }
-        else {
-            // Group by domain
-            const byDomain = new Map();
-            for (const agent of agents) {
-                if (!byDomain.has(agent.domain)) {
-                    byDomain.set(agent.domain, []);
-                }
-                byDomain.get(agent.domain).push(agent);
-            }
-            for (const [domain, domainAgents] of byDomain) {
-                console.log(chalk.cyan(`  ${domain}:`));
-                for (const agent of domainAgents) {
-                    console.log(`    ${agent.id}`);
-                    console.log(`      Type: ${agent.type}`);
-                    console.log(`      Status: ${getStatusColor(agent.status)}`);
-                    if (agent.startedAt) {
-                        console.log(chalk.gray(`      Started: ${agent.startedAt.toISOString()}`));
-                    }
-                }
-                console.log('');
-            }
-        }
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to list agents:'), error);
-        await cleanupAndExit(1);
-    }
-});
-agentCmd
-    .command('spawn <domain>')
-    .description('Spawn an agent in a domain')
-    .option('-t, --type <type>', 'Agent type', 'worker')
-    .option('-c, --capabilities <caps>', 'Comma-separated capabilities', 'general')
-    .option('--no-progress', 'Disable progress indicator')
-    .action(async (domain, options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const capabilities = options.capabilities.split(',');
-        console.log(chalk.blue(`\n Spawning agent in ${domain}...\n`));
-        // Use spinner for spawn operation
-        const spinner = options.progress !== false
-            ? createTimedSpinner(`Spawning ${options.type} agent`)
-            : null;
-        const result = await context.queen.requestAgentSpawn(domain, options.type, capabilities);
-        if (spinner) {
-            if (result.success) {
-                spinner.succeed(`Agent spawned successfully`);
-            }
-            else {
-                spinner.fail(`Failed to spawn agent`);
-            }
-        }
-        if (result.success) {
-            console.log(chalk.cyan(`   ID: ${result.value}`));
-            console.log(chalk.gray(`   Domain: ${domain}`));
-            console.log(chalk.gray(`   Type: ${options.type}`));
-            console.log(chalk.gray(`   Capabilities: ${capabilities.join(', ')}`));
-        }
-        else {
-            console.log(chalk.red(`   Error: ${result.error.message}`));
-        }
-        console.log('');
-    }
-    catch (error) {
-        console.error(chalk.red('\n Failed to spawn agent:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Domain Command Group
-// ============================================================================
-const domainCmd = program
-    .command('domain')
-    .description('Domain operations');
-domainCmd
-    .command('list')
-    .description('List all domains')
-    .action(async () => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        console.log(chalk.blue('\n📦 Domains\n'));
-        for (const domain of ALL_DOMAINS) {
-            const health = context.queen.getDomainHealth(domain);
-            const load = context.queen.getDomainLoad(domain);
-            console.log(`  ${chalk.cyan(domain)}`);
-            console.log(`    Status: ${getStatusColor(health?.status || 'unknown')}`);
-            console.log(`    Load: ${load} tasks`);
-            if (health) {
-                console.log(`    Agents: ${health.agents.active}/${health.agents.total}`);
-            }
-            console.log('');
-        }
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to list domains:'), error);
-        await cleanupAndExit(1);
-    }
-});
-domainCmd
-    .command('health <domain>')
-    .description('Get domain health')
-    .action(async (domain) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const health = context.queen.getDomainHealth(domain);
-        if (!health) {
-            console.log(chalk.red(`\n❌ Domain not found: ${domain}\n`));
-            return;
-        }
-        console.log(chalk.blue(`\n🏥 ${domain} Health\n`));
-        console.log(`  Status: ${getStatusColor(health.status)}`);
-        console.log(`  Agents Total: ${health.agents.total}`);
-        console.log(`  Agents Active: ${chalk.green(health.agents.active)}`);
-        console.log(`  Agents Idle: ${chalk.yellow(health.agents.idle)}`);
-        console.log(`  Agents Failed: ${chalk.red(health.agents.failed)}`);
-        if (health.lastActivity) {
-            console.log(`  Last Activity: ${health.lastActivity.toISOString()}`);
-        }
-        if (health.errors.length > 0) {
-            console.log(chalk.red('\n  Errors:'));
-            health.errors.forEach(err => console.log(chalk.red(`    • ${err}`)));
-        }
-        console.log('');
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to get domain health:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Protocol Command Group
+// Register Handlers via CommandRegistry
 // ============================================================================
-const protocolCmd = program
-    .command('protocol')
-    .description('Execute coordination protocols');
-protocolCmd
-    .command('run <protocolId>')
-    .description('Execute a protocol')
-    .option('--params <json>', 'Protocol parameters as JSON', '{}')
-    .action(async (protocolId, options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const params = parseJsonOption(options.params, 'params');
-        console.log(chalk.blue(`\n🔄 Executing protocol: ${protocolId}\n`));
-        const result = await context.queen.executeProtocol(protocolId, params);
-        if (result.success) {
-            console.log(chalk.green(`✅ Protocol execution started`));
-            console.log(chalk.cyan(`   Execution ID: ${result.value}`));
-        }
-        else {
-            console.log(chalk.red(`❌ Failed to execute protocol: ${result.error.message}`));
-        }
-        console.log('');
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed to execute protocol:'), error);
-        await cleanupAndExit(1);
-    }
-});
+const registry = createCommandRegistry(context, cleanupAndExit, ensureInitialized);
+registry.registerAll(program);
 // ============================================================================
 // Workflow Command Group (ADR-041)
 // ============================================================================
@@ -827,7 +163,6 @@ workflowCmd
     const filePath = pathModule.resolve(file);
     try {
         console.log(chalk.blue(`\n Running workflow from: ${file}\n`));
-        // Parse the pipeline file
         const parseResult = parsePipelineFile(filePath);
         if (!parseResult.success || !parseResult.workflow) {
             console.log(chalk.red('Failed to parse pipeline:'));
@@ -836,11 +171,8 @@ workflowCmd
             }
             await cleanupAndExit(1);
         }
-        // Additional params (SEC-001: safe parsing prevents prototype pollution)
         const additionalParams = parseJsonOption(options.params, 'params');
-        // Build input from pipeline params and additional params
         const input = { ...additionalParams };
-        // Add stage params to input context
         if (parseResult.pipeline) {
             for (const stage of parseResult.pipeline.stages) {
                 if (stage.params) {
@@ -850,7 +182,6 @@ workflowCmd
                 }
             }
         }
-        // Register the workflow if not already registered
         const existingWorkflow = context.workflowOrchestrator.getWorkflow(parseResult.workflow.id);
         if (!existingWorkflow) {
             const registerResult = context.workflowOrchestrator.registerWorkflow(parseResult.workflow);
@@ -859,19 +190,17 @@ workflowCmd
                 await cleanupAndExit(1);
             }
         }
-        // Execute the workflow
         const execResult = await context.workflowOrchestrator.executeWorkflow(parseResult.workflow.id, input);
         if (!execResult.success) {
             console.log(chalk.red(`Failed to start workflow: ${execResult.error.message}`));
             await cleanupAndExit(1);
-            return; // TypeScript flow analysis
+            return;
         }
         const executionId = execResult.value;
         console.log(chalk.cyan(`  Execution ID: ${executionId}`));
         console.log(chalk.gray(`  Workflow: ${parseResult.workflow.name}`));
         console.log(chalk.gray(`  Stages: ${parseResult.workflow.steps.length}`));
         console.log('');
-        // Watch progress if requested
         if (options.watch) {
             console.log(chalk.blue('Workflow Progress:\n'));
             let lastStatus;
@@ -880,12 +209,10 @@ workflowCmd
                 const status = context.workflowOrchestrator.getWorkflowStatus(executionId);
                 if (!status)
                     break;
-                // Update display if status changed
                 if (!lastStatus ||
                     lastStatus.progress !== status.progress ||
                     lastStatus.status !== status.status ||
                     JSON.stringify(lastStatus.currentSteps) !== JSON.stringify(status.currentSteps)) {
-                    // Clear line and show progress
                     process.stdout.write('\r\x1b[K');
                     const progressBar = String.fromCharCode(0x2588).repeat(Math.floor(status.progress / 5)) +
                         String.fromCharCode(0x2591).repeat(20 - Math.floor(status.progress / 5));
@@ -898,14 +225,11 @@ workflowCmd
                     }
                     lastStatus = status;
                 }
-                // Check if completed
                 if (status.status === 'completed' || status.status === 'failed' || status.status === 'cancelled') {
                     break;
                 }
-                // Wait before next check
                 await new Promise(resolve => setTimeout(resolve, 500));
             }
-            // Show final status
             const finalStatus = context.workflowOrchestrator.getWorkflowStatus(executionId);
             if (finalStatus) {
                 console.log('');
@@ -948,12 +272,10 @@ workflowCmd
     .action(async (file, options) => {
     if (!await ensureInitialized())
         return;
-    const fs = await import('fs');
     const pathModule = await import('path');
     const filePath = pathModule.resolve(file);
     try {
         console.log(chalk.blue(`\nScheduling workflow from: ${file}\n`));
-        // Parse the pipeline file
         const parseResult = parsePipelineFile(filePath);
         if (!parseResult.success || !parseResult.pipeline || !parseResult.workflow) {
             console.log(chalk.red('Failed to parse pipeline:'));
@@ -962,14 +284,12 @@ workflowCmd
             }
             await cleanupAndExit(1);
         }
-        // Get schedule from option or file
         const schedule = options.cron || parseResult.pipeline.schedule;
         if (!schedule) {
             console.log(chalk.red('No schedule specified'));
             console.log(chalk.gray('   Add "schedule" field to YAML or use --cron option'));
             await cleanupAndExit(1);
         }
-        // Register the workflow
         const existingWorkflow = context.workflowOrchestrator.getWorkflow(parseResult.workflow.id);
         if (!existingWorkflow) {
             const registerResult = context.workflowOrchestrator.registerWorkflow(parseResult.workflow);
@@ -978,7 +298,6 @@ workflowCmd
                 await cleanupAndExit(1);
             }
         }
-        // Create scheduled workflow entry using persistent scheduler (ADR-041)
         const persistedSchedule = createScheduleEntry({
             workflowId: parseResult.workflow.id,
             pipelinePath: filePath,
@@ -986,9 +305,7 @@ workflowCmd
             scheduleDescription: describeCronSchedule(schedule),
             enabled: options.enable !== false,
         });
-        // Persist to disk using PersistentScheduler
         await context.persistentScheduler.saveSchedule(persistedSchedule);
-        // Also keep in memory for backward compatibility
         const scheduledWorkflow = {
             id: persistedSchedule.id,
             workflowId: persistedSchedule.workflowId,
@@ -1029,17 +346,15 @@ workflowCmd
         return;
     try {
         console.log(chalk.blue('\nWorkflows\n'));
-        // Show scheduled workflows (from PersistentScheduler)
         if (options.scheduled || options.all) {
             console.log(chalk.cyan('Scheduled Workflows:'));
-            // Load schedules from persistent storage (ADR-041)
             const scheduled = await context.persistentScheduler.getSchedules();
             if (scheduled.length === 0) {
                 console.log(chalk.gray('  No scheduled workflows\n'));
             }
             else {
                 for (const sched of scheduled) {
-                    const statusIcon = sched.enabled ? chalk.green('●') : chalk.gray('○');
+                    const statusIcon = sched.enabled ? chalk.green('*') : chalk.gray('o');
                     console.log(`  ${statusIcon} ${chalk.white(sched.workflowId)}`);
                     console.log(chalk.gray(`     ID: ${sched.id}`));
                     console.log(chalk.gray(`     Schedule: ${sched.schedule} (${sched.scheduleDescription})`));
@@ -1053,7 +368,6 @@ workflowCmd
                 }
             }
         }
-        // Show active executions
         if (options.active || options.all) {
             console.log(chalk.cyan('Active Executions:'));
             const activeExecutions = context.workflowOrchestrator.getActiveExecutions();
@@ -1074,7 +388,6 @@ workflowCmd
                 }
             }
         }
-        // Show registered workflows (default behavior)
         if (!options.scheduled && !options.active || options.all) {
             console.log(chalk.cyan('Registered Workflows:'));
             const workflows = context.workflowOrchestrator.listWorkflows();
@@ -1116,12 +429,10 @@ workflowCmd
     const filePath = pathModule.resolve(file);
     try {
         console.log(chalk.blue(`\nValidating pipeline: ${file}\n`));
-        // Check file exists
         if (!fs.existsSync(filePath)) {
             console.log(chalk.red(`File not found: ${filePath}`));
             await cleanupAndExit(1);
         }
-        // Parse the pipeline file
         const parseResult = parsePipelineFile(filePath);
         if (!parseResult.success) {
             console.log(chalk.red('Parse errors:'));
@@ -1130,9 +441,7 @@ workflowCmd
             }
             await cleanupAndExit(1);
         }
-        // Validate the pipeline structure
         const validationResult = validatePipeline(parseResult.pipeline);
-        // Show results
         if (validationResult.valid) {
             console.log(chalk.green('Pipeline is valid\n'));
         }
@@ -1143,7 +452,6 @@ workflowCmd
             }
             console.log('');
         }
-        // Show warnings
         if (validationResult.warnings.length > 0) {
             console.log(chalk.yellow('Warnings:'));
             for (const warning of validationResult.warnings) {
@@ -1151,7 +459,6 @@ workflowCmd
             }
             console.log('');
         }
-        // Show pipeline details if verbose
         if (options.verbose && parseResult.pipeline) {
             const pipeline = parseResult.pipeline;
             console.log(chalk.cyan('Pipeline Details:\n'));
@@ -1191,7 +498,6 @@ workflowCmd
                 }
             }
         }
-        // Show converted workflow definition if verbose
         if (options.verbose && parseResult.workflow) {
             console.log(chalk.cyan('\n  Converted Workflow ID: ') + chalk.white(parseResult.workflow.id));
             console.log(chalk.gray(`  Steps: ${parseResult.workflow.steps.length}`));
@@ -1219,7 +525,7 @@ workflowCmd
         if (!status) {
             console.log(chalk.red(`\nExecution not found: ${executionId}\n`));
             await cleanupAndExit(1);
-            return; // TypeScript flow analysis
+            return;
         }
         console.log(chalk.blue(`\nWorkflow Execution Status\n`));
         const statusColor = status.status === 'completed' ? chalk.green :
@@ -1246,7 +552,6 @@ workflowCmd
         if (status.error) {
             console.log(chalk.red(`\n  Error: ${status.error}`));
         }
-        // Show detailed step results if verbose
         if (options.verbose && status.stepResults.size > 0) {
             console.log(chalk.cyan('\n  Step Results:'));
             for (const [stepId, result] of status.stepResults) {
@@ -1295,1861 +600,36 @@ workflowCmd
     }
 });
 // ============================================================================
-// Shortcut Commands
+// Shortcut Commands (test, coverage, quality, security, code)
 // ============================================================================
-// aqe test generate <source>
-program
-    .command('test')
-    .description('Test generation shortcut')
-    .argument('<action>', 'Action (generate|execute)')
-    .argument('[target]', 'Target file or directory')
-    .option('-f, --framework <framework>', 'Test framework', 'vitest')
-    .option('-t, --type <type>', 'Test type (unit|integration|e2e)', 'unit')
-    .action(async (action, target, options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        if (action === 'generate') {
-            console.log(chalk.blue(`\n🧪 Generating tests for ${target || 'current directory'}...\n`));
-            // Get test generation domain API directly (with lazy loading support)
-            const testGenAPI = await context.kernel.getDomainAPIAsync('test-generation');
-            if (!testGenAPI) {
-                console.log(chalk.red('❌ Test generation domain not available'));
-                return;
-            }
-            // Collect source files
-            const fs = await import('fs');
-            const path = await import('path');
-            const targetPath = path.resolve(target || '.');
-            let sourceFiles = [];
-            if (fs.existsSync(targetPath)) {
-                if (fs.statSync(targetPath).isDirectory()) {
-                    const walkDir = (dir, depth = 0) => {
-                        if (depth > 4)
-                            return [];
-                        const result = [];
-                        const items = fs.readdirSync(dir);
-                        for (const item of items) {
-                            if (item === 'node_modules' || item === 'dist' || item === 'tests' || item.includes('.test.') || item.includes('.spec.'))
-                                continue;
-                            const fullPath = path.join(dir, item);
-                            const stat = fs.statSync(fullPath);
-                            if (stat.isDirectory()) {
-                                result.push(...walkDir(fullPath, depth + 1));
-                            }
-                            else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-                                result.push(fullPath);
-                            }
-                        }
-                        return result;
-                    };
-                    sourceFiles = walkDir(targetPath);
-                }
-                else {
-                    sourceFiles = [targetPath];
-                }
-            }
-            if (sourceFiles.length === 0) {
-                console.log(chalk.yellow('No source files found'));
-                return;
-            }
-            console.log(chalk.gray(`  Found ${sourceFiles.length} source files\n`));
-            // Generate tests
-            const result = await testGenAPI.generateTests({
-                sourceFiles,
-                testType: options.type,
-                framework: options.framework,
-                coverageTarget: 80,
-            });
-            if (result.success && result.value) {
-                const generated = result.value;
-                console.log(chalk.green(`✅ Generated ${generated.tests.length} tests\n`));
-                console.log(chalk.cyan('  Tests:'));
-                for (const test of generated.tests.slice(0, 10)) {
-                    console.log(`    ${chalk.white(test.name)}`);
-                    console.log(chalk.gray(`      Source: ${path.basename(test.sourceFile)}`));
-                    console.log(chalk.gray(`      Assertions: ${test.assertions}`));
-                }
-                if (generated.tests.length > 10) {
-                    console.log(chalk.gray(`    ... and ${generated.tests.length - 10} more`));
-                }
-                console.log(`\n  Coverage Estimate: ${chalk.yellow(generated.coverageEstimate + '%')}`);
-                if (generated.patternsUsed.length > 0) {
-                    console.log(`  Patterns Used: ${chalk.cyan(generated.patternsUsed.join(', '))}`);
-                }
-            }
-            else {
-                console.log(chalk.red(`❌ Failed: ${result.error?.message || 'Unknown error'}`));
-            }
-        }
-        else if (action === 'execute') {
-            console.log(chalk.blue(`\n🧪 Executing tests in ${target || 'current directory'}...\n`));
-            // Get test execution domain API (with lazy loading support)
-            const testExecAPI = await context.kernel.getDomainAPIAsync('test-execution');
-            if (!testExecAPI) {
-                console.log(chalk.red('❌ Test execution domain not available'));
-                return;
-            }
-            // Collect test files
-            const fs = await import('fs');
-            const path = await import('path');
-            const targetPath = path.resolve(target || '.');
-            let testFiles = [];
-            if (fs.existsSync(targetPath)) {
-                if (fs.statSync(targetPath).isDirectory()) {
-                    const walkDir = (dir, depth = 0) => {
-                        if (depth > 4)
-                            return [];
-                        const result = [];
-                        const items = fs.readdirSync(dir);
-                        for (const item of items) {
-                            if (item === 'node_modules' || item === 'dist')
-                                continue;
-                            const fullPath = path.join(dir, item);
-                            const stat = fs.statSync(fullPath);
-                            if (stat.isDirectory()) {
-                                result.push(...walkDir(fullPath, depth + 1));
-                            }
-                            else if ((item.includes('.test.') || item.includes('.spec.')) && item.endsWith('.ts')) {
-                                result.push(fullPath);
-                            }
-                        }
-                        return result;
-                    };
-                    testFiles = walkDir(targetPath);
-                }
-                else {
-                    testFiles = [targetPath];
-                }
-            }
-            if (testFiles.length === 0) {
-                console.log(chalk.yellow('No test files found'));
-                return;
-            }
-            console.log(chalk.gray(`  Found ${testFiles.length} test files\n`));
-            const result = await testExecAPI.runTests({
-                testFiles,
-                parallel: true,
-                retryCount: 2,
-            });
-            if (result.success && result.value) {
-                const run = result.value;
-                const total = run.passed + run.failed + run.skipped;
-                console.log(chalk.green(`✅ Test run complete`));
-                console.log(`\n  Results:`);
-                console.log(`    Total: ${chalk.white(total)}`);
-                console.log(`    Passed: ${chalk.green(run.passed)}`);
-                console.log(`    Failed: ${chalk.red(run.failed)}`);
-                console.log(`    Skipped: ${chalk.yellow(run.skipped)}`);
-                console.log(`    Duration: ${chalk.cyan(run.duration + 'ms')}`);
-            }
-            else {
-                console.log(chalk.red(`❌ Failed: ${result.error?.message || 'Unknown error'}`));
-            }
-        }
-        else {
-            console.log(chalk.red(`\n❌ Unknown action: ${action}\n`));
-            await cleanupAndExit(1);
-        }
-        console.log('');
-        await cleanupAndExit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// aqe coverage <target>
-program
-    .command('coverage')
-    .description('Coverage analysis shortcut')
-    .argument('[target]', 'Target file or directory', '.')
-    .option('--risk', 'Include risk scoring')
-    .option('--gaps', 'Detect coverage gaps')
-    .option('--threshold <percent>', 'Coverage threshold percentage', '80')
-    .option('--sensitivity <level>', 'Gap detection sensitivity (low|medium|high)', 'medium')
-    .option('--wizard', 'Run interactive coverage analysis wizard')
-    .action(async (target, options) => {
-    let analyzeTarget = target;
-    let includeRisk = options.risk;
-    let detectGaps = options.gaps;
-    let threshold = parseInt(options.threshold, 10);
-    // Run wizard if requested
-    if (options.wizard) {
-        try {
-            const wizardResult = await runCoverageAnalysisWizard({
-                defaultTarget: target !== '.' ? target : undefined,
-                defaultThreshold: options.threshold !== '80' ? parseInt(options.threshold, 10) : undefined,
-                defaultRiskScoring: options.risk,
-                defaultSensitivity: options.sensitivity !== 'medium' ? options.sensitivity : undefined,
-            });
-            if (wizardResult.cancelled) {
-                console.log(chalk.yellow('\n  Coverage analysis cancelled.\n'));
-                await cleanupAndExit(0);
-            }
-            // Use wizard results
-            analyzeTarget = wizardResult.target;
-            includeRisk = wizardResult.riskScoring;
-            detectGaps = true; // Wizard always enables gap detection
-            threshold = wizardResult.threshold;
-            console.log(chalk.green('\n  Starting coverage analysis...\n'));
-        }
-        catch (err) {
-            console.error(chalk.red('\n  Wizard error:'), err);
-            await cleanupAndExit(1);
-        }
-    }
-    if (!await ensureInitialized())
-        return;
-    try {
-        console.log(chalk.blue(`\n  Analyzing coverage for ${analyzeTarget}...\n`));
-        // Get coverage analysis domain API directly (with lazy loading support)
-        const coverageAPI = await context.kernel.getDomainAPIAsync('coverage-analysis');
-        if (!coverageAPI) {
-            console.log(chalk.red('❌ Coverage analysis domain not available'));
-            return;
-        }
-        // Collect source files and generate synthetic coverage data for analysis
-        const fs = await import('fs');
-        const path = await import('path');
-        const targetPath = path.resolve(analyzeTarget);
-        let sourceFiles = [];
-        if (fs.existsSync(targetPath)) {
-            if (fs.statSync(targetPath).isDirectory()) {
-                const walkDir = (dir, depth = 0) => {
-                    if (depth > 4)
-                        return [];
-                    const result = [];
-                    const items = fs.readdirSync(dir);
-                    for (const item of items) {
-                        if (item === 'node_modules' || item === 'dist')
-                            continue;
-                        const fullPath = path.join(dir, item);
-                        const stat = fs.statSync(fullPath);
-                        if (stat.isDirectory()) {
-                            result.push(...walkDir(fullPath, depth + 1));
-                        }
-                        else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-                            result.push(fullPath);
-                        }
-                    }
-                    return result;
-                };
-                sourceFiles = walkDir(targetPath);
-            }
-            else {
-                sourceFiles = [targetPath];
-            }
-        }
-        if (sourceFiles.length === 0) {
-            console.log(chalk.yellow('No source files found'));
-            return;
-        }
-        console.log(chalk.gray(`  Analyzing ${sourceFiles.length} files...\n`));
-        // Build coverage data from file analysis
-        const files = sourceFiles.map(filePath => {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const lines = content.split('\n');
-            const totalLines = lines.length;
-            // Estimate coverage based on presence of corresponding test file
-            const testFile = filePath.replace('.ts', '.test.ts').replace('/src/', '/tests/');
-            const hasTest = fs.existsSync(testFile);
-            const coverageRate = hasTest ? 0.75 + Math.random() * 0.2 : 0.2 + Math.random() * 0.3;
-            const coveredLines = Math.floor(totalLines * coverageRate);
-            const uncoveredLines = Array.from({ length: totalLines - coveredLines }, (_, i) => i + coveredLines + 1);
-            return {
-                path: filePath,
-                lines: { covered: coveredLines, total: totalLines },
-                branches: { covered: Math.floor(coveredLines * 0.8), total: totalLines },
-                functions: { covered: Math.floor(coveredLines * 0.9), total: Math.ceil(totalLines / 20) },
-                statements: { covered: coveredLines, total: totalLines },
-                uncoveredLines,
-                uncoveredBranches: uncoveredLines.slice(0, Math.floor(uncoveredLines.length / 2)),
-            };
-        });
-        const totalLines = files.reduce((sum, f) => sum + f.lines.total, 0);
-        const coveredLines = files.reduce((sum, f) => sum + f.lines.covered, 0);
-        const totalBranches = files.reduce((sum, f) => sum + f.branches.total, 0);
-        const coveredBranches = files.reduce((sum, f) => sum + f.branches.covered, 0);
-        const totalFunctions = files.reduce((sum, f) => sum + f.functions.total, 0);
-        const coveredFunctions = files.reduce((sum, f) => sum + f.functions.covered, 0);
-        const coverageData = {
-            files,
-            summary: {
-                line: Math.round((coveredLines / totalLines) * 100),
-                branch: Math.round((coveredBranches / totalBranches) * 100),
-                function: Math.round((coveredFunctions / totalFunctions) * 100),
-                statement: Math.round((coveredLines / totalLines) * 100),
-                files: files.length,
-            },
-        };
-        // Run coverage analysis
-        const result = await coverageAPI.analyze({
-            coverageData,
-            threshold,
-            includeFileDetails: true,
-        });
-        if (result.success && result.value) {
-            const report = result.value;
-            console.log(chalk.cyan('  Coverage Summary:'));
-            console.log(`    Lines:      ${getColorForPercent(report.summary.line)(report.summary.line + '%')}`);
-            console.log(`    Branches:   ${getColorForPercent(report.summary.branch)(report.summary.branch + '%')}`);
-            console.log(`    Functions:  ${getColorForPercent(report.summary.function)(report.summary.function + '%')}`);
-            console.log(`    Statements: ${getColorForPercent(report.summary.statement)(report.summary.statement + '%')}`);
-            console.log(`\n    Threshold: ${report.meetsThreshold ? chalk.green(`Met (${threshold}%)`) : chalk.red(`Not met (${threshold}%)`)}`);
-            if (report.recommendations.length > 0) {
-                console.log(chalk.cyan('\n  Recommendations:'));
-                for (const rec of report.recommendations) {
-                    console.log(chalk.gray(`    - ${rec}`));
-                }
-            }
-        }
-        // Detect gaps if requested
-        if (detectGaps) {
-            console.log(chalk.cyan('\n  Coverage Gaps:'));
-            const gapResult = await coverageAPI.detectGaps({
-                coverageData,
-                minCoverage: threshold,
-                prioritize: includeRisk ? 'risk' : 'size',
-            });
-            if (gapResult.success && gapResult.value) {
-                const gaps = gapResult.value;
-                console.log(chalk.gray(`    Total uncovered lines: ${gaps.totalUncoveredLines}`));
-                console.log(chalk.gray(`    Estimated effort: ${gaps.estimatedEffort} hours\n`));
-                for (const gap of gaps.gaps.slice(0, 8)) {
-                    const severityColor = gap.severity === 'high' ? chalk.red : gap.severity === 'medium' ? chalk.yellow : chalk.gray;
-                    const filePath = gap.file.replace(process.cwd() + '/', '');
-                    console.log(`    ${severityColor(`[${gap.severity}]`)} ${chalk.white(filePath)}`);
-                    console.log(chalk.gray(`        ${gap.lines.length} uncovered lines, Risk: ${(gap.riskScore * 100).toFixed(0)}%`));
-                }
-                if (gaps.gaps.length > 8) {
-                    console.log(chalk.gray(`    ... and ${gaps.gaps.length - 8} more gaps`));
-                }
-            }
-        }
-        // Calculate risk if requested
-        if (includeRisk) {
-            console.log(chalk.cyan('\n⚠️  Risk Analysis:'));
-            // Calculate risk for top 5 files with lowest coverage
-            const lowCoverageFiles = [...files]
-                .sort((a, b) => (a.lines.covered / a.lines.total) - (b.lines.covered / b.lines.total))
-                .slice(0, 5);
-            for (const file of lowCoverageFiles) {
-                const riskResult = await coverageAPI.calculateRisk({
-                    file: file.path,
-                    uncoveredLines: file.uncoveredLines,
-                });
-                if (riskResult.success && riskResult.value) {
-                    const risk = riskResult.value;
-                    const riskColor = risk.riskLevel === 'high' ? chalk.red : risk.riskLevel === 'medium' ? chalk.yellow : chalk.green;
-                    const filePath = file.path.replace(process.cwd() + '/', '');
-                    console.log(`    ${riskColor(`[${risk.riskLevel}]`)} ${chalk.white(filePath)}`);
-                    console.log(chalk.gray(`        Risk: ${(risk.overallRisk * 100).toFixed(0)}%, Coverage: ${Math.round((file.lines.covered / file.lines.total) * 100)}%`));
-                }
-            }
-        }
-        console.log(chalk.green('\n✅ Coverage analysis complete\n'));
-        await cleanupAndExit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-function getColorForPercent(percent) {
-    if (percent >= 80)
-        return chalk.green;
-    if (percent >= 50)
-        return chalk.yellow;
-    return chalk.red;
-}
-// aqe token-usage (ADR-042)
-import { createTokenUsageCommand } from './commands/token-usage.js';
-program.addCommand(createTokenUsageCommand());
-// aqe llm (ADR-043)
-import { createLLMRouterCommand } from './commands/llm-router.js';
-program.addCommand(createLLMRouterCommand());
-// aqe quality
-program
-    .command('quality')
-    .description('Quality assessment shortcut')
-    .option('--gate', 'Run quality gate evaluation')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        console.log(chalk.blue(`\n🎯 Running quality assessment...\n`));
-        const result = await context.queen.submitTask({
-            type: 'assess-quality',
-            priority: 'p0',
-            targetDomains: ['quality-assessment'],
-            payload: { runGate: options.gate },
-            timeout: 300000,
-        });
-        if (result.success) {
-            console.log(chalk.green(`✅ Task submitted: ${result.value}`));
-            console.log(chalk.gray(`   Use 'aqe task status ${result.value}' to check progress`));
-        }
-        else {
-            console.log(chalk.red(`❌ Failed: ${result.error.message}`));
-        }
-        console.log('');
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// aqe security
-program
-    .command('security')
-    .description('Security scanning shortcut')
-    .option('--sast', 'Run SAST scan')
-    .option('--dast', 'Run DAST scan')
-    .option('--compliance <frameworks>', 'Check compliance (gdpr,hipaa,soc2)', '')
-    .option('-t, --target <path>', 'Target directory to scan', '.')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        console.log(chalk.blue(`\n🔒 Running security scan on ${options.target}...\n`));
-        // Get security domain API directly (with lazy loading support)
-        const securityAPI = await context.kernel.getDomainAPIAsync('security-compliance');
-        if (!securityAPI) {
-            console.log(chalk.red('❌ Security domain not available'));
-            return;
-        }
-        // Collect files from target
-        const fs = await import('fs');
-        const path = await import('path');
-        const targetPath = path.resolve(options.target);
-        let files = [];
-        if (fs.existsSync(targetPath)) {
-            if (fs.statSync(targetPath).isDirectory()) {
-                // Get TypeScript files recursively using fs
-                const walkDir = (dir, depth = 0) => {
-                    if (depth > 4)
-                        return []; // Max depth limit
-                    const result = [];
-                    const items = fs.readdirSync(dir);
-                    for (const item of items) {
-                        if (item === 'node_modules' || item === 'dist')
-                            continue;
-                        const fullPath = path.join(dir, item);
-                        const stat = fs.statSync(fullPath);
-                        if (stat.isDirectory()) {
-                            result.push(...walkDir(fullPath, depth + 1));
-                        }
-                        else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-                            result.push(fullPath);
-                        }
-                    }
-                    return result;
-                };
-                files = walkDir(targetPath);
-            }
-            else {
-                files = [targetPath];
-            }
-        }
-        if (files.length === 0) {
-            console.log(chalk.yellow('No files found to scan'));
-            return;
-        }
-        console.log(chalk.gray(`  Scanning ${files.length} files...\n`));
-        // Run SAST if requested
-        if (options.sast) {
-            console.log(chalk.blue('📋 SAST Scan:'));
-            const sastResult = await securityAPI.runSASTScan(files);
-            if (sastResult.success && sastResult.value) {
-                const result = sastResult.value;
-                const vulns = result.vulnerabilities || [];
-                if (vulns.length === 0) {
-                    console.log(chalk.green('  ✓ No vulnerabilities found'));
-                }
-                else {
-                    console.log(chalk.yellow(`  ⚠ Found ${vulns.length} potential issues:`));
-                    for (const v of vulns.slice(0, 10)) {
-                        const color = v.severity === 'high' ? chalk.red : v.severity === 'medium' ? chalk.yellow : chalk.gray;
-                        console.log(color(`    [${v.severity}] ${v.type}: ${v.file}:${v.line}`));
-                        console.log(chalk.gray(`           ${v.message}`));
-                    }
-                    if (vulns.length > 10) {
-                        console.log(chalk.gray(`    ... and ${vulns.length - 10} more`));
-                    }
-                }
-            }
-            else {
-                console.log(chalk.red(`  ✗ SAST failed: ${sastResult.error?.message || 'Unknown error'}`));
-            }
-            console.log('');
-        }
-        // Run compliance check if requested
-        if (options.compliance) {
-            const frameworks = options.compliance.split(',');
-            console.log(chalk.blue(`📜 Compliance Check (${frameworks.join(', ')}):`));
-            const compResult = await securityAPI.checkCompliance(frameworks);
-            if (compResult.success && compResult.value) {
-                const result = compResult.value;
-                if (result.compliant) {
-                    console.log(chalk.green('  ✓ Compliant with all frameworks'));
-                }
-                else {
-                    console.log(chalk.yellow('  ⚠ Compliance issues found:'));
-                    for (const issue of (result.issues || []).slice(0, 5)) {
-                        console.log(chalk.yellow(`    [${issue.framework}] ${issue.issue}`));
-                    }
-                }
-            }
-            else {
-                console.log(chalk.red(`  ✗ Compliance check failed: ${compResult.error?.message || 'Unknown error'}`));
-            }
-            console.log('');
-        }
-        // DAST note
-        if (options.dast) {
-            console.log(chalk.gray('Note: DAST requires running application URLs. Use --target with URLs for DAST scanning.'));
-        }
-        console.log(chalk.green('✅ Security scan complete\n'));
-        await cleanupAndExit(0);
-    }
-    catch (err) {
-        console.error(chalk.red('\n❌ Failed:'), err);
-        await cleanupAndExit(1);
-    }
-});
-// aqe code (code intelligence)
-program
-    .command('code')
-    .description('Code intelligence analysis')
-    .argument('<action>', 'Action (index|search|impact|deps)')
-    .argument('[target]', 'Target path or query')
-    .option('--depth <depth>', 'Analysis depth', '3')
-    .option('--include-tests', 'Include test files')
-    .action(async (action, target, options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        // Get code intelligence domain API directly (with lazy loading support)
-        const codeAPI = await context.kernel.getDomainAPIAsync('code-intelligence');
-        if (!codeAPI) {
-            console.log(chalk.red('❌ Code intelligence domain not available'));
-            return;
-        }
-        const fs = await import('fs');
-        const path = await import('path');
-        if (action === 'index') {
-            console.log(chalk.blue(`\n🗂️  Indexing codebase at ${target || '.'}...\n`));
-            const targetPath = path.resolve(target || '.');
-            let paths = [];
-            if (fs.existsSync(targetPath)) {
-                if (fs.statSync(targetPath).isDirectory()) {
-                    const walkDir = (dir, depth = 0) => {
-                        if (depth > 4)
-                            return [];
-                        const result = [];
-                        const items = fs.readdirSync(dir);
-                        for (const item of items) {
-                            if (item === 'node_modules' || item === 'dist')
-                                continue;
-                            const fullPath = path.join(dir, item);
-                            const stat = fs.statSync(fullPath);
-                            if (stat.isDirectory()) {
-                                result.push(...walkDir(fullPath, depth + 1));
-                            }
-                            else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-                                result.push(fullPath);
-                            }
-                        }
-                        return result;
-                    };
-                    paths = walkDir(targetPath);
-                }
-                else {
-                    paths = [targetPath];
-                }
-            }
-            console.log(chalk.gray(`  Found ${paths.length} files to index...\n`));
-            const result = await codeAPI.index({
-                paths,
-                incremental: false,
-                includeTests: options.includeTests || false,
-            });
-            if (result.success && result.value) {
-                const idx = result.value;
-                console.log(chalk.green(`✅ Indexing complete\n`));
-                console.log(chalk.cyan('  Results:'));
-                console.log(`    Files indexed: ${chalk.white(idx.filesIndexed)}`);
-                console.log(`    Nodes created: ${chalk.white(idx.nodesCreated)}`);
-                console.log(`    Edges created: ${chalk.white(idx.edgesCreated)}`);
-                console.log(`    Duration: ${chalk.yellow(idx.duration + 'ms')}`);
-                if (idx.errors.length > 0) {
-                    console.log(chalk.red(`\n  Errors (${idx.errors.length}):`));
-                    for (const err of idx.errors.slice(0, 5)) {
-                        console.log(chalk.red(`    ${err.file}: ${err.error}`));
-                    }
-                }
-            }
-            else {
-                console.log(chalk.red(`❌ Failed: ${result.error?.message || 'Unknown error'}`));
-            }
-        }
-        else if (action === 'search') {
-            if (!target) {
-                console.log(chalk.red('❌ Search query required'));
-                return;
-            }
-            console.log(chalk.blue(`\n🔎 Searching for: "${target}"...\n`));
-            const result = await codeAPI.search({
-                query: target,
-                type: 'semantic',
-                limit: 10,
-            });
-            if (result.success && result.value) {
-                const search = result.value;
-                console.log(chalk.green(`✅ Found ${search.total} results (${search.searchTime}ms)\n`));
-                for (const r of search.results) {
-                    const filePath = r.file.replace(process.cwd() + '/', '');
-                    console.log(`  ${chalk.cyan(filePath)}${r.line ? ':' + r.line : ''}`);
-                    console.log(chalk.gray(`    ${r.snippet.slice(0, 100)}...`));
-                    console.log(chalk.gray(`    Score: ${(r.score * 100).toFixed(0)}%\n`));
-                }
-            }
-            else {
-                console.log(chalk.red(`❌ Failed: ${result.error?.message || 'Unknown error'}`));
-            }
-        }
-        else if (action === 'impact') {
-            console.log(chalk.blue(`\n📊 Analyzing impact for ${target || 'recent changes'}...\n`));
-            const targetPath = path.resolve(target || '.');
-            let changedFiles = [];
-            if (fs.existsSync(targetPath)) {
-                if (fs.statSync(targetPath).isFile()) {
-                    changedFiles = [targetPath];
-                }
-                else {
-                    // Get recently modified files (simulated)
-                    const walkDir = (dir, depth = 0) => {
-                        if (depth > 2)
-                            return [];
-                        const result = [];
-                        const items = fs.readdirSync(dir);
-                        for (const item of items) {
-                            if (item === 'node_modules' || item === 'dist')
-                                continue;
-                            const fullPath = path.join(dir, item);
-                            const stat = fs.statSync(fullPath);
-                            if (stat.isDirectory()) {
-                                result.push(...walkDir(fullPath, depth + 1));
-                            }
-                            else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-                                result.push(fullPath);
-                            }
-                        }
-                        return result;
-                    };
-                    changedFiles = walkDir(targetPath).slice(0, 10);
-                }
-            }
-            const result = await codeAPI.analyzeImpact({
-                changedFiles,
-                depth: parseInt(options.depth),
-                includeTests: options.includeTests || false,
-            });
-            if (result.success && result.value) {
-                const impact = result.value;
-                const riskColor = impact.riskLevel === 'high' ? chalk.red : impact.riskLevel === 'medium' ? chalk.yellow : chalk.green;
-                console.log(`  Risk Level: ${riskColor(impact.riskLevel)}\n`);
-                console.log(chalk.cyan(`  Direct Impact (${impact.directImpact.length} files):`));
-                for (const file of impact.directImpact.slice(0, 5)) {
-                    const filePath = file.file.replace(process.cwd() + '/', '');
-                    console.log(`    ${chalk.white(filePath)}`);
-                    console.log(chalk.gray(`      Reason: ${file.reason}, Risk: ${(file.riskScore * 100).toFixed(0)}%`));
-                }
-                if (impact.transitiveImpact.length > 0) {
-                    console.log(chalk.cyan(`\n  Transitive Impact (${impact.transitiveImpact.length} files):`));
-                    for (const file of impact.transitiveImpact.slice(0, 5)) {
-                        const filePath = file.file.replace(process.cwd() + '/', '');
-                        console.log(`    ${chalk.white(filePath)} (distance: ${file.distance})`);
-                    }
-                }
-                if (impact.impactedTests.length > 0) {
-                    console.log(chalk.cyan(`\n  Impacted Tests (${impact.impactedTests.length}):`));
-                    for (const test of impact.impactedTests.slice(0, 5)) {
-                        console.log(`    ${chalk.gray(test)}`);
-                    }
-                }
-                if (impact.recommendations.length > 0) {
-                    console.log(chalk.cyan('\n  Recommendations:'));
-                    for (const rec of impact.recommendations) {
-                        console.log(chalk.gray(`    • ${rec}`));
-                    }
-                }
-            }
-            else {
-                console.log(chalk.red(`❌ Failed: ${result.error?.message || 'Unknown error'}`));
-            }
-        }
-        else if (action === 'deps') {
-            console.log(chalk.blue(`\n🔗 Mapping dependencies for ${target || '.'}...\n`));
-            const targetPath = path.resolve(target || '.');
-            let files = [];
-            if (fs.existsSync(targetPath)) {
-                if (fs.statSync(targetPath).isFile()) {
-                    files = [targetPath];
-                }
-                else {
-                    const walkDir = (dir, depth = 0) => {
-                        if (depth > 2)
-                            return [];
-                        const result = [];
-                        const items = fs.readdirSync(dir);
-                        for (const item of items) {
-                            if (item === 'node_modules' || item === 'dist')
-                                continue;
-                            const fullPath = path.join(dir, item);
-                            const stat = fs.statSync(fullPath);
-                            if (stat.isDirectory()) {
-                                result.push(...walkDir(fullPath, depth + 1));
-                            }
-                            else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-                                result.push(fullPath);
-                            }
-                        }
-                        return result;
-                    };
-                    files = walkDir(targetPath).slice(0, 50);
-                }
-            }
-            const result = await codeAPI.mapDependencies({
-                files,
-                direction: 'both',
-                depth: parseInt(options.depth),
-            });
-            if (result.success && result.value) {
-                const deps = result.value;
-                console.log(chalk.cyan('  Dependency Metrics:'));
-                console.log(`    Nodes: ${chalk.white(deps.metrics.totalNodes)}`);
-                console.log(`    Edges: ${chalk.white(deps.metrics.totalEdges)}`);
-                console.log(`    Avg Degree: ${chalk.yellow(deps.metrics.avgDegree.toFixed(2))}`);
-                console.log(`    Max Depth: ${chalk.yellow(deps.metrics.maxDepth)}`);
-                console.log(`    Cyclomatic Complexity: ${chalk.yellow(deps.metrics.cyclomaticComplexity)}`);
-                if (deps.cycles.length > 0) {
-                    console.log(chalk.red(`\n  ⚠️  Circular Dependencies (${deps.cycles.length}):`));
-                    for (const cycle of deps.cycles.slice(0, 3)) {
-                        console.log(chalk.red(`    ${cycle.join(' → ')}`));
-                    }
-                }
-                console.log(chalk.cyan(`\n  Top Dependencies (by connections):`));
-                const sortedNodes = [...deps.nodes].sort((a, b) => (b.inDegree + b.outDegree) - (a.inDegree + a.outDegree));
-                for (const node of sortedNodes.slice(0, 8)) {
-                    const filePath = node.path.replace(process.cwd() + '/', '');
-                    console.log(`    ${chalk.white(filePath)}`);
-                    console.log(chalk.gray(`      In: ${node.inDegree}, Out: ${node.outDegree}, Type: ${node.type}`));
-                }
-            }
-            else {
-                console.log(chalk.red(`❌ Failed: ${result.error?.message || 'Unknown error'}`));
-            }
-        }
-        else {
-            console.log(chalk.red(`\n❌ Unknown action: ${action}`));
-            console.log(chalk.gray('  Available: index, search, impact, deps\n'));
-            await cleanupAndExit(1);
-        }
-        console.log('');
-        await cleanupAndExit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n❌ Failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Migrate Command - V2 to V3 Migration (ADR-048)
-// ============================================================================
-const migrateCmd = program
-    .command('migrate')
-    .description('V2-to-V3 migration tools with agent compatibility (ADR-048)');
-// Helper to check path existence
-const pathExists = (p) => {
-    try {
-        require('fs').accessSync(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-// migrate run - Main migration command (default behavior)
-migrateCmd
-    .command('run')
-    .description('Run full migration from v2 to v3')
-    .option('--dry-run', 'Preview migration without making changes')
-    .option('--backup', 'Create backup before migration (recommended)', true)
-    .option('--skip-memory', 'Skip memory database migration')
-    .option('--skip-patterns', 'Skip pattern migration')
-    .option('--skip-config', 'Skip configuration migration')
-    .option('--skip-agents', 'Skip agent name migration')
-    .option('--target <component>', 'Migrate specific component (agents, skills, config, memory)')
-    .option('--force', 'Force migration even if v3 already exists')
-    .action(async (options) => {
-    const fs = await import('fs');
-    const path = await import('path');
-    console.log(chalk.blue('\n🔄 Agentic QE v2 to v3 Migration (ADR-048)\n'));
-    const cwd = process.cwd();
-    const v2Dir = path.join(cwd, '.agentic-qe');
-    const v3Dir = path.join(cwd, '.aqe');
-    const claudeAgentDir = path.join(cwd, '.claude', 'agents');
-    // Step 1: Detect v2 installation
-    console.log(chalk.white('1. Detecting v2 installation...'));
-    const hasV2Dir = fs.existsSync(v2Dir);
-    const hasClaudeAgents = fs.existsSync(claudeAgentDir);
-    if (!hasV2Dir && !hasClaudeAgents) {
-        console.log(chalk.yellow('   ⚠ No v2 installation found'));
-        console.log(chalk.gray('   This might be a fresh project. Use `aqe init` instead.'));
-        await cleanupAndExit(0);
-    }
-    const v2Files = {
-        memoryDb: path.join(v2Dir, 'memory.db'),
-        config: path.join(v2Dir, 'config.json'),
-        patterns: path.join(v2Dir, 'patterns'),
-    };
-    const hasMemory = hasV2Dir && fs.existsSync(v2Files.memoryDb);
-    const hasConfig = hasV2Dir && fs.existsSync(v2Files.config);
-    const hasPatterns = hasV2Dir && fs.existsSync(v2Files.patterns);
-    // Detect v2 agents needing migration
-    const agentsToMigrate = [];
-    if (hasClaudeAgents) {
-        const files = fs.readdirSync(claudeAgentDir);
-        for (const file of files) {
-            if (file.endsWith('.md') && file.startsWith('qe-')) {
-                const agentName = file.replace('.md', '');
-                if (isDeprecatedAgent(agentName)) {
-                    agentsToMigrate.push(agentName);
-                }
-            }
-        }
-    }
-    console.log(chalk.green('   ✓ Found v2 installation:'));
-    console.log(chalk.gray(`     Memory DB: ${hasMemory ? '✓' : '✗'}`));
-    console.log(chalk.gray(`     Config: ${hasConfig ? '✓' : '✗'}`));
-    console.log(chalk.gray(`     Patterns: ${hasPatterns ? '✓' : '✗'}`));
-    console.log(chalk.gray(`     Agents to migrate: ${agentsToMigrate.length}\n`));
-    // Step 2: Check v3 existence
-    console.log(chalk.white('2. Checking v3 status...'));
-    if (fs.existsSync(v3Dir) && !options.force) {
-        console.log(chalk.yellow('   ⚠ v3 directory already exists at .aqe/'));
-        console.log(chalk.gray('   Use --force to overwrite existing v3 installation.'));
-        await cleanupAndExit(1);
-    }
-    console.log(chalk.green('   ✓ Ready for migration\n'));
-    // Dry run mode
-    if (options.dryRun) {
-        console.log(chalk.blue('📋 Dry Run - Migration Plan:\n'));
-        if (!options.skipMemory && hasMemory) {
-            const stats = fs.statSync(v2Files.memoryDb);
-            console.log(chalk.gray(`  • Migrate memory.db (${(stats.size / 1024).toFixed(1)} KB)`));
-        }
-        if (!options.skipConfig && hasConfig) {
-            console.log(chalk.gray('  • Convert config.json to v3 format'));
-        }
-        if (!options.skipPatterns && hasPatterns) {
-            const patternFiles = fs.readdirSync(v2Files.patterns);
-            console.log(chalk.gray(`  • Migrate ${patternFiles.length} pattern files`));
-        }
-        if (!options.skipAgents && agentsToMigrate.length > 0) {
-            console.log(chalk.gray(`  • Migrate ${agentsToMigrate.length} agent names:`));
-            for (const agent of agentsToMigrate) {
-                console.log(chalk.gray(`      ${agent} → ${resolveAgentName(agent)}`));
-            }
-        }
-        console.log(chalk.yellow('\n⚠ This is a dry run. No changes were made.'));
-        console.log(chalk.gray('Run without --dry-run to execute migration.\n'));
-        await cleanupAndExit(0);
-    }
-    // Step 3: Create backup
-    if (options.backup) {
-        console.log(chalk.white('3. Creating backup...'));
-        const backupDir = path.join(cwd, '.aqe-backup', `backup-${Date.now()}`);
-        try {
-            fs.mkdirSync(backupDir, { recursive: true });
-            const copyDir = (src, dest) => {
-                if (!fs.existsSync(src))
-                    return;
-                if (fs.statSync(src).isDirectory()) {
-                    fs.mkdirSync(dest, { recursive: true });
-                    for (const file of fs.readdirSync(src)) {
-                        copyDir(path.join(src, file), path.join(dest, file));
-                    }
-                }
-                else {
-                    fs.copyFileSync(src, dest);
-                }
-            };
-            if (hasV2Dir)
-                copyDir(v2Dir, path.join(backupDir, '.agentic-qe'));
-            if (hasClaudeAgents)
-                copyDir(claudeAgentDir, path.join(backupDir, '.claude', 'agents'));
-            console.log(chalk.green(`   ✓ Backup created at .aqe-backup/\n`));
-        }
-        catch (err) {
-            console.log(chalk.red(`   ✗ Backup failed: ${err}`));
-            await cleanupAndExit(1);
-        }
-    }
-    else {
-        console.log(chalk.yellow('3. Backup skipped (--no-backup)\n'));
-    }
-    // Step 4: Create v3 directory structure
-    if (!options.target || options.target === 'config' || options.target === 'memory') {
-        console.log(chalk.white('4. Creating v3 directory structure...'));
-        try {
-            fs.mkdirSync(v3Dir, { recursive: true });
-            fs.mkdirSync(path.join(v3Dir, 'agentdb'), { recursive: true });
-            fs.mkdirSync(path.join(v3Dir, 'reasoning-bank'), { recursive: true });
-            fs.mkdirSync(path.join(v3Dir, 'cache'), { recursive: true });
-            fs.mkdirSync(path.join(v3Dir, 'logs'), { recursive: true });
-            console.log(chalk.green('   ✓ Directory structure created\n'));
-        }
-        catch (err) {
-            console.log(chalk.red(`   ✗ Failed: ${err}\n`));
-            await cleanupAndExit(1);
-        }
-    }
-    // Step 5: Migrate memory database
-    if ((!options.target || options.target === 'memory') && !options.skipMemory && hasMemory) {
-        console.log(chalk.white('5. Migrating memory database...'));
-        try {
-            const destDb = path.join(v3Dir, 'agentdb', 'memory.db');
-            fs.copyFileSync(v2Files.memoryDb, destDb);
-            const indexFile = path.join(v3Dir, 'agentdb', 'index.json');
-            fs.writeFileSync(indexFile, JSON.stringify({
-                version: '3.0.0',
-                migratedFrom: 'v2',
-                migratedAt: new Date().toISOString(),
-                hnswEnabled: true,
-                vectorDimensions: 128,
-            }, null, 2));
-            const stats = fs.statSync(v2Files.memoryDb);
-            console.log(chalk.green(`   ✓ Memory database migrated (${(stats.size / 1024).toFixed(1)} KB)\n`));
-        }
-        catch (err) {
-            console.log(chalk.red(`   ✗ Migration failed: ${err}\n`));
-        }
-    }
-    else if (options.target && options.target !== 'memory') {
-        console.log(chalk.gray('5. Memory migration skipped (--target)\n'));
-    }
-    else if (options.skipMemory) {
-        console.log(chalk.yellow('5. Memory migration skipped\n'));
-    }
-    else {
-        console.log(chalk.gray('5. No memory database to migrate\n'));
-    }
-    // Step 6: Migrate configuration
-    if ((!options.target || options.target === 'config') && !options.skipConfig && hasConfig) {
-        console.log(chalk.white('6. Migrating configuration...'));
-        try {
-            const v2ConfigRaw = fs.readFileSync(v2Files.config, 'utf-8');
-            const v2Config = parseJsonFile(v2ConfigRaw, v2Files.config);
-            const v3Config = {
-                version: '3.0.0',
-                migratedFrom: v2Config.version || '2.x',
-                migratedAt: new Date().toISOString(),
-                kernel: { eventBus: 'in-memory', coordinator: 'queen' },
-                domains: {
-                    'test-generation': { enabled: true },
-                    'test-execution': { enabled: true },
-                    'coverage-analysis': { enabled: true, algorithm: 'hnsw', dimensions: 128 },
-                    'quality-assessment': { enabled: true },
-                    'defect-intelligence': { enabled: true },
-                    'requirements-validation': { enabled: true },
-                    'code-intelligence': { enabled: true },
-                    'security-compliance': { enabled: true },
-                    'contract-testing': { enabled: true },
-                    'visual-accessibility': { enabled: false },
-                    'chaos-resilience': { enabled: true },
-                    'learning-optimization': { enabled: true },
-                },
-                memory: {
-                    backend: 'hybrid',
-                    path: '.aqe/agentdb/',
-                    hnsw: { M: 16, efConstruction: 200 },
-                },
-                learning: {
-                    reasoningBank: true,
-                    sona: true,
-                    patternRetention: v2Config.learning?.patternRetention || 180,
-                },
-                v2Migration: {
-                    originalConfig: v2Config,
-                    migrationDate: new Date().toISOString(),
-                },
-            };
-            const destConfig = path.join(v3Dir, 'config.json');
-            fs.writeFileSync(destConfig, JSON.stringify(v3Config, null, 2));
-            console.log(chalk.green('   ✓ Configuration migrated\n'));
-        }
-        catch (err) {
-            console.log(chalk.red(`   ✗ Config migration failed: ${err}\n`));
-        }
-    }
-    else if (options.target && options.target !== 'config') {
-        console.log(chalk.gray('6. Config migration skipped (--target)\n'));
-    }
-    else if (options.skipConfig) {
-        console.log(chalk.yellow('6. Configuration migration skipped\n'));
-    }
-    else {
-        console.log(chalk.gray('6. No configuration to migrate\n'));
-    }
-    // Step 7: Migrate patterns
-    if ((!options.target || options.target === 'memory') && !options.skipPatterns && hasPatterns) {
-        console.log(chalk.white('7. Migrating patterns to ReasoningBank...'));
-        try {
-            const patternFiles = fs.readdirSync(v2Files.patterns);
-            let migratedCount = 0;
-            for (const file of patternFiles) {
-                const srcPath = path.join(v2Files.patterns, file);
-                const destPath = path.join(v3Dir, 'reasoning-bank', file);
-                if (fs.statSync(srcPath).isFile()) {
-                    fs.copyFileSync(srcPath, destPath);
-                    migratedCount++;
-                }
-            }
-            const indexPath = path.join(v3Dir, 'reasoning-bank', 'index.json');
-            fs.writeFileSync(indexPath, JSON.stringify({
-                version: '3.0.0',
-                migratedFrom: 'v2',
-                migratedAt: new Date().toISOString(),
-                patternCount: migratedCount,
-                hnswIndexed: false,
-            }, null, 2));
-            console.log(chalk.green(`   ✓ ${migratedCount} patterns migrated\n`));
-        }
-        catch (err) {
-            console.log(chalk.red(`   ✗ Pattern migration failed: ${err}\n`));
-        }
-    }
-    else if (options.skipPatterns) {
-        console.log(chalk.yellow('7. Pattern migration skipped\n'));
-    }
-    else {
-        console.log(chalk.gray('7. No patterns to migrate\n'));
-    }
-    // Step 8: Migrate agent names (ADR-048)
-    if ((!options.target || options.target === 'agents') && !options.skipAgents && agentsToMigrate.length > 0) {
-        console.log(chalk.white('8. Migrating agent names (ADR-048)...'));
-        let migratedAgents = 0;
-        const deprecatedDir = path.join(claudeAgentDir, 'deprecated');
-        // Create deprecated directory for old agents
-        if (!fs.existsSync(deprecatedDir)) {
-            fs.mkdirSync(deprecatedDir, { recursive: true });
-        }
-        for (const v2Name of agentsToMigrate) {
-            const v3Name = resolveAgentName(v2Name);
-            const v2FilePath = path.join(claudeAgentDir, `${v2Name}.md`);
-            const v3FilePath = path.join(claudeAgentDir, `${v3Name}.md`);
-            const deprecatedPath = path.join(deprecatedDir, `${v2Name}.md.v2`);
-            try {
-                // Read the original file
-                const content = fs.readFileSync(v2FilePath, 'utf-8');
-                // Parse frontmatter (between first two ---)
-                const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-                if (!frontmatterMatch) {
-                    console.log(chalk.yellow(`   ⚠ ${v2Name}: No frontmatter found, skipping`));
-                    continue;
-                }
-                const frontmatter = frontmatterMatch[1];
-                const bodyStart = content.indexOf('---', 4) + 4; // After second ---
-                let body = content.slice(bodyStart);
-                // Update frontmatter: change name and add v2_compat
-                let newFrontmatter = frontmatter.replace(/^name:\s*.+$/m, `name: ${v3Name}`);
-                // Add v2_compat field if not present
-                if (!newFrontmatter.includes('v2_compat:')) {
-                    newFrontmatter += `\nv2_compat:\n  name: ${v2Name}\n  deprecated_in: "3.0.0"\n  removed_in: "4.0.0"`;
-                }
-                // Update body content: replace old agent name references
-                // Convert kebab-case to Title Case for display names
-                const toTitleCase = (s) => s.replace('qe-', '').split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
-                const v2DisplayName = toTitleCase(v2Name);
-                const v3DisplayName = toTitleCase(v3Name);
-                // Replace display names in body (e.g., "Test Generator" → "Test Architect")
-                body = body.replace(new RegExp(v2DisplayName, 'g'), v3DisplayName);
-                // Replace kebab-case references (e.g., "qe-test-generator" → "qe-test-architect")
-                body = body.replace(new RegExp(v2Name, 'g'), v3Name);
-                // Create new content
-                const newContent = `---\n${newFrontmatter}\n---${body}`;
-                // Write new v3 agent file
-                fs.writeFileSync(v3FilePath, newContent, 'utf-8');
-                // Move old file to deprecated folder
-                fs.renameSync(v2FilePath, deprecatedPath);
-                console.log(chalk.gray(`   ${v2Name} → ${v3Name}`));
-                migratedAgents++;
-            }
-            catch (err) {
-                console.log(chalk.red(`   ✗ ${v2Name}: ${err}`));
-            }
-        }
-        if (migratedAgents > 0) {
-            console.log(chalk.green(`   ✓ ${migratedAgents} agents migrated`));
-            console.log(chalk.gray(`   Old files archived to: ${deprecatedDir}\n`));
-        }
-        else {
-            console.log(chalk.yellow('   ⚠ No agents were migrated\n'));
-        }
-    }
-    else if (options.skipAgents) {
-        console.log(chalk.yellow('8. Agent migration skipped\n'));
-    }
-    else {
-        console.log(chalk.gray('8. No agents need migration\n'));
-    }
-    // Step 9: Validation
-    console.log(chalk.white('9. Validating migration...'));
-    const validationResults = {
-        v3DirExists: fs.existsSync(v3Dir),
-        configExists: fs.existsSync(path.join(v3Dir, 'config.json')),
-        agentdbExists: fs.existsSync(path.join(v3Dir, 'agentdb')),
-        reasoningBankExists: fs.existsSync(path.join(v3Dir, 'reasoning-bank')),
-    };
-    const allValid = Object.values(validationResults).every(v => v);
-    if (allValid) {
-        console.log(chalk.green('   ✓ Migration validated successfully\n'));
-    }
-    else {
-        console.log(chalk.yellow('   ⚠ Some validations failed:'));
-        for (const [key, value] of Object.entries(validationResults)) {
-            console.log(chalk.gray(`     ${key}: ${value ? '✓' : '✗'}`));
-        }
-    }
-    // Summary
-    console.log(chalk.blue('═══════════════════════════════════════════════'));
-    console.log(chalk.green.bold('✅ Migration Complete!\n'));
-    console.log(chalk.white('Next steps:'));
-    console.log(chalk.gray('  1. Run `aqe migrate verify` to validate'));
-    console.log(chalk.gray('  2. Run `aqe migrate status` to check'));
-    console.log(chalk.gray('  3. Use `aqe migrate rollback` if needed\n'));
-    await cleanupAndExit(0);
-});
-// migrate status - Check migration status
-migrateCmd
-    .command('status')
-    .description('Check migration status of current project')
-    .option('--json', 'Output as JSON')
-    .action(async (options) => {
-    const fs = await import('fs');
-    const path = await import('path');
-    const cwd = process.cwd();
-    const v2Dir = path.join(cwd, '.agentic-qe');
-    const v3Dir = path.join(cwd, '.aqe');
-    const claudeAgentDir = path.join(cwd, '.claude', 'agents');
-    const isV2Project = fs.existsSync(v2Dir);
-    const isV3Project = fs.existsSync(v3Dir);
-    // Find agents needing migration
-    const agentsToMigrate = [];
-    const agentsMigrated = [];
-    if (fs.existsSync(claudeAgentDir)) {
-        const files = fs.readdirSync(claudeAgentDir);
-        for (const file of files) {
-            if (file.endsWith('.md') && file.startsWith('qe-')) {
-                const agentName = file.replace('.md', '');
-                if (isDeprecatedAgent(agentName)) {
-                    agentsToMigrate.push(agentName);
-                }
-                else if (v3Agents.includes(agentName)) {
-                    agentsMigrated.push(agentName);
-                }
-            }
-        }
-    }
-    const needsMigration = isV2Project && !isV3Project || agentsToMigrate.length > 0;
-    const status = {
-        version: '3.0.0',
-        isV2Project,
-        isV3Project,
-        needsMigration,
-        agentsToMigrate,
-        agentsMigrated,
-        components: [
-            { name: 'Data Directory', status: isV3Project ? 'migrated' : (isV2Project ? 'pending' : 'not-required') },
-            { name: 'Agent Names', status: agentsToMigrate.length === 0 ? 'migrated' : 'pending' },
-        ],
-    };
-    if (options.json) {
-        console.log(JSON.stringify(status, null, 2));
-        return;
-    }
-    console.log(chalk.bold('\n📊 Migration Status\n'));
-    console.log(`Version: ${chalk.cyan(status.version)}`);
-    console.log(`V2 Project: ${status.isV2Project ? chalk.yellow('Yes') : chalk.dim('No')}`);
-    console.log(`V3 Project: ${status.isV3Project ? chalk.green('Yes') : chalk.dim('No')}`);
-    console.log(`Needs Migration: ${status.needsMigration ? chalk.yellow('Yes') : chalk.green('No')}`);
-    console.log(chalk.bold('\n📦 Components\n'));
-    for (const comp of status.components) {
-        const color = comp.status === 'migrated' ? chalk.green : comp.status === 'pending' ? chalk.yellow : chalk.dim;
-        console.log(`  ${comp.name}: ${color(comp.status)}`);
-    }
-    if (agentsToMigrate.length > 0) {
-        console.log(chalk.bold('\n⚠️  Agents Needing Migration\n'));
-        for (const agent of agentsToMigrate) {
-            console.log(`  ${chalk.yellow(agent)} → ${chalk.green(resolveAgentName(agent))}`);
-        }
-    }
-    console.log();
-    await cleanupAndExit(0);
-});
-// migrate verify - Verify migration
-migrateCmd
-    .command('verify')
-    .description('Verify migration integrity')
-    .option('--fix', 'Attempt to fix issues automatically')
-    .action(async (options) => {
-    const fs = await import('fs');
-    const path = await import('path');
-    console.log(chalk.bold('\n🔍 Verifying Migration...\n'));
-    const cwd = process.cwd();
-    const v3Dir = path.join(cwd, '.aqe');
-    const claudeAgentDir = path.join(cwd, '.claude', 'agents');
-    // Find deprecated agents still in use
-    const deprecatedInUse = [];
-    if (fs.existsSync(claudeAgentDir)) {
-        const files = fs.readdirSync(claudeAgentDir);
-        for (const file of files) {
-            if (file.endsWith('.md') && file.startsWith('qe-')) {
-                const agentName = file.replace('.md', '');
-                if (isDeprecatedAgent(agentName)) {
-                    deprecatedInUse.push(agentName);
-                }
-            }
-        }
-    }
-    const checks = [
-        {
-            name: 'V3 Directory',
-            passed: fs.existsSync(v3Dir),
-            message: fs.existsSync(v3Dir) ? 'Exists' : 'Missing .aqe/',
-        },
-        {
-            name: 'Agent Compatibility',
-            passed: deprecatedInUse.length === 0,
-            message: deprecatedInUse.length === 0 ? 'All agents use v3 names' : `${deprecatedInUse.length} deprecated agents`,
-        },
-        {
-            name: 'Config Format',
-            passed: fs.existsSync(path.join(v3Dir, 'config.json')),
-            message: 'Valid v3 config',
-        },
-    ];
-    let allPassed = true;
-    for (const check of checks) {
-        const icon = check.passed ? chalk.green('✓') : chalk.red('✗');
-        const color = check.passed ? chalk.green : chalk.red;
-        console.log(`  ${icon} ${check.name}: ${color(check.message)}`);
-        if (!check.passed)
-            allPassed = false;
-    }
-    console.log();
-    if (allPassed) {
-        console.log(chalk.green('✅ All verification checks passed!\n'));
-    }
-    else {
-        console.log(chalk.yellow('⚠️  Some checks failed.'));
-        if (options.fix) {
-            console.log(chalk.dim('   Attempting automatic fixes...\n'));
-            let fixedCount = 0;
-            // Fix 1: Create v3 directory if missing
-            if (!fs.existsSync(v3Dir)) {
-                fs.mkdirSync(v3Dir, { recursive: true });
-                fs.mkdirSync(path.join(v3Dir, 'agentdb'), { recursive: true });
-                fs.mkdirSync(path.join(v3Dir, 'reasoning-bank'), { recursive: true });
-                fs.writeFileSync(path.join(v3Dir, 'config.json'), JSON.stringify({
-                    version: '3.0.0',
-                    createdAt: new Date().toISOString(),
-                    autoCreated: true,
-                }, null, 2));
-                console.log(chalk.green('   ✓ Created .aqe/ directory structure'));
-                fixedCount++;
-            }
-            // Fix 2: Migrate deprecated agents
-            if (deprecatedInUse.length > 0) {
-                const deprecatedDir = path.join(claudeAgentDir, 'deprecated');
-                if (!fs.existsSync(deprecatedDir)) {
-                    fs.mkdirSync(deprecatedDir, { recursive: true });
-                }
-                for (const v2Name of deprecatedInUse) {
-                    const v3Name = resolveAgentName(v2Name);
-                    const v2FilePath = path.join(claudeAgentDir, `${v2Name}.md`);
-                    const v3FilePath = path.join(claudeAgentDir, `${v3Name}.md`);
-                    const deprecatedPath = path.join(deprecatedDir, `${v2Name}.md.v2`);
-                    try {
-                        const content = fs.readFileSync(v2FilePath, 'utf-8');
-                        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-                        if (frontmatterMatch) {
-                            const frontmatter = frontmatterMatch[1];
-                            const bodyStart = content.indexOf('---', 4) + 4;
-                            let body = content.slice(bodyStart);
-                            let newFrontmatter = frontmatter.replace(/^name:\s*.+$/m, `name: ${v3Name}`);
-                            if (!newFrontmatter.includes('v2_compat:')) {
-                                newFrontmatter += `\nv2_compat:\n  name: ${v2Name}\n  deprecated_in: "3.0.0"\n  removed_in: "4.0.0"`;
-                            }
-                            // Update body content: replace old agent name references
-                            const toTitleCase = (s) => s.replace('qe-', '').split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
-                            body = body.replace(new RegExp(toTitleCase(v2Name), 'g'), toTitleCase(v3Name));
-                            body = body.replace(new RegExp(v2Name, 'g'), v3Name);
-                            const newContent = `---\n${newFrontmatter}\n---${body}`;
-                            fs.writeFileSync(v3FilePath, newContent, 'utf-8');
-                            fs.renameSync(v2FilePath, deprecatedPath);
-                            console.log(chalk.green(`   ✓ Migrated ${v2Name} → ${v3Name}`));
-                            fixedCount++;
-                        }
-                    }
-                    catch (err) {
-                        console.log(chalk.red(`   ✗ Failed to migrate ${v2Name}: ${err}`));
-                    }
-                }
-            }
-            if (fixedCount > 0) {
-                console.log(chalk.green(`\n✅ Applied ${fixedCount} fixes. Re-run 'aqe migrate verify' to confirm.\n`));
-            }
-            else {
-                console.log(chalk.yellow('\n⚠️  No automatic fixes available for remaining issues.\n'));
-            }
-        }
-        else {
-            console.log(chalk.dim('   Run with --fix to attempt fixes.\n'));
-        }
-    }
-    await cleanupAndExit(0);
-});
-// migrate rollback - Rollback migration
-migrateCmd
-    .command('rollback')
-    .description('Rollback to previous version from backup')
-    .option('--backup-id <id>', 'Specific backup to restore')
-    .option('--force', 'Skip confirmation')
-    .action(async (options) => {
-    const fs = await import('fs');
-    const path = await import('path');
-    const cwd = process.cwd();
-    const backupRoot = path.join(cwd, '.aqe-backup');
-    if (!fs.existsSync(backupRoot)) {
-        console.log(chalk.yellow('\n⚠️  No backups found.\n'));
-        return;
-    }
-    const backups = fs.readdirSync(backupRoot)
-        .filter(f => f.startsWith('backup-'))
-        .sort()
-        .reverse();
-    if (backups.length === 0) {
-        console.log(chalk.yellow('\n⚠️  No backups found.\n'));
-        return;
-    }
-    console.log(chalk.bold('\n📦 Available Backups\n'));
-    for (const backup of backups.slice(0, 5)) {
-        const timestamp = backup.replace('backup-', '');
-        const date = new Date(parseInt(timestamp));
-        console.log(`  ${chalk.cyan(backup)} - ${date.toLocaleString()}`);
-    }
-    const targetBackup = options.backupId || backups[0];
-    const backupPath = path.join(backupRoot, targetBackup);
-    if (!fs.existsSync(backupPath)) {
-        console.log(chalk.red(`\n❌ Backup not found: ${targetBackup}\n`));
-        await cleanupAndExit(1);
-    }
-    if (!options.force) {
-        console.log(chalk.yellow(`\n⚠️  This will restore from: ${targetBackup}`));
-        console.log(chalk.dim('   Run with --force to confirm.\n'));
-        return;
-    }
-    console.log(chalk.bold(`\n🔄 Rolling back to ${targetBackup}...\n`));
-    // Restore backup
-    const v2Backup = path.join(backupPath, '.agentic-qe');
-    const agentsBackup = path.join(backupPath, '.claude', 'agents');
-    if (fs.existsSync(v2Backup)) {
-        const v2Dir = path.join(cwd, '.agentic-qe');
-        fs.cpSync(v2Backup, v2Dir, { recursive: true });
-        console.log(chalk.dim('  Restored .agentic-qe/'));
-    }
-    if (fs.existsSync(agentsBackup)) {
-        const agentsDir = path.join(cwd, '.claude', 'agents');
-        fs.cpSync(agentsBackup, agentsDir, { recursive: true });
-        console.log(chalk.dim('  Restored .claude/agents/'));
-    }
-    // Remove v3 directory
-    const v3Dir = path.join(cwd, '.aqe');
-    if (fs.existsSync(v3Dir)) {
-        fs.rmSync(v3Dir, { recursive: true, force: true });
-        console.log(chalk.dim('  Removed .aqe/'));
-    }
-    console.log(chalk.green('\n✅ Rollback complete!\n'));
-    await cleanupAndExit(0);
-});
-// migrate mapping - Show agent name mappings
-migrateCmd
-    .command('mapping')
-    .description('Show v2 to v3 agent name mappings (ADR-048)')
-    .option('--json', 'Output as JSON')
-    .action(async (options) => {
-    if (options.json) {
-        console.log(JSON.stringify(v2AgentMapping, null, 2));
-        return;
-    }
-    console.log(chalk.bold('\n🔄 Agent Name Mappings (V2 → V3)\n'));
-    const entries = Object.entries(v2AgentMapping);
-    for (const [v2Name, v3Name] of entries) {
-        console.log(`  ${chalk.yellow(v2Name)} → ${chalk.green(v3Name)}`);
-    }
-    console.log(chalk.dim(`\n  Total: ${entries.length} mappings\n`));
-    console.log(chalk.gray('  See ADR-048 for full migration strategy.\n'));
-    await cleanupAndExit(0);
-});
-// ============================================================================
-// Completions Command
-// ============================================================================
-const completionsCmd = program
-    .command('completions')
-    .description('Generate shell completions for aqe');
-completionsCmd
-    .command('bash')
-    .description('Generate Bash completion script')
-    .action(() => {
-    console.log(generateCompletion('bash'));
-});
-completionsCmd
-    .command('zsh')
-    .description('Generate Zsh completion script')
-    .action(() => {
-    console.log(generateCompletion('zsh'));
-});
-completionsCmd
-    .command('fish')
-    .description('Generate Fish completion script')
-    .action(() => {
-    console.log(generateCompletion('fish'));
-});
-completionsCmd
-    .command('powershell')
-    .description('Generate PowerShell completion script')
-    .action(() => {
-    console.log(generateCompletion('powershell'));
-});
-completionsCmd
-    .command('install')
-    .description('Auto-install completions for current shell')
-    .option('-s, --shell <shell>', 'Target shell (bash|zsh|fish|powershell)')
-    .action(async (options) => {
-    const fs = await import('fs');
-    const path = await import('path');
-    const shellInfo = options.shell
-        ? { name: options.shell, configFile: null, detected: false }
-        : detectShell();
-    if (shellInfo.name === 'unknown') {
-        console.log(chalk.red('Could not detect shell. Please specify with --shell option.\n'));
-        console.log(getInstallInstructions('unknown'));
-        await cleanupAndExit(1);
-        return; // TypeScript flow control hint - cleanupAndExit exits but TS doesn't know
-    }
-    console.log(chalk.blue(`\nInstalling completions for ${shellInfo.name}...\n`));
-    const script = generateCompletion(shellInfo.name);
-    // For Fish, write directly to completions directory
-    if (shellInfo.name === 'fish') {
-        const fishCompletionsDir = `${process.env.HOME}/.config/fish/completions`;
-        try {
-            fs.mkdirSync(fishCompletionsDir, { recursive: true });
-            const completionFile = path.join(fishCompletionsDir, 'aqe.fish');
-            fs.writeFileSync(completionFile, script);
-            console.log(chalk.green(`Completions installed to: ${completionFile}`));
-            console.log(chalk.gray('\nRestart your shell or run: source ~/.config/fish/completions/aqe.fish\n'));
-        }
-        catch (err) {
-            console.log(chalk.red(`Failed to install: ${err}`));
-            console.log(chalk.yellow('\nManual installation:'));
-            console.log(getInstallInstructions('fish'));
-        }
-    }
-    else {
-        // For other shells, show instructions
-        console.log(chalk.yellow('To install completions, follow these instructions:\n'));
-        console.log(getInstallInstructions(shellInfo.name));
-        console.log(chalk.gray('\n---\nCompletion script:\n'));
-        console.log(script);
-    }
-});
-completionsCmd
-    .command('list')
-    .description('List all completion values (domains, agents, etc.)')
-    .option('-t, --type <type>', 'Type to list (domains|agents|v3-qe-agents)', 'all')
-    .action((options) => {
-    if (options.type === 'domains' || options.type === 'all') {
-        console.log(chalk.blue('\n12 DDD Domains:'));
-        COMPLETION_DOMAINS.forEach(d => console.log(chalk.gray(`  ${d}`)));
-    }
-    if (options.type === 'v3-qe-agents' || options.type === 'all') {
-        console.log(chalk.blue('\nQE Agents (' + QE_AGENTS.length + '):'));
-        QE_AGENTS.forEach(a => console.log(chalk.gray(`  ${a}`)));
-    }
-    if (options.type === 'agents' || options.type === 'all') {
-        console.log(chalk.blue('\nOther Agents (' + OTHER_AGENTS.length + '):'));
-        OTHER_AGENTS.forEach(a => console.log(chalk.gray(`  ${a}`)));
-    }
-    console.log('');
-});
+import { createTestCommand } from './commands/test.js';
+import { createCoverageCommand } from './commands/coverage.js';
+import { createQualityCommand } from './commands/quality.js';
+import { createSecurityCommand } from './commands/security.js';
+import { createCodeCommand } from './commands/code.js';
+import { createMigrateCommand } from './commands/migrate.js';
+import { createCompletionsCommand } from './commands/completions.js';
+import { createFleetCommand } from './commands/fleet.js';
+// Register shortcut commands
+program.addCommand(createTestCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createCoverageCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createQualityCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createSecurityCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createCodeCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createMigrateCommand(context, cleanupAndExit, ensureInitialized));
+program.addCommand(createCompletionsCommand(cleanupAndExit));
+program.addCommand(createFleetCommand(context, cleanupAndExit, ensureInitialized, registerDomainWorkflowActions));
 // ============================================================================
-// Fleet Command Group - Multi-agent operations with progress
-// ============================================================================
-const fleetCmd = program
-    .command('fleet')
-    .description('Fleet operations with multi-agent progress tracking');
-// Fleet init with wizard (ADR-041)
-fleetCmd
-    .command('init')
-    .description('Initialize fleet with interactive wizard')
-    .option('--wizard', 'Run interactive fleet initialization wizard')
-    .option('-t, --topology <type>', 'Fleet topology (hierarchical|mesh|ring|adaptive|hierarchical-mesh)', 'hierarchical-mesh')
-    .option('-m, --max-agents <count>', 'Maximum agent count (5-50)', '15')
-    .option('-d, --domains <domains>', 'Domains to enable (comma-separated or "all")', 'all')
-    .option('--memory <backend>', 'Memory backend (sqlite|agentdb|hybrid)', 'hybrid')
-    .option('--lazy', 'Enable lazy loading', true)
-    .option('--skip-patterns', 'Skip loading pre-trained patterns')
-    .option('--skip-code-scan', 'Skip code intelligence index check')
-    .action(async (options) => {
-    try {
-        let topology = options.topology;
-        let maxAgents = parseInt(options.maxAgents, 10);
-        let domains = options.domains;
-        let memoryBackend = options.memory;
-        let lazyLoading = options.lazy;
-        let loadPatterns = !options.skipPatterns;
-        // CI-005: Check code intelligence index before fleet initialization
-        console.log(chalk.blue('\n 🧠 Code Intelligence Check\n'));
-        const ciResult = await integrateCodeIntelligence(process.cwd(), {
-            skipCodeScan: options.skipCodeScan,
-            nonInteractive: !options.wizard, // Only prompt in wizard mode
-        });
-        // If user requested scan, exit and let them run it
-        if (!ciResult.shouldProceed) {
-            console.log(chalk.blue('\n  Please run the code intelligence scan first:'));
-            console.log(chalk.cyan('    aqe code-intelligence index\n'));
-            console.log(chalk.gray('  Then re-run fleet init when ready.\n'));
-            await cleanupAndExit(0);
-            return;
-        }
-        // Run wizard if requested (ADR-041)
-        if (options.wizard) {
-            console.log(chalk.blue('\n🚀 Fleet Initialization Wizard\n'));
-            const wizardResult = await runFleetInitWizard({
-                defaultTopology: options.topology !== 'hierarchical-mesh' ? options.topology : undefined,
-                defaultMaxAgents: options.maxAgents !== '15' ? parseInt(options.maxAgents, 10) : undefined,
-                defaultDomains: options.domains !== 'all' ? options.domains.split(',') : undefined,
-                defaultMemoryBackend: options.memory !== 'hybrid' ? options.memory : undefined,
-            });
-            if (wizardResult.cancelled) {
-                console.log(chalk.yellow('\n  Fleet initialization cancelled.\n'));
-                await cleanupAndExit(0);
-            }
-            // Use wizard results
-            topology = wizardResult.topology;
-            maxAgents = wizardResult.maxAgents;
-            domains = wizardResult.domains.join(',');
-            memoryBackend = wizardResult.memoryBackend;
-            lazyLoading = wizardResult.lazyLoading;
-            loadPatterns = wizardResult.loadPatterns;
-            console.log(chalk.green('\n  Starting fleet initialization...\n'));
-        }
-        // Parse domains
-        const enabledDomains = domains === 'all'
-            ? [...ALL_DOMAINS]
-            : domains.split(',').filter((d) => ALL_DOMAINS.includes(d));
-        console.log(chalk.blue('\n Fleet Configuration\n'));
-        console.log(chalk.gray(`  Topology: ${topology}`));
-        console.log(chalk.gray(`  Max Agents: ${maxAgents}`));
-        console.log(chalk.gray(`  Domains: ${enabledDomains.length}`));
-        console.log(chalk.gray(`  Memory: ${memoryBackend}`));
-        console.log(chalk.gray(`  Lazy Loading: ${lazyLoading ? 'enabled' : 'disabled'}`));
-        console.log(chalk.gray(`  Pre-trained Patterns: ${loadPatterns ? 'load' : 'skip'}\n`));
-        // Initialize if not already done
-        if (!context.initialized) {
-            context.kernel = new QEKernelImpl({
-                maxConcurrentAgents: maxAgents,
-                memoryBackend,
-                hnswEnabled: true,
-                lazyLoading,
-                enabledDomains,
-            });
-            await context.kernel.initialize();
-            console.log(chalk.green('  ✓ Kernel initialized'));
-            context.router = new CrossDomainEventRouter(context.kernel.eventBus);
-            await context.router.initialize();
-            console.log(chalk.green('  ✓ Cross-domain router initialized'));
-            context.workflowOrchestrator = new WorkflowOrchestrator(context.kernel.eventBus, context.kernel.memory, context.kernel.coordinator);
-            await context.workflowOrchestrator.initialize();
-            console.log(chalk.green('  ✓ Workflow orchestrator initialized'));
-            context.persistentScheduler = createPersistentScheduler();
-            console.log(chalk.green('  ✓ Persistent scheduler initialized'));
-            const getDomainAPI = (domain) => {
-                return context.kernel.getDomainAPI(domain);
-            };
-            const protocolExecutor = new DefaultProtocolExecutor(context.kernel.eventBus, context.kernel.memory, getDomainAPI);
-            context.queen = createQueenCoordinator(context.kernel, context.router, protocolExecutor, undefined);
-            await context.queen.initialize();
-            console.log(chalk.green('  ✓ Queen coordinator initialized'));
-            context.initialized = true;
-        }
-        console.log(chalk.green('\n✅ Fleet initialized successfully!\n'));
-        console.log(chalk.white('Next steps:'));
-        console.log(chalk.gray('  1. Spawn agents: aqe fleet spawn --domains test-generation'));
-        console.log(chalk.gray('  2. Run operation: aqe fleet run test --target ./src'));
-        console.log(chalk.gray('  3. Check status: aqe fleet status\n'));
-        await cleanupAndExit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n Fleet initialization failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-fleetCmd
-    .command('spawn')
-    .description('Spawn multiple agents with progress tracking')
-    .option('-d, --domains <domains>', 'Comma-separated domains', 'test-generation,coverage-analysis')
-    .option('-t, --type <type>', 'Agent type for all', 'worker')
-    .option('-c, --count <count>', 'Number of agents per domain', '1')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const domains = options.domains.split(',');
-        const countPerDomain = parseInt(options.count, 10);
-        console.log(chalk.blue('\n Fleet Spawn Operation\n'));
-        // Create fleet progress manager
-        const progress = new FleetProgressManager({
-            title: 'Agent Spawn Progress',
-            showEta: true,
-        });
-        const totalAgents = domains.length * countPerDomain;
-        progress.start(totalAgents);
-        // Track spawned agents
-        const spawnedAgents = [];
-        let agentIndex = 0;
-        // Spawn agents across domains
-        for (const domain of domains) {
-            for (let i = 0; i < countPerDomain; i++) {
-                const agentName = `${domain}-${options.type}-${i + 1}`;
-                const agentId = `agent-${agentIndex++}`;
-                // Add agent to progress tracker
-                progress.addAgent({
-                    id: agentId,
-                    name: agentName,
-                    status: 'pending',
-                    progress: 0,
-                });
-                // Update to running
-                progress.updateAgent(agentId, 10, { status: 'running' });
-                try {
-                    // Spawn the agent
-                    progress.updateAgent(agentId, 30, { message: 'Initializing...' });
-                    const result = await context.queen.requestAgentSpawn(domain, options.type, ['general']);
-                    progress.updateAgent(agentId, 80, { message: 'Configuring...' });
-                    if (result.success) {
-                        progress.completeAgent(agentId, true);
-                        spawnedAgents.push({ id: result.value, domain, success: true });
-                    }
-                    else {
-                        progress.completeAgent(agentId, false);
-                        spawnedAgents.push({ id: agentId, domain, success: false });
-                    }
-                }
-                catch {
-                    progress.completeAgent(agentId, false);
-                    spawnedAgents.push({ id: agentId, domain, success: false });
-                }
-            }
-        }
-        progress.stop();
-        // Summary
-        const successful = spawnedAgents.filter(a => a.success).length;
-        const failed = spawnedAgents.filter(a => !a.success).length;
-        console.log(chalk.blue('\n Fleet Summary:'));
-        console.log(chalk.gray(`   Domains: ${domains.join(', ')}`));
-        console.log(chalk.green(`   Successful: ${successful}`));
-        if (failed > 0) {
-            console.log(chalk.red(`   Failed: ${failed}`));
-        }
-        console.log('');
-        await cleanupAndExit(failed > 0 ? 1 : 0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n Fleet spawn failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-fleetCmd
-    .command('run')
-    .description('Run a coordinated fleet operation')
-    .argument('<operation>', 'Operation type (test|analyze|scan)')
-    .option('-t, --target <path>', 'Target path', '.')
-    .option('--parallel <count>', 'Number of parallel agents', '4')
-    .action(async (operation, options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const parallelCount = parseInt(options.parallel, 10);
-        console.log(chalk.blue(`\n Fleet Operation: ${operation}\n`));
-        // Create fleet progress manager
-        const progress = new FleetProgressManager({
-            title: `${operation.charAt(0).toUpperCase() + operation.slice(1)} Progress`,
-            showEta: true,
-        });
-        progress.start(parallelCount);
-        // Define agent operations based on operation type
-        const domainMap = {
-            test: 'test-generation',
-            analyze: 'coverage-analysis',
-            scan: 'security-compliance',
-        };
-        const domain = domainMap[operation] || 'test-generation';
-        // Create parallel agent operations
-        const agentOperations = Array.from({ length: parallelCount }, (_, i) => {
-            const agentId = `${operation}-agent-${i + 1}`;
-            return {
-                id: agentId,
-                name: `${operation}-worker-${i + 1}`,
-                domain,
-            };
-        });
-        // Add all agents to progress
-        for (const op of agentOperations) {
-            progress.addAgent({
-                id: op.id,
-                name: op.name,
-                status: 'pending',
-                progress: 0,
-            });
-        }
-        // Execute operations in parallel with progress updates
-        const results = await Promise.all(agentOperations.map(async (op, index) => {
-            // Simulate staggered start
-            await new Promise(resolve => setTimeout(resolve, index * 200));
-            progress.updateAgent(op.id, 0, { status: 'running' });
-            try {
-                // Simulate operation phases with progress updates
-                for (let p = 10; p <= 90; p += 20) {
-                    await new Promise(resolve => setTimeout(resolve, 300 + Math.random() * 200));
-                    progress.updateAgent(op.id, p, {
-                        eta: Math.round((100 - p) * 50),
-                    });
-                }
-                // Submit actual task
-                const taskResult = await context.queen.submitTask({
-                    type: operation === 'test' ? 'generate-tests' :
-                        operation === 'analyze' ? 'analyze-coverage' :
-                            'scan-security',
-                    priority: 'p1',
-                    targetDomains: [domain],
-                    payload: { target: options.target, workerId: op.id },
-                    timeout: 60000,
-                });
-                progress.completeAgent(op.id, taskResult.success);
-                return { id: op.id, success: taskResult.success };
-            }
-            catch {
-                progress.completeAgent(op.id, false);
-                return { id: op.id, success: false };
-            }
-        }));
-        progress.stop();
-        // Summary
-        const successful = results.filter(r => r.success).length;
-        const failed = results.filter(r => !r.success).length;
-        console.log(chalk.blue('\n Operation Summary:'));
-        console.log(chalk.gray(`   Operation: ${operation}`));
-        console.log(chalk.gray(`   Target: ${options.target}`));
-        console.log(chalk.green(`   Successful: ${successful}`));
-        if (failed > 0) {
-            console.log(chalk.red(`   Failed: ${failed}`));
-        }
-        console.log('');
-        await cleanupAndExit(failed > 0 ? 1 : 0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n Fleet operation failed:'), error);
-        await cleanupAndExit(1);
-    }
-});
-fleetCmd
-    .command('status')
-    .description('Show fleet status with agent progress')
-    .option('-w, --watch', 'Watch mode with live updates')
-    .action(async (options) => {
-    if (!await ensureInitialized())
-        return;
-    try {
-        const showStatus = async () => {
-            const health = context.queen.getHealth();
-            const metrics = context.queen.getMetrics();
-            console.log(chalk.blue('\n Fleet Status\n'));
-            // Overall fleet bar
-            const utilizationBar = '\u2588'.repeat(Math.min(Math.round(metrics.agentUtilization * 20), 20)) +
-                '\u2591'.repeat(Math.max(20 - Math.round(metrics.agentUtilization * 20), 0));
-            console.log(chalk.white(`Fleet Utilization ${chalk.cyan(utilizationBar)} ${(metrics.agentUtilization * 100).toFixed(0)}%`));
-            console.log('');
-            // Agent status by domain
-            console.log(chalk.white('Agent Progress:'));
-            for (const [domain, domainHealth] of health.domainHealth) {
-                const active = domainHealth.agents.active;
-                const total = domainHealth.agents.total;
-                const progressPercent = total > 0 ? Math.round((active / total) * 100) : 0;
-                const statusIcon = domainHealth.status === 'healthy' ? chalk.green('\u2713') :
-                    domainHealth.status === 'degraded' ? chalk.yellow('\u25B6') :
-                        chalk.red('\u2717');
-                const bar = '\u2588'.repeat(Math.round(progressPercent / 5)) +
-                    '\u2591'.repeat(20 - Math.round(progressPercent / 5));
-                console.log(`  ${domain.padEnd(28)} ${chalk.cyan(bar)} ${progressPercent.toString().padStart(3)}% ${statusIcon}`);
-            }
-            console.log('');
-            console.log(chalk.gray(`  Active: ${health.activeAgents}/${health.totalAgents} agents`));
-            console.log(chalk.gray(`  Tasks: ${health.runningTasks} running, ${health.pendingTasks} pending`));
-            console.log('');
-        };
-        if (options.watch) {
-            const spinner = createTimedSpinner('Watching fleet status (Ctrl+C to exit)');
-            // Initial display
-            spinner.spinner.stop();
-            await showStatus();
-            // Watch mode - update every 2 seconds
-            const interval = setInterval(async () => {
-                console.clear();
-                await showStatus();
-            }, 2000);
-            // Handle Ctrl+C - use once to avoid conflict with global handler
-            process.once('SIGINT', async () => {
-                clearInterval(interval);
-                console.log(chalk.yellow('\nStopped watching.'));
-                await cleanupAndExit(0);
-            });
-        }
-        else {
-            await showStatus();
-            await cleanupAndExit(0);
-        }
-    }
-    catch (error) {
-        console.error(chalk.red('\n Failed to get fleet status:'), error);
-        await cleanupAndExit(1);
-    }
-});
-// ============================================================================
-// Hooks Command (AQE v3 Independent Hooks - using QEHookRegistry)
+// External Command Modules
 // ============================================================================
+import { createTokenUsageCommand } from './commands/token-usage.js';
+import { createLLMRouterCommand } from './commands/llm-router.js';
+import { createSyncCommands } from './commands/sync.js';
 import { createHooksCommand } from './commands/hooks.js';
-// Register the hooks command from the proper module (uses QEHookRegistry)
-const hooksCmd = createHooksCommand();
-program.addCommand(hooksCmd);
-// Note: All hooks functionality is now in ./commands/hooks.ts which uses:
-// - QEHookRegistry for event handling
-// - QEReasoningBank for pattern learning
-// - setupQEHooks() for proper initialization
+program.addCommand(createTokenUsageCommand());
+program.addCommand(createLLMRouterCommand());
+program.addCommand(createSyncCommands());
+program.addCommand(createHooksCommand());
 // ============================================================================
 // Shutdown Handlers
 // ============================================================================
@@ -3166,7 +646,6 @@ process.on('SIGTERM', async () => {
 // Main
 // ============================================================================
 async function main() {
-    // ADR-042: Initialize token tracking and optimization
     await bootstrapTokenTracking({
         enableOptimization: true,
         enablePersistence: true,