centaurus-cli 3.0.0 → 3.1.0

package/dist/services/checkpoint-manager.js

@@ -1,1035 +1,1575 @@
-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;
-    discardedIds = new Set();
-    baseDir;
-    constructor() {
-        this.baseDir = path.join(os.homedir(), '.centaurus', 'checkpoints');
-        this.ensureDirSync(this.baseDir);
-    }
-    setCurrentChatId(chatId) {
-        this.currentChatId = chatId;
-        this.loadIndex();
-    }
-    clear() {
-        this.checkpoints = [];
-        this.discardedIds.clear();
-    }
-    list() {
-        return [...this.checkpoints].sort((a, b) => b.createdAtMs - a.createdAtMs);
-    }
-    /**
-     * Get session changes for an active checkpoint (live calculation).
-     * Returns added/modified/deleted file lists plus per-file line stats.
-     */
-    async getSessionChanges(checkpointId, handler) {
-        const checkpoint = this.checkpoints.find(cp => cp.id === checkpointId);
-        if (!checkpoint)
-            return null;
-        const isRemote = checkpoint.contextType !== 'local';
-        if (isRemote && (!handler || !handler.isConnected())) {
-            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 });
-                }
-                catch {
-                    stats.push({ filePath, insertions: 0, deletions: 0 });
-                }
-            }
-        }
-        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 });
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { logError, logWarning } from "../utils/logger.js";
+import { quickLog } from "../utils/conversation-logger.js";
+class CheckpointManager {
+  checkpoints = [];
+  currentChatId = null;
+  discardedIds = /* @__PURE__ */ new Set();
+  baseDir;
+  constructor() {
+    this.baseDir = path.join(os.homedir(), ".centaurus", "checkpoints");
+    this.ensureDirSync(this.baseDir);
+  }
+  setCurrentChatId(chatId) {
+    this.currentChatId = chatId;
+    this.loadIndex();
+  }
+  clear() {
+    this.checkpoints = [];
+    this.discardedIds.clear();
+  }
+  list() {
+    return [...this.checkpoints].sort((a, b) => b.createdAtMs - a.createdAtMs);
+  }
+  /**
+   * Merge checkpoint metadata restored from chat history into in-memory state.
+   * This acts as a fallback when checkpoint index.json is missing or stale.
+   * Existing in-memory entries (loaded from disk index) take precedence.
+   *
+   * @returns Number of checkpoints merged from chat history.
+   */
+  hydrateFromChatHistory(entries) {
+    if (!Array.isArray(entries) || entries.length === 0) {
+      return 0;
+    }
+    const existingIds = new Set(this.checkpoints.map((cp) => cp.id));
+    let merged = 0;
+    for (const rawEntry of entries) {
+      const entry = this.normalizeCheckpointMeta(rawEntry);
+      if (!entry || existingIds.has(entry.id)) {
+        continue;
+      }
+      if (!fs.existsSync(entry.manifestPath)) {
+        continue;
+      }
+      this.checkpoints.push(entry);
+      existingIds.add(entry.id);
+      merged++;
+    }
+    if (merged > 0) {
+      this.saveIndex();
+    }
+    return merged;
+  }
+  // ── Backup-on-write: called by file tools before modifying a file ───
+  /**
+   * 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;
+    const baseCwd = checkpoint.cwd || cwd;
+    const { absolutePath, relativePath } = this.resolveCheckpointFilePath(baseCwd, absoluteFilePath);
+    const manifest = this.readManifestV2(checkpoint.manifestPath);
+    const alreadyBacked = manifest.fileBackups.some((b) => b.filePath === relativePath);
+    if (alreadyBacked) return;
+    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) {
+        const remotePath = path.posix.resolve(baseCwd, relativePath);
+        try {
+          const content = await handler.readFile(remotePath);
+          existed = true;
+          fileSize = Buffer.from(content, "utf-8").length;
+          const backupPath = path.join(backupDir, relativePath);
+          this.ensureDirSync(path.dirname(backupPath));
+          fs.writeFileSync(backupPath, content, "utf-8");
+        } catch {
+          existed = false;
+        }
+      } else {
+        if (fs.existsSync(absolutePath)) {
+          existed = true;
+          try {
+            const stat = fs.statSync(absolutePath);
+            fileSize = stat.size;
+            const backupPath = path.join(backupDir, relativePath);
+            this.ensureDirSync(path.dirname(backupPath));
+            fs.copyFileSync(absolutePath, backupPath);
+          } catch (err) {
+            logWarning(`Failed to backup file ${relativePath}: ${err.message}`);
+            return;
+          }
+        } else {
+          existed = false;
+        }
+      }
+      manifest.fileBackups.push({
+        filePath: relativePath,
+        existed,
+        size: fileSize,
+        backedUpAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      fs.writeFileSync(checkpoint.manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [Checkpoint] Backed up "${relativePath}" (existed=${existed}) in ${checkpointId}
+`);
+    } catch (error) {
+      logWarning(`Failed to backup file before change: ${error.message}`);
+    }
+  }
+  resolveCheckpointFilePath(cwd, filePath) {
+    const baseCwd = path.resolve(cwd);
+    const absolutePath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(baseCwd, filePath);
+    let relativePath = path.relative(baseCwd, absolutePath).replace(/\\/g, "/");
+    relativePath = relativePath.replace(/^\.\/+/, "");
+    if (!relativePath) {
+      relativePath = path.basename(absolutePath).replace(/\\/g, "/");
+    }
+    return { absolutePath, relativePath };
+  }
+  /**
+   * 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: (/* @__PURE__ */ 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) {
+    const checkpoint = this.checkpoints.find((cp) => cp.id === checkpointId);
+    if (!checkpoint) return null;
+    const isRemote = checkpoint.contextType !== "local";
+    if (isRemote && (!handler || !handler.isConnected())) {
+      return null;
+    }
+    const changes = await this.calculateChanges(checkpoint, handler);
+    const stats = [];
+    const manifest = this.readManifest(checkpoint.manifestPath);
+    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) {
+              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 {
+                const lines = backupContent.split("\n").length;
+                stats.push({ filePath: backup.filePath, insertions: 0, deletions: lines });
+              }
+            } else {
+              try {
+                const currentContent = await handler.readFile(remotePath);
+                const lines = currentContent.split("\n").length;
+                stats.push({ filePath: backup.filePath, insertions: lines, deletions: 0 });
+              } catch {
+              }
             }
-            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 });
+          } catch {
+            stats.push({ filePath: backup.filePath, insertions: 0, deletions: 0 });
+          }
+        } else {
+          const currentPath = path.join(checkpoint.cwd, backup.filePath);
+          if (backup.existed) {
+            if (fs.existsSync(currentPath)) {
+              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 {
+              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 });
+              }
             }
-            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 (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 });
+              }
             }
+          }
         }
-        return { changes, stats };
-    }
-    /**
-     * Get a unified diff for a single file within a checkpoint.
-     * Compares the snapshot version to the current version.
-     */
-    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;
+      }
+    } else {
+      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;
+    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;
+    const originalBackups = /* @__PURE__ */ 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
+          });
+        }
+      }
+    }
+    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 {
+          if (original.existed) {
+            const backupContent = fs.readFileSync(original.backupPath, "utf-8");
             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}]`;
-                }
+              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 });
             }
-            // Modified file
+          } else {
             try {
-                const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
-                const newContent = remoteContent ?? '';
-                return this.generateUnifiedDiff(filePath, oldContent, newContent);
+              const currentContent = await handler.readFile(remotePath);
+              changes.added.push(filePath);
+              const lines = currentContent.split("\n").length;
+              stats.push({ filePath, insertions: lines, deletions: 0 });
+            } catch {
             }
-            catch {
-                return `[Binary or unreadable file: ${filePath}]`;
+          }
+        } catch {
+        }
+      } else {
+        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 });
             }
-        }
-        // Local diff (original logic)
-        const currentPath = path.join(checkpoint.cwd, filePath);
-        const currentExists = fs.existsSync(currentPath);
-        if (!snapshotExists && !currentExists) {
-            return null;
-        }
-        // Added file: show full content as additions
-        if (!snapshotExists && currentExists) {
+          } else {
+            changes.deleted.push(filePath);
             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}]`;
+              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 });
             }
-        }
-        // Deleted file: show full content as deletions
-        if (snapshotExists && !currentExists) {
+          }
+        } else {
+          if (fs.existsSync(currentPath)) {
+            changes.added.push(filePath);
             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}]`;
+              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 });
             }
+          }
         }
-        // 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}]`;
-        }
+      }
     }
-    /**
-     * 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
-     */
-    calculateLineStats(snapshotPath, currentPath) {
-        try {
-            const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
-            const newContent = fs.readFileSync(currentPath, 'utf-8');
-            return this.calculateLineStatsFromContent(oldContent, newContent);
-        }
-        catch {
-            return { insertions: 0, deletions: 0 };
-        }
+    return { changes, stats };
+  }
+  /**
+   * Get a unified diff for a single file within a checkpoint.
+   * 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 normalizedPath = this.normalizeToRelativePath(filePath, checkpoint.cwd);
+    const manifest = this.readManifest(checkpoint.manifestPath);
+    if (this.isV2Manifest(manifest)) {
+      return this.getFileDiffV2(checkpoint, manifest, normalizedPath, handler);
+    } else {
+      return this.getFileDiffV1(checkpoint, normalizedPath, handler);
     }
-    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);
-        }
-        const newSet = new Map();
-        for (const line of newLines) {
-            newSet.set(line, (newSet.get(line) || 0) + 1);
-        }
-        let deletions = 0;
-        for (const [line, count] of oldSet) {
-            const newCount = newSet.get(line) || 0;
-            if (newCount < count) {
-                deletions += count - newCount;
-            }
-        }
-        let insertions = 0;
-        for (const [line, count] of newSet) {
-            const oldCount = oldSet.get(line) || 0;
-            if (oldCount < count) {
-                insertions += count - oldCount;
-            }
-        }
-        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}`;
-        }
-        for (const hunk of hunks) {
-            result += `@@ -${hunk.oldStart + 1},${hunk.oldCount} +${hunk.newStart + 1},${hunk.newCount} @@\n`;
-            for (const line of hunk.lines) {
-                result += line + '\n';
-            }
-        }
-        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;
-        let newIdx = 0;
-        let lcsIdx = 0;
-        while (oldIdx < oldLines.length || newIdx < newLines.length) {
-            if (lcsIdx < lcs.length && oldIdx < oldLines.length && newIdx < newLines.length &&
-                oldLines[oldIdx] === lcs[lcsIdx] && newLines[newIdx] === lcs[lcsIdx]) {
-                editScript.push({ type: 'keep', oldIdx, newIdx, line: oldLines[oldIdx] });
-                oldIdx++;
-                newIdx++;
-                lcsIdx++;
-            }
-            else if (oldIdx < oldLines.length && (lcsIdx >= lcs.length || oldLines[oldIdx] !== lcs[lcsIdx])) {
-                editScript.push({ type: 'delete', oldIdx, newIdx, line: oldLines[oldIdx] });
-                oldIdx++;
-            }
-            else if (newIdx < newLines.length) {
-                editScript.push({ type: 'insert', oldIdx, newIdx, line: newLines[newIdx] });
-                newIdx++;
-            }
-        }
-        // Group into hunks with context (3 lines)
-        const CONTEXT = 3;
-        const hunks = [];
-        let currentHunk = null;
-        let contextCounter = 0;
-        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,
-                        oldCount: 0,
-                        newStart: editScript[contextStart]?.newIdx ?? edit.newIdx,
-                        newCount: 0,
-                        lines: [],
-                    };
-                    for (let j = contextStart; j < i; j++) {
-                        if (editScript[j].type === 'keep') {
-                            currentHunk.lines.push(` ${editScript[j].line}`);
-                            currentHunk.oldCount++;
-                            currentHunk.newCount++;
-                        }
-                    }
-                }
-                if (edit.type === 'delete') {
-                    currentHunk.lines.push(`-${edit.line}`);
-                    currentHunk.oldCount++;
-                }
-                else {
-                    currentHunk.lines.push(`+${edit.line}`);
-                    currentHunk.newCount++;
-                }
-                contextCounter = 0;
-            }
-            else if (currentHunk) {
-                contextCounter++;
-                if (contextCounter <= CONTEXT) {
-                    currentHunk.lines.push(` ${edit.line}`);
-                    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--;
+  }
+  /**
+   * 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 normalizedPath = this.normalizeToRelativePath(filePath, cp.cwd);
+      const backup = manifest.fileBackups.find((b) => b.filePath === normalizedPath);
+      if (backup) {
+        return this.getFileDiffV2(cp, manifest, normalizedPath, handler);
+      }
+    }
+    return null;
+  }
+  /**
+   * Normalise a file path to be relative to the given cwd.
+   * If the path is already relative, it is returned unchanged.
+   * This handles the common case where the AI passes an absolute remote path
+   * (e.g. /home/user/project/foo.ts) to the diff tool while the checkpoint
+   * manifest stores relative paths (e.g. project/foo.ts).
+   */
+  normalizeToRelativePath(filePath, cwd) {
+    if (!path.isAbsolute(filePath)) return filePath;
+    try {
+      const rel = path.relative(cwd, filePath).replace(/\\/g, "/");
+      return rel || filePath;
+    } catch {
+      return filePath;
+    }
+  }
+  /**
+   * Get the initial checkpoint for the current chat session.
+   */
+  getInitialCheckpoint() {
+    if (this.checkpoints.length === 0) return null;
+    return [...this.checkpoints].sort((a, b) => a.createdAtMs - b.createdAtMs)[0];
+  }
+  // ── 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);
+      const manifest = {
+        version: 2,
+        createdAt: (/* @__PURE__ */ 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: (/* @__PURE__ */ 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();
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [Checkpoint] Created ${checkpointId} (${params.contextType}) cwd="${params.cwd}"
+`);
+      return meta;
+    } catch (error) {
+      logError("Failed to create checkpoint", error);
+      return null;
+    }
+  }
+  async finalizeCheckpoint(id, handler) {
+    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, handler);
+      checkpoint.changes = changes;
+      checkpoint.status = "finalized";
+      this.saveIndex();
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [Checkpoint] Finalized ${id} \u2014 ${checkpoint.changes.modified.length} modified, ${checkpoint.changes.added.length} added, ${checkpoint.changes.deleted.length} deleted
+`);
+    } 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);
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [Checkpoint] Reverting to ${id} (${checkpoint.contextType}, ${this.isV2Manifest(manifest) ? "V2" : "V1"})
+`);
+    let result;
+    if (this.isV2Manifest(manifest)) {
+      result = await this.revertV2(checkpoint, manifest, handler);
+    } else {
+      result = await (checkpoint.contextType !== "local" && handler ? this.revertRemoteCheckpointV1(checkpoint, manifest, handler) : this.revertLocalCheckpointV1(checkpoint, manifest));
+    }
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [Checkpoint] Revert complete \u2014 restored=${result.restored}, removed=${result.removed}, errors=${result.errors.length}
+`);
+    return result;
+  }
+  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 errors = [];
+    let restored = 0;
+    let removed = 0;
+    const incrementalResult = await this.revertV2IncrementalBackups(checkpoint, manifest, handler);
+    restored += incrementalResult.restored;
+    removed += incrementalResult.removed;
+    errors.push(...incrementalResult.errors);
+    return { checkpoint, restored, removed, errors };
+  }
+  async revertV2IncrementalBackups(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) {
+            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 {
+            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}`);
         }
-        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;
-                    }
-                }
+      } else {
+        const targetPath = path.join(checkpoint.cwd, backup.filePath);
+        try {
+          if (backup.existed) {
+            this.ensureDirSync(path.dirname(targetPath));
+            fs.copyFileSync(backupPath, targetPath);
+            restored++;
+          } else {
+            if (fs.existsSync(targetPath)) {
+              this.removeFileOrDirSync(targetPath);
+              removed++;
             }
+          }
+        } catch (error) {
+          errors.push(`Failed to revert ${backup.filePath}: ${error.message}`);
         }
-        return result;
+      }
     }
-    markDiscarded(id) {
-        this.discardedIds.add(id);
+    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);
     }
-    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');
+    return { restored, removed, errors };
+  }
+  // ── V2 Diff ─────────────────────────────────────────────────────────
+  async getFileDiffV2(checkpoint, manifest, filePath, handler) {
+    const backup = manifest.fileBackups.find((b) => b.filePath === filePath);
+    if (!backup) {
+      return null;
+    }
+    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) {
+        const lines = currentContent.split("\n");
+        let diff = `--- /dev/null
++++ b/${filePath}
+@@ -0,0 +1,${lines.length} @@
+`;
+        diff += lines.map((l) => `+${l}`).join("\n");
+        return diff;
+      }
+      if (backup.existed && currentContent === null) {
         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;
+          const content = fs.readFileSync(backupPath, "utf-8");
+          const lines = content.split("\n");
+          let diff = `--- a/${filePath}
++++ /dev/null
+@@ -1,${lines.length} +0,0 @@
+`;
+          diff += lines.map((l) => `-${l}`).join("\n");
+          return diff;
+        } catch {
+          return `[Binary or unreadable file: ${filePath}]`;
+        }
+      }
+      if (backup.existed && currentContent !== null) {
+        try {
+          const oldContent = fs.readFileSync(backupPath, "utf-8");
+          return this.generateUnifiedDiff(filePath, oldContent, currentContent);
+        } catch {
+          return `[Binary or unreadable file: ${filePath}]`;
         }
+      }
+      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;
-        }
+    const currentPath = path.join(checkpoint.cwd, filePath);
+    const currentExists = fs.existsSync(currentPath);
+    if (!backup.existed && currentExists) {
+      try {
+        const content = fs.readFileSync(currentPath, "utf-8");
+        const lines = content.split("\n");
+        let diff = `--- /dev/null
++++ b/${filePath}
+@@ -0,0 +1,${lines.length} @@
+`;
+        diff += lines.map((l) => `+${l}`).join("\n");
+        return diff;
+      } catch {
+        return `[Binary or unreadable file: ${filePath}]`;
+      }
+    }
+    if (backup.existed && !currentExists) {
+      try {
+        const content = fs.readFileSync(backupPath, "utf-8");
+        const lines = content.split("\n");
+        let diff = `--- a/${filePath}
++++ /dev/null
+@@ -1,${lines.length} +0,0 @@
+`;
+        diff += lines.map((l) => `-${l}`).join("\n");
+        return diff;
+      } catch {
+        return `[Binary or unreadable file: ${filePath}]`;
+      }
+    }
+    if (backup.existed && currentExists) {
+      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}]`;
+      }
+    }
+    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
++++ b/${filePath}
+@@ -0,0 +1,${lines.length} @@
+`;
+        diff += lines.map((l) => `+${l}`).join("\n");
+        return diff;
+      }
+      if (snapshotExists && remoteContent === null) {
         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}`);
