centaurus-cli 2.9.9 → 3.0.1

package/dist/services/checkpoint-manager.js

@@ -1,27 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import fg from 'fast-glob';
 import { logError, logWarning } from '../utils/logger.js';
-const DEFAULT_IGNORE_PATTERNS = [
-    '**/.git/**',
-    '**/node_modules/**',
-    '**/dist/**',
-    '**/build/**',
-    '**/out/**',
-    '**/.next/**',
-    '**/.turbo/**',
-    '**/.cache/**',
-    '**/coverage/**',
-    '**/__pycache__/**',
-    '**/.venv/**',
-    '**/venv/**',
-    '**/.idea/**',
-    '**/.vscode/**',
-    '**/.DS_Store',
-    '**/Thumbs.db',
-    '**/.centaurus/**',
-];
 export class CheckpointManager {
     checkpoints = [];
     currentChatId = null;
@@ -42,8 +22,107 @@ export class CheckpointManager {
     list() {
         return [...this.checkpoints].sort((a, b) => b.createdAtMs - a.createdAtMs);
     }
+    // ── Backup-on-write: called by file tools before modifying a file ───
     /**
-     * Get session changes for an active checkpoint (live calculation).
+     * Back up a single file before the AI modifies it.
+     * This is the core of the new checkpoint system: instead of copying the
+     * entire project at checkpoint start, we only back up the specific files
+     * that the AI actually touches, right before it touches them.
+     *
+     * If the file has already been backed up in this checkpoint, this is a no-op
+     * (we always want the ORIGINAL state, not intermediate states).
+     */
+    async backupFileBeforeChange(checkpointId, absoluteFilePath, cwd, handler) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === checkpointId);
+        if (!checkpoint || checkpoint.status !== 'active')
+            return;
+        // Compute relative path (forward-slash separated)
+        const relativePath = path.relative(cwd, absoluteFilePath).replace(/\\/g, '/');
+        // Read the current manifest to check if this file is already backed up
+        const manifest = this.readManifestV2(checkpoint.manifestPath);
+        const alreadyBacked = manifest.fileBackups.some(b => b.filePath === relativePath);
+        if (alreadyBacked)
+            return; // Already have the original — skip
+        const isRemote = checkpoint.contextType !== 'local' && handler && handler.isConnected();
+        const backupDir = path.join(path.dirname(checkpoint.manifestPath), 'backups');
+        try {
+            let existed = false;
+            let fileSize;
+            if (isRemote) {
+                // Remote: try to read the file via handler
+                const remotePath = cwd + '/' + relativePath;
+                try {
+                    const content = await handler.readFile(remotePath);
+                    existed = true;
+                    fileSize = Buffer.from(content, 'utf-8').length;
+                    // Save backup locally
+                    const backupPath = path.join(backupDir, relativePath);
+                    this.ensureDirSync(path.dirname(backupPath));
+                    fs.writeFileSync(backupPath, content, 'utf-8');
+                }
+                catch {
+                    // File doesn't exist on remote — it will be created
+                    existed = false;
+                }
+            }
+            else {
+                // Local: check if file exists and back it up
+                if (fs.existsSync(absoluteFilePath)) {
+                    existed = true;
+                    try {
+                        const stat = fs.statSync(absoluteFilePath);
+                        fileSize = stat.size;
+                        const backupPath = path.join(backupDir, relativePath);
+                        this.ensureDirSync(path.dirname(backupPath));
+                        fs.copyFileSync(absoluteFilePath, backupPath);
+                    }
+                    catch (err) {
+                        logWarning(`Failed to backup file ${relativePath}: ${err.message}`);
+                        return;
+                    }
+                }
+                else {
+                    existed = false;
+                }
+            }
+            // Add entry to manifest
+            manifest.fileBackups.push({
+                filePath: relativePath,
+                existed,
+                size: fileSize,
+                backedUpAt: new Date().toISOString(),
+            });
+            fs.writeFileSync(checkpoint.manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+        }
+        catch (error) {
+            logWarning(`Failed to backup file before change: ${error.message}`);
+        }
+    }
+    /**
+     * Record a file operation in the checkpoint's operation log.
+     * Called by file tools after successfully modifying a file.
+     */
+    recordFileOperation(checkpointId, type, filePath, toolName) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === checkpointId);
+        if (!checkpoint || checkpoint.status !== 'active')
+            return;
+        try {
+            const manifest = this.readManifestV2(checkpoint.manifestPath);
+            manifest.operations.push({
+                type,
+                filePath,
+                toolName,
+                timestamp: new Date().toISOString(),
+            });
+            fs.writeFileSync(checkpoint.manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+        }
+        catch (error) {
+            logWarning(`Failed to record file operation: ${error.message}`);
+        }
+    }
+    // ── Session changes and diff ────────────────────────────────────────
+    /**
+     * Get session changes for a checkpoint (live calculation).
      * Returns added/modified/deleted file lists plus per-file line stats.
      */
     async getSessionChanges(checkpointId, handler) {
@@ -55,75 +134,204 @@ export class CheckpointManager {
             return null;
         }
         const changes = await this.calculateChanges(checkpoint, handler);
-        // Calculate line-level stats for modified files
         const stats = [];
-        if (!isRemote) {
-            for (const filePath of changes.modified) {
-                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
-                const currentPath = path.join(checkpoint.cwd, filePath);
-                const lineStat = this.calculateLineStats(snapshotPath, currentPath);
-                stats.push({ filePath, ...lineStat });
-            }
-            // For added files, count all lines as insertions
-            for (const filePath of changes.added) {
-                const currentPath = path.join(checkpoint.cwd, filePath);
-                try {
-                    const content = fs.readFileSync(currentPath, 'utf-8');
-                    const lines = content.split('\n').length;
-                    stats.push({ filePath, insertions: lines, deletions: 0 });
-                }
-                catch {
-                    stats.push({ filePath, insertions: 0, deletions: 0 });
-                }
-            }
-            // For deleted files, count all lines as deletions
-            for (const filePath of changes.deleted) {
-                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
-                try {
-                    const content = fs.readFileSync(snapshotPath, 'utf-8');
-                    const lines = content.split('\n').length;
-                    stats.push({ filePath, insertions: 0, deletions: lines });
+        const manifest = this.readManifest(checkpoint.manifestPath);
+        // V2: use backup-based stats
+        if (this.isV2Manifest(manifest)) {
+            for (const backup of manifest.fileBackups) {
+                const backupPath = path.join(path.dirname(checkpoint.manifestPath), 'backups', backup.filePath);
+                if (isRemote && handler) {
+                    const remotePath = checkpoint.cwd + '/' + backup.filePath;
+                    try {
+                        if (backup.existed) {
+                            // Modified or possibly deleted
+                            const backupContent = fs.readFileSync(backupPath, 'utf-8');
+                            try {
+                                const currentContent = await handler.readFile(remotePath);
+                                if (backupContent !== currentContent) {
+                                    const lineStat = this.calculateLineStatsFromContent(backupContent, currentContent);
+                                    stats.push({ filePath: backup.filePath, ...lineStat });
+                                }
+                            }
+                            catch {
+                                // File was deleted
+                                const lines = backupContent.split('\n').length;
+                                stats.push({ filePath: backup.filePath, insertions: 0, deletions: lines });
+                            }
+                        }
+                        else {
+                            // Created file
+                            try {
+                                const currentContent = await handler.readFile(remotePath);
+                                const lines = currentContent.split('\n').length;
+                                stats.push({ filePath: backup.filePath, insertions: lines, deletions: 0 });
+                            }
+                            catch {
+                                // Created then deleted — no net change
+                            }
+                        }
+                    }
+                    catch {
+                        stats.push({ filePath: backup.filePath, insertions: 0, deletions: 0 });
+                    }
                 }
-                catch {
-                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                else {
+                    // Local
+                    const currentPath = path.join(checkpoint.cwd, backup.filePath);
+                    if (backup.existed) {
+                        if (fs.existsSync(currentPath)) {
+                            // Modified
+                            try {
+                                const lineStat = this.calculateLineStats(backupPath, currentPath);
+                                if (lineStat.insertions > 0 || lineStat.deletions > 0) {
+                                    stats.push({ filePath: backup.filePath, ...lineStat });
+                                }
+                            }
+                            catch {
+                                stats.push({ filePath: backup.filePath, insertions: 0, deletions: 0 });
+                            }
+                        }
+                        else {
+                            // Deleted
+                            try {
+                                const content = fs.readFileSync(backupPath, 'utf-8');
+                                const lines = content.split('\n').length;
+                                stats.push({ filePath: backup.filePath, insertions: 0, deletions: lines });
+                            }
+                            catch {
+                                stats.push({ filePath: backup.filePath, insertions: 0, deletions: 0 });
+                            }
+                        }
+                    }
+                    else {
+                        // Created
+                        if (fs.existsSync(currentPath)) {
+                            try {
+                                const content = fs.readFileSync(currentPath, 'utf-8');
+                                const lines = content.split('\n').length;
+                                stats.push({ filePath: backup.filePath, insertions: lines, deletions: 0 });
+                            }
+                            catch {
+                                stats.push({ filePath: backup.filePath, insertions: 0, deletions: 0 });
+                            }
+                        }
+                        // If file doesn't exist — created then deleted, no stats
+                    }
                 }
             }
         }
-        else if (handler) {
-            // Remote stats: use handler to read remote file contents
-            for (const filePath of changes.modified) {
-                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
-                const remotePath = checkpoint.cwd + '/' + filePath;
-                try {
-                    const snapshotContent = fs.readFileSync(snapshotPath, 'utf-8');
-                    const remoteContent = await handler.readFile(remotePath);
-                    const lineStat = this.calculateLineStatsFromContent(snapshotContent, remoteContent);
-                    stats.push({ filePath, ...lineStat });
-                }
-                catch {
-                    stats.push({ filePath, insertions: 0, deletions: 0 });
+        else {
+            // V1 legacy: use full-scan approach for older checkpoints
+            await this.getSessionChangesV1(checkpoint, changes, stats, isRemote, handler);
+        }
+        return { changes, stats };
+    }
+    /**
+     * Get session changes across ALL checkpoints (for session scope).
+     * Aggregates backups from all checkpoints to find the original state of each file.
+     */
+    async getAggregatedSessionChanges(handler) {
+        if (this.checkpoints.length === 0)
+            return null;
+        // Sort checkpoints by creation time (earliest first)
+        const sorted = [...this.checkpoints].sort((a, b) => a.createdAtMs - b.createdAtMs);
+        const firstCheckpoint = sorted[0];
+        const isRemote = firstCheckpoint.contextType !== 'local';
+        if (isRemote && (!handler || !handler.isConnected()))
+            return null;
+        // Collect original state for each unique file across all checkpoints
+        // The FIRST backup for each file path is the true original
+        const originalBackups = new Map();
+        for (const cp of sorted) {
+            const manifest = this.readManifest(cp.manifestPath);
+            if (!this.isV2Manifest(manifest))
+                continue;
+            for (const backup of manifest.fileBackups) {
+                if (!originalBackups.has(backup.filePath)) {
+                    const backupPath = path.join(path.dirname(cp.manifestPath), 'backups', backup.filePath);
+                    originalBackups.set(backup.filePath, {
+                        existed: backup.existed,
+                        backupPath,
+                        cwd: cp.cwd,
+                    });
                 }
             }
-            for (const filePath of changes.added) {
-                const remotePath = checkpoint.cwd + '/' + filePath;
+        }
+        const changes = { added: [], modified: [], deleted: [] };
+        const stats = [];
+        const cwd = firstCheckpoint.cwd;
+        for (const [filePath, original] of originalBackups) {
+            if (isRemote && handler) {
+                const remotePath = cwd + '/' + filePath;
                 try {
-                    const remoteContent = await handler.readFile(remotePath);
-                    const lines = remoteContent.split('\n').length;
-                    stats.push({ filePath, insertions: lines, deletions: 0 });
+                    if (original.existed) {
+                        const backupContent = fs.readFileSync(original.backupPath, 'utf-8');
+                        try {
+                            const currentContent = await handler.readFile(remotePath);
+                            if (backupContent !== currentContent) {
+                                changes.modified.push(filePath);
+                                const lineStat = this.calculateLineStatsFromContent(backupContent, currentContent);
+                                stats.push({ filePath, ...lineStat });
+                            }
+                        }
+                        catch {
+                            changes.deleted.push(filePath);
+                            const lines = backupContent.split('\n').length;
+                            stats.push({ filePath, insertions: 0, deletions: lines });
+                        }
+                    }
+                    else {
+                        try {
+                            const currentContent = await handler.readFile(remotePath);
+                            changes.added.push(filePath);
+                            const lines = currentContent.split('\n').length;
+                            stats.push({ filePath, insertions: lines, deletions: 0 });
+                        }
+                        catch {
+                            // Created then deleted — no net change
+                        }
+                    }
                 }
                 catch {
-                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                    // Skip on error
                 }
             }
-            for (const filePath of changes.deleted) {
-                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
-                try {
-                    const content = fs.readFileSync(snapshotPath, 'utf-8');
-                    const lines = content.split('\n').length;
-                    stats.push({ filePath, insertions: 0, deletions: lines });
+            else {
+                // Local
+                const currentPath = path.join(cwd, filePath);
+                if (original.existed) {
+                    if (fs.existsSync(currentPath)) {
+                        if (this.filesDiffer(original.backupPath, currentPath)) {
+                            changes.modified.push(filePath);
+                            const lineStat = this.calculateLineStats(original.backupPath, currentPath);
+                            stats.push({ filePath, ...lineStat });
+                        }
+                    }
+                    else {
+                        changes.deleted.push(filePath);
+                        try {
+                            const content = fs.readFileSync(original.backupPath, 'utf-8');
+                            const lines = content.split('\n').length;
+                            stats.push({ filePath, insertions: 0, deletions: lines });
+                        }
+                        catch {
+                            stats.push({ filePath, insertions: 0, deletions: 0 });
+                        }
+                    }
                 }
-                catch {
-                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                else {
+                    if (fs.existsSync(currentPath)) {
+                        changes.added.push(filePath);
+                        try {
+                            const content = fs.readFileSync(currentPath, 'utf-8');
+                            const lines = content.split('\n').length;
+                            stats.push({ filePath, insertions: lines, deletions: 0 });
+                        }
+                        catch {
+                            stats.push({ filePath, insertions: 0, deletions: 0 });
+                        }
+                    }
+                    // If doesn't exist — created then fully reverted, ignore
                 }
             }
         }
@@ -131,115 +339,844 @@ export class CheckpointManager {
     }
     /**
      * Get a unified diff for a single file within a checkpoint.
-     * Compares the snapshot version to the current version.
+     * For V2 checkpoints: compares the backed-up original to the current version.
+     * For V1 checkpoints: compares the full snapshot to the current version (legacy).
      */
     async getFileDiff(checkpointId, filePath, handler) {
         const checkpoint = this.checkpoints.find(cp => cp.id === checkpointId);
         if (!checkpoint)
             return null;
-        const isRemote = checkpoint.contextType !== 'local';
-        const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
-        const snapshotExists = fs.existsSync(snapshotPath);
-        if (isRemote) {
-            if (!handler || !handler.isConnected()) {
-                return null;
-            }
-            const remotePath = checkpoint.cwd + '/' + filePath;
-            let remoteContent = null;
-            try {
-                remoteContent = await handler.readFile(remotePath);
-            }
-            catch {
-                remoteContent = null;
-            }
-            if (!snapshotExists && remoteContent === null) {
-                return null;
-            }
-            // Added file
-            if (!snapshotExists && remoteContent !== null) {
-                const lines = remoteContent.split('\n');
-                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
-                diff += lines.map(l => `+${l}`).join('\n');
-                return diff;
-            }
-            // Deleted file
-            if (snapshotExists && remoteContent === null) {
-                try {
-                    const content = fs.readFileSync(snapshotPath, 'utf-8');
-                    const lines = content.split('\n');
-                    let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
-                    diff += lines.map(l => `-${l}`).join('\n');
-                    return diff;
-                }
-                catch {
-                    return `[Binary or unreadable file: ${filePath}]`;
-                }
-            }
-            // Modified file
-            try {
-                const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
-                const newContent = remoteContent ?? '';
-                return this.generateUnifiedDiff(filePath, oldContent, newContent);
-            }
-            catch {
-                return `[Binary or unreadable file: ${filePath}]`;
-            }
-        }
-        // Local diff (original logic)
-        const currentPath = path.join(checkpoint.cwd, filePath);
-        const currentExists = fs.existsSync(currentPath);
-        if (!snapshotExists && !currentExists) {
-            return null;
+        const manifest = this.readManifest(checkpoint.manifestPath);
+        if (this.isV2Manifest(manifest)) {
+            return this.getFileDiffV2(checkpoint, manifest, filePath, handler);
         }
-        // Added file: show full content as additions
-        if (!snapshotExists && currentExists) {
-            try {
-                const content = fs.readFileSync(currentPath, 'utf-8');
-                const lines = content.split('\n');
-                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
-                diff += lines.map(l => `+${l}`).join('\n');
-                return diff;
-            }
-            catch {
-                return `[Binary or unreadable file: ${filePath}]`;
-            }
+        else {
+            return this.getFileDiffV1(checkpoint, filePath, handler);
         }
-        // Deleted file: show full content as deletions
-        if (snapshotExists && !currentExists) {
-            try {
-                const content = fs.readFileSync(snapshotPath, 'utf-8');
-                const lines = content.split('\n');
-                let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
-                diff += lines.map(l => `-${l}`).join('\n');
-                return diff;
-            }
-            catch {
-                return `[Binary or unreadable file: ${filePath}]`;
+    }
+    /**
+     * Get a session-wide diff for a single file (across all checkpoints).
+     * Finds the earliest backup of the file and compares to current state.
+     */
+    async getSessionFileDiff(filePath, handler) {
+        const sorted = [...this.checkpoints].sort((a, b) => a.createdAtMs - b.createdAtMs);
+        for (const cp of sorted) {
+            const manifest = this.readManifest(cp.manifestPath);
+            if (!this.isV2Manifest(manifest))
+                continue;
+            const backup = manifest.fileBackups.find(b => b.filePath === filePath);
+            if (backup) {
+                return this.getFileDiffV2(cp, manifest, filePath, handler);
             }
         }
-        // Modified file: produce unified diff
-        try {
-            const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
-            const newContent = fs.readFileSync(currentPath, 'utf-8');
-            return this.generateUnifiedDiff(filePath, oldContent, newContent);
-        }
-        catch {
-            return `[Binary or unreadable file: ${filePath}]`;
-        }
+        return null;
     }
     /**
      * Get the initial checkpoint for the current chat session.
-     * This represents the state at the start of the conversation.
      */
     getInitialCheckpoint() {
         if (this.checkpoints.length === 0)
             return null;
-        // Sort by creation time to find the first one
         return [...this.checkpoints].sort((a, b) => a.createdAtMs - b.createdAtMs)[0];
     }
-    /**
-     * Calculate insertions/deletions between two file versions
-     */
+    // ── Checkpoint lifecycle ────────────────────────────────────────────
+    /**
+     * Start a new checkpoint. With V2 (backup-on-write), this is nearly instant:
+     * no file scanning or copying. Just creates the checkpoint metadata and an
+     * empty manifest.
+     */
+    async startCheckpoint(params) {
+        if (!this.currentChatId) {
+            return null;
+        }
+        const checkpointId = this.generateCheckpointId();
+        const checkpointDir = path.join(this.getChatDir(), checkpointId);
+        const backupsDir = path.join(checkpointDir, 'backups');
+        const manifestPath = path.join(checkpointDir, 'manifest.json');
+        try {
+            this.ensureDirSync(backupsDir);
+            // Create an empty V2 manifest — backups will be added incrementally
+            // as the AI tools modify files via backupFileBeforeChange()
+            const manifest = {
+                version: 2,
+                createdAt: new Date().toISOString(),
+                cwd: params.cwd,
+                fileBackups: [],
+                operations: [],
+            };
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+            const meta = {
+                id: checkpointId,
+                prompt: params.prompt,
+                createdAt: new Date().toISOString(),
+                createdAtMs: Date.now(),
+                cwd: params.cwd,
+                contextType: params.contextType,
+                remoteSessionInfo: params.remoteSessionInfo,
+                conversationIndex: params.conversationIndex,
+                uiMessageIndex: params.uiMessageIndex,
+                uiMessageId: params.uiMessageId,
+                // V2: snapshotDir points to 'backups' directory (only has backed-up files)
+                snapshotDir: backupsDir,
+                manifestPath,
+                commands: [],
+                toolCalls: [],
+                status: 'active',
+            };
+            this.checkpoints.push(meta);
+            this.saveIndex();
+            return meta;
+        }
+        catch (error) {
+            logError('Failed to create checkpoint', error);
+            return null;
+        }
+    }
+    async finalizeCheckpoint(id) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === id);
+        if (!checkpoint)
+            return;
+        if (this.discardedIds.has(id)) {
+            this.discardCheckpoint(id);
+            return;
+        }
+        try {
+            const changes = await this.calculateChanges(checkpoint);
+            checkpoint.changes = changes;
+            checkpoint.status = 'finalized';
+            this.saveIndex();
+        }
+        catch (error) {
+            logWarning(`Failed to finalize checkpoint ${id}: ${error.message}`);
+        }
+    }
+    recordToolCall(id, toolCall) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === id);
+        if (!checkpoint || checkpoint.status === 'discarded')
+            return;
+        if (toolCall.id && checkpoint.toolCalls.some(tc => tc.id === toolCall.id)) {
+            return;
+        }
+        checkpoint.toolCalls.push(toolCall);
+        if (toolCall.name === 'execute_command') {
+            const command = toolCall.arguments?.CommandLine || toolCall.arguments?.command;
+            const isShellInput = Boolean(toolCall.arguments?.shell_input);
+            if (command && !isShellInput) {
+                checkpoint.commands.push(String(command));
+            }
+        }
+        if (toolCall.name === 'background_command') {
+            const command = toolCall.arguments?.command;
+            const action = toolCall.arguments?.action;
+            if (command && action === 'start') {
+                checkpoint.commands.push(String(command));
+            }
+        }
+        this.saveIndex();
+    }
+    /**
+     * Revert to a checkpoint. For V2 checkpoints, this is efficient:
+     * only the files the AI actually touched are restored.
+     *
+     * - Files the AI created (existed=false): deleted
+     * - Files the AI modified (existed=true): restored from backup
+     */
+    async revertToCheckpoint(id, handler) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === id);
+        if (!checkpoint) {
+            throw new Error(`Checkpoint "${id}" not found`);
+        }
+        if (checkpoint.contextType !== 'local') {
+            if (!handler || !handler.isConnected()) {
+                const sessionType = checkpoint.contextType.toUpperCase();
+                const sessionInfo = checkpoint.remoteSessionInfo;
+                const target = sessionInfo?.connectionString || sessionInfo?.hostname || 'the remote machine';
+                throw new Error(`This checkpoint was created during a ${sessionType} session (${target}). ` +
+                    `You are not currently connected to that session. Please reconnect to the ${sessionType} session first, then retry /revert.`);
+            }
+        }
+        const manifest = this.readManifest(checkpoint.manifestPath);
+        if (this.isV2Manifest(manifest)) {
+            return this.revertV2(checkpoint, manifest, handler);
+        }
+        else {
+            // Legacy V1 full-scan revert
+            return checkpoint.contextType !== 'local' && handler
+                ? this.revertRemoteCheckpointV1(checkpoint, manifest, handler)
+                : this.revertLocalCheckpointV1(checkpoint, manifest);
+        }
+    }
+    markDiscarded(id) {
+        this.discardedIds.add(id);
+    }
+    removeCheckpointsFrom(id) {
+        const index = this.checkpoints.findIndex(cp => cp.id === id);
+        if (index === -1)
+            return;
+        const toRemove = this.checkpoints.slice(index);
+        for (const checkpoint of toRemove) {
+            this.discardCheckpoint(checkpoint.id);
+        }
+    }
+    discardCheckpointById(id) {
+        this.discardCheckpoint(id);
+    }
+    deleteCheckpointsForChat(chatId) {
+        const chatDir = path.join(this.baseDir, chatId);
+        try {
+            if (fs.existsSync(chatDir)) {
+                fs.rmSync(chatDir, { recursive: true, force: true });
+            }
+        }
+        catch (error) {
+            logWarning(`Failed to delete checkpoints for chat ${chatId}: ${error.message}`);
+        }
+        if (this.currentChatId === chatId) {
+            this.clear();
+        }
+    }
+    // ── V2 Revert (backup-on-write) ────────────────────────────────────
+    async revertV2(checkpoint, manifest, handler) {
+        const isRemote = checkpoint.contextType !== 'local' && handler && handler.isConnected();
+        const errors = [];
+        let restored = 0;
+        let removed = 0;
+        const backupsDir = path.join(path.dirname(checkpoint.manifestPath), 'backups');
+        for (const backup of manifest.fileBackups) {
+            const backupPath = path.join(backupsDir, backup.filePath);
+            if (isRemote && handler) {
+                const remotePath = checkpoint.cwd + '/' + backup.filePath;
+                try {
+                    if (backup.existed) {
+                        // Restore original content
+                        const content = fs.readFileSync(backupPath, 'utf-8');
+                        const remoteDir = remotePath.substring(0, remotePath.lastIndexOf('/'));
+                        await handler.executeCommand(`mkdir -p "${remoteDir}"`);
+                        await handler.writeFile(remotePath, content);
+                        restored++;
+                    }
+                    else {
+                        // File was created by AI — delete it
+                        const result = await handler.executeCommand(`rm -f "${remotePath}"`);
+                        if (result.exitCode === 0) {
+                            removed++;
+                        }
+                        else {
+                            errors.push(`Failed to remove ${backup.filePath}: ${result.stderr}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    errors.push(`Failed to revert ${backup.filePath}: ${error.message}`);
+                }
+            }
+            else {
+                // Local revert
+                const targetPath = path.join(checkpoint.cwd, backup.filePath);
+                try {
+                    if (backup.existed) {
+                        // Restore original content
+                        this.ensureDirSync(path.dirname(targetPath));
+                        fs.copyFileSync(backupPath, targetPath);
+                        restored++;
+                    }
+                    else {
+                        // File was created by AI — delete it
+                        if (fs.existsSync(targetPath)) {
+                            this.removeFileOrDirSync(targetPath);
+                            removed++;
+                        }
+                    }
+                }
+                catch (error) {
+                    errors.push(`Failed to revert ${backup.filePath}: ${error.message}`);
+                }
+            }
+        }
+        // Clean up empty directories left after deleting files
+        if (!isRemote) {
+            this.cleanupEmptyDirectories(checkpoint.cwd, manifest.fileBackups
+                .filter(b => !b.existed)
+                .map(b => b.filePath));
+        }
+        else if (handler) {
+            await this.cleanupEmptyDirectoriesRemote(checkpoint.cwd, manifest.fileBackups
+                .filter(b => !b.existed)
+                .map(b => b.filePath), handler);
+        }
+        return { checkpoint, restored, removed, errors };
+    }
+    // ── V2 Diff ─────────────────────────────────────────────────────────
+    async getFileDiffV2(checkpoint, manifest, filePath, handler) {
+        const backup = manifest.fileBackups.find(b => b.filePath === filePath);
+        if (!backup)
+            return null; // File wasn't touched by AI in this checkpoint
+        const isRemote = checkpoint.contextType !== 'local';
+        const backupPath = path.join(path.dirname(checkpoint.manifestPath), 'backups', filePath);
+        if (isRemote) {
+            if (!handler || !handler.isConnected())
+                return null;
+            const remotePath = checkpoint.cwd + '/' + filePath;
+            let currentContent = null;
+            try {
+                currentContent = await handler.readFile(remotePath);
+            }
+            catch {
+                currentContent = null;
+            }
+            if (!backup.existed && currentContent !== null) {
+                // Added file
+                const lines = currentContent.split('\n');
+                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+                diff += lines.map(l => `+${l}`).join('\n');
+                return diff;
+            }
+            if (backup.existed && currentContent === null) {
+                // Deleted file
+                try {
+                    const content = fs.readFileSync(backupPath, 'utf-8');
+                    const lines = content.split('\n');
+                    let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
+                    diff += lines.map(l => `-${l}`).join('\n');
+                    return diff;
+                }
+                catch {
+                    return `[Binary or unreadable file: ${filePath}]`;
+                }
+            }
+            if (backup.existed && currentContent !== null) {
+                // Modified file
+                try {
+                    const oldContent = fs.readFileSync(backupPath, 'utf-8');
+                    return this.generateUnifiedDiff(filePath, oldContent, currentContent);
+                }
+                catch {
+                    return `[Binary or unreadable file: ${filePath}]`;
+                }
+            }
+            // Created then deleted — no diff
+            return null;
+        }
+        // Local diff
+        const currentPath = path.join(checkpoint.cwd, filePath);
+        const currentExists = fs.existsSync(currentPath);
+        if (!backup.existed && currentExists) {
+            // Added file
+            try {
+                const content = fs.readFileSync(currentPath, 'utf-8');
+                const lines = content.split('\n');
+                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+                diff += lines.map(l => `+${l}`).join('\n');
+                return diff;
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        if (backup.existed && !currentExists) {
+            // Deleted file
+            try {
+                const content = fs.readFileSync(backupPath, 'utf-8');
+                const lines = content.split('\n');
+                let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
+                diff += lines.map(l => `-${l}`).join('\n');
+                return diff;
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        if (backup.existed && currentExists) {
+            // Modified file
+            try {
+                const oldContent = fs.readFileSync(backupPath, 'utf-8');
+                const newContent = fs.readFileSync(currentPath, 'utf-8');
+                return this.generateUnifiedDiff(filePath, oldContent, newContent);
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        // Created then deleted
+        return null;
+    }
+    // ── V1 Legacy Support ───────────────────────────────────────────────
+    /**
+     * V1 diff: uses full snapshot files (legacy checkpoints).
+     */
+    async getFileDiffV1(checkpoint, filePath, handler) {
+        const isRemote = checkpoint.contextType !== 'local';
+        const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+        const snapshotExists = fs.existsSync(snapshotPath);
+        if (isRemote) {
+            if (!handler || !handler.isConnected())
+                return null;
+            const remotePath = checkpoint.cwd + '/' + filePath;
+            let remoteContent = null;
+            try {
+                remoteContent = await handler.readFile(remotePath);
+            }
+            catch {
+                remoteContent = null;
+            }
+            if (!snapshotExists && remoteContent === null)
+                return null;
+            if (!snapshotExists && remoteContent !== null) {
+                const lines = remoteContent.split('\n');
+                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+                diff += lines.map(l => `+${l}`).join('\n');
+                return diff;
+            }
+            if (snapshotExists && remoteContent === null) {
+                try {
+                    const content = fs.readFileSync(snapshotPath, 'utf-8');
+                    const lines = content.split('\n');
+                    let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
+                    diff += lines.map(l => `-${l}`).join('\n');
+                    return diff;
+                }
+                catch {
+                    return `[Binary or unreadable file: ${filePath}]`;
+                }
+            }
+            try {
+                const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
+                const newContent = remoteContent ?? '';
+                return this.generateUnifiedDiff(filePath, oldContent, newContent);
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        // Local V1 diff
+        const currentPath = path.join(checkpoint.cwd, filePath);
+        const currentExists = fs.existsSync(currentPath);
+        if (!snapshotExists && !currentExists)
+            return null;
+        if (!snapshotExists && currentExists) {
+            try {
+                const content = fs.readFileSync(currentPath, 'utf-8');
+                const lines = content.split('\n');
+                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+                diff += lines.map(l => `+${l}`).join('\n');
+                return diff;
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        if (snapshotExists && !currentExists) {
+            try {
+                const content = fs.readFileSync(snapshotPath, 'utf-8');
+                const lines = content.split('\n');
+                let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
+                diff += lines.map(l => `-${l}`).join('\n');
+                return diff;
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        try {
+            const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
+            const newContent = fs.readFileSync(currentPath, 'utf-8');
+            return this.generateUnifiedDiff(filePath, oldContent, newContent);
+        }
+        catch {
+            return `[Binary or unreadable file: ${filePath}]`;
+        }
+    }
+    async getSessionChangesV1(checkpoint, changes, stats, isRemote, handler) {
+        if (!isRemote) {
+            for (const filePath of changes.modified) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                const currentPath = path.join(checkpoint.cwd, filePath);
+                const lineStat = this.calculateLineStats(snapshotPath, currentPath);
+                stats.push({ filePath, ...lineStat });
+            }
+            for (const filePath of changes.added) {
+                const currentPath = path.join(checkpoint.cwd, filePath);
+                try {
+                    const content = fs.readFileSync(currentPath, 'utf-8');
+                    const lines = content.split('\n').length;
+                    stats.push({ filePath, insertions: lines, deletions: 0 });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+            for (const filePath of changes.deleted) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                try {
+                    const content = fs.readFileSync(snapshotPath, 'utf-8');
+                    const lines = content.split('\n').length;
+                    stats.push({ filePath, insertions: 0, deletions: lines });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+        }
+        else if (handler) {
+            for (const filePath of changes.modified) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                const remotePath = checkpoint.cwd + '/' + filePath;
+                try {
+                    const snapshotContent = fs.readFileSync(snapshotPath, 'utf-8');
+                    const remoteContent = await handler.readFile(remotePath);
+                    const lineStat = this.calculateLineStatsFromContent(snapshotContent, remoteContent);
+                    stats.push({ filePath, ...lineStat });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+            for (const filePath of changes.added) {
+                const remotePath = checkpoint.cwd + '/' + filePath;
+                try {
+                    const remoteContent = await handler.readFile(remotePath);
+                    const lines = remoteContent.split('\n').length;
+                    stats.push({ filePath, insertions: lines, deletions: 0 });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+            for (const filePath of changes.deleted) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                try {
+                    const content = fs.readFileSync(snapshotPath, 'utf-8');
+                    const lines = content.split('\n').length;
+                    stats.push({ filePath, insertions: 0, deletions: lines });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+        }
+    }
+    /**
+     * V1 local revert: legacy full-scan approach.
+     */
+    async revertLocalCheckpointV1(checkpoint, manifest) {
+        const manifestSet = new Set(manifest.files.map(file => file.path));
+        const currentFiles = await this.scanLocalFiles(checkpoint.cwd);
+        const errors = [];
+        let removed = 0;
+        for (const filePath of currentFiles) {
+            if (!manifestSet.has(filePath)) {
+                const absolutePath = path.join(checkpoint.cwd, filePath);
+                try {
+                    this.removeFileOrDirSync(absolutePath);
+                    removed++;
+                }
+                catch (error) {
+                    errors.push(`Failed to remove ${filePath}: ${error.message}`);
+                }
+            }
+        }
+        let restored = 0;
+        for (const file of manifest.files) {
+            const sourcePath = path.join(checkpoint.snapshotDir, file.path);
+            const targetPath = path.join(checkpoint.cwd, file.path);
+            try {
+                this.ensureDirSync(path.dirname(targetPath));
+                this.removeFileOrDirSync(targetPath);
+                fs.copyFileSync(sourcePath, targetPath);
+                restored++;
+            }
+            catch (error) {
+                errors.push(`Failed to restore ${file.path}: ${error.message}`);
+            }
+        }
+        // Clean up empty directories
+        const manifestDirs = new Set();
+        for (const file of manifest.files) {
+            let dir = path.dirname(file.path);
+            while (dir && dir !== '.' && dir !== '/') {
+                manifestDirs.add(dir);
+                dir = path.dirname(dir);
+            }
+        }
+        try {
+            const allDirs = this.scanLocalDirectories(checkpoint.cwd, checkpoint.cwd);
+            allDirs.sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
+            for (const dir of allDirs) {
+                if (!manifestDirs.has(dir)) {
+                    const absDir = path.join(checkpoint.cwd, dir);
+                    try {
+                        const entries = fs.readdirSync(absDir);
+                        if (entries.length === 0) {
+                            fs.rmdirSync(absDir);
+                            removed++;
+                        }
+                    }
+                    catch {
+                        // Skip
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-critical
+        }
+        return { checkpoint, restored, removed, errors };
+    }
+    /**
+     * V1 remote revert: legacy full-scan approach.
+     */
+    async revertRemoteCheckpointV1(checkpoint, manifest, handler) {
+        const manifestSet = new Set(manifest.files.map(file => file.path));
+        const currentFiles = await this.scanRemoteFiles(checkpoint.cwd, handler);
+        const errors = [];
+        let removed = 0;
+        for (const filePath of currentFiles) {
+            if (!manifestSet.has(filePath)) {
+                const remotePath = checkpoint.cwd + '/' + filePath;
+                try {
+                    const result = await handler.executeCommand(`rm -f "${remotePath}"`);
+                    if (result.exitCode === 0) {
+                        removed++;
+                    }
+                    else {
+                        errors.push(`Failed to remove ${filePath}: ${result.stderr}`);
+                    }
+                }
+                catch (error) {
+                    errors.push(`Failed to remove ${filePath}: ${error.message}`);
+                }
+            }
+        }
+        let restored = 0;
+        for (const file of manifest.files) {
+            const localSnapshotPath = path.join(checkpoint.snapshotDir, file.path);
+            const remotePath = checkpoint.cwd + '/' + file.path;
+            try {
+                const content = fs.readFileSync(localSnapshotPath, 'utf-8');
+                const remoteDir = remotePath.substring(0, remotePath.lastIndexOf('/'));
+                await handler.executeCommand(`mkdir -p "${remoteDir}"`);
+                await handler.writeFile(remotePath, content);
+                restored++;
+            }
+            catch (error) {
+                errors.push(`Failed to restore ${file.path}: ${error.message}`);
+            }
+        }
+        // Clean up empty directories
+        const manifestDirs = new Set();
+        for (const file of manifest.files) {
+            let dir = file.path.substring(0, file.path.lastIndexOf('/'));
+            while (dir && dir !== '.' && dir !== '/') {
+                manifestDirs.add(dir);
+                const lastSlash = dir.lastIndexOf('/');
+                dir = lastSlash > 0 ? dir.substring(0, lastSlash) : '';
+            }
+        }
+        try {
+            const findDirsCmd = `find "${checkpoint.cwd}" -mindepth 1 -type d 2>/dev/null`;
+            const dirsResult = await handler.executeCommand(findDirsCmd);
+            if (dirsResult.exitCode === 0 && dirsResult.stdout.trim()) {
+                const cwdPrefix = checkpoint.cwd.endsWith('/') ? checkpoint.cwd : checkpoint.cwd + '/';
+                const remoteDirs = dirsResult.stdout
+                    .split('\n')
+                    .map((l) => l.trim())
+                    .filter((l) => l.length > 0 && l.startsWith(cwdPrefix))
+                    .map((l) => l.substring(cwdPrefix.length))
+                    .filter((relPath) => relPath.length > 0);
+                remoteDirs.sort((a, b) => b.split('/').length - a.split('/').length);
+                for (const dir of remoteDirs) {
+                    if (!manifestDirs.has(dir)) {
+                        const remoteDirPath = checkpoint.cwd + '/' + dir;
+                        try {
+                            const rmResult = await handler.executeCommand(`rmdir "${remoteDirPath}" 2>/dev/null`);
+                            if (rmResult.exitCode === 0) {
+                                removed++;
+                            }
+                        }
+                        catch {
+                            // Skip
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-critical
+        }
+        return { checkpoint, restored, removed, errors };
+    }
+    // ── Change calculation ──────────────────────────────────────────────
+    async calculateChanges(checkpoint, handler) {
+        const manifest = this.readManifest(checkpoint.manifestPath);
+        if (this.isV2Manifest(manifest)) {
+            return this.calculateChangesV2(checkpoint, manifest, handler);
+        }
+        else {
+            return this.calculateChangesV1(checkpoint, manifest, handler);
+        }
+    }
+    /**
+     * V2: Calculate changes from backup entries only.
+     * No directory scanning needed — we only track files the AI touched.
+     */
+    async calculateChangesV2(checkpoint, manifest, handler) {
+        const isRemote = checkpoint.contextType !== 'local' && handler && handler.isConnected();
+        const added = [];
+        const modified = [];
+        const deleted = [];
+        for (const backup of manifest.fileBackups) {
+            const backupPath = path.join(path.dirname(checkpoint.manifestPath), 'backups', backup.filePath);
+            if (isRemote && handler) {
+                const remotePath = checkpoint.cwd + '/' + backup.filePath;
+                try {
+                    if (backup.existed) {
+                        try {
+                            const remoteContent = await handler.readFile(remotePath);
+                            const backupContent = fs.readFileSync(backupPath, 'utf-8');
+                            if (remoteContent !== backupContent) {
+                                modified.push(backup.filePath);
+                            }
+                        }
+                        catch {
+                            deleted.push(backup.filePath);
+                        }
+                    }
+                    else {
+                        try {
+                            await handler.readFile(remotePath);
+                            added.push(backup.filePath);
+                        }
+                        catch {
+                            // Created then deleted — no net change
+                        }
+                    }
+                }
+                catch {
+                    // Skip on error
+                }
+            }
+            else {
+                // Local
+                const currentPath = path.join(checkpoint.cwd, backup.filePath);
+                if (backup.existed) {
+                    if (fs.existsSync(currentPath)) {
+                        if (this.filesDiffer(backupPath, currentPath)) {
+                            modified.push(backup.filePath);
+                        }
+                    }
+                    else {
+                        deleted.push(backup.filePath);
+                    }
+                }
+                else {
+                    if (fs.existsSync(currentPath)) {
+                        added.push(backup.filePath);
+                    }
+                    // If doesn't exist — created then deleted, no change
+                }
+            }
+        }
+        return { added, modified, deleted };
+    }
+    /**
+     * V1 legacy: full directory scan approach.
+     */
+    async calculateChangesV1(checkpoint, manifest, handler) {
+        const manifestSet = new Set(manifest.files.map(file => file.path));
+        const isRemote = checkpoint.contextType !== 'local' && handler && handler.isConnected();
+        const currentFiles = isRemote
+            ? await this.scanRemoteFiles(checkpoint.cwd, handler)
+            : await this.scanLocalFiles(checkpoint.cwd);
+        const currentSet = new Set(currentFiles);
+        const added = [];
+        const deleted = [];
+        const modified = [];
+        for (const filePath of currentFiles) {
+            if (!manifestSet.has(filePath)) {
+                added.push(filePath);
+            }
+        }
+        for (const file of manifest.files) {
+            if (!currentSet.has(file.path)) {
+                deleted.push(file.path);
+                continue;
+            }
+            if (isRemote && handler) {
+                try {
+                    const remotePath = checkpoint.cwd + '/' + file.path;
+                    const remoteContent = await handler.readFile(remotePath);
+                    const snapshotPath = path.join(checkpoint.snapshotDir, file.path);
+                    const snapshotContent = fs.readFileSync(snapshotPath, 'utf-8');
+                    if (remoteContent !== snapshotContent) {
+                        modified.push(file.path);
+                    }
+                }
+                catch {
+                    modified.push(file.path);
+                }
+            }
+            else {
+                const currentPath = path.join(checkpoint.cwd, file.path);
+                const snapshotPath = path.join(checkpoint.snapshotDir, file.path);
+                if (this.filesDiffer(snapshotPath, currentPath)) {
+                    modified.push(file.path);
+                }
+            }
+        }
+        return { added, modified, deleted };
+    }
+    // ── Helpers: directory cleanup ──────────────────────────────────────
+    /**
+     * Clean up empty directories after deleting files that the AI created.
+     */
+    cleanupEmptyDirectories(cwd, deletedRelPaths) {
+        // Gather unique parent directories of deleted files, sorted deepest first
+        const dirs = new Set();
+        for (const relPath of deletedRelPaths) {
+            let dir = path.dirname(relPath);
+            while (dir && dir !== '.' && dir !== '/' && dir !== '\\') {
+                dirs.add(dir);
+                dir = path.dirname(dir);
+            }
+        }
+        const sortedDirs = Array.from(dirs).sort((a, b) => b.split('/').length - a.split('/').length);
+        for (const dir of sortedDirs) {
+            const absDir = path.join(cwd, dir);
+            try {
+                if (fs.existsSync(absDir)) {
+                    const entries = fs.readdirSync(absDir);
+                    if (entries.length === 0) {
+                        fs.rmdirSync(absDir);
+                    }
+                }
+            }
+            catch {
+                // Best-effort
+            }
+        }
+    }
+    async cleanupEmptyDirectoriesRemote(cwd, deletedRelPaths, handler) {
+        const dirs = new Set();
+        for (const relPath of deletedRelPaths) {
+            let dir = relPath.substring(0, relPath.lastIndexOf('/'));
+            while (dir && dir !== '.' && dir !== '/') {
+                dirs.add(dir);
+                const lastSlash = dir.lastIndexOf('/');
+                dir = lastSlash > 0 ? dir.substring(0, lastSlash) : '';
+            }
+        }
+        const sortedDirs = Array.from(dirs).sort((a, b) => b.split('/').length - a.split('/').length);
+        for (const dir of sortedDirs) {
+            const remoteDirPath = cwd + '/' + dir;
+            try {
+                await handler.executeCommand(`rmdir "${remoteDirPath}" 2>/dev/null`);
+            }
+            catch {
+                // Best-effort
+            }
+        }
+    }
+    // ── Helpers: line stats and diff generation ─────────────────────────
     calculateLineStats(snapshotPath, currentPath) {
         try {
             const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
@@ -253,7 +1190,6 @@ export class CheckpointManager {
     calculateLineStatsFromContent(oldContent, newContent) {
         const oldLines = oldContent.split('\n');
         const newLines = newContent.split('\n');
-        // Simple LCS-based diff to count insertions and deletions
         const oldSet = new Map();
         for (const line of oldLines) {
             oldSet.set(line, (oldSet.get(line) || 0) + 1);
@@ -278,15 +1214,10 @@ export class CheckpointManager {
         }
         return { insertions, deletions };
     }
-    /**
-     * Generate a unified diff between old and new content
-     */
     generateUnifiedDiff(filePath, oldContent, newContent) {
         const oldLines = oldContent.split('\n');
         const newLines = newContent.split('\n');
-        // Use a simple diff algorithm: find common prefix/suffix, then show changes
         let result = `--- a/${filePath}\n+++ b/${filePath}\n`;
-        // Find changed regions using a simple approach
         const hunks = this.computeHunks(oldLines, newLines);
         if (hunks.length === 0) {
             return `No differences found in ${filePath}`;
@@ -299,11 +1230,7 @@ export class CheckpointManager {
         }
         return result;
     }
-    /**
-     * Compute diff hunks between old and new lines using Myers-like approach
-     */
     computeHunks(oldLines, newLines) {
-        // Build an edit script using LCS
         const lcs = this.longestCommonSubsequence(oldLines, newLines);
         const editScript = [];
         let oldIdx = 0;
@@ -326,7 +1253,6 @@ export class CheckpointManager {
                 newIdx++;
             }
         }
-        // Group into hunks with context (3 lines)
         const CONTEXT = 3;
         const hunks = [];
         let currentHunk = null;
@@ -334,9 +1260,7 @@ export class CheckpointManager {
         for (let i = 0; i < editScript.length; i++) {
             const edit = editScript[i];
             if (edit.type !== 'keep') {
-                // Start a new hunk or extend current
                 if (!currentHunk) {
-                    // Look back for context
                     const contextStart = Math.max(0, i - CONTEXT);
                     currentHunk = {
                         oldStart: editScript[contextStart]?.oldIdx ?? edit.oldIdx,
@@ -370,528 +1294,147 @@ export class CheckpointManager {
                     currentHunk.oldCount++;
                     currentHunk.newCount++;
                 }
-                else {
-                    // End the hunk
-                    hunks.push(currentHunk);
-                    currentHunk = null;
-                    contextCounter = 0;
-                }
-            }
-        }
-        if (currentHunk) {
-            hunks.push(currentHunk);
-        }
-        return hunks;
-    }
-    /**
-     * Compute longest common subsequence of two string arrays
-     * Uses optimized approach for large files (limit LCS table size)
-     */
-    longestCommonSubsequence(a, b) {
-        // For very large files, use a simpler approach
-        if (a.length > 1000 || b.length > 1000) {
-            return this.simpleLCS(a, b);
-        }
-        const m = a.length;
-        const n = b.length;
-        const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-        for (let i = 1; i <= m; i++) {
-            for (let j = 1; j <= n; j++) {
-                if (a[i - 1] === b[j - 1]) {
-                    dp[i][j] = dp[i - 1][j - 1] + 1;
-                }
-                else {
-                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-                }
-            }
-        }
-        // Backtrack
-        const result = [];
-        let i = m, j = n;
-        while (i > 0 && j > 0) {
-            if (a[i - 1] === b[j - 1]) {
-                result.unshift(a[i - 1]);
-                i--;
-                j--;
-            }
-            else if (dp[i - 1][j] > dp[i][j - 1]) {
-                i--;
-            }
-            else {
-                j--;
-            }
-        }
-        return result;
-    }
-    /**
-     * Simple LCS for large files - uses hash-based matching
-     */
-    simpleLCS(a, b) {
-        const bMap = new Map();
-        for (let i = 0; i < b.length; i++) {
-            const positions = bMap.get(b[i]) || [];
-            positions.push(i);
-            bMap.set(b[i], positions);
-        }
-        const result = [];
-        let lastMatchB = -1;
-        for (let i = 0; i < a.length; i++) {
-            const positions = bMap.get(a[i]);
-            if (positions) {
-                // Find earliest position after lastMatchB
-                for (const pos of positions) {
-                    if (pos > lastMatchB) {
-                        result.push(a[i]);
-                        lastMatchB = pos;
-                        break;
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    markDiscarded(id) {
-        this.discardedIds.add(id);
-    }
-    async startCheckpoint(params) {
-        if (!this.currentChatId) {
-            return null;
-        }
-        const checkpointId = this.generateCheckpointId();
-        const checkpointDir = path.join(this.getChatDir(), checkpointId);
-        const snapshotDir = path.join(checkpointDir, 'snapshot');
-        const manifestPath = path.join(checkpointDir, 'manifest.json');
-        try {
-            this.ensureDirSync(snapshotDir);
-            // Use remote snapshot when a handler is provided (SSH/WSL/Docker sessions)
-            const isRemote = params.contextType !== 'local' && params.handler;
-            const manifest = isRemote
-                ? await this.createRemoteSnapshot(params.cwd, snapshotDir, params.handler)
-                : await this.createSnapshot(params.cwd, snapshotDir);
-            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
-            const meta = {
-                id: checkpointId,
-                prompt: params.prompt,
-                createdAt: new Date().toISOString(),
-                createdAtMs: Date.now(),
-                cwd: params.cwd,
-                contextType: params.contextType,
-                remoteSessionInfo: params.remoteSessionInfo,
-                conversationIndex: params.conversationIndex,
-                uiMessageIndex: params.uiMessageIndex,
-                uiMessageId: params.uiMessageId,
-                snapshotDir,
-                manifestPath,
-                commands: [],
-                toolCalls: [],
-                status: 'active',
-            };
-            this.checkpoints.push(meta);
-            this.saveIndex();
-            return meta;
-        }
-        catch (error) {
-            logError('Failed to create checkpoint snapshot', error);
-            return null;
-        }
-    }
-    async finalizeCheckpoint(id) {
-        const checkpoint = this.checkpoints.find(cp => cp.id === id);
-        if (!checkpoint)
-            return;
-        if (this.discardedIds.has(id)) {
-            this.discardCheckpoint(id);
-            return;
-        }
-        try {
-            const changes = await this.calculateChanges(checkpoint);
-            checkpoint.changes = changes;
-            checkpoint.status = 'finalized';
-            this.saveIndex();
-        }
-        catch (error) {
-            logWarning(`Failed to finalize checkpoint ${id}: ${error.message}`);
-        }
-    }
-    recordToolCall(id, toolCall) {
-        const checkpoint = this.checkpoints.find(cp => cp.id === id);
-        if (!checkpoint || checkpoint.status === 'discarded')
-            return;
-        if (toolCall.id && checkpoint.toolCalls.some(tc => tc.id === toolCall.id)) {
-            return;
-        }
-        checkpoint.toolCalls.push(toolCall);
-        if (toolCall.name === 'execute_command') {
-            const command = toolCall.arguments?.CommandLine || toolCall.arguments?.command;
-            const isShellInput = Boolean(toolCall.arguments?.shell_input);
-            if (command && !isShellInput) {
-                checkpoint.commands.push(String(command));
-            }
-        }
-        if (toolCall.name === 'background_command') {
-            const command = toolCall.arguments?.command;
-            const action = toolCall.arguments?.action;
-            if (command && action === 'start') {
-                checkpoint.commands.push(String(command));
-            }
-        }
-        this.saveIndex();
-    }
-    async revertToCheckpoint(id, handler) {
-        const checkpoint = this.checkpoints.find(cp => cp.id === id);
-        if (!checkpoint) {
-            throw new Error(`Checkpoint "${id}" not found`);
-        }
-        // Remote checkpoint requires a connected handler to revert
-        if (checkpoint.contextType !== 'local') {
-            if (!handler || !handler.isConnected()) {
-                const sessionType = checkpoint.contextType.toUpperCase();
-                const sessionInfo = checkpoint.remoteSessionInfo;
-                const target = sessionInfo?.connectionString || sessionInfo?.hostname || 'the remote machine';
-                throw new Error(`This checkpoint was created during a ${sessionType} session (${target}). ` +
-                    `You are not currently connected to that session. Please reconnect to the ${sessionType} session first, then retry /revert.`);
-            }
-            return this.revertRemoteCheckpoint(checkpoint, handler);
-        }
-        // Local revert (original logic)
-        const manifest = this.readManifest(checkpoint.manifestPath);
-        const manifestSet = new Set(manifest.files.map(file => file.path));
-        const currentFiles = await this.scanFiles(checkpoint.cwd);
-        const errors = [];
-        let removed = 0;
-        for (const filePath of currentFiles) {
-            if (!manifestSet.has(filePath)) {
-                const absolutePath = path.join(checkpoint.cwd, filePath);
-                try {
-                    this.removeFileOrDirSync(absolutePath);
-                    removed++;
-                }
-                catch (error) {
-                    errors.push(`Failed to remove ${filePath}: ${error.message}`);
-                }
-            }
-        }
-        let restored = 0;
-        for (const file of manifest.files) {
-            const sourcePath = path.join(checkpoint.snapshotDir, file.path);
-            const targetPath = path.join(checkpoint.cwd, file.path);
-            try {
-                this.ensureDirSync(path.dirname(targetPath));
-                this.removeFileOrDirSync(targetPath);
-                fs.copyFileSync(sourcePath, targetPath);
-                restored++;
-            }
-            catch (error) {
-                errors.push(`Failed to restore ${file.path}: ${error.message}`);
-            }
-        }
-        // Clean up empty directories that were created after the checkpoint
-        // Build the set of directories that existed in the manifest
-        const manifestDirs = new Set();
-        for (const file of manifest.files) {
-            let dir = path.dirname(file.path);
-            while (dir && dir !== '.' && dir !== '/') {
-                manifestDirs.add(dir);
-                dir = path.dirname(dir);
-            }
-        }
-        // Walk the cwd and find directories not in the manifest, remove if empty (deepest first)
-        try {
-            const allDirs = this.scanLocalDirectories(checkpoint.cwd, checkpoint.cwd);
-            // Sort deepest first so nested empty dirs are removed before their parents
-            allDirs.sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
-            for (const dir of allDirs) {
-                if (!manifestDirs.has(dir)) {
-                    const absDir = path.join(checkpoint.cwd, dir);
-                    try {
-                        const entries = fs.readdirSync(absDir);
-                        if (entries.length === 0) {
-                            fs.rmdirSync(absDir);
-                            removed++;
-                        }
-                    }
-                    catch {
-                        // Directory may already be gone or inaccessible, skip
-                    }
-                }
-            }
-        }
-        catch {
-            // Non-critical: directory cleanup is best-effort
-        }
-        return { checkpoint, restored, removed, errors };
-    }
-    /**
-     * Revert a remote checkpoint by uploading snapshot files back to the remote machine.
-     */
-    async revertRemoteCheckpoint(checkpoint, handler) {
-        const manifest = this.readManifest(checkpoint.manifestPath);
-        const manifestSet = new Set(manifest.files.map(file => file.path));
-        const currentFiles = await this.scanRemoteFiles(checkpoint.cwd, handler);
-        const errors = [];
-        // Remove files that were added after the checkpoint
-        let removed = 0;
-        for (const filePath of currentFiles) {
-            if (!manifestSet.has(filePath)) {
-                const remotePath = checkpoint.cwd + '/' + filePath;
-                try {
-                    const result = await handler.executeCommand(`rm -f "${remotePath}"`);
-                    if (result.exitCode === 0) {
-                        removed++;
-                    }
-                    else {
-                        errors.push(`Failed to remove ${filePath}: ${result.stderr}`);
-                    }
-                }
-                catch (error) {
-                    errors.push(`Failed to remove ${filePath}: ${error.message}`);
+                else {
+                    hunks.push(currentHunk);
+                    currentHunk = null;
+                    contextCounter = 0;
                 }
             }
         }
-        // Restore files from the snapshot
-        let restored = 0;
-        for (const file of manifest.files) {
-            const localSnapshotPath = path.join(checkpoint.snapshotDir, file.path);
-            const remotePath = checkpoint.cwd + '/' + file.path;
-            try {
-                // Read the snapshot content from local storage
-                const content = fs.readFileSync(localSnapshotPath, 'utf-8');
-                // Ensure remote directory exists
-                const remoteDir = remotePath.substring(0, remotePath.lastIndexOf('/'));
-                await handler.executeCommand(`mkdir -p "${remoteDir}"`);
-                // Write the file back to the remote machine
-                await handler.writeFile(remotePath, content);
-                restored++;
-            }
-            catch (error) {
-                errors.push(`Failed to restore ${file.path}: ${error.message}`);
-            }
+        if (currentHunk) {
+            hunks.push(currentHunk);
         }
-        // Clean up empty directories that were created after the checkpoint
-        // Build the set of directories referenced by manifest files
-        const manifestDirs = new Set();
-        for (const file of manifest.files) {
-            let dir = file.path.substring(0, file.path.lastIndexOf('/'));
-            while (dir && dir !== '.' && dir !== '/') {
-                manifestDirs.add(dir);
-                const lastSlash = dir.lastIndexOf('/');
-                dir = lastSlash > 0 ? dir.substring(0, lastSlash) : '';
-            }
+        return hunks;
+    }
+    longestCommonSubsequence(a, b) {
+        if (a.length > 1000 || b.length > 1000) {
+            return this.simpleLCS(a, b);
         }
-        // Find all current directories on the remote and remove empty ones not in the manifest
-        try {
-            const findDirsCmd = `find "${checkpoint.cwd}" -mindepth 1 -type d 2>/dev/null`;
-            const dirsResult = await handler.executeCommand(findDirsCmd);
-            if (dirsResult.exitCode === 0 && dirsResult.stdout.trim()) {
-                const cwdPrefix = checkpoint.cwd.endsWith('/') ? checkpoint.cwd : checkpoint.cwd + '/';
-                const remoteDirs = dirsResult.stdout
-                    .split('\n')
-                    .map((l) => l.trim())
-                    .filter((l) => l.length > 0 && l.startsWith(cwdPrefix))
-                    .map((l) => l.substring(cwdPrefix.length))
-                    .filter((relPath) => relPath.length > 0);
-                // Sort deepest first so nested empty dirs are removed before their parents
-                remoteDirs.sort((a, b) => b.split('/').length - a.split('/').length);
-                for (const dir of remoteDirs) {
-                    if (!manifestDirs.has(dir)) {
-                        const remoteDirPath = checkpoint.cwd + '/' + dir;
-                        try {
-                            // rmdir only removes empty directories (safe)
-                            const rmResult = await handler.executeCommand(`rmdir "${remoteDirPath}" 2>/dev/null`);
-                            if (rmResult.exitCode === 0) {
-                                removed++;
-                            }
-                        }
-                        catch {
-                            // Directory not empty or inaccessible, skip
-                        }
-                    }
+        const m = a.length;
+        const n = b.length;
+        const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                if (a[i - 1] === b[j - 1]) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                }
+                else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                 }
             }
         }
-        catch {
-            // Non-critical: directory cleanup is best-effort
+        const result = [];
+        let i = m, j = n;
+        while (i > 0 && j > 0) {
+            if (a[i - 1] === b[j - 1]) {
+                result.unshift(a[i - 1]);
+                i--;
+                j--;
+            }
+            else if (dp[i - 1][j] > dp[i][j - 1]) {
+                i--;
+            }
+            else {
+                j--;
+            }
         }
-        return { checkpoint, restored, removed, errors };
+        return result;
     }
-    removeCheckpointsFrom(id) {
-        const index = this.checkpoints.findIndex(cp => cp.id === id);
-        if (index === -1)
-            return;
-        // Remove checkpoints FROM the given checkpoint (INCLUDING the checkpoint itself)
-        // This is used during revert - the reverted checkpoint is also removed
-        // because the user will re-submit the prompt
-        const toRemove = this.checkpoints.slice(index);
-        for (const checkpoint of toRemove) {
-            this.discardCheckpoint(checkpoint.id);
+    simpleLCS(a, b) {
+        const bMap = new Map();
+        for (let i = 0; i < b.length; i++) {
+            const positions = bMap.get(b[i]) || [];
+            positions.push(i);
+            bMap.set(b[i], positions);
         }
-    }
-    /**
-     * Discard a single checkpoint by id.
-     * Used when a background/late checkpoint should not be kept.
-     */
-    discardCheckpointById(id) {
-        this.discardCheckpoint(id);
-    }
-    deleteCheckpointsForChat(chatId) {
-        const chatDir = path.join(this.baseDir, chatId);
-        try {
-            if (fs.existsSync(chatDir)) {
-                fs.rmSync(chatDir, { recursive: true, force: true });
+        const result = [];
+        let lastMatchB = -1;
+        for (let i = 0; i < a.length; i++) {
+            const positions = bMap.get(a[i]);
+            if (positions) {
+                for (const pos of positions) {
+                    if (pos > lastMatchB) {
+                        result.push(a[i]);
+                        lastMatchB = pos;
+                        break;
+                    }
+                }
             }
         }
-        catch (error) {
-            logWarning(`Failed to delete checkpoints for chat ${chatId}: ${error.message}`);
-        }
-        if (this.currentChatId === chatId) {
-            this.clear();
-        }
+        return result;
     }
-    discardCheckpoint(id) {
-        const checkpointIndex = this.checkpoints.findIndex(cp => cp.id === id);
-        if (checkpointIndex === -1)
-            return;
-        const [checkpoint] = this.checkpoints.splice(checkpointIndex, 1);
-        this.discardedIds.delete(id);
+    // ── Helpers: file operations ────────────────────────────────────────
+    filesDiffer(snapshotPath, currentPath) {
         try {
-            if (fs.existsSync(path.dirname(checkpoint.manifestPath))) {
-                fs.rmSync(path.dirname(checkpoint.manifestPath), { recursive: true, force: true });
+            const snapStat = fs.statSync(snapshotPath);
+            const currStat = fs.statSync(currentPath);
+            if (snapStat.size !== currStat.size) {
+                return true;
+            }
+            const snapBuffer = fs.readFileSync(snapshotPath);
+            const currBuffer = fs.readFileSync(currentPath);
+            if (snapBuffer.length !== currBuffer.length) {
+                return true;
             }
+            return !snapBuffer.equals(currBuffer);
         }
-        catch (error) {
-            logWarning(`Failed to delete checkpoint ${id}: ${error.message}`);
+        catch {
+            return true;
         }
-        this.saveIndex();
     }
-    async calculateChanges(checkpoint, handler) {
-        const manifest = this.readManifest(checkpoint.manifestPath);
-        const manifestSet = new Set(manifest.files.map(file => file.path));
-        // Use remote scanning when checkpoint is remote and handler is available
-        const isRemote = checkpoint.contextType !== 'local' && handler && handler.isConnected();
-        const currentFiles = isRemote
-            ? await this.scanRemoteFiles(checkpoint.cwd, handler)
-            : await this.scanFiles(checkpoint.cwd);
-        const currentSet = new Set(currentFiles);
-        const added = [];
-        const deleted = [];
-        const modified = [];
-        for (const filePath of currentFiles) {
-            if (!manifestSet.has(filePath)) {
-                added.push(filePath);
-            }
-        }
-        for (const file of manifest.files) {
-            if (!currentSet.has(file.path)) {
-                deleted.push(file.path);
-                continue;
-            }
-            if (isRemote) {
-                // For remote: read current file from remote and compare with local snapshot
-                try {
-                    const remotePath = checkpoint.cwd + '/' + file.path;
-                    const remoteContent = await handler.readFile(remotePath);
-                    const snapshotPath = path.join(checkpoint.snapshotDir, file.path);
-                    const snapshotContent = fs.readFileSync(snapshotPath, 'utf-8');
-                    if (remoteContent !== snapshotContent) {
-                        modified.push(file.path);
-                    }
-                }
-                catch {
-                    modified.push(file.path); // Assume modified if we can't read
-                }
-            }
-            else {
-                const currentPath = path.join(checkpoint.cwd, file.path);
-                const snapshotPath = path.join(checkpoint.snapshotDir, file.path);
-                if (this.filesDiffer(snapshotPath, currentPath)) {
-                    modified.push(file.path);
-                }
-            }
+    removeFileOrDirSync(targetPath) {
+        if (!fs.existsSync(targetPath))
+            return;
+        const stat = fs.lstatSync(targetPath);
+        if (stat.isDirectory()) {
+            fs.rmSync(targetPath, { recursive: true, force: true });
+            return;
         }
-        return { added, modified, deleted };
+        fs.rmSync(targetPath, { force: true });
     }
+    // ── Helpers: manifest & index I/O ───────────────────────────────────
     readManifest(manifestPath) {
         const raw = fs.readFileSync(manifestPath, 'utf-8');
         return JSON.parse(raw);
     }
-    async createSnapshot(cwd, snapshotDir) {
-        const files = await this.scanFiles(cwd);
-        const manifestEntries = [];
-        for (const filePath of files) {
-            const absolutePath = path.join(cwd, filePath);
-            try {
-                const stat = fs.statSync(absolutePath);
-                if (!stat.isFile())
-                    continue;
-                const snapshotPath = path.join(snapshotDir, filePath);
-                this.ensureDirSync(path.dirname(snapshotPath));
-                fs.copyFileSync(absolutePath, snapshotPath);
-                manifestEntries.push({
-                    path: filePath,
-                    size: stat.size,
-                    mtimeMs: stat.mtimeMs,
-                    mode: stat.mode,
-                });
-            }
-            catch (error) {
-                logWarning(`Failed to snapshot ${filePath}: ${error.message}`);
-            }
+    readManifestV2(manifestPath) {
+        const raw = fs.readFileSync(manifestPath, 'utf-8');
+        const manifest = JSON.parse(raw);
+        // Already V2 or convert
+        if (manifest.version === 2) {
+            return manifest;
         }
+        // Return default V2 structure if called on an unexpected manifest
         return {
-            version: 1,
-            createdAt: new Date().toISOString(),
-            cwd,
-            files: manifestEntries,
+            version: 2,
+            createdAt: manifest.createdAt || new Date().toISOString(),
+            cwd: manifest.cwd || '',
+            fileBackups: [],
+            operations: [],
         };
     }
-    /**
-     * Create a snapshot of remote files by downloading them via the handler.
-     * Files are stored locally in the snapshot directory for later comparison/revert.
-     */
-    async createRemoteSnapshot(cwd, snapshotDir, handler) {
-        const files = await this.scanRemoteFiles(cwd, handler);
-        const manifestEntries = [];
-        for (const filePath of files) {
-            const remotePath = cwd + '/' + filePath;
-            try {
-                const content = await handler.readFile(remotePath);
-                const snapshotPath = path.join(snapshotDir, filePath);
-                this.ensureDirSync(path.dirname(snapshotPath));
-                fs.writeFileSync(snapshotPath, content, 'utf-8');
-                const contentBuffer = Buffer.from(content, 'utf-8');
-                manifestEntries.push({
-                    path: filePath,
-                    size: contentBuffer.length,
-                    mtimeMs: Date.now(),
-                    mode: 0o644,
-                });
-            }
-            catch (error) {
-                logWarning(`Failed to snapshot remote file ${filePath}: ${error.message}`);
-            }
-        }
-        return {
-            version: 1,
-            createdAt: new Date().toISOString(),
-            cwd,
-            files: manifestEntries,
-        };
+    isV2Manifest(manifest) {
+        return manifest.version === 2;
     }
-    async scanFiles(cwd) {
+    // ── Helpers: file scanning (only used for V1 legacy) ────────────────
+    async scanLocalFiles(cwd) {
+        const fg = (await import('fast-glob')).default;
         const files = await fg(['**/*'], {
             cwd,
             dot: true,
             onlyFiles: true,
             followSymbolicLinks: false,
             unique: true,
-            ignore: DEFAULT_IGNORE_PATTERNS,
+            ignore: [
+                '**/.git/**', '**/node_modules/**', '**/dist/**', '**/build/**',
+                '**/out/**', '**/.next/**', '**/.turbo/**', '**/.cache/**',
+                '**/coverage/**', '**/__pycache__/**', '**/.venv/**', '**/venv/**',
+                '**/.idea/**', '**/.vscode/**', '**/.DS_Store', '**/Thumbs.db',
+                '**/.centaurus/**',
+            ],
         });
         return files.map((file) => file.replace(/\\/g, '/'));
     }
-    /**
-     * Recursively scan all subdirectories under root, returning relative paths.
-     * Used by local revert to find directories that may need cleanup.
-     */
     scanLocalDirectories(rootDir, cwd) {
         const dirs = [];
         const ignoreDirs = new Set([
@@ -918,12 +1461,7 @@ export class CheckpointManager {
         walk(rootDir);
         return dirs;
     }
-    /**
-     * Scan files on a remote machine using the handler's executeCommand.
-     * Uses `find` with ignore patterns equivalent to DEFAULT_IGNORE_PATTERNS.
-     */
     async scanRemoteFiles(cwd, handler) {
-        // Build find command with exclusion patterns matching DEFAULT_IGNORE_PATTERNS
         const excludeDirs = [
             '.git', 'node_modules', 'dist', 'build', 'out',
             '.next', '.turbo', '.cache', 'coverage',
@@ -932,7 +1470,6 @@ export class CheckpointManager {
         const excludeFiles = ['.DS_Store', 'Thumbs.db'];
         const pruneArgs = excludeDirs.map(d => `-name "${d}" -prune`).join(' -o ');
         const notFileArgs = excludeFiles.map(f => `! -name "${f}"`).join(' ');
-        // find <cwd> ( -name .git -prune -o ... ) -o -type f ! -name .DS_Store ... -print
         const findCmd = `find "${cwd}" \\( ${pruneArgs} \\) -o -type f ${notFileArgs} -print 2>/dev/null`;
         try {
             const result = await handler.executeCommand(findCmd);
@@ -953,33 +1490,22 @@ export class CheckpointManager {
             return [];
         }
     }
-    filesDiffer(snapshotPath, currentPath) {
+    // ── Helpers: checkpoint management ──────────────────────────────────
+    discardCheckpoint(id) {
+        const checkpointIndex = this.checkpoints.findIndex(cp => cp.id === id);
+        if (checkpointIndex === -1)
+            return;
+        const [checkpoint] = this.checkpoints.splice(checkpointIndex, 1);
+        this.discardedIds.delete(id);
         try {
-            const snapStat = fs.statSync(snapshotPath);
-            const currStat = fs.statSync(currentPath);
-            if (snapStat.size !== currStat.size) {
-                return true;
-            }
-            const snapBuffer = fs.readFileSync(snapshotPath);
-            const currBuffer = fs.readFileSync(currentPath);
-            if (snapBuffer.length !== currBuffer.length) {
-                return true;
+            if (fs.existsSync(path.dirname(checkpoint.manifestPath))) {
+                fs.rmSync(path.dirname(checkpoint.manifestPath), { recursive: true, force: true });
             }
-            return !snapBuffer.equals(currBuffer);
-        }
-        catch {
-            return true;
         }
-    }
-    removeFileOrDirSync(targetPath) {
-        if (!fs.existsSync(targetPath))
-            return;
-        const stat = fs.lstatSync(targetPath);
-        if (stat.isDirectory()) {
-            fs.rmSync(targetPath, { recursive: true, force: true });
-            return;
+        catch (error) {
+            logWarning(`Failed to delete checkpoint ${id}: ${error.message}`);
         }
-        fs.rmSync(targetPath, { force: true });
+        this.saveIndex();
     }
     generateCheckpointId() {
         const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '');