@claude-flow/cli 3.5.42 → 3.5.44

package/dist/src/commands/migrate.js

@@ -3,7 +3,8 @@
  * Migration tools for V2 to V3 transition
  */
 import { output } from '../output.js';
-import { select, confirm } from '../prompt.js';
+import * as fs from 'fs';
+import * as path from 'path';
 // Migration targets
 const MIGRATION_TARGETS = [
     { value: 'config', label: 'Configuration', hint: 'Migrate configuration files' },
@@ -19,49 +20,117 @@ const statusCommand = {
     name: 'status',
     description: 'Check migration status',
     action: async (ctx) => {
-        const status = {
-            v2Version: '2.6.0',
-            v3Version: '3.0.0-alpha.1',
-            migrationState: 'partial',
-            components: [
-                { name: 'Configuration', status: 'migrated', v2Path: './claude-flow.json', v3Path: './claude-flow.config.json' },
-                { name: 'Memory Data', status: 'pending', v2Path: './.claude-flow/memory', v3Path: './data/memory' },
-                { name: 'Agent Configs', status: 'pending', v2Path: './.claude-flow/agents', v3Path: './v3/agents' },
-                { name: 'Hooks', status: 'pending', v2Path: './src/hooks', v3Path: './v3/hooks' },
-                { name: 'Workflows', status: 'not-required', v2Path: 'N/A', v3Path: 'N/A' },
-                { name: 'Embeddings', status: 'pending', v2Path: 'OpenAI/TF.js', v3Path: 'ONNX + Hyperbolic' }
-            ],
-            recommendations: [
-                'Backup v2 data before migration',
-                'Test migration in staging environment first',
-                'Review breaking changes in CHANGELOG.md'
-            ]
-        };
+        const cwd = ctx.cwd || process.cwd();
+        const components = [];
+        // Check v2 config: claude-flow.config.json with version "2" or missing version
+        const v2ConfigPath = path.join(cwd, 'claude-flow.config.json');
+        const v3ConfigDir = path.join(cwd, '.claude-flow');
+        let hasV2Config = false;
+        let hasV3Config = false;
+        try {
+            if (fs.existsSync(v2ConfigPath)) {
+                const raw = fs.readFileSync(v2ConfigPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed.version === '2' || parsed.version === 2 || !parsed.version) {
+                    hasV2Config = true;
+                }
+            }
+        }
+        catch { /* ignore parse errors */ }
+        try {
+            hasV3Config = fs.existsSync(v3ConfigDir) && fs.statSync(v3ConfigDir).isDirectory();
+        }
+        catch { /* ignore */ }
+        if (hasV2Config && hasV3Config) {
+            components.push({ component: 'Config', status: 'v2 + v3', migrationNeeded: 'no' });
+        }
+        else if (hasV2Config) {
+            components.push({ component: 'Config', status: 'v2', migrationNeeded: 'yes' });
+        }
+        else if (hasV3Config) {
+            components.push({ component: 'Config', status: 'v3', migrationNeeded: 'no' });
+        }
+        else {
+            components.push({ component: 'Config', status: 'missing', migrationNeeded: 'no' });
+        }
+        // Check v2 memory: ./data/memory/*.json or memory.db
+        const v2MemoryDir = path.join(cwd, 'data', 'memory');
+        let hasV2MemoryJson = false;
+        let hasV2MemoryDb = false;
+        try {
+            if (fs.existsSync(v2MemoryDir)) {
+                const files = fs.readdirSync(v2MemoryDir);
+                hasV2MemoryJson = files.some(f => f.endsWith('.json'));
+                hasV2MemoryDb = files.includes('memory.db');
+            }
+        }
+        catch { /* ignore */ }
+        if (hasV2MemoryJson || hasV2MemoryDb) {
+            components.push({ component: 'Memory', status: 'v2', migrationNeeded: 'yes' });
+        }
+        else {
+            components.push({ component: 'Memory', status: 'missing', migrationNeeded: 'no' });
+        }
+        // Check v2 sessions: ./data/sessions/
+        const v2SessionsDir = path.join(cwd, 'data', 'sessions');
+        let hasV2Sessions = false;
+        try {
+            if (fs.existsSync(v2SessionsDir)) {
+                const files = fs.readdirSync(v2SessionsDir);
+                hasV2Sessions = files.length > 0;
+            }
+        }
+        catch { /* ignore */ }
+        if (hasV2Sessions) {
+            components.push({ component: 'Sessions', status: 'v2', migrationNeeded: 'yes' });
+        }
+        else {
+            components.push({ component: 'Sessions', status: 'missing', migrationNeeded: 'no' });
+        }
+        // Check migration state
+        const migrationStatePath = path.join(cwd, '.claude-flow', 'migration-state.json');
+        let migrationState = null;
+        try {
+            if (fs.existsSync(migrationStatePath)) {
+                const raw = fs.readFileSync(migrationStatePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                migrationState = parsed.status || 'unknown';
+            }
+        }
+        catch { /* ignore */ }
+        if (migrationState) {
+            components.push({ component: 'Migration State', status: migrationState, migrationNeeded: 'no' });
+        }
+        // Display results
         if (ctx.flags.format === 'json') {
-            output.printJson(status);
-            return { success: true, data: status };
+            output.printJson({ components, migrationState });
+            return { success: true, data: { components, migrationState } };
         }
         output.writeln();
         output.writeln(output.bold('Migration Status'));
         output.writeln();
-        output.writeln(`V2 Version: ${status.v2Version}`);
-        output.writeln(`V3 Version: ${status.v3Version}`);
-        output.writeln(`State: ${formatMigrationStatus(status.migrationState)}`);
-        output.writeln();
-        output.writeln(output.bold('Components'));
         output.printTable({
             columns: [
-                { key: 'name', header: 'Component', width: 18 },
-                { key: 'status', header: 'Status', width: 15, format: (v) => formatMigrationStatus(String(v)) },
-                { key: 'v2Path', header: 'V2 Path', width: 25 },
-                { key: 'v3Path', header: 'V3 Path', width: 25 }
+                { key: 'component', header: 'Component', width: 20 },
+                { key: 'status', header: 'Status', width: 15 },
+                { key: 'migrationNeeded', header: 'Migration Needed', width: 20 }
             ],
-            data: status.components
+            data: components.map(c => ({
+                component: c.component,
+                status: formatMigrationStatus(c.status),
+                migrationNeeded: c.migrationNeeded === 'yes' ? output.warning('yes') : output.dim('no')
+            })),
+            border: false
         });
+        const needsMigration = components.some(c => c.migrationNeeded === 'yes');
         output.writeln();
-        output.writeln(output.bold('Recommendations'));
-        output.printList(status.recommendations);
-        return { success: true, data: status };
+        if (needsMigration) {
+            output.printInfo('V2 artifacts detected. Run "claude-flow migrate run" to migrate.');
+        }
+        else {
+            output.printSuccess('No migration needed.');
+        }
+        return { success: true, data: { components, needsMigration } };
     }
 };
 // Run migration
@@ -97,59 +166,199 @@ const runCommand = {
         }
     ],
     action: async (ctx) => {
-        let target = ctx.flags.target;
-        const dryRun = ctx.flags.dryRun;
-        const backup = ctx.flags.backup;
-        const force = ctx.flags.force;
-        if (!target && ctx.interactive) {
-            target = await select({
-                message: 'Select migration target:',
-                options: MIGRATION_TARGETS,
-                default: 'all'
-            });
-        }
-        target = target || 'all';
+        const cwd = ctx.cwd || process.cwd();
+        const dryRun = ctx.flags['dry-run'] === true;
+        const skipBackup = ctx.flags.backup === false;
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const v3Dir = path.join(cwd, '.claude-flow');
+        const backupDir = path.join(v3Dir, 'backup', `v2-${timestamp}`);
+        const migrationStatePath = path.join(v3Dir, 'migration-state.json');
+        const migrated = [];
+        const skipped = [];
         output.writeln();
+        output.writeln(output.bold('V2 to V3 Migration'));
         if (dryRun) {
-            output.printInfo('DRY RUN - No changes will be made');
-            output.writeln();
+            output.printWarning('Dry run mode — no changes will be made.');
         }
-        output.printInfo(`Migrating: ${target}`);
         output.writeln();
-        // Backup step
-        if (backup && !dryRun) {
+        // Ensure .claude-flow directory exists
+        if (!dryRun) {
+            fs.mkdirSync(v3Dir, { recursive: true });
+        }
+        // --- Backup ---
+        if (!skipBackup && !dryRun) {
             output.writeln(output.dim('Creating backup...'));
-            output.writeln(output.dim(`  Backup created: ./.claude-flow-backup-${Date.now()}`));
-            output.writeln();
+            fs.mkdirSync(backupDir, { recursive: true });
         }
-        // Migration steps based on target
-        const steps = getMigrationSteps(target);
-        for (const step of steps) {
-            output.writeln(`${output.info('>')} ${step.name}`);
-            output.writeln(output.dim(`   ${step.description}`));
-            if (!dryRun) {
-                // Execute migration step
-                output.writeln(output.dim(`   ${output.success('[OK]')} Completed`));
+        // --- Config migration ---
+        const v2ConfigPath = path.join(cwd, 'claude-flow.config.json');
+        try {
+            if (fs.existsSync(v2ConfigPath)) {
+                const raw = fs.readFileSync(v2ConfigPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed.version === '2' || parsed.version === 2 || !parsed.version) {
+                    if (dryRun) {
+                        output.printInfo(`Would migrate config: ${v2ConfigPath}`);
+                    }
+                    else {
+                        // Backup
+                        if (!skipBackup) {
+                            fs.copyFileSync(v2ConfigPath, path.join(backupDir, 'claude-flow.config.json'));
+                        }
+                        // Transform to v3 format
+                        const v3Config = { ...parsed, version: '3' };
+                        // Rename swarm.mode -> swarm.topology if present
+                        if (v3Config.swarm && typeof v3Config.swarm === 'object') {
+                            const swarm = v3Config.swarm;
+                            if ('mode' in swarm && !('topology' in swarm)) {
+                                swarm.topology = swarm.mode;
+                                delete swarm.mode;
+                            }
+                        }
+                        // Rename memory.type -> memory.backend if present
+                        if (v3Config.memory && typeof v3Config.memory === 'object') {
+                            const mem = v3Config.memory;
+                            if ('type' in mem && !('backend' in mem)) {
+                                mem.backend = mem.type;
+                                delete mem.type;
+                            }
+                        }
+                        const v3ConfigPath = path.join(v3Dir, 'config.json');
+                        fs.writeFileSync(v3ConfigPath, JSON.stringify(v3Config, null, 2));
+                        output.printSuccess(`Config migrated to ${v3ConfigPath}`);
+                    }
+                    migrated.push('config');
+                }
+                else {
+                    output.printInfo('Config already at v3 — skipping.');
+                    skipped.push('config');
+                }
             }
             else {
-                output.writeln(output.dim(`   Would migrate: ${step.source} -> ${step.dest}`));
+                output.writeln(output.dim('No v2 config found — skipping config migration.'));
+                skipped.push('config');
             }
+        }
+        catch (err) {
+            output.printError('Config migration failed', String(err));
+            skipped.push('config');
+        }
+        // --- Memory migration ---
+        const v2MemoryDir = path.join(cwd, 'data', 'memory');
+        try {
+            if (fs.existsSync(v2MemoryDir)) {
+                const files = fs.readdirSync(v2MemoryDir);
+                const jsonFiles = files.filter(f => f.endsWith('.json'));
+                const hasDb = files.includes('memory.db');
+                if (jsonFiles.length > 0 || hasDb) {
+                    if (dryRun) {
+                        output.printInfo(`Would migrate memory: ${jsonFiles.length} JSON files, ${hasDb ? '1 DB' : 'no DB'}`);
+                    }
+                    else {
+                        // Backup memory files
+                        if (!skipBackup) {
+                            const memBackup = path.join(backupDir, 'data', 'memory');
+                            fs.mkdirSync(memBackup, { recursive: true });
+                            for (const f of files) {
+                                const src = path.join(v2MemoryDir, f);
+                                if (fs.statSync(src).isFile()) {
+                                    fs.copyFileSync(src, path.join(memBackup, f));
+                                }
+                            }
+                        }
+                        output.printSuccess(`Memory files backed up (${jsonFiles.length} JSON, ${hasDb ? '1 DB' : '0 DB'}).`);
+                        output.printInfo('Run "claude-flow memory init --force" to import v2 memory into v3 AgentDB.');
+                    }
+                    migrated.push('memory');
+                }
+                else {
+                    output.writeln(output.dim('No v2 memory files found — skipping.'));
+                    skipped.push('memory');
+                }
+            }
+            else {
+                output.writeln(output.dim('No v2 memory directory found — skipping.'));
+                skipped.push('memory');
+            }
+        }
+        catch (err) {
+            output.printError('Memory migration failed', String(err));
+            skipped.push('memory');
+        }
+        // --- Session migration ---
+        const v2SessionsDir = path.join(cwd, 'data', 'sessions');
+        try {
+            if (fs.existsSync(v2SessionsDir)) {
+                const files = fs.readdirSync(v2SessionsDir);
+                if (files.length > 0) {
+                    if (dryRun) {
+                        output.printInfo(`Would migrate sessions: ${files.length} files from ${v2SessionsDir}`);
+                    }
+                    else {
+                        const v3SessionsDir = path.join(v3Dir, 'sessions');
+                        fs.mkdirSync(v3SessionsDir, { recursive: true });
+                        // Backup
+                        if (!skipBackup) {
+                            const sessBackup = path.join(backupDir, 'data', 'sessions');
+                            fs.mkdirSync(sessBackup, { recursive: true });
+                            for (const f of files) {
+                                const src = path.join(v2SessionsDir, f);
+                                if (fs.statSync(src).isFile()) {
+                                    fs.copyFileSync(src, path.join(sessBackup, f));
+                                }
+                            }
+                        }
+                        // Copy to v3 location
+                        for (const f of files) {
+                            const src = path.join(v2SessionsDir, f);
+                            if (fs.statSync(src).isFile()) {
+                                fs.copyFileSync(src, path.join(v3SessionsDir, f));
+                            }
+                        }
+                        output.printSuccess(`Sessions migrated: ${files.length} files to ${v3SessionsDir}`);
+                    }
+                    migrated.push('sessions');
+                }
+                else {
+                    output.writeln(output.dim('No v2 session files found — skipping.'));
+                    skipped.push('sessions');
+                }
+            }
+            else {
+                output.writeln(output.dim('No v2 sessions directory found — skipping.'));
+                skipped.push('sessions');
+            }
+        }
+        catch (err) {
+            output.printError('Session migration failed', String(err));
+            skipped.push('sessions');
+        }
+        // --- Save migration state ---
+        if (!dryRun && migrated.length > 0) {
+            const state = {
+                status: 'completed',
+                timestamp,
+                backupPath: skipBackup ? null : backupDir,
+                migrated,
+                skipped
+            };
+            fs.writeFileSync(migrationStatePath, JSON.stringify(state, null, 2));
             output.writeln();
+            output.printSuccess(`Migration state saved to ${migrationStatePath}`);
         }
-        const result = {
-            target,
-            dryRun,
-            backup,
-            stepsCompleted: steps.length,
-            success: true
-        };
+        // Summary
+        output.writeln();
         if (dryRun) {
-            output.printInfo('Dry run complete. Run without --dry-run to apply changes.');
+            output.printInfo(`Dry run complete. ${migrated.length} component(s) would be migrated.`);
+        }
+        else if (migrated.length > 0) {
+            output.printSuccess(`Migration complete. ${migrated.length} component(s) migrated: ${migrated.join(', ')}`);
+            output.printInfo('Run "claude-flow migrate verify" to validate the migration.');
         }
         else {
-            output.printSuccess('Migration completed successfully');
+            output.printInfo('Nothing to migrate.');
         }
-        return { success: true, data: result };
+        return { success: true, data: { migrated, skipped, dryRun } };
     }
 };
 // Verify migration
@@ -165,47 +374,125 @@ const verifyCommand = {
         }
     ],
     action: async (ctx) => {
-        const fix = ctx.flags.fix;
+        const cwd = ctx.cwd || process.cwd();
+        const v3Dir = path.join(cwd, '.claude-flow');
+        const migrationStatePath = path.join(v3Dir, 'migration-state.json');
+        const checks = [];
+        let allPassed = true;
         output.writeln();
-        output.printInfo('Verifying migration...');
+        output.writeln(output.bold('Migration Verification'));
         output.writeln();
-        const checks = [
-            { name: 'Configuration Schema', status: 'passed', details: 'V3 schema valid' },
-            { name: 'Memory Data Integrity', status: 'passed', details: 'All entries valid' },
-            { name: 'Agent Configurations', status: 'warning', details: '2 deprecated fields detected' },
-            { name: 'Hook Definitions', status: 'passed', details: 'All hooks registered' },
-            { name: 'File Permissions', status: 'passed', details: 'Correct permissions' },
-            { name: 'Dependencies', status: 'passed', details: 'All dependencies available' }
-        ];
+        // Check 1: Migration state file exists
+        let migrationState = null;
+        try {
+            if (fs.existsSync(migrationStatePath)) {
+                const raw = fs.readFileSync(migrationStatePath, 'utf-8');
+                migrationState = JSON.parse(raw);
+                checks.push({ check: 'Migration state file', result: 'passed' });
+            }
+            else {
+                checks.push({ check: 'Migration state file', result: 'failed' });
+                allPassed = false;
+            }
+        }
+        catch {
+            checks.push({ check: 'Migration state file', result: 'failed' });
+            allPassed = false;
+        }
+        // Check 2: V3 config exists and is valid JSON
+        const v3ConfigPath = path.join(v3Dir, 'config.json');
+        try {
+            if (fs.existsSync(v3ConfigPath)) {
+                const raw = fs.readFileSync(v3ConfigPath, 'utf-8');
+                JSON.parse(raw); // validate JSON
+                checks.push({ check: 'V3 config (valid JSON)', result: 'passed' });
+            }
+            else {
+                // Config might not have been migrated if there was no v2 config
+                const wasMigrated = migrationState &&
+                    Array.isArray(migrationState.migrated) &&
+                    migrationState.migrated.includes('config');
+                if (wasMigrated) {
+                    checks.push({ check: 'V3 config (valid JSON)', result: 'failed' });
+                    allPassed = false;
+                }
+                else {
+                    checks.push({ check: 'V3 config (valid JSON)', result: 'skipped' });
+                }
+            }
+        }
+        catch {
+            checks.push({ check: 'V3 config (valid JSON)', result: 'failed' });
+            allPassed = false;
+        }
+        // Check 3: Backup exists
+        if (migrationState && migrationState.backupPath) {
+            const backupPath = migrationState.backupPath;
+            try {
+                if (fs.existsSync(backupPath) && fs.statSync(backupPath).isDirectory()) {
+                    checks.push({ check: 'Backup directory', result: 'passed' });
+                }
+                else {
+                    checks.push({ check: 'Backup directory', result: 'failed' });
+                    allPassed = false;
+                }
+            }
+            catch {
+                checks.push({ check: 'Backup directory', result: 'failed' });
+                allPassed = false;
+            }
+        }
+        else if (migrationState && migrationState.backupPath === null) {
+            checks.push({ check: 'Backup directory', result: 'skipped (backup was disabled)' });
+        }
+        else {
+            checks.push({ check: 'Backup directory', result: 'failed' });
+            allPassed = false;
+        }
+        // Check 4: V3 sessions directory if sessions were migrated
+        if (migrationState &&
+            Array.isArray(migrationState.migrated) &&
+            migrationState.migrated.includes('sessions')) {
+            const v3Sessions = path.join(v3Dir, 'sessions');
+            try {
+                if (fs.existsSync(v3Sessions) && fs.readdirSync(v3Sessions).length > 0) {
+                    checks.push({ check: 'V3 sessions directory', result: 'passed' });
+                }
+                else {
+                    checks.push({ check: 'V3 sessions directory', result: 'failed' });
+                    allPassed = false;
+                }
+            }
+            catch {
+                checks.push({ check: 'V3 sessions directory', result: 'failed' });
+                allPassed = false;
+            }
+        }
+        // Display
+        if (ctx.flags.format === 'json') {
+            output.printJson({ checks, allPassed });
+            return { success: allPassed, data: { checks, allPassed } };
+        }
         output.printTable({
             columns: [
-                { key: 'name', header: 'Check', width: 25 },
-                { key: 'status', header: 'Status', width: 12, format: (v) => {
-                        if (v === 'passed')
-                            return output.success('PASSED');
-                        if (v === 'warning')
-                            return output.warning('WARNING');
-                        return output.error('FAILED');
-                    } },
-                { key: 'details', header: 'Details', width: 30 }
+                { key: 'check', header: 'Check', width: 30 },
+                { key: 'result', header: 'Result', width: 35 }
             ],
-            data: checks
+            data: checks.map(c => ({
+                check: c.check,
+                result: formatMigrationStatus(c.result)
+            })),
+            border: false
         });
-        const hasIssues = checks.some(c => c.status !== 'passed');
         output.writeln();
-        if (hasIssues) {
-            if (fix) {
-                output.printInfo('Attempting to fix issues...');
-                output.printSuccess('Issues fixed');
-            }
-            else {
-                output.printWarning('Some issues detected. Run with --fix to attempt automatic fixes.');
-            }
+        if (allPassed) {
+            output.printSuccess('All verification checks passed.');
         }
         else {
-            output.printSuccess('All verification checks passed');
+            output.printError('Some verification checks failed.');
+            output.printInfo('Run "claude-flow migrate run" to re-run the migration, or "migrate rollback" to restore from backup.');
         }
-        return { success: true, data: { checks, hasIssues } };
+        return { success: allPassed, data: { checks, allPassed }, exitCode: allPassed ? 0 : 1 };
     }
 };
 // Rollback migration
@@ -227,53 +514,93 @@ const rollbackCommand = {
         }
     ],
     action: async (ctx) => {
-        const backupId = ctx.flags.backupId;
-        const force = ctx.flags.force;
-        // List available backups
-        const backups = [
-            { id: 'backup-1704369600', date: '2024-01-04 10:00:00', size: '45.2 MB' },
-            { id: 'backup-1704283200', date: '2024-01-03 10:00:00', size: '44.8 MB' },
-            { id: 'backup-1704196800', date: '2024-01-02 10:00:00', size: '43.5 MB' }
-        ];
-        if (!backupId && ctx.interactive) {
-            output.writeln();
-            output.writeln(output.bold('Available Backups'));
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'Backup ID', width: 20 },
-                    { key: 'date', header: 'Date', width: 22 },
-                    { key: 'size', header: 'Size', width: 12, align: 'right' }
-                ],
-                data: backups
-            });
-            output.writeln();
-            const confirmed = await confirm({
-                message: `Rollback to most recent backup (${backups[0].id})?`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
+        const cwd = ctx.cwd || process.cwd();
+        const v3Dir = path.join(cwd, '.claude-flow');
+        const migrationStatePath = path.join(v3Dir, 'migration-state.json');
+        output.writeln();
+        output.writeln(output.bold('Migration Rollback'));
+        output.writeln();
+        // Read migration state
+        let migrationState;
+        try {
+            if (!fs.existsSync(migrationStatePath)) {
+                output.printError('No migration state found.', 'Run "migrate run" first before attempting rollback.');
+                return { success: false, exitCode: 1 };
             }
+            const raw = fs.readFileSync(migrationStatePath, 'utf-8');
+            migrationState = JSON.parse(raw);
         }
-        const targetBackup = backupId || backups[0].id;
-        if (!force && !ctx.interactive) {
-            output.printError('Use --force to rollback without confirmation');
+        catch (err) {
+            output.printError('Failed to read migration state', String(err));
+            return { success: false, exitCode: 1 };
+        }
+        const backupPath = migrationState.backupPath;
+        if (!backupPath) {
+            output.printError('No backup path in migration state.', 'Migration was run with --no-backup. Cannot rollback.');
+            return { success: false, exitCode: 1 };
+        }
+        if (!fs.existsSync(backupPath)) {
+            output.printError('Backup directory not found.', `Expected: ${backupPath}`);
+            return { success: false, exitCode: 1 };
+        }
+        const restored = [];
+        try {
+            // Restore config
+            const backupConfig = path.join(backupPath, 'claude-flow.config.json');
+            if (fs.existsSync(backupConfig)) {
+                const destConfig = path.join(cwd, 'claude-flow.config.json');
+                fs.copyFileSync(backupConfig, destConfig);
+                // Remove v3 config
+                const v3Config = path.join(v3Dir, 'config.json');
+                if (fs.existsSync(v3Config)) {
+                    fs.unlinkSync(v3Config);
+                }
+                output.printSuccess('Restored: config');
+                restored.push('config');
+            }
+            // Restore memory
+            const backupMemory = path.join(backupPath, 'data', 'memory');
+            if (fs.existsSync(backupMemory)) {
+                const destMemory = path.join(cwd, 'data', 'memory');
+                fs.mkdirSync(destMemory, { recursive: true });
+                const files = fs.readdirSync(backupMemory);
+                for (const f of files) {
+                    fs.copyFileSync(path.join(backupMemory, f), path.join(destMemory, f));
+                }
+                output.printSuccess(`Restored: memory (${files.length} files)`);
+                restored.push('memory');
+            }
+            // Restore sessions
+            const backupSessions = path.join(backupPath, 'data', 'sessions');
+            if (fs.existsSync(backupSessions)) {
+                const destSessions = path.join(cwd, 'data', 'sessions');
+                fs.mkdirSync(destSessions, { recursive: true });
+                const files = fs.readdirSync(backupSessions);
+                for (const f of files) {
+                    fs.copyFileSync(path.join(backupSessions, f), path.join(destSessions, f));
+                }
+                // Remove v3 sessions
+                const v3Sessions = path.join(v3Dir, 'sessions');
+                if (fs.existsSync(v3Sessions)) {
+                    const v3Files = fs.readdirSync(v3Sessions);
+                    for (const f of v3Files) {
+                        fs.unlinkSync(path.join(v3Sessions, f));
+                    }
+                    fs.rmdirSync(v3Sessions);
+                }
+                output.printSuccess(`Restored: sessions (${files.length} files)`);
+                restored.push('sessions');
+            }
+            // Delete migration state
+            fs.unlinkSync(migrationStatePath);
+            output.writeln();
+            output.printSuccess(`Rollback complete. Restored: ${restored.join(', ') || 'nothing to restore'}`);
+            return { success: true, data: { restored } };
+        }
+        catch (err) {
+            output.printError('Rollback failed', String(err));
             return { success: false, exitCode: 1 };
         }
-        output.writeln();
-        output.printInfo(`Rolling back to ${targetBackup}...`);
-        output.writeln();
-        output.writeln(output.dim('  Stopping services...'));
-        output.writeln(output.dim('  Restoring configuration...'));
-        output.writeln(output.dim('  Restoring memory data...'));
-        output.writeln(output.dim('  Restoring agent configs...'));
-        output.writeln(output.dim('  Verifying integrity...'));
-        output.writeln();
-        output.printSuccess(`Rolled back to ${targetBackup}`);
-        output.writeln(output.dim('  Note: Restart services to apply changes'));
-        return { success: true, data: { backupId: targetBackup, rolledBack: true } };
     }
 };
 // Breaking changes info
@@ -378,20 +705,25 @@ export const migrateCommand = {
 };
 // Helper functions
 function formatMigrationStatus(status) {
-    switch (status) {
-        case 'migrated':
-        case 'passed':
-            return output.success(status);
-        case 'pending':
-        case 'partial':
-            return output.warning(status);
-        case 'failed':
-            return output.error(status);
-        case 'not-required':
-            return output.dim(status);
-        default:
-            return status;
+    if (status === 'migrated' || status === 'passed' || status === 'completed') {
+        return output.success(status);
+    }
+    if (status === 'pending' || status === 'partial') {
+        return output.warning(status);
+    }
+    if (status === 'failed') {
+        return output.error(status);
+    }
+    if (status === 'not-required' || status.startsWith('skipped') || status === 'v3' || status === 'missing') {
+        return output.dim(status);
+    }
+    if (status === 'v2') {
+        return output.warning(status);
+    }
+    if (status === 'v2 + v3') {
+        return output.success(status);
     }
+    return status;
 }
 function getMigrationSteps(target) {
     const allSteps = [