-        }
+          const content = fs.readFileSync(snapshotPath, "utf-8");
+          const lines = content.split("\n");
+          let diff = `--- a/${filePath}
++++ /dev/null
+@@ -1,${lines.length} +0,0 @@
+`;
+          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}]`;
+      }
     }
-    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();
+    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
++++ b/${filePath}
+@@ -0,0 +1,${lines.length} @@
+`;
+        diff += lines.map((l) => `+${l}`).join("\n");
+        return diff;
+      } catch {
+        return `[Binary or unreadable file: ${filePath}]`;
+      }
     }
-    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)
+    if (snapshotExists && !currentExists) {
+      try {
+        const content = fs.readFileSync(snapshotPath, "utf-8");
+        const lines = content.split("\n");
+        let diff = `--- a/${filePath}
++++ /dev/null
+@@ -1,${lines.length} +0,0 @@
+`;
+        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 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}`);
-                }
-            }
-        }
-        // 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}`);
-            }
-        }
-        // 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) : '';
-            }
-        }
-        // Find all current directories on the remote and remove empty ones not in the manifest
+          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 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
-                        }
-                    }
-                }
-            }
-        }
-        catch {
-            // Non-critical: directory cleanup is best-effort
+          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 });
         }
-        return { checkpoint, restored, removed, errors };
+      }
     }
-    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);
+  }
+  /**
+   * 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}`);
         }
+      }
     }
-    /**
-     * Discard a single checkpoint by id.
-     * Used when a background/late checkpoint should not be kept.
-     */
-    discardCheckpointById(id) {
-        this.discardCheckpoint(id);
+    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}`);
+      }
     }
-    deleteCheckpointsForChat(chatId) {
-        const chatDir = path.join(this.baseDir, chatId);
-        try {
-            if (fs.existsSync(chatDir)) {
-                fs.rmSync(chatDir, { recursive: true, force: true });
+    const manifestDirs = /* @__PURE__ */ 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 {
+          }
         }
-        catch (error) {
-            logWarning(`Failed to delete checkpoints for chat ${chatId}: ${error.message}`);
-        }
-        if (this.currentChatId === chatId) {
-            this.clear();
-        }
+      }
+    } catch {
     }
-    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);
+    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 {
-            if (fs.existsSync(path.dirname(checkpoint.manifestPath))) {
-                fs.rmSync(path.dirname(checkpoint.manifestPath), { recursive: true, force: true });
-            }
-        }
-        catch (error) {
-            logWarning(`Failed to delete checkpoint ${id}: ${error.message}`);
-        }
-        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);
-                }
-            }
-        }
-        return { added, modified, deleted };
+          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}`);
+        }
+      }
     }
