feat(checkpoint): git file snapshots complete codex/claude rewind (phase 2)

Before each codex/claude turn the working tree is snapshotted as a dangling
commit (git_checkpoint_capture — isolated temp index, tracked + untracked, never
touches the real index/worktree). A rewind now also restores files to the target
turn's checkpoint (git_checkpoint_restore), which snapshots the current state as
a recovery commit first so nothing is ever unrecoverable; files created after the
checkpoint are left in place (never deletes untracked work).

Dedicated Tauri commands keep the security-restricted general git bridge
unchanged. Verified with a real-git capture→modify→restore integration test.

This completes #31: codex (thread/rollback) and claude (--resume-session-at) both
rewind conversation + files, with no Agent SDK / Node sidecar.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: gaoyu06

src-tauri/src/lib.rs

@@ -1730,6 +1730,81 @@ fn git(args: Vec<String>, cwd: Option<String>) -> Result<String, String> {
     }
 }
 
+/// Runs a fixed git plumbing command in `dir` (optionally with an isolated index
+/// file). A stable checkpoint identity is set so `commit-tree` works even in a
+/// repo without a configured user. Returns trimmed stdout on success.
+fn git_plumb(dir: &Path, index: Option<&Path>, args: &[&str]) -> Result<String, String> {
+    let mut cmd = Command::new("git");
+    shell_env::merge_into(&mut cmd);
+    cmd.args(args)
+        .current_dir(dir)
+        .env("GIT_TERMINAL_PROMPT", "0")
+        .env("GIT_AUTHOR_NAME", "JuCode")
+        .env("GIT_AUTHOR_EMAIL", "checkpoint@jucode.local")
+        .env("GIT_COMMITTER_NAME", "JuCode")
+        .env("GIT_COMMITTER_EMAIL", "checkpoint@jucode.local");
+    if let Some(idx) = index {
+        cmd.env("GIT_INDEX_FILE", idx);
+    }
+    let output = cmd
+        .output()
+        .map_err(|e| format!("failed to run git: {e}"))?;
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+    } else {
+        Err(String::from_utf8_lossy(&output.stderr).trim().to_string())
+    }
+}
+
+/// Snapshot the full working tree (tracked + untracked) as a dangling commit
+/// object, WITHOUT touching the user's index or working tree (uses an isolated
+/// temp index). Returns the commit sha — a rewind file-checkpoint. `Ok(String::new())`
+/// only if the tree is unwritable; errors bubble the git message.
+#[tauri::command(async)]
+fn git_checkpoint_capture(cwd: String) -> Result<String, String> {
+    let dir = PathBuf::from(&cwd);
+    let idx = std::env::temp_dir().join(format!("jucode-ckpt-{}.idx", std::process::id()));
+    let _ = std::fs::remove_file(&idx);
+    let has_head = git_plumb(&dir, None, &["rev-parse", "--verify", "HEAD"]).is_ok();
+    if has_head {
+        git_plumb(&dir, Some(&idx), &["read-tree", "HEAD"])?;
+    }
+    git_plumb(&dir, Some(&idx), &["add", "-A"])?;
+    let tree = git_plumb(&dir, Some(&idx), &["write-tree"])?;
+    let _ = std::fs::remove_file(&idx);
+    let commit = if has_head {
+        let head = git_plumb(&dir, None, &["rev-parse", "HEAD"])?;
+        git_plumb(
+            &dir,
+            None,
+            &["commit-tree", &tree, "-p", &head, "-m", "jucode-checkpoint"],
+        )?
+    } else {
+        git_plumb(&dir, None, &["commit-tree", &tree, "-m", "jucode-checkpoint"])?
+    };
+    Ok(commit)
+}
+
+/// Restore the working tree + index to a checkpoint commit. First snapshots the
+/// CURRENT state as a recovery commit (returned, so nothing is ever unrecoverable),
+/// then restores the checkpoint's paths. Files created after the checkpoint are
+/// left in place — this never deletes untracked work.
+#[tauri::command(async)]
+fn git_checkpoint_restore(cwd: String, checkpoint: String) -> Result<String, String> {
+    if checkpoint.len() < 7
+        || checkpoint.len() > 64
+        || !checkpoint.chars().all(|c| c.is_ascii_hexdigit())
+    {
+        return Err(format!("invalid checkpoint sha: {checkpoint}"));
+    }
+    let dir = PathBuf::from(&cwd);
+    git_plumb(&dir, None, &["cat-file", "-e", &checkpoint])
+        .map_err(|_| format!("checkpoint object not found: {checkpoint}"))?;
+    let safety = git_checkpoint_capture(cwd.clone())?;
+    git_plumb(&dir, None, &["checkout", &checkpoint, "--", "."])?;
+    Ok(safety)
+}
+
 /// Resolves the GitHub CLI binary: PATH first, then the usual install locations
 /// (a packaged .app inherits a minimal PATH from launchd).
 fn resolve_gh() -> PathBuf {
@@ -2139,6 +2214,8 @@ pub fn run() {
             fetch_deepseek_balance,
             transcribe_audio,
             generate_text,
+            git_checkpoint_capture,
+            git_checkpoint_restore,
             project_root,
             list_providers,
             list_dir,
@@ -2199,6 +2276,45 @@ mod tests {
         assert_eq!(read_json_strict(&p).unwrap(), serde_json::json!({}));
     }
 
+    #[test]
+    fn checkpoint_capture_and_restore_roundtrip() {
+        use std::process::Command;
+        let dir = std::env::temp_dir().join(format!("jucode-ckpt-it-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let git = |args: &[&str]| {
+            Command::new("git")
+                .current_dir(&dir)
+                .env("GIT_AUTHOR_NAME", "T")
+                .env("GIT_AUTHOR_EMAIL", "t@t")
+                .env("GIT_COMMITTER_NAME", "T")
+                .env("GIT_COMMITTER_EMAIL", "t@t")
+                .args(args)
+                .output()
+                .unwrap()
+        };
+        git(&["init", "-q"]);
+        std::fs::write(dir.join("a.txt"), "v1").unwrap();
+        git(&["add", "."]);
+        git(&["commit", "-q", "-m", "init"]);
+        let cwd = dir.to_string_lossy().to_string();
+        // Snapshot the "v1" state.
+        let cp0 = super::git_checkpoint_capture(cwd.clone()).unwrap();
+        assert!(!cp0.is_empty());
+        // The agent modifies a tracked file and adds a new one.
+        std::fs::write(dir.join("a.txt"), "v2").unwrap();
+        std::fs::write(dir.join("b.txt"), "new").unwrap();
+        // Restore to the checkpoint: a.txt reverts, current state saved as safety.
+        let safety = super::git_checkpoint_restore(cwd.clone(), cp0).unwrap();
+        assert!(!safety.is_empty());
+        assert_eq!(std::fs::read_to_string(dir.join("a.txt")).unwrap(), "v1");
+        // Files created after the checkpoint are left in place (never deleted).
+        assert!(dir.join("b.txt").exists());
+        // A bogus sha is rejected without touching the tree.
+        assert!(super::git_checkpoint_restore(cwd, "nothex!!".into()).is_err());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     #[test]
     fn empty_file_is_empty_object() {
         let p = tmp("empty.json");

src/lib/chat.svelte.ts

@@ -110,6 +110,10 @@ export class ChatState {
 	// instantly from cache while a fresh `/model` round-trip refreshes it.
 	modelCatalog = $state<ModelOption[]>([]);
 	modelCatalogEffort = $state('');
+	// File-checkpoint sha captured just before each user turn (index = turn), so a
+	// rewind can restore the working tree to that turn's state (codex/claude, where
+	// the engine only rewinds the conversation, not files).
+	fileCheckpoints = $state<Record<number, string>>({});
 	contextTokens = $state(0);
 	contextWindow = $state(0);
 	contextLimit = $state(0);

src/lib/protocol.ts

@@ -318,6 +318,18 @@ export function transcribeAudio(audioBase64: string, mime?: string, language?: s
 	return invoke('transcribe_audio', { audioBase64, mime, language });
 }
 
+/** Snapshot the working tree as a dangling checkpoint commit (returns its sha).
+ *  Non-destructive: it never touches the index or working tree. */
+export function gitCheckpointCapture(cwd: string): Promise<string> {
+	return invoke('git_checkpoint_capture', { cwd });
+}
+
+/** Restore the working tree to a checkpoint sha. Snapshots the current state
+ *  first (returns that recovery sha) so nothing is unrecoverable. */
+export function gitCheckpointRestore(cwd: string, checkpoint: string): Promise<string> {
+	return invoke('git_checkpoint_restore', { cwd, checkpoint });
+}
+
 /** One-shot LLM completion (no agent / no chat pollution) — powers AI commit
  *  messages and PR text. The key is read engine-side from auth.json by provider. */
 export function generateText(

src/routes/+page.svelte

@@ -23,6 +23,8 @@
 		stopScreenRecording,
 		processVideo,
 		claudeSessions,
+		gitCheckpointCapture,
+		gitCheckpointRestore,
 		type EventPayload,
 		type Op
 	} from '$lib/protocol';
@@ -373,7 +375,10 @@
 	// engine. Returns false when there's no live session to receive it.
 	function sendAiEdit(content: string): boolean {
 		if (!chat || chat.engineState === 'exited') return false;
-		if (!chat.busy) chat.optimisticUser(content);
+		if (!chat.busy) {
+			captureCheckpoint();
+			chat.optimisticUser(content);
+		}
 		send({ op: 'user_message', content });
 		return true;
 	}
@@ -777,7 +782,10 @@
 			}
 			// Echo the message instantly when it starts a turn now (a busy session
 			// queues it instead, shown in the composer's queue strip).
-			if (chat && !chat.busy) chat.optimisticUser(content);
+			if (chat && !chat.busy) {
+				captureCheckpoint(); // snapshot files before this turn (for rewind)
+				chat.optimisticUser(content);
+			}
 			send({ op: 'user_message', content, images: images.length ? images : undefined });
 		}
 		input = '';
@@ -980,6 +988,28 @@
 	// Real edit-and-resend: rewind the conversation (and files) to the turn that
 	// produced this user message, then drop its text back into the composer. The
 	// engine lists user turns in order, so the i-th turn matches the i-th message.
+	// Before each codex/claude turn, snapshot the working tree so a later rewind
+	// can restore files to this turn's starting state (the engines rewind only the
+	// conversation). Fire-and-forget; the sha lands under its turn index.
+	function captureCheckpoint() {
+		const c = chat;
+		const cwd = activeProject?.path;
+		if (!c || !cwd || (c.backendId !== 'codex' && c.backendId !== 'claude')) return;
+		const idx = c.userTurns;
+		gitCheckpointCapture(cwd)
+			.then((sha) => {
+				if (sha) c.fileCheckpoints[idx] = sha;
+			})
+			.catch(() => {});
+	}
+	// Restore the working tree to the checkpoint captured before the target turn.
+	function restoreCheckpoint(userIndex: number) {
+		const c = chat;
+		const cwd = activeProject?.path;
+		const sha = c?.fileCheckpoints[userIndex];
+		if (c && cwd && sha) gitCheckpointRestore(cwd, sha).catch((e) => console.error('checkpoint restore failed', e));
+	}
+
 	function rewindToMessage(text: string, userIndex: number) {
 		if (!chat) return;
 		// codex (thread/rollback) and claude (resume-at-uuid respawn) rewind without
@@ -1000,10 +1030,12 @@
 			if (numTurns > 0) send({ op: 'command', input: `/rewind ${numTurns}` });
 			// codex rolls back its own history; mirror it in our projected transcript.
 			chat.truncateToUserTurn(userIndex);
+			restoreCheckpoint(userIndex); // …and the files it changed
 		} else if (pr.id.startsWith('claude:')) {
 			const userIndex = Number(pr.id.slice('claude:'.length));
 			// Respawn resuming at the previous turn's assistant uuid (or fresh at 0).
 			store.rewindClaudeSession(activeId, chat.claudeRewindTarget(userIndex), userIndex);
+			restoreCheckpoint(userIndex);
 		} else {
 			send({ op: 'command', input: `/rewind ${pr.id}` });
 		}