claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/src/cli/commands/recovery-resume.js

@@ -0,0 +1,369 @@
+/**
+ * Recovery Resume CLI Command
+ *
+ * Interactive CLI for resuming interrupted CFN Loop executions.
+ * Provides user-friendly prompts for recovery mode selection and
+ * progress tracking during recovery process.
+ *
+ * Usage:
+ * ```bash
+ * claude-flow-novice recovery:resume
+ * claude-flow-novice recovery:resume --epic-id epic-123 --mode resume
+ * claude-flow-novice recovery:resume --list
+ * ```
+ *
+ * @module cli/commands/recovery-resume
+ */ import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { table } from "table";
+import { RecoveryEngine, RecoveryMode } from "../../cfn-loop/recovery-engine.js";
+import { CrashDetector } from "../../cfn-loop/crash-detector.js";
+import { StateCheckpointManager } from "../../cfn-loop/state-checkpoint-manager.js";
+import { createClient } from "redis";
+// ===== RECOVERY RESUME COMMAND =====
+/**
+ * Interactive recovery prompt
+ */ async function promptRecoveryMode(interrupted) {
+    console.log(chalk.bold('\n🔍 Interrupted Execution Detected\n'));
+    // Display execution details
+    console.log(table([
+        [
+            chalk.cyan('Epic ID'),
+            interrupted.epicId
+        ],
+        [
+            chalk.cyan('Epic Name'),
+            interrupted.epicName
+        ],
+        [
+            chalk.cyan('Last Heartbeat'),
+            new Date(interrupted.lastHeartbeat).toLocaleString()
+        ],
+        [
+            chalk.cyan('Time Since Heartbeat'),
+            formatDuration(interrupted.timeSinceHeartbeat)
+        ],
+        [
+            chalk.cyan('Sprints Completed'),
+            `${interrupted.sprintsCompleted} / ${interrupted.sprintsTotal}`
+        ],
+        [
+            chalk.cyan('Sprints In Progress'),
+            interrupted.sprintsInProgress.length.toString()
+        ],
+        [
+            chalk.cyan('Estimated Work Loss'),
+            `${interrupted.estimatedWorkLoss}%`
+        ],
+        [
+            chalk.cyan('Recovery Time Estimate'),
+            `${interrupted.recoveryTimeEstimate} minutes`
+        ],
+        [
+            chalk.cyan('Checkpoint Available'),
+            interrupted.checkpointVersion > 0 ? '✅ Yes' : '❌ No'
+        ],
+        [
+            chalk.cyan('Clean Shutdown'),
+            interrupted.isCleanShutdown ? '✅ Yes' : '⚠️  No (Crash)'
+        ]
+    ]));
+    // Show in-progress sprints
+    if (interrupted.sprintsInProgress.length > 0) {
+        console.log(chalk.bold('\n📊 In-Progress Sprints:\n'));
+        const sprintData = [
+            [
+                chalk.cyan('Sprint ID'),
+                chalk.cyan('Progress'),
+                chalk.cyan('Phases'),
+                chalk.cyan('Files')
+            ],
+            ...interrupted.sprintsInProgress.map((sprint)=>[
+                    sprint.sprintId,
+                    `${(sprint.progress * 100).toFixed(1)}%`,
+                    `${sprint.phasesCompleted} / ${sprint.phasesTotal}`,
+                    sprint.filesInProgress.length.toString()
+                ])
+        ];
+        console.log(table(sprintData));
+    }
+    // Prompt for recovery mode
+    const { mode } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'mode',
+            message: 'How would you like to proceed?',
+            choices: [
+                {
+                    name: `${chalk.green('Resume')} - Continue from last checkpoint (recommended)`,
+                    value: RecoveryMode.RESUME
+                },
+                {
+                    name: `${chalk.yellow('Inspect')} - View checkpoint state without resuming`,
+                    value: RecoveryMode.INSPECT
+                },
+                {
+                    name: `${chalk.red('Restart')} - Restart epic from beginning`,
+                    value: RecoveryMode.RESTART
+                },
+                {
+                    name: `${chalk.gray('Abandon')} - Clean up and exit`,
+                    value: RecoveryMode.ABANDON
+                }
+            ],
+            default: RecoveryMode.RESUME
+        }
+    ]);
+    return mode;
+}
+/**
+ * Format duration in milliseconds to human-readable string
+ */ function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    } else if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    } else {
+        return `${seconds}s`;
+    }
+}
+/**
+ * Display recovery progress
+ */ function displayRecoveryProgress(result) {
+    console.log(chalk.bold('\n✅ Recovery Completed\n'));
+    const statusIcon = result.success ? '✅' : '❌';
+    const statusColor = result.success ? chalk.green : chalk.red;
+    console.log(table([
+        [
+            chalk.cyan('Status'),
+            `${statusIcon} ${statusColor(result.success ? 'Success' : 'Failed')}`
+        ],
+        [
+            chalk.cyan('Mode'),
+            result.mode
+        ],
+        [
+            chalk.cyan('Duration'),
+            formatDuration(result.recoveryDurationMs)
+        ],
+        [
+            chalk.cyan('Sprints Resumed'),
+            result.sprintsResumed.length.toString()
+        ],
+        [
+            chalk.cyan('Sprints Skipped'),
+            result.sprintsSkipped.length.toString()
+        ],
+        [
+            chalk.cyan('Files Reconciled'),
+            result.filesReconciled.toString()
+        ],
+        [
+            chalk.cyan('Locks Restored'),
+            result.locksRestored.toString()
+        ],
+        [
+            chalk.cyan('Agents Resumed'),
+            result.agentsResumed.toString()
+        ],
+        [
+            chalk.cyan('Estimated Work Loss'),
+            `${result.estimatedWorkLoss}%`
+        ]
+    ]));
+    // Show sprints resumed
+    if (result.sprintsResumed.length > 0) {
+        console.log(chalk.bold('\n📊 Resumed Sprints:\n'));
+        result.sprintsResumed.forEach((sprintId, index)=>{
+            console.log(`  ${index + 1}. ${sprintId}`);
+        });
+    }
+    // Show errors if any
+    if (result.errors.length > 0) {
+        console.log(chalk.bold.red('\n⚠️  Errors During Recovery:\n'));
+        result.errors.forEach((error, index)=>{
+            console.log(chalk.red(`  ${index + 1}. ${error}`));
+        });
+    }
+    // Show next steps
+    if (result.success) {
+        console.log(chalk.bold.green('\n🎯 Next Steps:\n'));
+        if (result.mode === RecoveryMode.RESUME) {
+            console.log(chalk.green('  ✓ Execution resumed from checkpoint'));
+            console.log(chalk.green('  ✓ Monitor progress with: claude-flow-novice status'));
+            console.log(chalk.green('  ✓ View logs with: tail -f logs/cfn-loop.log'));
+        } else if (result.mode === RecoveryMode.RESTART) {
+            console.log(chalk.yellow('  ⚠  Epic restarted from beginning'));
+            console.log(chalk.yellow('  ⚠  Run: claude-flow-novice cfn-loop <epic-name>'));
+        } else if (result.mode === RecoveryMode.ABANDON) {
+            console.log(chalk.gray('  ✓ State cleaned up'));
+            console.log(chalk.gray('  ✓ Ready for new epic execution'));
+        }
+    }
+}
+/**
+ * List all interrupted executions
+ */ async function listInterruptedExecutions(detector) {
+    const spinner = ora('Scanning for interrupted executions...').start();
+    try {
+        const interrupted = await detector.detectInterruptedExecutions();
+        spinner.stop();
+        if (interrupted.length === 0) {
+            console.log(chalk.green('\n✓ No interrupted executions found\n'));
+            return;
+        }
+        console.log(chalk.bold(`\n🔍 Found ${interrupted.length} Interrupted Execution(s)\n`));
+        const data = [
+            [
+                chalk.cyan('Epic ID'),
+                chalk.cyan('Epic Name'),
+                chalk.cyan('Progress'),
+                chalk.cyan('Work Loss'),
+                chalk.cyan('Recovery Time'),
+                chalk.cyan('Status')
+            ],
+            ...interrupted.map((exec)=>[
+                    exec.epicId,
+                    exec.epicName,
+                    `${exec.sprintsCompleted} / ${exec.sprintsTotal}`,
+                    `${exec.estimatedWorkLoss}%`,
+                    `${exec.recoveryTimeEstimate}m`,
+                    exec.isCleanShutdown ? chalk.green('Clean') : chalk.red('Crash')
+                ])
+        ];
+        console.log(table(data));
+    } catch (error) {
+        spinner.fail('Failed to scan for interrupted executions');
+        throw error;
+    }
+}
+/**
+ * Execute recovery with progress tracking
+ */ async function executeRecovery(engine, options) {
+    const spinner = ora('Initializing recovery...').start();
+    // Track recovery progress
+    engine.on('checkpoint-loaded', (state)=>{
+        spinner.text = `Checkpoint loaded: ${state.sprints.length} sprints`;
+    });
+    engine.on('sprint-resumed', (context)=>{
+        spinner.text = `Resuming sprint: ${context.name}`;
+    });
+    try {
+        spinner.text = `Executing ${options.mode} recovery...`;
+        const result = await engine.resumeFromCheckpoint(options);
+        if (result.success) {
+            spinner.succeed('Recovery completed successfully');
+        } else {
+            spinner.fail('Recovery completed with errors');
+        }
+        return result;
+    } catch (error) {
+        spinner.fail('Recovery failed');
+        throw error;
+    }
+}
+/**
+ * Main recovery resume command handler
+ */ async function recoveryResumeCommand(cmdOptions) {
+    try {
+        // Initialize dependencies
+        const redis = createClient({
+            url: cmdOptions.redisUrl || 'redis://localhost:6379'
+        });
+        await redis.connect();
+        const checkpointManager = new StateCheckpointManager({
+            redisUrl: cmdOptions.redisUrl
+        });
+        await checkpointManager.initialize();
+        const crashDetector = new CrashDetector({
+            redisUrl: cmdOptions.redisUrl
+        });
+        await crashDetector.initialize();
+        const recoveryEngine = new RecoveryEngine({
+            redisUrl: cmdOptions.redisUrl,
+            checkpointManager,
+            crashDetector
+        });
+        await recoveryEngine.initialize();
+        // Handle --list flag
+        if (cmdOptions.list) {
+            await listInterruptedExecutions(crashDetector);
+            await redis.quit();
+            return;
+        }
+        // Detect interrupted executions
+        const spinner = ora('Scanning for interrupted executions...').start();
+        const interrupted = await crashDetector.detectInterruptedExecutions();
+        spinner.stop();
+        if (interrupted.length === 0) {
+            console.log(chalk.green('\n✓ No interrupted executions found\n'));
+            await redis.quit();
+            return;
+        }
+        // Select epic to recover
+        let execution;
+        if (cmdOptions.epicId) {
+            const found = interrupted.find((e)=>e.epicId === cmdOptions.epicId);
+            if (!found) {
+                console.error(chalk.red(`\n✗ Epic ID not found: ${cmdOptions.epicId}\n`));
+                await redis.quit();
+                process.exit(1);
+            }
+            execution = found;
+        } else if (interrupted.length === 1) {
+            execution = interrupted[0];
+        } else {
+            // Multiple interrupted executions - prompt user to select
+            const { selectedEpicId } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedEpicId',
+                    message: 'Select epic to recover:',
+                    choices: interrupted.map((e)=>({
+                            name: `${e.epicName} (${e.epicId}) - ${e.estimatedWorkLoss}% work loss`,
+                            value: e.epicId
+                        }))
+                }
+            ]);
+            execution = interrupted.find((e)=>e.epicId === selectedEpicId);
+        }
+        // Determine recovery mode
+        let mode;
+        if (cmdOptions.mode) {
+            mode = cmdOptions.mode;
+        } else {
+            mode = await promptRecoveryMode(execution);
+        }
+        // Build recovery options
+        const options = {
+            mode,
+            epicId: execution.epicId,
+            continueFromSprint: cmdOptions.continueFrom,
+            skipFileReconciliation: cmdOptions.skipFileReconciliation
+        };
+        // Execute recovery
+        const result = await executeRecovery(recoveryEngine, options);
+        // Display results
+        displayRecoveryProgress(result);
+        // Cleanup
+        await recoveryEngine.shutdown();
+        await redis.quit();
+        // Exit with appropriate code
+        process.exit(result.success ? 0 : 1);
+    } catch (error) {
+        console.error(chalk.red('\n✗ Recovery failed:\n'));
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+/**
+ * Register recovery resume command
+ */ export function registerRecoveryResumeCommand(program) {
+    program.command('recovery:resume').description('Resume interrupted CFN Loop executions from checkpoint').option('--epic-id <id>', 'Epic ID to recover (auto-detect if not specified)').option('--mode <mode>', 'Recovery mode: resume, restart, inspect, abandon').option('--list', 'List all interrupted executions without recovering').option('--continue-from <sprint-id>', 'Resume from specific sprint').option('--skip-file-reconciliation', 'Skip file reconciliation (faster but riskier)').option('--redis-url <url>', 'Redis URL (default: redis://localhost:6379)', 'redis://localhost:6379').action(recoveryResumeCommand);
+}
+// Export for direct usage
+export { recoveryResumeCommand };

package/.claude-flow-novice/dist/src/cli/commands/recovery-status.js

@@ -0,0 +1,265 @@
+/**
+ * Recovery Status CLI Command - Dashboard for Interrupted Executions
+ *
+ * Provides a comprehensive dashboard for crash recovery:
+ * - List of interrupted epics with details
+ * - Sprint progress percentages
+ * - Estimated recovery time
+ * - Options: resume/restart/inspect/abandon
+ *
+ * Usage:
+ * ```bash
+ * claude-flow-novice recovery:status
+ * claude-flow-novice recovery:status --detailed
+ * claude-flow-novice recovery:inspect <epicId>
+ * claude-flow-novice recovery:resume <epicId>
+ * claude-flow-novice recovery:abandon <epicId>
+ * ```
+ *
+ * @module cli/commands/recovery-status
+ */ import { CrashDetector } from "../../cfn-loop/crash-detector.js";
+import { Logger } from "../../core/logger.js";
+// ===== FORMATTING UTILITIES =====
+/**
+ * Format milliseconds to human-readable duration
+ */ function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) return `${days}d ${hours % 24}h`;
+    if (hours > 0) return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+/**
+ * Format timestamp to human-readable date
+ */ function formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    return date.toISOString().replace('T', ' ').substring(0, 19);
+}
+/**
+ * Format progress percentage with bar
+ */ function formatProgress(progress) {
+    const percentage = Math.round(progress * 100);
+    const barLength = 20;
+    const filled = Math.round(barLength * percentage / 100);
+    const empty = barLength - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    return `[${bar}] ${percentage}%`;
+}
+/**
+ * Format file list with truncation
+ */ function formatFileList(files, maxFiles = 3) {
+    if (files.length === 0) return 'none';
+    if (files.length <= maxFiles) return files.join(', ');
+    const shown = files.slice(0, maxFiles);
+    return `${shown.join(', ')} ... (+${files.length - maxFiles} more)`;
+}
+// ===== DASHBOARD RENDERER =====
+/**
+ * Render recovery dashboard
+ */ function renderRecoveryDashboard(interrupted, detailed = false) {
+    if (interrupted.length === 0) {
+        console.log('\n✅ No interrupted executions detected\n');
+        console.log('All CFN Loop epics completed or shut down cleanly.\n');
+        return;
+    }
+    console.log('\n╔══════════════════════════════════════════════════════════════════════╗');
+    console.log('║              🔍 CFN LOOP RECOVERY DASHBOARD                          ║');
+    console.log('╚══════════════════════════════════════════════════════════════════════╝\n');
+    console.log(`📊 Summary: ${interrupted.length} interrupted execution(s) detected\n`);
+    for (const execution of interrupted){
+        renderExecutionSummary(execution, detailed);
+    }
+    console.log('\n╔══════════════════════════════════════════════════════════════════════╗');
+    console.log('║                      RECOVERY OPTIONS                                ║');
+    console.log('╚══════════════════════════════════════════════════════════════════════╝\n');
+    console.log('  claude-flow-novice recovery:inspect <epicId>  - Detailed inspection');
+    console.log('  claude-flow-novice recovery:resume <epicId>   - Resume from checkpoint');
+    console.log('  claude-flow-novice recovery:restart <epicId>  - Restart from beginning');
+    console.log('  claude-flow-novice recovery:abandon <epicId>  - Abandon and cleanup\n');
+}
+/**
+ * Render execution summary
+ */ function renderExecutionSummary(execution, detailed) {
+    const statusIcon = execution.isCleanShutdown ? '🟢' : '🔴';
+    const statusText = execution.isCleanShutdown ? 'CLEAN SHUTDOWN' : 'INTERRUPTED';
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log(`${statusIcon} Epic: ${execution.epicName} (${execution.epicId})`);
+    console.log(`   Status: ${statusText}`);
+    console.log(`   Last Activity: ${formatTimestamp(execution.lastHeartbeat)} (${formatDuration(execution.timeSinceHeartbeat)} ago)`);
+    console.log(`   Checkpoint: v${execution.checkpointVersion} at ${formatTimestamp(execution.lastCheckpointTime)}`);
+    console.log();
+    // Sprint progress
+    console.log(`   📈 Sprints: ${execution.sprintsCompleted}/${execution.sprintsTotal} completed`);
+    if (execution.sprintsInProgress.length > 0) {
+        console.log(`   🔄 In Progress:`);
+        for (const sprint of execution.sprintsInProgress){
+            console.log(`      • ${sprint.name}: ${formatProgress(sprint.progress)}`);
+            console.log(`        Phases: ${sprint.phasesCompleted}/${sprint.phasesTotal} completed`);
+            if (detailed && sprint.filesInProgress.length > 0) {
+                console.log(`        Files: ${formatFileList(sprint.filesInProgress, 5)}`);
+            }
+        }
+    }
+    console.log();
+    // Recovery estimates
+    console.log(`   ⚠️  Estimated Work Loss: ${execution.estimatedWorkLoss}%`);
+    console.log(`   ⏱️  Recovery Time Estimate: ${execution.recoveryTimeEstimate} minutes`);
+    console.log();
+}
+/**
+ * Render detailed inspection
+ */ function renderDetailedInspection(execution) {
+    console.log('\n╔══════════════════════════════════════════════════════════════════════╗');
+    console.log('║                    DETAILED INSPECTION                               ║');
+    console.log('╚══════════════════════════════════════════════════════════════════════╝\n');
+    console.log(`Epic ID: ${execution.epicId}`);
+    console.log(`Epic Name: ${execution.epicName}`);
+    console.log(`Status: ${execution.isCleanShutdown ? 'Clean Shutdown' : 'Interrupted'}`);
+    console.log();
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log('TIMELINE');
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log(`Last Heartbeat:    ${formatTimestamp(execution.lastHeartbeat)}`);
+    console.log(`Last Checkpoint:   ${formatTimestamp(execution.lastCheckpointTime)} (v${execution.checkpointVersion})`);
+    console.log(`Time Since Update: ${formatDuration(execution.timeSinceHeartbeat)}`);
+    console.log();
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log('SPRINT DETAILS');
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log(`Total Sprints:     ${execution.sprintsTotal}`);
+    console.log(`Completed:         ${execution.sprintsCompleted}`);
+    console.log(`In Progress:       ${execution.sprintsInProgress.length}`);
+    console.log();
+    for (const sprint of execution.sprintsInProgress){
+        console.log(`Sprint: ${sprint.name} (${sprint.sprintId})`);
+        console.log(`  Progress: ${formatProgress(sprint.progress)}`);
+        console.log(`  Phases: ${sprint.phasesCompleted}/${sprint.phasesTotal} completed`);
+        console.log(`  Last Update: ${formatTimestamp(sprint.lastUpdateTime)}`);
+        console.log(`  Files In Progress (${sprint.filesInProgress.length}):`);
+        for (const file of sprint.filesInProgress){
+            console.log(`    - ${file}`);
+        }
+        console.log();
+    }
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log('RECOVERY ANALYSIS');
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log(`Estimated Work Loss:      ${execution.estimatedWorkLoss}%`);
+    console.log(`Recovery Time Estimate:   ${execution.recoveryTimeEstimate} minutes`);
+    console.log(`Checkpoint Available:     ${execution.checkpointVersion > 0 ? 'Yes' : 'No'}`);
+    console.log(`Resume Recommended:       ${execution.estimatedWorkLoss < 50 ? 'Yes' : 'Restart may be faster'}`);
+    console.log();
+}
+// ===== COMMAND HANDLERS =====
+/**
+ * Handle recovery:status command
+ */ async function handleRecoveryStatus(options) {
+    const logger = new Logger({
+        level: 'info',
+        format: 'json',
+        name: 'RecoveryStatus'
+    }, 'RecoveryStatus');
+    const detector = new CrashDetector();
+    try {
+        console.log('\n🔍 Scanning for interrupted executions...\n');
+        await detector.initialize();
+        const interrupted = await detector.detectInterruptedExecutions();
+        const stats = detector.getStats();
+        renderRecoveryDashboard(interrupted, options.detailed || false);
+        // Show statistics
+        if (options.detailed) {
+            console.log('╔══════════════════════════════════════════════════════════════════════╗');
+            console.log('║                       SCAN STATISTICS                                ║');
+            console.log('╚══════════════════════════════════════════════════════════════════════╝\n');
+            console.log(`  Epics Scanned:         ${stats.totalEpicsScanned}`);
+            console.log(`  Interrupted Found:     ${stats.interruptedEpicsFound}`);
+            console.log(`  Clean Shutdowns:       ${stats.cleanShutdownsFound}`);
+            console.log(`  Redis Keys Scanned:    ${stats.redisKeysScanned}`);
+            console.log(`  Scan Duration:         ${stats.scanDurationMs}ms`);
+            console.log();
+        }
+        await detector.shutdown();
+    } catch (error) {
+        logger.error('Recovery status failed', {
+            error
+        });
+        console.error('\n❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+/**
+ * Handle recovery:inspect command
+ */ async function handleRecoveryInspect(epicId) {
+    const logger = new Logger({
+        level: 'info',
+        format: 'json',
+        name: 'RecoveryInspect'
+    }, 'RecoveryInspect');
+    const detector = new CrashDetector();
+    try {
+        await detector.initialize();
+        const interrupted = await detector.detectInterruptedExecutions();
+        const execution = interrupted.find((e)=>e.epicId === epicId);
+        if (!execution) {
+            console.log(`\n❌ No interrupted execution found for epic: ${epicId}\n`);
+            process.exit(1);
+        }
+        renderDetailedInspection(execution);
+        await detector.shutdown();
+    } catch (error) {
+        logger.error('Recovery inspect failed', {
+            error
+        });
+        console.error('\n❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+/**
+ * Handle recovery:resume command
+ */ async function handleRecoveryResume(epicId) {
+    console.log(`\n🔄 Resuming epic: ${epicId}\n`);
+    console.log('⚠️  Resume functionality not yet implemented');
+    console.log('    This will restore state from latest checkpoint and continue execution\n');
+// TODO: Implement resume logic with StateCheckpointManager
+}
+/**
+ * Handle recovery:restart command
+ */ async function handleRecoveryRestart(epicId) {
+    console.log(`\n🔄 Restarting epic: ${epicId}\n`);
+    console.log('⚠️  Restart functionality not yet implemented');
+    console.log('    This will clear checkpoints and restart from beginning\n');
+// TODO: Implement restart logic
+}
+/**
+ * Handle recovery:abandon command
+ */ async function handleRecoveryAbandon(epicId) {
+    console.log(`\n🗑️  Abandoning epic: ${epicId}\n`);
+    console.log('⚠️  Abandon functionality not yet implemented');
+    console.log('    This will cleanup Redis keys and mark epic as abandoned\n');
+// TODO: Implement abandon logic with Redis cleanup
+}
+// ===== COMMAND REGISTRATION =====
+/**
+ * Register recovery commands
+ */ function registerRecoveryCommands(program) {
+    const recovery = program.command('recovery').description('CFN Loop crash recovery management');
+    recovery.command('status').description('Show recovery dashboard for interrupted executions').option('-d, --detailed', 'Show detailed information').action(handleRecoveryStatus);
+    recovery.command('inspect <epicId>').description('Detailed inspection of interrupted epic').action(handleRecoveryInspect);
+    recovery.command('resume <epicId>').description('Resume execution from latest checkpoint').action(handleRecoveryResume);
+    recovery.command('restart <epicId>').description('Restart execution from beginning').action(handleRecoveryRestart);
+    recovery.command('abandon <epicId>').description('Abandon execution and cleanup').action(handleRecoveryAbandon);
+}
+// Export named functions for direct import
+export { registerRecoveryCommands, handleRecoveryStatus, handleRecoveryInspect, handleRecoveryResume, handleRecoveryRestart, handleRecoveryAbandon };
+// Export for integration with main CLI
+export default {
+    registerRecoveryCommands,
+    handleRecoveryStatus,
+    handleRecoveryInspect,
+    handleRecoveryResume,
+    handleRecoveryRestart,
+    handleRecoveryAbandon
+};