-    readManifest(manifestPath) {
-        const raw = fs.readFileSync(manifestPath, 'utf-8');
-        return JSON.parse(raw);
+    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}`);
+      }
     }
-    async createSnapshot(cwd, snapshotDir) {
-        const files = await this.scanFiles(cwd);
-        const manifestEntries = [];
-        for (const filePath of files) {
-            const absolutePath = path.join(cwd, filePath);
+    const manifestDirs = /* @__PURE__ */ 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 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}`);
+              const rmResult = await handler.executeCommand(`rmdir "${remoteDirPath}" 2>/dev/null`);
+              if (rmResult.exitCode === 0) {
+                removed++;
+              }
+            } catch {
             }
+          }
         }
-        return {
-            version: 1,
-            createdAt: new Date().toISOString(),
-            cwd,
-            files: manifestEntries,
-        };
-    }
-    /**
-     * 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;
+      }
+    } catch {
+    }
+    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 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}`);
+              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);
             }
-        }
-        return {
-            version: 1,
-            createdAt: new Date().toISOString(),
-            cwd,
-            files: manifestEntries,
-        };
-    }
-    async scanFiles(cwd) {
-        const files = await fg(['**/*'], {
-            cwd,
-            dot: true,
-            onlyFiles: true,
-            followSymbolicLinks: false,
-            unique: true,
-            ignore: DEFAULT_IGNORE_PATTERNS,
-        });
-        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([
-            '.git', 'node_modules', 'dist', 'build', 'out',
-            '.next', '.turbo', '.cache', 'coverage',
-            '__pycache__', '.venv', 'venv', '.idea', '.vscode', '.centaurus',
-        ]);
-        const walk = (dir) => {
+          } else {
             try {
-                const entries = fs.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.isDirectory() && !ignoreDirs.has(entry.name)) {
-                        const fullPath = path.join(dir, entry.name);
-                        const relPath = path.relative(cwd, fullPath).replace(/\\/g, '/');
-                        dirs.push(relPath);
-                        walk(fullPath);
-                    }
-                }
+              await handler.readFile(remotePath);
+              added.push(backup.filePath);
+            } catch {
             }
-            catch {
-                // Skip inaccessible directories
-            }
-        };
-        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',
-            '__pycache__', '.venv', 'venv', '.idea', '.vscode', '.centaurus',
-        ];
-        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);
-            if (result.exitCode !== 0 && !result.stdout.trim()) {
-                logWarning(`Remote file scan failed: ${result.stderr}`);
-                return [];
+          }
+        } catch {
+        }
+      } else {
+        const currentPath = path.join(checkpoint.cwd, backup.filePath);
+        if (backup.existed) {
+          if (fs.existsSync(currentPath)) {
+            if (this.filesDiffer(backupPath, currentPath)) {
+              modified.push(backup.filePath);
             }
-            const cwdPrefix = cwd.endsWith('/') ? cwd : cwd + '/';
-            return result.stdout
-                .split('\n')
-                .map(line => line.trim())
-                .filter(line => line.length > 0 && line.startsWith(cwdPrefix))
-                .map(line => line.substring(cwdPrefix.length))
-                .filter(relPath => relPath.length > 0);
-        }
-        catch (error) {
-            logWarning(`Failed to scan remote files: ${error.message}`);
-            return [];
-        }
+          } else {
+            deleted.push(backup.filePath);
+          }
+        } else {
+          if (fs.existsSync(currentPath)) {
+            added.push(backup.filePath);
+          }
+        }
+      }
+    }
+    return {
+      added: Array.from(new Set(added)),
+      modified: Array.from(new Set(modified)),
+      deleted: Array.from(new Set(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);
+      }
     }
-    filesDiffer(snapshotPath, currentPath) {
+    for (const file of manifest.files) {
+      if (!currentSet.has(file.path)) {
+        deleted.push(file.path);
+        continue;
+      }
+      if (isRemote && handler) {
         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;
+          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) {
+    const dirs = /* @__PURE__ */ 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 {
+      }
+    }
+  }
+  async cleanupEmptyDirectoriesRemote(cwd, deletedRelPaths, handler) {
+    const dirs = /* @__PURE__ */ 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 {
+      }
+    }
+  }
+  // ── Helpers: line stats and diff generation ─────────────────────────
+  calculateLineStats(snapshotPath, currentPath) {
+    try {
+      const oldContent = fs.readFileSync(snapshotPath, "utf-8");
+      const newContent = fs.readFileSync(currentPath, "utf-8");
+      return this.calculateLineStatsFromContent(oldContent, newContent);
+    } catch {
+      return { insertions: 0, deletions: 0 };
+    }
+  }
+  calculateLineStatsFromContent(oldContent, newContent) {
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const oldSet = /* @__PURE__ */ new Map();
+    for (const line of oldLines) {
+      oldSet.set(line, (oldSet.get(line) || 0) + 1);
+    }
+    const newSet = /* @__PURE__ */ new Map();
+    for (const line of newLines) {
+      newSet.set(line, (newSet.get(line) || 0) + 1);
+    }
+    let deletions = 0;
+    for (const [line, count] of oldSet) {
+      const newCount = newSet.get(line) || 0;
+      if (newCount < count) {
+        deletions += count - newCount;
+      }
+    }
+    let insertions = 0;
+    for (const [line, count] of newSet) {
+      const oldCount = oldSet.get(line) || 0;
+      if (oldCount < count) {
+        insertions += count - oldCount;
+      }
+    }
+    return { insertions, deletions };
+  }
+  generateUnifiedDiff(filePath, oldContent, newContent) {
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    let result = `--- a/${filePath}
++++ b/${filePath}
+`;
+    const hunks = this.computeHunks(oldLines, newLines);
+    if (hunks.length === 0) {
+      return `No differences found in ${filePath}`;
+    }
+    for (const hunk of hunks) {
+      result += `@@ -${hunk.oldStart + 1},${hunk.oldCount} +${hunk.newStart + 1},${hunk.newCount} @@
+`;
+      for (const line of hunk.lines) {
+        result += line + "\n";
+      }
+    }
+    return result;
+  }
+  computeHunks(oldLines, newLines) {
+    const lcs = this.longestCommonSubsequence(oldLines, newLines);
+    const editScript = [];
+    let oldIdx = 0;
+    let newIdx = 0;
+    let lcsIdx = 0;
+    while (oldIdx < oldLines.length || newIdx < newLines.length) {
+      if (lcsIdx < lcs.length && oldIdx < oldLines.length && newIdx < newLines.length && oldLines[oldIdx] === lcs[lcsIdx] && newLines[newIdx] === lcs[lcsIdx]) {
+        editScript.push({ type: "keep", oldIdx, newIdx, line: oldLines[oldIdx] });
+        oldIdx++;
+        newIdx++;
+        lcsIdx++;
+      } else if (oldIdx < oldLines.length && (lcsIdx >= lcs.length || oldLines[oldIdx] !== lcs[lcsIdx])) {
+        editScript.push({ type: "delete", oldIdx, newIdx, line: oldLines[oldIdx] });
+        oldIdx++;
+      } else if (newIdx < newLines.length) {
+        editScript.push({ type: "insert", oldIdx, newIdx, line: newLines[newIdx] });
+        newIdx++;
+      }
+    }
+    const CONTEXT = 3;
+    const hunks = [];
+    let currentHunk = null;
+    let contextCounter = 0;
+    for (let i = 0; i < editScript.length; i++) {
+      const edit = editScript[i];
+      if (edit.type !== "keep") {
+        if (!currentHunk) {
+          const contextStart = Math.max(0, i - CONTEXT);
+          currentHunk = {
+            oldStart: editScript[contextStart]?.oldIdx ?? edit.oldIdx,
+            oldCount: 0,
+            newStart: editScript[contextStart]?.newIdx ?? edit.newIdx,
+            newCount: 0,
+            lines: []
+          };
+          for (let j = contextStart; j < i; j++) {
+            if (editScript[j].type === "keep") {
+              currentHunk.lines.push(` ${editScript[j].line}`);
+              currentHunk.oldCount++;
+              currentHunk.newCount++;
             }
-            return !snapBuffer.equals(currBuffer);
-        }
-        catch {
-            return true;
-        }
+          }
+        }
+        if (edit.type === "delete") {
+          currentHunk.lines.push(`-${edit.line}`);
+          currentHunk.oldCount++;
+        } else {
+          currentHunk.lines.push(`+${edit.line}`);
+          currentHunk.newCount++;
+        }
+        contextCounter = 0;
+      } else if (currentHunk) {
+        contextCounter++;
+        if (contextCounter <= CONTEXT) {
+          currentHunk.lines.push(` ${edit.line}`);
+          currentHunk.oldCount++;
+          currentHunk.newCount++;
+        } else {
+          hunks.push(currentHunk);
+          currentHunk = null;
+          contextCounter = 0;
+        }
+      }
     }
-    removeFileOrDirSync(targetPath) {
-        if (!fs.existsSync(targetPath))
-            return;
-        const stat = fs.lstatSync(targetPath);
-        if (stat.isDirectory()) {
-            fs.rmSync(targetPath, { recursive: true, force: true });
-            return;
-        }
-        fs.rmSync(targetPath, { force: true });
+    if (currentHunk) {
+      hunks.push(currentHunk);
     }
-    generateCheckpointId() {
-        const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '');
-        const random = Math.random().toString(36).substring(2, 6);
-        return `cp-${timestamp}-${random}`;
+    return hunks;
+  }
+  longestCommonSubsequence(a, b) {
+    if (a.length > 1e3 || b.length > 1e3) {
+      return this.simpleLCS(a, b);
     }
-    ensureDirSync(dirPath) {
-        if (!fs.existsSync(dirPath)) {
-            fs.mkdirSync(dirPath, { recursive: true });
-        }
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i2 = 1; i2 <= m; i2++) {
+      for (let j2 = 1; j2 <= n; j2++) {
+        if (a[i2 - 1] === b[j2 - 1]) {
+          dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+        } else {
+          dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+        }
+      }
     }
-    getChatDir() {
-        if (!this.currentChatId) {
-            return this.baseDir;
-        }
-        const dir = path.join(this.baseDir, this.currentChatId);
-        this.ensureDirSync(dir);
-        return dir;
-    }
-    getIndexPath() {
-        if (!this.currentChatId)
-            return null;
-        return path.join(this.getChatDir(), 'index.json');
-    }
-    loadIndex() {
-        this.checkpoints = [];
-        this.discardedIds.clear();
-        const indexPath = this.getIndexPath();
-        if (!indexPath || !fs.existsSync(indexPath)) {
-            return;
-        }
-        try {
-            const raw = fs.readFileSync(indexPath, 'utf-8');
-            const data = JSON.parse(raw);
-            this.checkpoints = data.filter(entry => fs.existsSync(entry.manifestPath));
-        }
-        catch (error) {
-            logWarning(`Failed to load checkpoint index: ${error.message}`);
-        }
+    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--;
+      }
     }
-    saveIndex() {
-        const indexPath = this.getIndexPath();
-        if (!indexPath)
-            return;
-        try {
-            fs.writeFileSync(indexPath, JSON.stringify(this.checkpoints, null, 2), 'utf-8');
-        }
-        catch (error) {
-            logWarning(`Failed to save checkpoint index: ${error.message}`);
-        }
+    return result;
+  }
+  simpleLCS(a, b) {
+    const bMap = /* @__PURE__ */ 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) {
+        for (const pos of positions) {
+          if (pos > lastMatchB) {
+            result.push(a[i]);
+            lastMatchB = pos;
+            break;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  // ── Helpers: file operations ────────────────────────────────────────
+  filesDiffer(snapshotPath, currentPath) {
+    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;
+      }
+      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;
+    }
+    fs.rmSync(targetPath, { force: true });
+  }
+  // ── Helpers: manifest & index I/O ───────────────────────────────────
+  readManifest(manifestPath) {
+    const raw = fs.readFileSync(manifestPath, "utf-8");
+    return JSON.parse(raw);
+  }
+  readManifestV2(manifestPath) {
+    const raw = fs.readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(raw);
+    if (manifest.version === 2) {
+      return manifest;
+    }
+    return {
+      version: 2,
+      createdAt: manifest.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      cwd: manifest.cwd || "",
+      fileBackups: [],
+      operations: []
+    };
+  }
+  isV2Manifest(manifest) {
+    return manifest.version === 2;
+  }
+  // ── 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: [
+        "**/.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, "/"));
+  }
+  scanLocalDirectories(rootDir, cwd) {
+    const dirs = [];
+    const ignoreDirs = /* @__PURE__ */ new Set([
+      ".git",
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".turbo",
+      ".cache",
+      "coverage",
+      "__pycache__",
+      ".venv",
+      "venv",
+      ".idea",
+      ".vscode",
+      ".centaurus"
+    ]);
+    const walk = (dir) => {
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !ignoreDirs.has(entry.name)) {
+            const fullPath = path.join(dir, entry.name);
+            const relPath = path.relative(cwd, fullPath).replace(/\\/g, "/");
+            dirs.push(relPath);
+            walk(fullPath);
+          }
+        }
+      } catch {
+      }
+    };
+    walk(rootDir);
+    return dirs;
+  }
+  async scanRemoteFiles(cwd, handler) {
+    const excludeDirs = [
+      ".git",
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".turbo",
+      ".cache",
+      "coverage",
+      "__pycache__",
+      ".venv",
+      "venv",
+      ".idea",
+      ".vscode",
+      ".centaurus"
+    ];
+    const excludeFiles = [".DS_Store", "Thumbs.db"];
+    const pruneArgs = excludeDirs.map((d) => `-name "${d}" -prune`).join(" -o ");
+    const notFileArgs = excludeFiles.map((f) => `! -name "${f}"`).join(" ");
+    const findCmd = `find "${cwd}" \\( ${pruneArgs} \\) -o -type f ${notFileArgs} -print 2>/dev/null`;
+    try {
+      const result = await handler.executeCommand(findCmd);
+      if (result.exitCode !== 0 && !result.stdout.trim()) {
+        logWarning(`Remote file scan failed: ${result.stderr}`);
+        return [];
+      }
+      const cwdPrefix = cwd.endsWith("/") ? cwd : cwd + "/";
+      return result.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && line.startsWith(cwdPrefix)).map((line) => line.substring(cwdPrefix.length)).filter((relPath) => relPath.length > 0);
+    } catch (error) {
+      logWarning(`Failed to scan remote files: ${error.message}`);
+      return [];
+    }
+  }
+  // ── 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 {
+      if (fs.existsSync(path.dirname(checkpoint.manifestPath))) {
+        fs.rmSync(path.dirname(checkpoint.manifestPath), { recursive: true, force: true });
+      }
+    } catch (error) {
+      logWarning(`Failed to delete checkpoint ${id}: ${error.message}`);
+    }
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [Checkpoint] Discarded ${id}
+`);
+    this.saveIndex();
+  }
+  generateCheckpointId() {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..+/, "");
+    const random = Math.random().toString(36).substring(2, 6);
+    return `cp-${timestamp}-${random}`;
+  }
+  ensureDirSync(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+  getChatDir() {
+    if (!this.currentChatId) {
+      return this.baseDir;
+    }
+    const dir = path.join(this.baseDir, this.currentChatId);
+    this.ensureDirSync(dir);
+    return dir;
+  }
+  getIndexPath() {
+    if (!this.currentChatId) return null;
+    return path.join(this.getChatDir(), "index.json");
+  }
+  loadIndex() {
+    this.checkpoints = [];
+    this.discardedIds.clear();
+    const indexPath = this.getIndexPath();
+    if (!indexPath || !fs.existsSync(indexPath)) {
+      return;
+    }
+    try {
+      const raw = fs.readFileSync(indexPath, "utf-8");
+      const data = JSON.parse(raw);
+      this.checkpoints = data.filter((entry) => fs.existsSync(entry.manifestPath));
+    } catch (error) {
+      logWarning(`Failed to load checkpoint index: ${error.message}`);
+    }
+  }
+  saveIndex() {
+    const indexPath = this.getIndexPath();
+    if (!indexPath) return;
+    try {
+      fs.writeFileSync(indexPath, JSON.stringify(this.checkpoints, null, 2), "utf-8");
+    } catch (error) {
+      logWarning(`Failed to save checkpoint index: ${error.message}`);
+    }
+  }
+  normalizeCheckpointMeta(rawEntry) {
+    if (!rawEntry || typeof rawEntry !== "object" || typeof rawEntry.id !== "string" || typeof rawEntry.manifestPath !== "string") {
+      return null;
     }
+    const createdAt = typeof rawEntry.createdAt === "string" ? rawEntry.createdAt : (/* @__PURE__ */ new Date()).toISOString();
+    const parsedCreatedAtMs = typeof rawEntry.createdAtMs === "number" ? rawEntry.createdAtMs : Date.parse(createdAt);
+    const createdAtMs = Number.isFinite(parsedCreatedAtMs) ? parsedCreatedAtMs : Date.now();
+    const contextType = rawEntry.contextType === "ssh" || rawEntry.contextType === "wsl" || rawEntry.contextType === "docker" ? rawEntry.contextType : "local";
+    const status = rawEntry.status === "active" || rawEntry.status === "discarded" ? rawEntry.status : "finalized";
+    const toolCalls = Array.isArray(rawEntry.toolCalls) ? rawEntry.toolCalls.filter((toolCall) => toolCall && typeof toolCall.name === "string").map((toolCall) => ({
+      id: typeof toolCall.id === "string" ? toolCall.id : void 0,
+      name: toolCall.name,
+      arguments: toolCall.arguments && typeof toolCall.arguments === "object" ? toolCall.arguments : void 0,
+      timestamp: typeof toolCall.timestamp === "string" ? toolCall.timestamp : createdAt
+    })) : [];
+    const commands = Array.isArray(rawEntry.commands) ? rawEntry.commands.filter((command) => typeof command === "string") : [];
+    const snapshotDir = typeof rawEntry.snapshotDir === "string" ? rawEntry.snapshotDir : path.join(path.dirname(rawEntry.manifestPath), "backups");
+    const remoteSessionInfo = rawEntry.remoteSessionInfo && typeof rawEntry.remoteSessionInfo === "object" ? {
+      hostname: typeof rawEntry.remoteSessionInfo.hostname === "string" ? rawEntry.remoteSessionInfo.hostname : void 0,
+      username: typeof rawEntry.remoteSessionInfo.username === "string" ? rawEntry.remoteSessionInfo.username : void 0,
+      sessionId: typeof rawEntry.remoteSessionInfo.sessionId === "string" ? rawEntry.remoteSessionInfo.sessionId : "",
+      connectionString: typeof rawEntry.remoteSessionInfo.connectionString === "string" ? rawEntry.remoteSessionInfo.connectionString : void 0
+    } : void 0;
+    return {
+      id: rawEntry.id,
+      prompt: typeof rawEntry.prompt === "string" ? rawEntry.prompt : "",
+      createdAt,
+      createdAtMs,
+      cwd: typeof rawEntry.cwd === "string" ? rawEntry.cwd : "",
+      contextType,
+      remoteSessionInfo: remoteSessionInfo?.sessionId ? remoteSessionInfo : void 0,
+      conversationIndex: typeof rawEntry.conversationIndex === "number" ? rawEntry.conversationIndex : 0,
+      uiMessageIndex: typeof rawEntry.uiMessageIndex === "number" ? rawEntry.uiMessageIndex : void 0,
+      uiMessageId: typeof rawEntry.uiMessageId === "string" ? rawEntry.uiMessageId : void 0,
+      snapshotDir,
+      manifestPath: rawEntry.manifestPath,
+      changes: rawEntry.changes && typeof rawEntry.changes === "object" ? {
+        added: Array.isArray(rawEntry.changes.added) ? rawEntry.changes.added.filter((f) => typeof f === "string") : [],
+        modified: Array.isArray(rawEntry.changes.modified) ? rawEntry.changes.modified.filter((f) => typeof f === "string") : [],
+        deleted: Array.isArray(rawEntry.changes.deleted) ? rawEntry.changes.deleted.filter((f) => typeof f === "string") : []
+      } : void 0,
+      commands,
+      toolCalls,
+      status
+    };
+  }
 }
+export {
+  CheckpointManager
+};
 //# sourceMappingURL=checkpoint-manager.js.map