Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
Add checkpoint diff API and hydrate turn diffs in UI
Julius Marmingecf8a2f03fc1c
diff --git a/apps/server/src/codexAppServerManager.ts b/apps/server/src/codexAppServerManager.tsindex 01722a696..73af81bbe 100644--- a/apps/server/src/codexAppServerManager.ts+++ b/apps/server/src/codexAppServerManager.ts@@ -148,19 +148,20 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEveasync startSession(input: ProviderSessionStartInput): Promise<ProviderSession> {const sessionId = randomUUID();const now = new Date().toISOString();+ const resolvedCwd = input.cwd ?? process.cwd();const session: ProviderSession = {sessionId,provider: "codex",status: "connecting",model: normalizeCodexModelSlug(input.model),- cwd: input.cwd,+ cwd: resolvedCwd,createdAt: now,updatedAt: now,};const child = spawn("codex", ["app-server"], {- cwd: input.cwd,+ cwd: resolvedCwd,env: process.env,stdio: ["pipe", "pipe", "pipe"],});@@ -198,7 +199,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEveconst normalizedModel = normalizeCodexModelSlug(input.model);const sessionOverrides = {model: normalizedModel ?? null,- cwd: input.cwd ?? null,+ cwd: resolvedCwd,approvalPolicy: input.approvalPolicy,sandbox: input.sandboxMode,};diff --git a/apps/server/src/filesystemCheckpointStore.test.ts b/apps/server/src/filesystemCheckpointStore.test.tsindex 37a1f7696..185ac2807 100644--- a/apps/server/src/filesystemCheckpointStore.test.ts+++ b/apps/server/src/filesystemCheckpointStore.test.ts@@ -93,6 +93,32 @@ describe("FilesystemCheckpointStore", () => {}});+ it("falls back to HEAD when restoring turn 0 and root checkpoint ref is missing", async () => {+ const cwd = await createRepo();+ const store = new FilesystemCheckpointStore();+ const threadId = "thr_2b";++ try {+ await writeFile(path.join(cwd, "README.md"), "v2\n");+ await store.captureCheckpoint({ cwd, threadId, turnCount: 1 });++ await writeFile(path.join(cwd, "README.md"), "v3\n");+ await writeFile(path.join(cwd, "scratch.txt"), "scratch\n");++ const restored = await store.restoreCheckpoint({+ cwd,+ threadId,+ turnCount: 0,+ });++ expect(restored).toBe(true);+ expect(await readFile(path.join(cwd, "README.md"), "utf8")).toBe("v1\n");+ expect(exists(path.join(cwd, "scratch.txt"))).toBe(false);+ } finally {+ await rm(cwd, { recursive: true, force: true });+ }+ });+it("prunes refs newer than the retained turn", async () => {const cwd = await createRepo();const store = new FilesystemCheckpointStore();@@ -119,6 +145,55 @@ describe("FilesystemCheckpointStore", () => {}});+ it("returns a unified patch between checkpoint turns", async () => {+ const cwd = await createRepo();+ const store = new FilesystemCheckpointStore();+ const threadId = "thr_4";++ try {+ await store.captureCheckpoint({ cwd, threadId, turnCount: 0 });+ await writeFile(path.join(cwd, "README.md"), "v2\n");+ await writeFile(path.join(cwd, "new.txt"), "new file\n");+ await store.captureCheckpoint({ cwd, threadId, turnCount: 1 });++ const diff = await store.diffCheckpoints({+ cwd,+ threadId,+ fromTurnCount: 0,+ toTurnCount: 1,+ });++ expect(diff).toContain("diff --git a/README.md b/README.md");+ expect(diff).toContain("diff --git a/new.txt b/new.txt");+ } finally {+ await rm(cwd, { recursive: true, force: true });+ }+ });++ it("falls back to HEAD as diff base when turn 0 checkpoint is missing", async () => {+ const cwd = await createRepo();+ const store = new FilesystemCheckpointStore();+ const threadId = "thr_5";++ try {+ await writeFile(path.join(cwd, "README.md"), "v2\n");+ await writeFile(path.join(cwd, "new.txt"), "new file\n");+ await store.captureCheckpoint({ cwd, threadId, turnCount: 1 });++ const diff = await store.diffCheckpoints({+ cwd,+ threadId,+ fromTurnCount: 0,+ toTurnCount: 1,+ });++ expect(diff).toContain("diff --git a/README.md b/README.md");+ expect(diff).toContain("diff --git a/new.txt b/new.txt");+ } finally {+ await rm(cwd, { recursive: true, force: true });+ }+ });+it("detects non-repo folders", async () => {const cwd = await mkdtemp(path.join(os.tmpdir(), "t3-fs-checkpoints-nonrepo-"));const store = new FilesystemCheckpointStore();diff --git a/apps/server/src/filesystemCheckpointStore.ts b/apps/server/src/filesystemCheckpointStore.tsindex 99ab6567a..516832bb5 100644--- a/apps/server/src/filesystemCheckpointStore.ts+++ b/apps/server/src/filesystemCheckpointStore.ts@@ -91,10 +91,30 @@ export class FilesystemCheckpointStore {return commit !== null;}+ async ensureRootCheckpoint(input: { cwd: string; threadId: string }): Promise<boolean> {+ const { cwd, threadId } = input;+ const rootRef = checkpointRefForThreadTurn(threadId, 0);+ const existing = await this.resolveCheckpointCommit(cwd, rootRef);+ if (existing) {+ return true;+ }++ const headCommit = await this.resolveHeadCommit(cwd);+ if (!headCommit) {+ return false;+ }++ await this.runGit(cwd, ["update-ref", rootRef, headCommit]);+ return true;+ }+async restoreCheckpoint(input: { cwd: string; threadId: string; turnCount: number }): Promise<boolean> {const { cwd, threadId, turnCount } = input;const ref = checkpointRefForThreadTurn(threadId, turnCount);- const commitOid = await this.resolveCheckpointCommit(cwd, ref);+ let commitOid = await this.resolveCheckpointCommit(cwd, ref);+ if (!commitOid && turnCount === 0) {+ commitOid = await this.resolveHeadCommit(cwd);+ }if (!commitOid) {return false;}@@ -105,6 +125,64 @@ export class FilesystemCheckpointStore {return true;}+ async diffCheckpoints(input: {+ cwd: string;+ threadId: string;+ fromTurnCount: number;+ toTurnCount: number;+ }): Promise<string> {+ const { cwd, threadId, fromTurnCount, toTurnCount } = input;+ if (!Number.isInteger(fromTurnCount) || fromTurnCount < 0) {+ throw new Error(`Invalid from turn count: ${fromTurnCount}`);+ }+ if (!Number.isInteger(toTurnCount) || toTurnCount < 0) {+ throw new Error(`Invalid to turn count: ${toTurnCount}`);+ }+ if (fromTurnCount > toTurnCount) {+ throw new Error(`Invalid checkpoint range: ${fromTurnCount}..${toTurnCount}`);+ }++ const fromRef = checkpointRefForThreadTurn(threadId, fromTurnCount);+ const toRef = checkpointRefForThreadTurn(threadId, toTurnCount);+ let fromCommitOid = await this.resolveCheckpointCommit(cwd, fromRef);+ const toCommitOid = await this.resolveCheckpointCommit(cwd, toRef);+ if (!fromCommitOid && fromTurnCount === 0) {+ const headCommit = await this.resolveHeadCommit(cwd);+ if (headCommit) {+ fromCommitOid = headCommit;+ }+ }+ if (!fromCommitOid) {+ throw new Error(+ `Filesystem checkpoint is unavailable for turn ${fromTurnCount} in thread ${threadId}.`,+ );+ }+ if (!toCommitOid) {+ throw new Error(`Filesystem checkpoint is unavailable for turn ${toTurnCount} in thread ${threadId}.`);+ }++ const result = await this.runGit(cwd, [+ "diff",+ "--patch",+ "--minimal",+ "--no-color",+ fromCommitOid,+ toCommitOid,+ ]);+ return result.stdout;+ }++ private async resolveHeadCommit(cwd: string): Promise<string | null> {+ const result = await this.runGit(cwd, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], {+ allowNonZeroExit: true,+ });+ if (result.code !== 0) {+ return null;+ }+ const commit = result.stdout.trim();+ return commit.length > 0 ? commit : null;+ }+async pruneAfterTurn(input: { cwd: string; threadId: string; maxTurnCount: number }): Promise<void> {const { cwd, threadId, maxTurnCount } = input;if (!Number.isInteger(maxTurnCount) || maxTurnCount < 0) {diff --git a/apps/server/src/providerManager.test.ts b/apps/server/src/providerManager.test.tsindex 794e2183d..66baa5e53 100644--- a/apps/server/src/providerManager.test.ts+++ b/apps/server/src/providerManager.test.ts@@ -76,6 +76,14 @@ describe("ProviderManager", () => {}),).rejects.toThrow("Unknown provider session: missing-session");+ await expect(+ manager.getCheckpointDiff({+ sessionId: "missing-session",+ fromTurnCount: 0,+ toTurnCount: 1,+ }),+ ).rejects.toThrow("Unknown provider session: missing-session");+manager.dispose();});@@ -155,12 +163,39 @@ describe("ProviderManager", () => {threadId: string;turns: Array<{ id: string; items: unknown[] }>;}>;+ listSessions: () => Array<{+ sessionId: string;+ provider: "codex";+ status: "ready";+ createdAt: string;+ updatedAt: string;+ cwd?: string;+ }>;+ };+ filesystemCheckpointStore: {+ isGitRepository: (cwd: string) => Promise<boolean>;+ ensureRootCheckpoint: (input: { cwd: string; threadId: string }) => Promise<boolean>;};}).codex;+ const internals = manager as unknown as {+ filesystemCheckpointStore: {+ isGitRepository: (cwd: string) => Promise<boolean>;+ ensureRootCheckpoint: (input: { cwd: string; threadId: string }) => Promise<boolean>;+ };+ };const rollbackCalls: Array<{ sessionId: string; numTurns: number }> = [];codex.hasSession = () => true;+ codex.listSessions = () => [+ {+ sessionId: "sess_1",+ provider: "codex",+ status: "ready",+ createdAt: "2026-02-18T00:00:00.000Z",+ updatedAt: "2026-02-18T00:00:00.000Z",+ },+ ];codex.readThread = async () => ({threadId: "thr_1",turns: [@@ -176,6 +211,8 @@ describe("ProviderManager", () => {turns: [{ id: "turn_1", items: [] }],};};+ internals.filesystemCheckpointStore.isGitRepository = async () => false;+ internals.filesystemCheckpointStore.ensureRootCheckpoint = async () => true;const result = await manager.revertToCheckpoint({sessionId: "sess_1",@@ -192,6 +229,239 @@ describe("ProviderManager", () => {manager.dispose();});+ it("returns diff text for a checkpoint range", async () => {+ const manager = new ProviderManager();+ const internals = manager as unknown as {+ codex: {+ hasSession: (sessionId: string) => boolean;+ readThread: (sessionId: string) => Promise<{+ threadId: string;+ turns: Array<{ id: string; items: unknown[] }>;+ }>;+ };+ filesystemCheckpointStore: {+ diffCheckpoints: (input: {+ cwd: string;+ threadId: string;+ fromTurnCount: number;+ toTurnCount: number;+ }) => Promise<string>;+ };+ sessionCheckpointCwds: Map<string, string>;+ };++ internals.codex.hasSession = () => true;+ internals.codex.readThread = async () => ({+ threadId: "thr_1",+ turns: [{ id: "turn_1", items: [] }, { id: "turn_2", items: [] }],+ });+ const diffCheckpoints = vi.fn(async () => "diff --git a/a.ts b/a.ts");+ internals.filesystemCheckpointStore.diffCheckpoints = diffCheckpoints;+ internals.sessionCheckpointCwds.set("sess_1", "/repo");++ const result = await manager.getCheckpointDiff({+ sessionId: "sess_1",+ fromTurnCount: 1,+ toTurnCount: 2,+ });++ expect(result).toEqual({+ threadId: "thr_1",+ fromTurnCount: 1,+ toTurnCount: 2,+ diff: "diff --git a/a.ts b/a.ts",+ });+ expect(diffCheckpoints).toHaveBeenCalledWith({+ cwd: "/repo",+ threadId: "thr_1",+ fromTurnCount: 1,+ toTurnCount: 2,+ });++ manager.dispose();+ });++ it("lazily initializes filesystem checkpoints before diffing when cache is missing", async () => {+ const manager = new ProviderManager();+ const internals = manager as unknown as {+ codex: {+ hasSession: (sessionId: string) => boolean;+ listSessions: () => Array<{+ sessionId: string;+ provider: "codex";+ status: "ready";+ createdAt: string;+ updatedAt: string;+ cwd?: string;+ }>;+ readThread: (sessionId: string) => Promise<{+ threadId: string;+ turns: Array<{ id: string; items: unknown[] }>;+ }>;+ };+ filesystemCheckpointStore: {+ isGitRepository: (cwd: string) => Promise<boolean>;+ ensureRootCheckpoint: (input: { cwd: string; threadId: string }) => Promise<boolean>;+ captureCheckpoint: (input: {+ cwd: string;+ threadId: string;+ turnCount: number;+ }) => Promise<void>;+ diffCheckpoints: (input: {+ cwd: string;+ threadId: string;+ fromTurnCount: number;+ toTurnCount: number;+ }) => Promise<string>;+ };+ sessionCheckpointCwds: Map<string, string>;+ };++ internals.codex.hasSession = () => true;+ internals.codex.listSessions = () => [+ {+ sessionId: "sess_1",+ provider: "codex",+ status: "ready",+ createdAt: "2026-02-18T00:00:00.000Z",+ updatedAt: "2026-02-18T00:00:00.000Z",+ cwd: "/repo",+ },+ ];+ internals.codex.readThread = async () => ({+ threadId: "thr_1",+ turns: [{ id: "turn_1", items: [] }, { id: "turn_2", items: [] }],+ });+ const isGitRepository = vi.fn(async () => true);+ const ensureRootCheckpoint = vi.fn(async () => true);+ const captureCheckpoint = vi.fn(async () => undefined);+ const diffCheckpoints = vi.fn(async () => "diff --git a/a.ts b/a.ts");+ internals.filesystemCheckpointStore.isGitRepository = isGitRepository;+ internals.filesystemCheckpointStore.ensureRootCheckpoint = ensureRootCheckpoint;+ internals.filesystemCheckpointStore.captureCheckpoint = captureCheckpoint;+ internals.filesystemCheckpointStore.diffCheckpoints = diffCheckpoints;+ internals.sessionCheckpointCwds.delete("sess_1");++ const result = await manager.getCheckpointDiff({+ sessionId: "sess_1",+ fromTurnCount: 1,+ toTurnCount: 2,+ });++ expect(result.diff).toBe("diff --git a/a.ts b/a.ts");+ expect(isGitRepository).toHaveBeenCalledWith("/repo");+ expect(captureCheckpoint).toHaveBeenCalledWith({+ cwd: "/repo",+ threadId: "thr_1",+ turnCount: 2,+ });+ expect(ensureRootCheckpoint).toHaveBeenCalledWith({+ cwd: "/repo",+ threadId: "thr_1",+ });+ expect(diffCheckpoints).toHaveBeenCalledWith({+ cwd: "/repo",+ threadId: "thr_1",+ fromTurnCount: 1,+ toTurnCount: 2,+ });+ expect(internals.sessionCheckpointCwds.get("sess_1")).toBe("/repo");++ manager.dispose();+ });++ it("falls back to process cwd for lazy checkpoint init when session cwd is missing", async () => {+ const manager = new ProviderManager();+ const internals = manager as unknown as {+ codex: {+ hasSession: (sessionId: string) => boolean;+ listSessions: () => Array<{+ sessionId: string;+ provider: "codex";+ status: "ready";+ createdAt: string;+ updatedAt: string;+ cwd?: string;+ }>;+ readThread: (sessionId: string) => Promise<{+ threadId: string;+ turns: Array<{ id: string; items: unknown[] }>;+ }>;+ };+ filesystemCheckpointStore: {+ isGitRepository: (cwd: string) => Promise<boolean>;+ ensureRootCheckpoint: (input: { cwd: string; threadId: string }) => Promise<boolean>;+ captureCheckpoint: (input: {+ cwd: string;+ threadId: string;+ turnCount: number;+ }) => Promise<void>;+ diffCheckpoints: (input: {+ cwd: string;+ threadId: string;+ fromTurnCount: number;+ toTurnCount: number;+ }) => Promise<string>;+ };+ sessionCheckpointCwds: Map<string, string>;+ };++ const processCwd = vi.spyOn(process, "cwd").mockReturnValue("/fallback-repo");+ try {+ internals.codex.hasSession = () => true;+ internals.codex.listSessions = () => [+ {+ sessionId: "sess_1",+ provider: "codex",+ status: "ready",+ createdAt: "2026-02-18T00:00:00.000Z",+ updatedAt: "2026-02-18T00:00:00.000Z",+ },+ ];+ internals.codex.readThread = async () => ({+ threadId: "thr_1",+ turns: [{ id: "turn_1", items: [] }],+ });+ const isGitRepository = vi.fn(async (cwd: string) => cwd === "/fallback-repo");+ const ensureRootCheckpoint = vi.fn(async () => true);+ const captureCheckpoint = vi.fn(async () => undefined);+ const diffCheckpoints = vi.fn(async () => "diff --git a/a.ts b/a.ts");+ internals.filesystemCheckpointStore.isGitRepository = isGitRepository;+ internals.filesystemCheckpointStore.ensureRootCheckpoint = ensureRootCheckpoint;+ internals.filesystemCheckpointStore.captureCheckpoint = captureCheckpoint;+ internals.filesystemCheckpointStore.diffCheckpoints = diffCheckpoints;+ internals.sessionCheckpointCwds.delete("sess_1");++ const result = await manager.getCheckpointDiff({+ sessionId: "sess_1",+ fromTurnCount: 0,+ toTurnCount: 1,+ });++ expect(result.diff).toBe("diff --git a/a.ts b/a.ts");+ expect(isGitRepository).toHaveBeenCalledWith("/fallback-repo");+ expect(captureCheckpoint).toHaveBeenCalledWith({+ cwd: "/fallback-repo",+ threadId: "thr_1",+ turnCount: 1,+ });+ expect(ensureRootCheckpoint).toHaveBeenCalledWith({+ cwd: "/fallback-repo",+ threadId: "thr_1",+ });+ expect(diffCheckpoints).toHaveBeenCalledWith({+ cwd: "/fallback-repo",+ threadId: "thr_1",+ fromTurnCount: 0,+ toTurnCount: 1,+ });+ expect(internals.sessionCheckpointCwds.get("sess_1")).toBe("/fallback-repo");+ } finally {+ processCwd.mockRestore();+ manager.dispose();+ }+ });+it("restores filesystem checkpoint when reverting and checkpointing is enabled", async () => {const manager = new ProviderManager();const internals = manager as unknown as {@@ -263,6 +533,73 @@ describe("ProviderManager", () => {manager.dispose();});+ it("reverts to turn 0 without requiring an explicit turn 0 checkpoint ref", async () => {+ const manager = new ProviderManager();+ const internals = manager as unknown as {+ codex: {+ hasSession: (sessionId: string) => boolean;+ readThread: (sessionId: string) => Promise<{+ threadId: string;+ turns: Array<{ id: string; items: unknown[] }>;+ }>;+ rollbackThread: (sessionId: string, numTurns: number) => Promise<{+ threadId: string;+ turns: Array<{ id: string; items: unknown[] }>;+ }>;+ };+ filesystemCheckpointStore: {+ hasCheckpoint: (input: { cwd: string; threadId: string; turnCount: number }) => Promise<boolean>;+ restoreCheckpoint: (input: {+ cwd: string;+ threadId: string;+ turnCount: number;+ }) => Promise<boolean>;+ pruneAfterTurn: (input: { cwd: string; threadId: string; maxTurnCount: number }) => Promise<void>;+ };+ sessionCheckpointCwds: Map<string, string>;+ };++ internals.codex.hasSession = () => true;+ internals.codex.readThread = async () => ({+ threadId: "thr_1",+ turns: [+ { id: "turn_1", items: [] },+ { id: "turn_2", items: [] },+ ],+ });+ internals.codex.rollbackThread = async () => ({+ threadId: "thr_1",+ turns: [],+ });+ const hasCheckpoint = vi.fn(async () => false);+ const restoreCheckpoint = vi.fn(async () => true);+ const pruneAfterTurn = vi.fn(async () => undefined);+ internals.filesystemCheckpointStore.hasCheckpoint = hasCheckpoint;+ internals.filesystemCheckpointStore.restoreCheckpoint = restoreCheckpoint;+ internals.filesystemCheckpointStore.pruneAfterTurn = pruneAfterTurn;+ internals.sessionCheckpointCwds.set("sess_1", "/repo");++ const result = await manager.revertToCheckpoint({+ sessionId: "sess_1",+ turnCount: 0,+ });++ expect(result.turnCount).toBe(0);+ expect(hasCheckpoint).not.toHaveBeenCalled();+ expect(restoreCheckpoint).toHaveBeenCalledWith({+ cwd: "/repo",+ threadId: "thr_1",+ turnCount: 0,+ });+ expect(pruneAfterTurn).toHaveBeenCalledWith({+ cwd: "/repo",+ threadId: "thr_1",+ maxTurnCount: 0,+ });++ manager.dispose();+ });+it("fails before rollback when filesystem checkpoint is missing", async () => {const manager = new ProviderManager();const internals = manager as unknown as {diff --git a/apps/server/src/providerManager.ts b/apps/server/src/providerManager.tsindex 1038ed41d..5e55f0b1c 100644--- a/apps/server/src/providerManager.ts+++ b/apps/server/src/providerManager.ts@@ -6,6 +6,8 @@ import { randomUUID } from "node:crypto";import {type ProviderCheckpoint,type ProviderEvent,+ type ProviderGetCheckpointDiffInput,+ type ProviderGetCheckpointDiffResult,type ProviderInterruptTurnInput,type ProviderListCheckpointsInput,type ProviderListCheckpointsResult,@@ -18,6 +20,7 @@ import {type ProviderStopSessionInput,type ProviderTurnStartResult,providerInterruptTurnInputSchema,+ providerGetCheckpointDiffInputSchema,providerListCheckpointsInputSchema,providerRevertToCheckpointInputSchema,providerRespondToRequestInputSchema,@@ -198,7 +201,7 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {this.sessionThreadIds.set(session.sessionId, session.threadId);this.flushPendingSessionEvents(session.sessionId, session.threadId);}- await this.initializeFilesystemCheckpointing(session).catch((error) => {+ await this.initializeFilesystemCheckpointing(session, input.cwd).catch((error) => {const message =error instanceof Error ? error.message : "Failed to initialize filesystem checkpoints.";this.emitFilesystemCheckpointError(session.sessionId, message, session.threadId);@@ -259,6 +262,43 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {};}+ async getCheckpointDiff(+ raw: ProviderGetCheckpointDiffInput,+ ): Promise<ProviderGetCheckpointDiffResult> {+ const input = providerGetCheckpointDiffInputSchema.parse(raw);+ if (!this.codex.hasSession(input.sessionId)) {+ throw new Error(`Unknown provider session: ${input.sessionId}`);+ }++ const checkpointCwd = await this.getOrInitializeFilesystemCheckpointCwd(input.sessionId);+ if (!checkpointCwd) {+ throw new Error("Filesystem checkpoints are unavailable for this session.");+ }++ return this.withFilesystemLock(input.sessionId, async () => {+ const snapshot = await this.codex.readThread(input.sessionId);+ if (input.toTurnCount > snapshot.turns.length) {+ throw new Error(+ `Checkpoint turn count ${input.toTurnCount} exceeds current turn count ${snapshot.turns.length}.`,+ );+ }++ const diff = await this.filesystemCheckpointStore.diffCheckpoints({+ cwd: checkpointCwd,+ threadId: snapshot.threadId,+ fromTurnCount: input.fromTurnCount,+ toTurnCount: input.toTurnCount,+ });++ return {+ threadId: snapshot.threadId,+ fromTurnCount: input.fromTurnCount,+ toTurnCount: input.toTurnCount,+ diff,+ };+ });+ }+async revertToCheckpoint(raw: ProviderRevertToCheckpointInput,): Promise<ProviderRevertToCheckpointResult> {@@ -267,6 +307,7 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {throw new Error(`Unknown provider session: ${input.sessionId}`);}+ const checkpointCwd = await this.getOrInitializeFilesystemCheckpointCwd(input.sessionId);return this.withFilesystemLock(input.sessionId, async () => {const beforeSnapshot = await this.codex.readThread(input.sessionId);const currentTurnCount = beforeSnapshot.turns.length;@@ -276,8 +317,7 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {);}- const checkpointCwd = this.sessionCheckpointCwds.get(input.sessionId);- if (checkpointCwd) {+ if (checkpointCwd && input.turnCount > 0) {const hasCheckpoint = await this.filesystemCheckpointStore.hasCheckpoint({cwd: checkpointCwd,threadId: beforeSnapshot.threadId,@@ -352,8 +392,11 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {this.filesystemLocks.clear();}- private async initializeFilesystemCheckpointing(session: ProviderSession): Promise<void> {- const cwd = session.cwd ?? process.cwd();+ private async initializeFilesystemCheckpointing(+ session: ProviderSession,+ preferredCwd?: string,+ ): Promise<void> {+ const cwd = preferredCwd ?? session.cwd ?? process.cwd();await this.withFilesystemLock(session.sessionId, async () => {const supportsGit = await this.filesystemCheckpointStore.isGitRepository(cwd);@@ -363,6 +406,10 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {}const snapshot = await this.codex.readThread(session.sessionId);+ await this.filesystemCheckpointStore.ensureRootCheckpoint({+ cwd,+ threadId: snapshot.threadId,+ });await this.filesystemCheckpointStore.captureCheckpoint({cwd,threadId: snapshot.threadId,@@ -372,6 +419,54 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {});}+ private async getOrInitializeFilesystemCheckpointCwd(sessionId: string): Promise<string | null> {+ const existingCwd = this.sessionCheckpointCwds.get(sessionId);+ if (existingCwd) {+ return existingCwd;+ }++ const session = this.codex.listSessions().find((candidate) => candidate.sessionId === sessionId);+ const candidateCwds = Array.from(+ new Set([session?.cwd, process.cwd()].filter((value): value is string => Boolean(value))),+ );+ if (candidateCwds.length === 0) {+ return null;+ }++ await this.withFilesystemLock(sessionId, async () => {+ const currentCwd = this.sessionCheckpointCwds.get(sessionId);+ if (currentCwd) {+ return;+ }++ const cwdSupport = await Promise.all(+ candidateCwds.map(async (cwd) => ({+ cwd,+ supportsGit: await this.filesystemCheckpointStore.isGitRepository(cwd),+ })),+ );+ const supportedCwd = cwdSupport.find((entry) => entry.supportsGit)?.cwd;+ if (supportedCwd) {+ const snapshot = await this.codex.readThread(sessionId);+ await this.filesystemCheckpointStore.ensureRootCheckpoint({+ cwd: supportedCwd,+ threadId: snapshot.threadId,+ });+ await this.filesystemCheckpointStore.captureCheckpoint({+ cwd: supportedCwd,+ threadId: snapshot.threadId,+ turnCount: snapshot.turns.length,+ });+ this.sessionCheckpointCwds.set(sessionId, supportedCwd);+ return;+ }++ this.sessionCheckpointCwds.delete(sessionId);+ });++ return this.sessionCheckpointCwds.get(sessionId) ?? null;+ }+private maybeCaptureFilesystemCheckpoint(event: ProviderEvent): void {if (event.kind !== "notification" || event.method !== "turn/completed") {return;@@ -379,6 +474,11 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {const checkpointCwd = this.sessionCheckpointCwds.get(event.sessionId);if (!checkpointCwd) {+ void this.getOrInitializeFilesystemCheckpointCwd(event.sessionId).catch((error) => {+ const message =+ error instanceof Error ? error.message : "Failed to initialize filesystem checkpoints.";+ this.emitFilesystemCheckpointError(event.sessionId, message, event.threadId);+ });return;}diff --git a/apps/server/src/wsServer.test.ts b/apps/server/src/wsServer.test.tsindex a860c5d8a..48782bd26 100644--- a/apps/server/src/wsServer.test.ts+++ b/apps/server/src/wsServer.test.ts@@ -668,6 +668,14 @@ describe("WebSocket Server", () => {});expect(revertResponse.result).toBeUndefined();expect(revertResponse.error?.message).toContain("Unknown provider session");++ const diffResponse = await sendRequest(ws, WS_METHODS.providersGetCheckpointDiff, {+ sessionId: "missing-session",+ fromTurnCount: 0,+ toTurnCount: 1,+ });+ expect(diffResponse.result).toBeUndefined();+ expect(diffResponse.error?.message).toContain("Unknown provider session");});it("routes terminal RPC methods and broadcasts terminal events", async () => {diff --git a/apps/server/src/wsServer.ts b/apps/server/src/wsServer.tsindex ec0d73d59..325727827 100644--- a/apps/server/src/wsServer.ts+++ b/apps/server/src/wsServer.ts@@ -313,6 +313,9 @@ export function createServer(options: ServerOptions) {case WS_METHODS.providersListCheckpoints:return providerManager.listCheckpoints(request.params as never);+ case WS_METHODS.providersGetCheckpointDiff:+ return providerManager.getCheckpointDiff(request.params as never);+case WS_METHODS.providersRevertToCheckpoint:return providerManager.revertToCheckpoint(request.params as never);diff --git a/apps/web/src/App.tsx b/apps/web/src/App.tsxindex 6a3d09363..13058c114 100644--- a/apps/web/src/App.tsx+++ b/apps/web/src/App.tsx@@ -9,10 +9,13 @@ import { StoreProvider, useStore } from "./store";import { DEFAULT_THREAD_TERMINAL_HEIGHT, DEFAULT_THREAD_TERMINAL_ID } from "./types";import { onServerWelcome } from "./wsNativeApi";import { useNativeApi } from "./hooks/useNativeApi";+import { useMediaQuery } from "./hooks/useMediaQuery";import { AnchoredToastProvider, ToastProvider } from "./components/ui/toast";+import { Sheet, SheetPopup } from "./components/ui/sheet";import { invalidateGitQueries } from "./lib/gitReactQuery";const DiffPanel = lazy(() => import("./components/DiffPanel"));+const DIFF_INLINE_LAYOUT_MEDIA_QUERY = "(max-width: 1180px)";function EventRouter() {const api = useNativeApi();@@ -112,6 +115,7 @@ function AutoProjectBootstrap() {session: null,messages: [],events: [],+ turnDiffSummaries: [],error: null,createdAt: new Date().toISOString(),branch: null,@@ -177,7 +181,8 @@ function DesktopProjectBootstrap() {function Layout() {const api = useNativeApi();- const { state } = useStore();+ const { state, dispatch } = useStore();+ const shouldUseDiffSheet = useMediaQuery(DIFF_INLINE_LAYOUT_MEDIA_QUERY);if (!api) {return (@@ -196,7 +201,7 @@ function Layout() {<DesktopProjectBootstrap /><Sidebar /><ChatView />- {state.diffOpen && (+ {state.diffOpen && !shouldUseDiffSheet && (<Suspensefallback={<aside className="flex h-full w-[560px] shrink-0 items-center justify-center border-l border-border bg-card px-4 text-center text-xs text-muted-foreground/70">@@ -204,9 +209,35 @@ function Layout() {</aside>}>- <DiffPanel />+ <DiffPanel mode="inline" /></Suspense>)}+ {state.diffOpen && shouldUseDiffSheet && (+ <Sheet+ open={state.diffOpen}+ onOpenChange={(open) => {+ if (!open) {+ dispatch({ type: "CLOSE_DIFF" });+ }+ }}+ >+ <SheetPopup+ side="right"+ showCloseButton={false}+ className="w-[min(88vw,820px)] max-w-[820px] p-0"+ >+ <Suspense+ fallback={+ <div className="flex h-full min-h-0 items-center justify-center px-4 text-center text-xs text-muted-foreground/70">+ Loading diff viewer...+ </div>+ }+ >+ <DiffPanel mode="sheet" />+ </Suspense>+ </SheetPopup>+ </Sheet>+ )}</div>);}diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex dda7d6a5a..a053dc732 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -8,7 +8,6 @@ import {PROVIDER_SEND_TURN_MAX_INPUT_CHARS,PROVIDER_SEND_TURN_MAX_ATTACHMENTS,PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,- type ProviderCheckpoint,type ResolvedKeybindingsConfig,type ProviderApprovalDecision,type ProviderSendTurnAttachmentInput,@@ -50,10 +49,12 @@ import {resolveModelSlug,} from "../model-logic";import {+ countDiffStat,derivePendingApprovals,derivePhase,deriveTurnDiffSummaries,deriveTimelineEntries,+ inferCheckpointTurnCountByTurnId,type TurnDiffSummary,type PendingApproval,deriveWorkLogEntries,@@ -87,6 +88,7 @@ import {CircleAlertIcon,FileIcon,FolderIcon,+ DiffIcon,FolderClosedIcon,InfoIcon,LockIcon,@@ -348,9 +350,7 @@ export default function ChatView() {const [expandedImage, setExpandedImage] = useState<ExpandedImagePreview | null>(null);const [isSending, setIsSending] = useState(false);const [isConnecting, setIsConnecting] = useState(false);- const [isLoadingCheckpoints, setIsLoadingCheckpoints] = useState(false);const [isRevertingCheckpoint, setIsRevertingCheckpoint] = useState(false);- const [checkpoints, setCheckpoints] = useState<ProviderCheckpoint[]>([]);const [selectedEffort, setSelectedEffort] = useState(DEFAULT_REASONING);const [envMode, setEnvMode] = useState<"local" | "worktree">("local");const [isSwitchingRuntimeMode, setIsSwitchingRuntimeMode] = useState(false);@@ -371,10 +371,13 @@ export default function ChatView() {const composerImagesRef = useRef<ComposerImageAttachment[]>([]);const dragDepthRef = useRef(0);const terminalOpenByThreadRef = useRef<Record<string, boolean>>({});+ const checkpointDiffRequestsRef = useRef(new Set<string>());+ const checkpointHydrationSessionRequestRef = useRef(new Set<string>());const activeThread = state.threads.find((t) => t.id === state.activeThreadId);const activeThreadId = activeThread?.id ?? null;const activeSessionId = activeThread?.session?.sessionId;+ const activeThreadRuntimeId = activeThread?.codexThreadId ?? activeThread?.session?.threadId ?? null;const activeProject = state.projects.find((p) => p.id === activeThread?.projectId);const selectedModel = resolveModelSlug(activeThread?.model ?? activeProject?.model ?? DEFAULT_MODEL,@@ -409,8 +412,11 @@ export default function ChatView() {[activeThread?.messages, workLogEntries],);const turnDiffSummaries = useMemo(- () => deriveTurnDiffSummaries(activeThread?.events ?? []),- [activeThread?.events],+ () =>+ activeThread?.turnDiffSummaries.length+ ? activeThread.turnDiffSummaries+ : deriveTurnDiffSummaries(activeThread?.events ?? []),+ [activeThread?.events, activeThread?.turnDiffSummaries],);const turnDiffSummaryByAssistantMessageId = useMemo(() => {const byMessageId = new Map<string, TurnDiffSummary>();@@ -420,6 +426,134 @@ export default function ChatView() {}return byMessageId;}, [turnDiffSummaries]);+ const inferredCheckpointTurnCountByTurnId = useMemo(+ () => inferCheckpointTurnCountByTurnId(turnDiffSummaries),+ [turnDiffSummaries],+ );+ const revertTurnCountByUserMessageId = useMemo(() => {+ const byUserMessageId = new Map<string, number>();+ for (let index = 0; index < timelineEntries.length; index += 1) {+ const entry = timelineEntries[index];+ if (!entry || entry.kind !== "message" || entry.message.role !== "user") {+ continue;+ }++ for (let nextIndex = index + 1; nextIndex < timelineEntries.length; nextIndex += 1) {+ const nextEntry = timelineEntries[nextIndex];+ if (!nextEntry || nextEntry.kind !== "message") {+ continue;+ }+ if (nextEntry.message.role === "user") {+ break;+ }+ const summary = turnDiffSummaryByAssistantMessageId.get(nextEntry.message.id);+ if (!summary) {+ continue;+ }+ const turnCount =+ summary.checkpointTurnCount ?? inferredCheckpointTurnCountByTurnId[summary.turnId];+ if (typeof turnCount !== "number") {+ break;+ }+ byUserMessageId.set(entry.message.id, Math.max(0, turnCount - 1));+ break;+ }+ }++ return byUserMessageId;+ }, [inferredCheckpointTurnCountByTurnId, timelineEntries, turnDiffSummaryByAssistantMessageId]);++ useEffect(() => {+ if (!activeThreadId || turnDiffSummaries.length === 0) {+ return;+ }++ const inferredMissingTurnCounts = turnDiffSummaries.reduce<Record<string, number>>(+ (acc, summary) => {+ if (typeof summary.checkpointTurnCount === "number") {+ return acc;+ }+ const inferredTurnCount = inferredCheckpointTurnCountByTurnId[summary.turnId];+ if (typeof inferredTurnCount !== "number") {+ return acc;+ }+ acc[summary.turnId] = inferredTurnCount;+ return acc;+ },+ {},+ );+ if (Object.keys(inferredMissingTurnCounts).length === 0) {+ return;+ }++ dispatch({+ type: "SET_THREAD_TURN_CHECKPOINT_COUNTS",+ threadId: activeThreadId,+ checkpointTurnCountByTurnId: inferredMissingTurnCounts,+ });+ }, [activeThreadId, dispatch, inferredCheckpointTurnCountByTurnId, turnDiffSummaries]);++ useEffect(() => {+ if (!api || !activeThreadId || !activeSessionId || turnDiffSummaries.length === 0) {+ return;+ }++ const turnSummariesNeedingDiff = turnDiffSummaries.filter(+ (summary) => !summary.checkpointDiffLoaded && inferredCheckpointTurnCountByTurnId[summary.turnId],+ );+ const requestedSummaries = turnSummariesNeedingDiff.filter((summary) => {+ const requestKey = `${activeThreadId}:${summary.turnId}`;+ if (checkpointDiffRequestsRef.current.has(requestKey)) {+ return false;+ }+ checkpointDiffRequestsRef.current.add(requestKey);+ return true;+ });+ if (requestedSummaries.length === 0) {+ return;+ }++ let cancelled = false;+ void Promise.all(+ requestedSummaries.map(async (summary) => {+ const turnCount = inferredCheckpointTurnCountByTurnId[summary.turnId] ?? 0;+ const result = await api.providers.getCheckpointDiff({+ sessionId: activeSessionId,+ fromTurnCount: Math.max(0, turnCount - 1),+ toTurnCount: turnCount,+ });+ return [summary.turnId, result.diff] as const;+ }),+ )+ .then((entries) => {+ if (cancelled) return;+ dispatch({+ type: "SET_THREAD_TURN_CHECKPOINT_DIFFS",+ threadId: activeThreadId,+ checkpointDiffByTurnId: Object.fromEntries(entries),+ });+ })+ .catch(() => {+ if (cancelled) return;+ })+ .finally(() => {+ for (const summary of requestedSummaries) {+ checkpointDiffRequestsRef.current.delete(`${activeThreadId}:${summary.turnId}`);+ }+ });++ return () => {+ cancelled = true;+ };+ }, [+ activeSessionId,+ activeThreadId,+ api,+ dispatch,+ inferredCheckpointTurnCountByTurnId,+ turnDiffSummaries,+ ]);+const completionSummary = useMemo(() => {if (!activeThread?.latestTurnStartedAt) return null;if (!activeThread.latestTurnCompletedAt) return null;@@ -475,16 +609,9 @@ export default function ChatView() {completionSummary,timelineEntries,]);- const runtimeSessionConfig =- state.runtimeMode === "full-access"- ? ({- approvalPolicy: "never",- sandboxMode: "danger-full-access",- } as const)- : ({- approvalPolicy: "on-request",- sandboxMode: "workspace-write",- } as const);+ const runtimeApprovalPolicy = state.runtimeMode === "full-access" ? "never" : "on-request";+ const runtimeSandboxMode =+ state.runtimeMode === "full-access" ? "danger-full-access" : "workspace-write";const gitCwd = activeThread?.worktreePath ?? activeProject?.cwd ?? null;const composerTrigger = useMemo(() => detectComposerTrigger(prompt, composerCursor),@@ -593,12 +720,6 @@ export default function ChatView() {);const hasReachedTerminalLimit =(activeThread?.terminalIds.length ?? 0) >= MAX_THREAD_TERMINAL_COUNT;- const canCheckpoint =- Boolean(api && activeThread && (activeThread.codexThreadId ?? activeThread.session?.threadId)) &&- phase !== "running" &&- !isSending &&- !isConnecting &&- !isRevertingCheckpoint;const revokePreviewUrls = useCallback((images: Array<{ previewUrl?: string }>) => {for (const image of images) {@@ -988,8 +1109,6 @@ export default function ChatView() {}, [composerMenuItems, composerMenuOpen]);useEffect(() => {- setCheckpoints([]);- setIsLoadingCheckpoints(false);setIsRevertingCheckpoint(false);}, [activeThread?.id]);@@ -1172,14 +1291,17 @@ export default function ChatView() {toggleTerminalVisibility,]);- const setThreadError = (threadId: string | null, error: string | null) => {- if (!threadId) return;- dispatch({- type: "SET_ERROR",- threadId,- error,- });- };+ const setThreadError = useCallback(+ (threadId: string | null, error: string | null) => {+ if (!threadId) return;+ dispatch({+ type: "SET_ERROR",+ threadId,+ error,+ });+ },+ [dispatch],+ );const addComposerImages = (files: File[]) => {if (!activeThreadId || files.length === 0) return;@@ -1284,134 +1406,169 @@ export default function ChatView() {focusComposer();};- const ensureSession = async (cwdOverride?: string): Promise<EnsuredSessionInfo | null> => {- if (!api || !activeThread || !activeProject) return null;- if (activeThread.session && activeThread.session.status !== "closed") {- const sessionThreadId = activeThread.session.threadId ?? null;- const continuityState: SessionContinuityState =- activeThread.codexThreadId === null- ? "new"- : sessionThreadId === activeThread.codexThreadId- ? "resumed"- : "fallback_new";- return {- sessionId: activeThread.session.sessionId,- resolvedThreadId: sessionThreadId,- continuityState,- } satisfies EnsuredSessionInfo;- }-- const priorCodexThreadId = activeThread.codexThreadId;- setIsConnecting(true);- try {- const session = await api.providers.startSession({- provider: "codex",- cwd: cwdOverride ?? activeThread.worktreePath ?? activeProject.cwd,- model: selectedModel || undefined,- resumeThreadId: priorCodexThreadId ?? undefined,- approvalPolicy: runtimeSessionConfig.approvalPolicy,- sandboxMode: runtimeSessionConfig.sandboxMode,- });- dispatch({- type: "UPDATE_SESSION",- threadId: activeThread.id,- session,- });- const resolvedThreadId = session.threadId ?? null;- const continuityState: SessionContinuityState =- priorCodexThreadId === null- ? "new"- : resolvedThreadId === priorCodexThreadId- ? "resumed"- : "fallback_new";- return {- sessionId: session.sessionId,- resolvedThreadId,- continuityState,- };- } catch (err) {- dispatch({- type: "SET_ERROR",- threadId: activeThread.id,- error: err instanceof Error ? err.message : "Failed to connect.",- });- return null;- } finally {- setIsConnecting(false);- }- };-- const loadCheckpoints = async (): Promise<ProviderCheckpoint[] | null> => {- if (!api || !activeThread) return null;- if (phase === "running" || isSending || isConnecting || isRevertingCheckpoint) {- return null;- }- const hasThreadIdentity = Boolean(activeThread.codexThreadId ?? activeThread.session?.threadId);- if (!hasThreadIdentity) {- setCheckpoints([]);- return [];- }+ const ensureSession = useCallback(+ async (cwdOverride?: string): Promise<EnsuredSessionInfo | null> => {+ if (!api || !activeThread || !activeProject) return null;+ if (activeThread.session && activeThread.session.status !== "closed") {+ const sessionThreadId = activeThread.session.threadId ?? null;+ const continuityState: SessionContinuityState =+ activeThread.codexThreadId === null+ ? "new"+ : sessionThreadId === activeThread.codexThreadId+ ? "resumed"+ : "fallback_new";+ return {+ sessionId: activeThread.session.sessionId,+ resolvedThreadId: sessionThreadId,+ continuityState,+ } satisfies EnsuredSessionInfo;+ }- setIsLoadingCheckpoints(true);- setThreadError(activeThread.id, null);- try {- const sessionInfo = await ensureSession();- if (!sessionInfo) {+ const priorCodexThreadId = activeThread.codexThreadId;+ setIsConnecting(true);+ try {+ const session = await api.providers.startSession({+ provider: "codex",+ cwd: cwdOverride ?? activeThread.worktreePath ?? activeProject.cwd,+ model: selectedModel || undefined,+ resumeThreadId: priorCodexThreadId ?? undefined,+ approvalPolicy: runtimeApprovalPolicy,+ sandboxMode: runtimeSandboxMode,+ });+ dispatch({+ type: "UPDATE_SESSION",+ threadId: activeThread.id,+ session,+ });+ const resolvedThreadId = session.threadId ?? null;+ const continuityState: SessionContinuityState =+ priorCodexThreadId === null+ ? "new"+ : resolvedThreadId === priorCodexThreadId+ ? "resumed"+ : "fallback_new";+ return {+ sessionId: session.sessionId,+ resolvedThreadId,+ continuityState,+ };+ } catch (err) {+ dispatch({+ type: "SET_ERROR",+ threadId: activeThread.id,+ error: err instanceof Error ? err.message : "Failed to connect.",+ });return null;+ } finally {+ setIsConnecting(false);}- const result = await api.providers.listCheckpoints({- sessionId: sessionInfo.sessionId,- });- setCheckpoints(result.checkpoints);- return result.checkpoints;- } catch (err) {- setThreadError(- activeThread.id,- err instanceof Error ? err.message : "Failed to load checkpoints.",- );- return null;- } finally {- setIsLoadingCheckpoints(false);- }- };+ },+ [activeProject, activeThread, api, dispatch, runtimeApprovalPolicy, runtimeSandboxMode, selectedModel],+ );- const onRevertToCheckpoint = async (checkpoint: ProviderCheckpoint) => {- if (!api || !activeThread || checkpoint.isCurrent || isRevertingCheckpoint) {- return;- }- if (phase === "running" || isSending || isConnecting) {- setThreadError(activeThread.id, "Interrupt the current turn before reverting checkpoints.");+ useEffect(() => {+ if (!api || !activeThreadId || activeSessionId) return;+ if (phase === "running" || isSending || isConnecting || isRevertingCheckpoint) return;+ const hasThreadIdentity = Boolean(activeThreadRuntimeId);+ if (!hasThreadIdentity) return;+ const selectedDiffTurnId =+ state.diffOpen && state.diffThreadId === activeThreadId ? state.diffTurnId : null;+ const selectedDiffTurn =+ turnDiffSummaries.find((summary) => summary.turnId === selectedDiffTurnId) ?? turnDiffSummaries[0];+ const selectedTurnMissingPatchBody = Boolean(+ selectedDiffTurn &&+ !selectedDiffTurn.unifiedDiff &&+ selectedDiffTurn.files.every((file) => !file.diff),+ );+ const hasPendingDiffHydration =+ turnDiffSummaries.some((summary) => !summary.checkpointDiffLoaded) || selectedTurnMissingPatchBody;+ if (!hasPendingDiffHydration) return;++ const requestKey = `${activeThreadId}:${activeThreadRuntimeId ?? "none"}`;+ if (checkpointHydrationSessionRequestRef.current.has(requestKey)) {return;}+ checkpointHydrationSessionRequestRef.current.add(requestKey);+ setThreadError(activeThreadId, null);+ void ensureSession().finally(() => {+ checkpointHydrationSessionRequestRef.current.delete(requestKey);+ });+ }, [+ activeThreadId,+ activeThreadRuntimeId,+ activeSessionId,+ api,+ ensureSession,+ isConnecting,+ isRevertingCheckpoint,+ isSending,+ phase,+ setThreadError,+ state.diffOpen,+ state.diffThreadId,+ state.diffTurnId,+ turnDiffSummaries,+ ]);- setIsRevertingCheckpoint(true);- setThreadError(activeThread.id, null);- try {- const sessionInfo = await ensureSession();- if (!sessionInfo) {+ const onRevertToTurnCount = useCallback(+ async (turnCount: number) => {+ if (!api || !activeThread || isRevertingCheckpoint) {+ return;+ }+ if (phase === "running" || isSending || isConnecting) {+ setThreadError(activeThread.id, "Interrupt the current turn before reverting checkpoints.");return;}- const result = await api.providers.revertToCheckpoint({- sessionId: sessionInfo.sessionId,- turnCount: checkpoint.turnCount,- });- dispatch({- type: "REVERT_TO_CHECKPOINT",- threadId: activeThread.id,- sessionId: sessionInfo.sessionId,- threadRuntimeId: result.threadId,- messageCount: result.messageCount,- });- setCheckpoints(result.checkpoints);- } catch (err) {- setThreadError(- activeThread.id,- err instanceof Error ? err.message : "Failed to revert checkpoint.",- );- } finally {- setIsRevertingCheckpoint(false);- }- };++ setIsRevertingCheckpoint(true);+ setThreadError(activeThread.id, null);+ try {+ const sessionInfo = await ensureSession();+ if (!sessionInfo) {+ return;+ }+ const result = await api.providers.revertToCheckpoint({+ sessionId: sessionInfo.sessionId,+ turnCount,+ });+ dispatch({+ type: "REVERT_TO_CHECKPOINT",+ threadId: activeThread.id,+ sessionId: sessionInfo.sessionId,+ threadRuntimeId: result.threadId,+ turnCount: result.turnCount,+ messageCount: result.messageCount,+ });+ dispatch({+ type: "SET_THREAD_TURN_CHECKPOINT_COUNTS",+ threadId: activeThread.id,+ checkpointTurnCountByTurnId: Object.fromEntries(+ result.checkpoints+ .filter((entry) => entry.turnCount > 0)+ .map((entry) => [entry.id, entry.turnCount] as const),+ ),+ });+ } catch (err) {+ setThreadError(+ activeThread.id,+ err instanceof Error ? err.message : "Failed to revert thread state.",+ );+ } finally {+ setIsRevertingCheckpoint(false);+ }+ },+ [+ activeThread,+ api,+ dispatch,+ ensureSession,+ isConnecting,+ isRevertingCheckpoint,+ isSending,+ phase,+ setThreadError,+ ],+ );const onSend = async (e: FormEvent) => {e.preventDefault();@@ -1704,8 +1861,7 @@ export default function ChatView() {return;}- const latestSummary = turnDiffSummaries[0];- if (!activeThread || !latestSummary) {+ if (!activeThread) {dispatch({ type: "TOGGLE_DIFF" });return;}@@ -1713,10 +1869,8 @@ export default function ChatView() {dispatch({type: "OPEN_DIFF",threadId: activeThread.id,- turnId: latestSummary.turnId,- ...(latestSummary.files[0]?.path ? { filePath: latestSummary.files[0].path } : {}),});- }, [activeThread, dispatch, state.diffOpen, turnDiffSummaries]);+ }, [activeThread, dispatch, state.diffOpen]);const onOpenTurnDiff = useCallback((turnId: string, filePath?: string) => {if (!activeThread) return;@@ -1729,6 +1883,16 @@ export default function ChatView() {},[activeThread, dispatch],);+ const onRevertUserMessage = useCallback(+ (messageId: string) => {+ const targetTurnCount = revertTurnCountByUserMessageId.get(messageId);+ if (typeof targetTurnCount !== "number") {+ return;+ }+ void onRevertToTurnCount(targetTurnCount);+ },+ [onRevertToTurnCount, revertTurnCountByUserMessageId],+ );// Empty state: no active threadif (!activeThread) {@@ -1771,14 +1935,6 @@ export default function ChatView() {onAddProjectScript={saveProjectScript}onUpdateProjectScript={updateProjectScript}onToggleDiff={onToggleDiff}- checkpoints={checkpoints}- canCheckpoint={canCheckpoint}- isLoadingCheckpoints={isLoadingCheckpoints}- isRevertingCheckpoint={isRevertingCheckpoint}- onOpenCheckpoints={() => {- void loadCheckpoints();- }}- onRevertToCheckpoint={onRevertToCheckpoint}/></header>@@ -1808,6 +1964,9 @@ export default function ChatView() {expandedWorkGroups={expandedWorkGroups}onToggleWorkGroup={onToggleWorkGroup}onOpenTurnDiff={onOpenTurnDiff}+ revertTurnCountByUserMessageId={revertTurnCountByUserMessageId}+ onRevertUserMessage={onRevertUserMessage}+ isRevertingCheckpoint={isRevertingCheckpoint}onImageExpand={onExpandTimelineImage}messagesEndRef={messagesEndRef}/>@@ -2114,12 +2273,6 @@ interface ChatHeaderProps {onAddProjectScript: (input: NewProjectScriptInput) => Promise<void>;onUpdateProjectScript: (scriptId: string, input: NewProjectScriptInput) => Promise<void>;onToggleDiff: () => void;- checkpoints: ProviderCheckpoint[];- canCheckpoint: boolean;- isLoadingCheckpoints: boolean;- isRevertingCheckpoint: boolean;- onOpenCheckpoints: () => void;- onRevertToCheckpoint: (checkpoint: ProviderCheckpoint) => void;}const ChatHeader = memo(function ChatHeader({@@ -2135,12 +2288,6 @@ const ChatHeader = memo(function ChatHeader({onAddProjectScript,onUpdateProjectScript,onToggleDiff,- checkpoints,- canCheckpoint,- isLoadingCheckpoints,- isRevertingCheckpoint,- onOpenCheckpoints,- onRevertToCheckpoint,}: ChatHeaderProps) {return (<>@@ -2163,56 +2310,14 @@ const ChatHeader = memo(function ChatHeader({)}{activeProjectName && <OpenInPicker keybindings={keybindings} />}{activeProjectName && <GitActionsControl api={api} gitCwd={gitCwd} />}- <Menu>- <MenuTrigger- render={- <Button- size="xs"- variant="ghost"- className="text-muted-foreground/70 hover:text-foreground/80"- disabled={!canCheckpoint || isRevertingCheckpoint}- onClick={onOpenCheckpoints}- >- {isRevertingCheckpoint- ? "Reverting..."- : isLoadingCheckpoints- ? "Loading..."- : "Checkpoints"}- </Button>- }- />- <MenuPopup align="end" className="w-72">- {!canCheckpoint ? (- <MenuItem disabled>Send at least one message to create checkpoints.</MenuItem>- ) : checkpoints.length === 0 ? (- <MenuItem disabled>- {isLoadingCheckpoints ? "Loading checkpoints..." : "No checkpoints available."}- </MenuItem>- ) : (- checkpoints.map((checkpoint) => (- <MenuItem- key={checkpoint.id}- disabled={checkpoint.isCurrent || isRevertingCheckpoint}- onClick={() => onRevertToCheckpoint(checkpoint)}- >- {checkpoint.label}- {checkpoint.preview ? `: ${checkpoint.preview}` : ""}- {checkpoint.isCurrent ? " (Current)" : ""}- </MenuItem>- ))- )}- </MenuPopup>- </Menu><Button- size="xs"- variant="ghost"- className={cn(- "text-muted-foreground/70 hover:text-foreground/80",- diffOpen && "bg-accent text-accent-foreground",- )}+ aria-label="Toggle diff panel"+ size="icon-xs"+ variant="outline"+ className={cn(diffOpen && "bg-accent text-accent-foreground")}onClick={onToggleDiff}>- Diff+ <DiffIcon /></Button></div></>@@ -2317,6 +2422,9 @@ interface MessagesTimelineProps {expandedWorkGroups: Record<string, boolean>;onToggleWorkGroup: (groupId: string) => void;onOpenTurnDiff: (turnId: string, filePath?: string) => void;+ revertTurnCountByUserMessageId: Map<string, number>;+ onRevertUserMessage: (messageId: string) => void;+ isRevertingCheckpoint: boolean;onImageExpand: (image: ExpandedImagePreview) => void;messagesEndRef: RefObject<HTMLDivElement | null>;}@@ -2333,6 +2441,9 @@ const MessagesTimeline = memo(function MessagesTimeline({expandedWorkGroups,onToggleWorkGroup,onOpenTurnDiff,+ revertTurnCountByUserMessageId,+ onRevertUserMessage,+ isRevertingCheckpoint,onImageExpand,messagesEndRef,}: MessagesTimelineProps) {@@ -2433,6 +2544,7 @@ const MessagesTimeline = memo(function MessagesTimeline({if (timelineEntry.message.role === "user") {const userImages = timelineEntry.message.attachments ?? [];+ const canRevertAgentWork = revertTurnCountByUserMessageId.has(timelineEntry.message.id);return (<Fragment key={timelineEntry.id}><div className="flex justify-end">@@ -2467,9 +2579,22 @@ const MessagesTimeline = memo(function MessagesTimeline({{timelineEntry.message.text}</pre>)}- <p className="mt-1.5 text-right text-[10px] text-muted-foreground/30">- {formatTimestamp(timelineEntry.message.createdAt)}- </p>+ <div className="mt-1.5 flex items-center justify-end gap-2">+ {canRevertAgentWork && (+ <Button+ type="button"+ size="xs"+ variant="outline"+ disabled={isRevertingCheckpoint || isWorking}+ onClick={() => onRevertUserMessage(timelineEntry.message.id)}+ >+ {isRevertingCheckpoint ? "Reverting..." : "Revert agent work"}+ </Button>+ )}+ <p className="text-right text-[10px] text-muted-foreground/30">+ {formatTimestamp(timelineEntry.message.createdAt)}+ </p>+ </div></div></div></Fragment>@@ -2497,11 +2622,45 @@ const MessagesTimeline = memo(function MessagesTimeline({{(() => {const turnSummary = turnDiffSummaryByAssistantMessageId.get(timelineEntry.message.id);if (!turnSummary) return null;+ const isCheckpointDiffLoading =+ !turnSummary.checkpointDiffLoaded && turnSummary.files.length === 0;+ const summaryStat = turnSummary.unifiedDiff+ ? countDiffStat(turnSummary.unifiedDiff)+ : turnSummary.files.reduce(+ (acc, file) => {+ const next =+ typeof file.additions === "number" && typeof file.deletions === "number"+ ? { additions: file.additions, deletions: file.deletions }+ : file.diff+ ? countDiffStat(file.diff)+ : null;+ if (!next) {+ return acc;+ }+ return {+ additions: acc.additions + next.additions,+ deletions: acc.deletions + next.deletions,+ };+ },+ { additions: 0, deletions: 0 },+ );+ const changedFileCountLabel = isCheckpointDiffLoading+ ? "..."+ : String(turnSummary.files.length);return (<div className="mt-2 rounded-lg border border-border/80 bg-card/45 p-2.5"><div className="mb-1.5 flex items-center justify-between gap-2"><p className="text-[10px] uppercase tracking-[0.12em] text-muted-foreground/65">- Changed files ({turnSummary.files.length})+ <span>Changed files ({changedFileCountLabel})</span>+ {!isCheckpointDiffLoading &&+ (summaryStat.additions > 0 || summaryStat.deletions > 0) && (+ <>+ <span className="mx-1">•</span>+ <span className="text-success">+{summaryStat.additions}</span>+ <span className="mx-0.5 text-muted-foreground/70">/</span>+ <span className="text-destructive">-{summaryStat.deletions}</span>+ </>+ )}</p><Buttontype="button"@@ -2512,18 +2671,48 @@ const MessagesTimeline = memo(function MessagesTimeline({View diff</Button></div>- <div className="flex flex-wrap gap-1.5">- {turnSummary.files.map((file) => (- <button- key={`${turnSummary.turnId}:${file.path}`}- type="button"- className="rounded-md border border-border/70 bg-background/70 px-2 py-1 font-mono text-[11px] text-muted-foreground/80 transition-colors hover:border-border hover:text-foreground/90"- onClick={() => onOpenTurnDiff(turnSummary.turnId, file.path)}- >- {file.path}- </button>- ))}- </div>+ {isCheckpointDiffLoading && (+ <p className="mb-1.5 text-[11px] text-muted-foreground/70">+ Loading checkpoint diff...+ </p>+ )}+ {turnSummary.files.length > 0 ? (+ <div className="flex flex-wrap gap-1.5">+ {turnSummary.files.map((file) => (+ <button+ key={`${turnSummary.turnId}:${file.path}`}+ type="button"+ className="rounded-md border border-border/70 bg-background/70 px-2 py-1 font-mono text-[11px] text-muted-foreground/80 transition-colors hover:border-border hover:text-foreground/90"+ onClick={() => onOpenTurnDiff(turnSummary.turnId, file.path)}+ >+ {(() => {+ const stat =+ typeof file.additions === "number" &&+ typeof file.deletions === "number"+ ? { additions: file.additions, deletions: file.deletions }+ : file.diff+ ? countDiffStat(file.diff)+ : null;+ if (!stat) {+ return file.path;+ }+ return (+ <>+ <span>{file.path}</span>+ <span className="ml-1 text-muted-foreground/70">(</span>+ <span className="text-success">+{stat.additions}</span>+ <span className="mx-0.5 text-muted-foreground/70">/</span>+ <span className="text-destructive">-{stat.deletions}</span>+ <span className="text-muted-foreground/70">)</span>+ </>+ );+ })()}+ </button>+ ))}+ </div>+ ) : !isCheckpointDiffLoading ? (+ <p className="text-[11px] text-muted-foreground/70">No changed files.</p>+ ) : null}</div>);})()}diff --git a/apps/web/src/components/DiffPanel.tsx b/apps/web/src/components/DiffPanel.tsxindex 8cecdedd5..07014c6a3 100644--- a/apps/web/src/components/DiffPanel.tsx+++ b/apps/web/src/components/DiffPanel.tsx@@ -1,62 +1,473 @@-import { PatchDiff } from "@pierre/diffs/react";-import { XIcon } from "lucide-react";-import { useMemo } from "react";+import { parsePatchFiles } from "@pierre/diffs";+import { FileDiff, type FileDiffMetadata } from "@pierre/diffs/react";+import { Columns2Icon, Rows3Icon, XIcon } from "lucide-react";+import { useEffect, useMemo, useRef, useState } from "react";import { isElectron } from "../env";-import { deriveTurnDiffSummaries, formatTimestamp } from "../session-logic";+import { useNativeApi } from "../hooks/useNativeApi";+import { useTheme } from "../hooks/useTheme";+import {+ deriveTurnDiffSummaries,+ formatTimestamp,+ inferCheckpointTurnCountByTurnId,+} from "../session-logic";import { useStore } from "../store";import { Button } from "./ui/button";+import { Popover, PopoverPopup, PopoverTrigger } from "./ui/popover";import { cn } from "~/lib/utils";-export default function DiffPanel() {+type DiffRenderMode = "stacked" | "split";++type RenderablePatch =+ | {+ kind: "files";+ files: FileDiffMetadata[];+ }+ | {+ kind: "raw";+ text: string;+ reason: string;+ };++function getRenderablePatch(patch: string | undefined): RenderablePatch | null {+ if (!patch) return null;+ const normalizedPatch = patch.trim();+ if (normalizedPatch.length === 0) return null;++ try {+ const parsedPatches = parsePatchFiles(normalizedPatch, "diff-panel");+ const files = parsedPatches.flatMap((parsedPatch) => parsedPatch.files);+ if (files.length > 0) {+ return { kind: "files", files };+ }++ return {+ kind: "raw",+ text: normalizedPatch,+ reason: "Unsupported diff format. Showing raw patch.",+ };+ } catch {+ return {+ kind: "raw",+ text: normalizedPatch,+ reason: "Failed to parse patch. Showing raw patch.",+ };+ }+}++function resolveFileDiffPath(fileDiff: FileDiffMetadata): string {+ const raw = fileDiff.name ?? fileDiff.prevName ?? "";+ if (raw.startsWith("a/") || raw.startsWith("b/")) {+ return raw.slice(2);+ }+ return raw;+}++function buildCheckpointDiffKey(+ sessionId: string,+ fromTurnCount: number,+ toTurnCount: number,+): string {+ return `${sessionId}:${fromTurnCount}-${toTurnCount}`;+}++interface DiffPanelProps {+ mode?: "inline" | "sheet";+}++export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {+ const api = useNativeApi();+ const { resolvedTheme } = useTheme();const { state, dispatch } = useStore();+ const [checkpointDiffByKey, setCheckpointDiffByKey] = useState<Record<string, string>>({});+ const [isLoadingCheckpointDiff, setIsLoadingCheckpointDiff] = useState(false);+ const [checkpointDiffError, setCheckpointDiffError] = useState<string | null>(null);+ const [diffRenderMode, setDiffRenderMode] = useState<DiffRenderMode>("stacked");+ const patchViewportRef = useRef<HTMLDivElement>(null);const activeThread = state.threads.find((thread) => thread.id === state.activeThreadId);const turnDiffSummaries = useMemo(- () => deriveTurnDiffSummaries(activeThread?.events ?? []),- [activeThread?.events],+ () =>+ activeThread?.turnDiffSummaries.length+ ? activeThread.turnDiffSummaries+ : deriveTurnDiffSummaries(activeThread?.events ?? []),+ [activeThread?.events, activeThread?.turnDiffSummaries],);+ const inferredCheckpointTurnCountByTurnId = useMemo(+ () => inferCheckpointTurnCountByTurnId(turnDiffSummaries),+ [turnDiffSummaries],+ );++ useEffect(() => {+ setCheckpointDiffByKey({});+ setCheckpointDiffError(null);+ }, [activeThread?.id]);const canApplyStoredTarget = Boolean(activeThread && state.diffThreadId === activeThread.id);const selectedTurnId = canApplyStoredTarget ? state.diffTurnId : null;- const selectedFilePath = canApplyStoredTarget ? state.diffFilePath : null;+ const selectedFilePath =+ canApplyStoredTarget && selectedTurnId !== null ? state.diffFilePath : null;const selectedTurn =- turnDiffSummaries.find((summary) => summary.turnId === selectedTurnId) ?? turnDiffSummaries[0];- const selectedFile =- selectedTurn?.files.find((file) => file.path === selectedFilePath) ?? selectedTurn?.files[0];- const selectedPatch = selectedFile?.diff ?? selectedTurn?.unifiedDiff;+ selectedTurnId === null+ ? undefined+ : (turnDiffSummaries.find((summary) => summary.turnId === selectedTurnId) ??+ turnDiffSummaries[0]);+ const selectedCheckpointTurnCount =+ selectedTurn &&+ (selectedTurn.checkpointTurnCount ?? inferredCheckpointTurnCountByTurnId[selectedTurn.turnId]);+ const selectedCheckpointRange = useMemo(+ () =>+ typeof selectedCheckpointTurnCount === "number"+ ? {+ fromTurnCount: Math.max(0, selectedCheckpointTurnCount - 1),+ toTurnCount: selectedCheckpointTurnCount,+ }+ : null,+ [selectedCheckpointTurnCount],+ );+ const conversationCheckpointTurnCount = useMemo(() => {+ const turnCounts = turnDiffSummaries+ .map(+ (summary) =>+ summary.checkpointTurnCount ?? inferredCheckpointTurnCountByTurnId[summary.turnId],+ )+ .filter((value): value is number => typeof value === "number");+ if (turnCounts.length === 0) {+ return undefined;+ }+ const latest = Math.max(...turnCounts);+ return latest > 0 ? latest : undefined;+ }, [inferredCheckpointTurnCountByTurnId, turnDiffSummaries]);+ const conversationCheckpointRange = useMemo(+ () =>+ !selectedTurn && typeof conversationCheckpointTurnCount === "number"+ ? {+ fromTurnCount: 0,+ toTurnCount: conversationCheckpointTurnCount,+ }+ : null,+ [conversationCheckpointTurnCount, selectedTurn],+ );+ const selectedCheckpointDiffKey =+ activeThread?.session?.sessionId && selectedCheckpointRange+ ? buildCheckpointDiffKey(+ activeThread.session.sessionId,+ selectedCheckpointRange.fromTurnCount,+ selectedCheckpointRange.toTurnCount,+ )+ : null;+ const conversationCheckpointDiffKey =+ activeThread?.session?.sessionId && conversationCheckpointRange+ ? buildCheckpointDiffKey(+ activeThread.session.sessionId,+ conversationCheckpointRange.fromTurnCount,+ conversationCheckpointRange.toTurnCount,+ )+ : null;+ const selectedTurnCheckpointDiff =+ selectedCheckpointDiffKey === null ? undefined : checkpointDiffByKey[selectedCheckpointDiffKey];+ const conversationCheckpointDiff =+ conversationCheckpointDiffKey === null+ ? undefined+ : checkpointDiffByKey[conversationCheckpointDiffKey];+ const selectedPatch = useMemo(() => {+ const patchForSummary = (summary: (typeof turnDiffSummaries)[number]): string | undefined => {+ const checkpointTurnCount =+ summary.checkpointTurnCount ?? inferredCheckpointTurnCountByTurnId[summary.turnId];+ if (activeThread?.session?.sessionId && typeof checkpointTurnCount === "number") {+ const checkpointPatch =+ checkpointDiffByKey[+ buildCheckpointDiffKey(+ activeThread.session.sessionId,+ Math.max(0, checkpointTurnCount - 1),+ checkpointTurnCount,+ )+ ];+ if (checkpointPatch) {+ return checkpointPatch;+ }+ }+ if (summary.unifiedDiff) {+ return summary.unifiedDiff;+ }+ const filePatches = summary.files+ .map((file) => file.diff?.trim())+ .filter((patch): patch is string => Boolean(patch));+ if (filePatches.length === 0) {+ return undefined;+ }+ return filePatches.join("\n\n");+ };++ if (selectedTurn) {+ return selectedTurnCheckpointDiff ?? patchForSummary(selectedTurn);+ }++ if (conversationCheckpointDiff) {+ return conversationCheckpointDiff;+ }++ // Fallback when a conversation checkpoint diff isn't available yet:+ // keep one patch per file path (latest change wins) so files aren't duplicated.+ const latestPatchByPath = new Map<string, string>();+ for (const summary of turnDiffSummaries) {+ for (const file of summary.files) {+ if (latestPatchByPath.has(file.path)) {+ continue;+ }+ const patch = file.diff?.trim();+ if (!patch) {+ continue;+ }+ latestPatchByPath.set(file.path, patch);+ }+ }+ if (latestPatchByPath.size > 0) {+ return Array.from(latestPatchByPath.entries())+ .toSorted(([leftPath], [rightPath]) =>+ leftPath.localeCompare(rightPath, undefined, { numeric: true, sensitivity: "base" }),+ )+ .map(([, patch]) => patch)+ .join("\n\n");+ }++ const patches = turnDiffSummaries+ .toReversed()+ .map((summary) => patchForSummary(summary)?.trim())+ .filter((patch): patch is string => Boolean(patch));+ if (patches.length === 0) {+ return undefined;+ }+ return patches.join("\n\n");+ }, [+ activeThread?.session?.sessionId,+ checkpointDiffByKey,+ conversationCheckpointDiff,+ inferredCheckpointTurnCountByTurnId,+ selectedTurn,+ selectedTurnCheckpointDiff,+ turnDiffSummaries,+ ]);+ const renderablePatch = useMemo(() => getRenderablePatch(selectedPatch), [selectedPatch]);+ const renderableFiles = useMemo(() => {+ if (!renderablePatch || renderablePatch.kind !== "files") {+ return [];+ }+ return renderablePatch.files.toSorted((left, right) =>+ resolveFileDiffPath(left).localeCompare(resolveFileDiffPath(right), undefined, {+ numeric: true,+ sensitivity: "base",+ }),+ );+ }, [renderablePatch]);++ useEffect(() => {+ const checkpointFetchRange = selectedTurn+ ? selectedCheckpointRange+ : conversationCheckpointRange;+ const checkpointFetchKey = selectedTurn+ ? selectedCheckpointDiffKey+ : conversationCheckpointDiffKey;+ if (!api || !activeThread?.session?.sessionId || !checkpointFetchRange || !checkpointFetchKey) {+ return;+ }+ if (checkpointDiffByKey[checkpointFetchKey] !== undefined) {+ return;+ }++ let cancelled = false;+ setIsLoadingCheckpointDiff(true);+ setCheckpointDiffError(null);+ void api.providers+ .getCheckpointDiff({+ sessionId: activeThread.session.sessionId,+ fromTurnCount: checkpointFetchRange.fromTurnCount,+ toTurnCount: checkpointFetchRange.toTurnCount,+ })+ .then((result) => {+ if (cancelled) return;+ setCheckpointDiffByKey((previous) => ({+ ...previous,+ [checkpointFetchKey]: result.diff,+ }));+ if (selectedTurn) {+ dispatch({+ type: "SET_THREAD_TURN_CHECKPOINT_DIFFS",+ threadId: activeThread.id,+ checkpointDiffByTurnId: {+ [selectedTurn.turnId]: result.diff,+ },+ });+ }+ })+ .catch((error) => {+ if (cancelled) return;+ setCheckpointDiffError(+ error instanceof Error ? error.message : "Failed to load checkpoint diff.",+ );+ })+ .finally(() => {+ if (cancelled) return;+ setIsLoadingCheckpointDiff(false);+ });++ return () => {+ cancelled = true;+ };+ }, [+ activeThread?.id,+ activeThread?.session?.sessionId,+ api,+ checkpointDiffByKey,+ conversationCheckpointDiffKey,+ conversationCheckpointRange,+ dispatch,+ selectedCheckpointDiffKey,+ selectedCheckpointRange,+ selectedTurn,+ ]);++ useEffect(() => {+ if (!selectedFilePath || !patchViewportRef.current) {+ return;+ }+ const target = Array.from(+ patchViewportRef.current.querySelectorAll<HTMLElement>("[data-diff-file-path]"),+ ).find((element) => element.dataset.diffFilePath === selectedFilePath);+ target?.scrollIntoView({ block: "nearest" });+ }, [selectedFilePath, renderableFiles]);const selectTurn = (turnId: string) => {if (!activeThread) return;- const turn = turnDiffSummaries.find((summary) => summary.turnId === turnId);dispatch({type: "SET_DIFF_TARGET",threadId: activeThread.id,turnId,- ...(turn?.files[0]?.path ? { filePath: turn.files[0].path } : {}),});};-- const selectFile = (filePath: string) => {- if (!activeThread || !selectedTurn) return;+ const selectWholeConversation = () => {+ if (!activeThread) return;dispatch({type: "SET_DIFF_TARGET",threadId: activeThread.id,- turnId: selectedTurn.turnId,- filePath,});};+ const shouldUseDragRegion = isElectron && mode === "inline";+return (- <aside className="flex h-full w-[560px] shrink-0 flex-col border-l border-border bg-card">+ <aside+ className={cn(+ "flex h-full min-w-0 flex-col bg-card",+ mode === "inline"+ ? "w-[42vw] min-w-[360px] max-w-[560px] shrink-0 border-l border-border"+ : "w-full",+ )}+ ><divclassName={cn("flex items-center justify-between border-b border-border px-4",- isElectron ? "drag-region h-[52px]" : "py-3",+ shouldUseDragRegion ? "drag-region h-[52px]" : "py-3",)}>- <h3 className="text-xs font-medium text-foreground">Turn diffs</h3>- <Button type="button" size="icon-xs" variant="ghost" onClick={() => dispatch({ type: "CLOSE_DIFF" })}>- <XIcon />- </Button>+ <div className="flex gap-1.5 overflow-x-auto pb-0.5">+ <button type="button" className="shrink-0 rounded-md" onClick={selectWholeConversation}>+ <div+ className={cn(+ "rounded-md border px-2 py-1 text-left transition-colors",+ selectedTurnId === null+ ? "border-border bg-accent text-accent-foreground"+ : "border-border/70 bg-background/70 text-muted-foreground/80 hover:border-border hover:text-foreground/80",+ )}+ >+ <div className="text-[10px] font-medium">All turns</div>+ <div className="text-[8px] opacity-70">Conversation</div>+ </div>+ </button>+ {turnDiffSummaries.map((summary, index) => (+ <button+ key={summary.turnId}+ type="button"+ className="shrink-0 rounded-md"+ onClick={() => selectTurn(summary.turnId)}+ title={summary.turnId}+ >+ <div+ className={cn(+ "rounded-md border px-2 py-1 text-left transition-colors",+ summary.turnId === selectedTurn?.turnId+ ? "border-border bg-accent text-accent-foreground"+ : "border-border/70 bg-background/70 text-muted-foreground/80 hover:border-border hover:text-foreground/80",+ )}+ >+ <div className="text-[10px] font-medium">+ Turn {turnDiffSummaries.length - index}+ </div>+ <div className="text-[8px] opacity-70">{formatTimestamp(summary.completedAt)}</div>+ </div>+ </button>+ ))}+ </div>+ <div className="flex items-center gap-1">+ <Popover>+ <PopoverTrigger+ openOnHover+ render={+ <Button+ aria-label="Stacked diff view"+ aria-pressed={diffRenderMode === "stacked"}+ size="icon-xs"+ variant="outline"+ className={cn(diffRenderMode === "stacked" && "bg-accent text-accent-foreground")}+ onClick={() => setDiffRenderMode("stacked")}+ />+ }+ >+ <Rows3Icon />+ </PopoverTrigger>+ <PopoverPopup+ tooltipStyle+ side="bottom"+ sideOffset={6}+ align="center"+ className="pointer-events-none select-none"+ >+ Stacked+ </PopoverPopup>+ </Popover>+ <Popover>+ <PopoverTrigger+ openOnHover+ render={+ <Button+ aria-label="Split diff view"+ aria-pressed={diffRenderMode === "split"}+ size="icon-xs"+ variant="outline"+ className={cn(diffRenderMode === "split" && "bg-accent text-accent-foreground")}+ onClick={() => setDiffRenderMode("split")}+ />+ }+ >+ <Columns2Icon />+ </PopoverTrigger>+ <PopoverPopup+ tooltipStyle+ side="bottom"+ sideOffset={6}+ align="center"+ className="pointer-events-none select-none"+ >+ Split+ </PopoverPopup>+ </Popover>+ <Button+ type="button"+ size="icon-xs"+ variant="ghost"+ onClick={() => dispatch({ type: "CLOSE_DIFF" })}+ >+ <XIcon />+ </Button>+ </div></div>{!activeThread ? (@@ -65,78 +476,52 @@ export default function DiffPanel() {</div>) : turnDiffSummaries.length === 0 ? (<div className="flex flex-1 items-center justify-center px-5 text-center text-xs text-muted-foreground/70">- No completed turn file changes yet.+ No completed turns yet.</div>) : (<>- <div className="border-b border-border px-3 py-2.5">- <p className="mb-1.5 text-[10px] uppercase tracking-[0.12em] text-muted-foreground/60">- Turns- </p>- <div className="flex flex-wrap gap-1.5">- {turnDiffSummaries.map((summary, index) => (- <button- key={summary.turnId}- type="button"- className={cn(- "rounded-md border px-2 py-1 text-left transition-colors",- summary.turnId === selectedTurn?.turnId- ? "border-border bg-accent text-accent-foreground"- : "border-border/70 bg-background/70 text-muted-foreground/80 hover:border-border hover:text-foreground/80",- )}- onClick={() => selectTurn(summary.turnId)}- title={summary.turnId}- >- <div className="text-[10px] font-medium">Turn {turnDiffSummaries.length - index}</div>- <div className="text-[10px] opacity-70">{formatTimestamp(summary.completedAt)}</div>- </button>- ))}- </div>- </div>-- <div className="min-h-0 flex flex-1">- <div className="w-[220px] shrink-0 border-r border-border px-2 py-2">- <p className="mb-1.5 px-1 text-[10px] uppercase tracking-[0.12em] text-muted-foreground/60">- Files+ <div ref={patchViewportRef} className="min-w-0 flex-1 overflow-auto px-3 py-2">+ {!canApplyStoredTarget && state.diffThreadId && (+ <p className="mb-2 text-[11px] text-muted-foreground/65">+ Showing diffs for the active thread.</p>- <div className="space-y-1 overflow-y-auto">- {selectedTurn?.files.map((file) => (- <button- key={`${selectedTurn.turnId}:${file.path}`}- type="button"- className={cn(- "flex w-full items-center justify-between gap-2 rounded-md border px-2 py-1.5 text-left font-mono text-[11px] transition-colors",- selectedFile?.path === file.path- ? "border-border bg-accent text-accent-foreground"- : "border-border/60 bg-background/60 text-muted-foreground/85 hover:border-border hover:text-foreground/90",- )}- onClick={() => selectFile(file.path)}+ )}+ {checkpointDiffError && !renderablePatch && (+ <p className="mb-2 text-[11px] text-red-500/80">{checkpointDiffError}</p>+ )}+ {!renderablePatch ? (+ <div className="flex h-full items-center justify-center text-xs text-muted-foreground/70">+ {isLoadingCheckpointDiff+ ? "Loading checkpoint diff..."+ : "No patch available for this selection."}+ </div>+ ) : renderablePatch.kind === "files" ? (+ <div className="space-y-3">+ {renderableFiles.map((fileDiff) => (+ <div+ key={fileDiff.cacheKey ?? `${fileDiff.prevName ?? "none"}:${fileDiff.name}`}+ data-diff-file-path={resolveFileDiffPath(fileDiff)}+ className="rounded-md">- <span className="truncate">{file.path}</span>- {file.kind && (- <span className="rounded-sm border border-border/60 px-1 py-0.5 text-[9px] uppercase tracking-[0.08em]">- {file.kind}- </span>- )}- </button>+ <FileDiff+ fileDiff={fileDiff}+ options={{+ diffStyle: diffRenderMode === "split" ? "split" : "unified",+ lineDiffType: "none",+ themeType: resolvedTheme,+ }}+ />+ </div>))}</div>- </div>-- <div className="min-w-0 flex-1 overflow-auto px-3 py-2">- {!canApplyStoredTarget && state.diffThreadId && (- <p className="mb-2 text-[11px] text-muted-foreground/65">- Showing diffs for the active thread.- </p>- )}- {!selectedPatch ? (- <div className="flex h-full items-center justify-center text-xs text-muted-foreground/70">- No patch available for this selection.- </div>- ) : (- <PatchDiff patch={selectedPatch} />- )}- </div>+ ) : (+ <div className="space-y-2">+ <p className="text-[11px] text-muted-foreground/75">{renderablePatch.reason}</p>+ <pre className="max-h-[72vh] overflow-auto rounded-md border border-border/70 bg-background/70 p-3 font-mono text-[11px] leading-relaxed text-muted-foreground/90">+ {renderablePatch.text}+ </pre>+ </div>+ )}</div></>)}diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsxindex 23110cde8..68544c0dd 100644--- a/apps/web/src/components/Sidebar.tsx+++ b/apps/web/src/components/Sidebar.tsx@@ -170,6 +170,7 @@ export default function Sidebar() {session: null,messages: [],events: [],+ turnDiffSummaries: [],error: null,createdAt: new Date().toISOString(),branch: options?.branch ?? null,diff --git a/apps/web/src/hooks/useMediaQuery.ts b/apps/web/src/hooks/useMediaQuery.tsnew file mode 100644index 000000000..1488eb0bf--- /dev/null+++ b/apps/web/src/hooks/useMediaQuery.ts@@ -0,0 +1,27 @@+import { useEffect, useState } from "react";++function getMediaQueryMatch(query: string): boolean {+ if (typeof window === "undefined") {+ return false;+ }+ return window.matchMedia(query).matches;+}++export function useMediaQuery(query: string): boolean {+ const [matches, setMatches] = useState(() => getMediaQueryMatch(query));++ useEffect(() => {+ const mediaQueryList = window.matchMedia(query);+ const handleChange = () => {+ setMatches(mediaQueryList.matches);+ };++ setMatches(mediaQueryList.matches);+ mediaQueryList.addEventListener("change", handleChange);+ return () => {+ mediaQueryList.removeEventListener("change", handleChange);+ };+ }, [query]);++ return matches;+}diff --git a/apps/web/src/persistenceSchema.test.ts b/apps/web/src/persistenceSchema.test.tsindex ff19f2a9a..6d9804718 100644--- a/apps/web/src/persistenceSchema.test.ts+++ b/apps/web/src/persistenceSchema.test.ts@@ -263,6 +263,68 @@ describe("hydratePersistedState", () => {]);expect(hydrated?.threads[0]?.activeTerminalGroupId).toBe(`group-${DEFAULT_THREAD_TERMINAL_ID}`);});++ it("hydrates persisted turn diff summaries", () => {+ const payload = JSON.stringify({+ version: 7,+ runtimeMode: "full-access",+ projects: [+ {+ id: "p-1",+ name: "Project",+ cwd: "/tmp/project",+ model: "gpt-5.3-codex",+ expanded: true,+ },+ ],+ threads: [+ {+ id: "t-1",+ codexThreadId: "thr_1",+ projectId: "p-1",+ title: "Thread",+ model: "gpt-5.3-codex",+ messages: [],+ createdAt: "2026-02-08T10:00:00.000Z",+ turnDiffSummaries: [+ {+ turnId: "turn-1",+ completedAt: "2026-02-08T10:05:00.000Z",+ checkpointTurnCount: 1,+ checkpointDiffLoaded: true,+ files: [+ {+ path: "src/app.ts",+ kind: "modified",+ additions: 3,+ deletions: 1,+ },+ ],+ },+ ],+ },+ ],+ activeThreadId: "t-1",+ });++ const hydrated = hydratePersistedState(payload, false);+ expect(hydrated?.threads[0]?.turnDiffSummaries).toEqual([+ {+ turnId: "turn-1",+ completedAt: "2026-02-08T10:05:00.000Z",+ checkpointTurnCount: 1,+ checkpointDiffLoaded: true,+ files: [+ {+ path: "src/app.ts",+ kind: "modified",+ additions: 3,+ deletions: 1,+ },+ ],+ },+ ]);+ });});describe("toPersistedState", () => {@@ -309,6 +371,25 @@ describe("toPersistedState", () => {lastVisitedAt: "2026-02-08T10:02:00.000Z",branch: null,worktreePath: null,+ turnDiffSummaries: [+ {+ turnId: "turn-1",+ completedAt: "2026-02-08T10:05:00.000Z",+ status: "completed",+ checkpointTurnCount: 1,+ checkpointDiffLoaded: true,+ files: [+ {+ path: "src/app.ts",+ kind: "modified",+ additions: 3,+ deletions: 1,+ diff: "diff --git a/src/app.ts b/src/app.ts",+ },+ ],+ unifiedDiff: "diff --git a/src/app.ts b/src/app.ts",+ },+ ],};const persisted = toPersistedState({@@ -366,6 +447,23 @@ describe("toPersistedState", () => {lastVisitedAt: thread.lastVisitedAt,branch: null,worktreePath: null,+ turnDiffSummaries: [+ {+ turnId: "turn-1",+ completedAt: "2026-02-08T10:05:00.000Z",+ status: "completed",+ checkpointTurnCount: 1,+ checkpointDiffLoaded: true,+ files: [+ {+ path: "src/app.ts",+ kind: "modified",+ additions: 3,+ deletions: 1,+ },+ ],+ },+ ],});const persistedThread = persisted.threads[0];expect(persistedThread).toBeDefined();diff --git a/apps/web/src/persistenceSchema.ts b/apps/web/src/persistenceSchema.tsindex 9d6e3a90b..1daedcb6b 100644--- a/apps/web/src/persistenceSchema.ts+++ b/apps/web/src/persistenceSchema.ts@@ -47,6 +47,23 @@ const persistedTerminalGroupSchema = z.object({terminalIds: z.array(z.string().trim().min(1)),});+const persistedTurnDiffFileChangeSchema = z.object({+ path: z.string().min(1),+ kind: z.string().min(1).optional(),+ additions: z.number().int().min(0).optional(),+ deletions: z.number().int().min(0).optional(),+});++const persistedTurnDiffSummarySchema = z.object({+ turnId: z.string().min(1),+ completedAt: z.string().min(1),+ status: z.string().min(1).optional(),+ files: z.array(persistedTurnDiffFileChangeSchema),+ assistantMessageId: z.string().min(1).optional(),+ checkpointTurnCount: z.number().int().min(0).optional(),+ checkpointDiffLoaded: z.boolean().optional(),+});+const persistedThreadSchema = z.object({id: z.string().min(1),codexThreadId: z.string().min(1).nullable().default(null),@@ -67,6 +84,7 @@ const persistedThreadSchema = z.object({lastVisitedAt: z.string().min(1).optional(),branch: z.string().min(1).nullable().optional(),worktreePath: z.string().min(1).nullable().optional(),+ turnDiffSummaries: z.array(persistedTurnDiffSummarySchema).default([]),});const persistedStateBodySchema = z.object({@@ -273,6 +291,22 @@ function hydrateThread(lastVisitedAt: thread.lastVisitedAt,branch: thread.branch ?? null,worktreePath: thread.worktreePath ?? null,+ turnDiffSummaries: thread.turnDiffSummaries.map((summary) => ({+ turnId: summary.turnId,+ completedAt: summary.completedAt,+ ...(summary.status ? { status: summary.status } : {}),+ files: summary.files.map((file) => ({+ path: file.path,+ ...(file.kind ? { kind: file.kind } : {}),+ ...(typeof file.additions === "number" ? { additions: file.additions } : {}),+ ...(typeof file.deletions === "number" ? { deletions: file.deletions } : {}),+ })),+ ...(summary.assistantMessageId ? { assistantMessageId: summary.assistantMessageId } : {}),+ ...(typeof summary.checkpointTurnCount === "number"+ ? { checkpointTurnCount: summary.checkpointTurnCount }+ : {}),+ ...(summary.checkpointDiffLoaded ? { checkpointDiffLoaded: true } : {}),+ })),};}@@ -353,6 +387,22 @@ export function toPersistedState(...(thread.lastVisitedAt ? { lastVisitedAt: thread.lastVisitedAt } : {}),branch: thread.branch,worktreePath: thread.worktreePath,+ turnDiffSummaries: thread.turnDiffSummaries.map((summary) => ({+ turnId: summary.turnId,+ completedAt: summary.completedAt,+ ...(summary.status ? { status: summary.status } : {}),+ files: summary.files.map((file) => ({+ path: file.path,+ ...(file.kind ? { kind: file.kind } : {}),+ ...(typeof file.additions === "number" ? { additions: file.additions } : {}),+ ...(typeof file.deletions === "number" ? { deletions: file.deletions } : {}),+ })),+ ...(summary.assistantMessageId ? { assistantMessageId: summary.assistantMessageId } : {}),+ ...(typeof summary.checkpointTurnCount === "number"+ ? { checkpointTurnCount: summary.checkpointTurnCount }+ : {}),+ ...(summary.checkpointDiffLoaded ? { checkpointDiffLoaded: true } : {}),+ })),})),activeThreadId: state.activeThreadId,runtimeMode: state.runtimeMode,diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.tsindex 4b6302b2b..eec1b3808 100644--- a/apps/web/src/session-logic.test.ts+++ b/apps/web/src/session-logic.test.ts@@ -5,6 +5,7 @@ import {type WorkLogEntry,applyEventToMessages,derivePendingApprovals,+ deriveTurnDiffFilesFromUnifiedDiff,deriveTurnDiffSummaries,deriveTimelineEntries,deriveWorkLogEntries,@@ -395,7 +396,7 @@ describe("deriveWorkLogEntries", () => {});describe("deriveTurnDiffSummaries", () => {- it("collects per-turn file changes and links them to assistant message completion", () => {+ it("tracks completed turns and links them to assistant message completion", () => {const summaries = deriveTurnDiffSummaries([makeEvent({id: "evt-turn-start",@@ -492,8 +493,57 @@ describe("deriveTurnDiffSummaries", () => {expect(summaries).toHaveLength(1);expect(summaries[0]?.turnId).toBe("turn-1");expect(summaries[0]?.assistantMessageId).toBe("msg-1");- expect(summaries[0]?.files.map((file) => file.path)).toEqual(["src/a.ts", "src/b.ts"]);- expect(summaries[0]?.files[0]?.kind).toBe("modified");+ expect(summaries[0]?.files).toEqual([]);+ });++ it("includes completed turns even when no fileChange tool events were emitted", () => {+ const summaries = deriveTurnDiffSummaries([+ makeEvent({+ id: "evt-turn-start",+ method: "turn/started",+ turnId: "turn-1",+ createdAt: "2026-02-08T10:00:00.000Z",+ }),+ makeEvent({+ id: "evt-turn-completed",+ method: "turn/completed",+ turnId: "turn-1",+ createdAt: "2026-02-08T10:00:01.000Z",+ payload: {+ turn: {+ id: "turn-1",+ status: "completed",+ },+ },+ }),+ ]);++ expect(summaries).toHaveLength(1);+ expect(summaries[0]?.turnId).toBe("turn-1");+ expect(summaries[0]?.files).toEqual([]);+ });+});++describe("deriveTurnDiffFilesFromUnifiedDiff", () => {+ it("splits a multi-file patch into sorted per-file entries", () => {+ const files = deriveTurnDiffFilesFromUnifiedDiff(+ [+ "diff --git a/src/b.ts b/src/b.ts",+ "@@ -1 +1 @@",+ "-old-b",+ "+new-b",+ "diff --git a/src/a.ts b/src/a.ts",+ "@@ -1 +1 @@",+ "-old-a",+ "+new-a",+ ].join("\n"),+ );++ expect(files.map((file) => file.path)).toEqual(["src/a.ts", "src/b.ts"]);+ expect(files[0]?.diff).toContain("diff --git a/src/a.ts b/src/a.ts");+ expect(files[1]?.diff).toContain("diff --git a/src/b.ts b/src/b.ts");+ expect(files[0]?.additions).toBe(1);+ expect(files[0]?.deletions).toBe(1);});});diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.tsindex ef2855784..f9f3013ca 100644--- a/apps/web/src/session-logic.ts+++ b/apps/web/src/session-logic.ts@@ -1,5 +1,5 @@import type { NativeApi, ProviderEvent, ProviderKind, ProviderSession } from "@t3tools/contracts";-import type { ChatMessage, SessionPhase } from "./types";+import type { ChatMessage, SessionPhase, TurnDiffFileChange, TurnDiffSummary } from "./types";import { createWsNativeApi } from "./wsNativeApi";export const PROVIDER_OPTIONS: Array<{@@ -99,20 +99,7 @@ export type TimelineEntry =entry: WorkLogEntry;};-export interface TurnDiffFileChange {- path: string;- kind?: string;- diff?: string;-}--export interface TurnDiffSummary {- turnId: string;- completedAt: string;- status?: string;- files: TurnDiffFileChange[];- unifiedDiff?: string;- assistantMessageId?: string;-}+export type { TurnDiffFileChange, TurnDiffSummary } from "./types";function normalizeDetail(value: string | undefined): string | undefined {if (!value) return undefined;@@ -120,10 +107,6 @@ function normalizeDetail(value: string | undefined): string | undefined {return trimmed.length > 0 ? trimmed : undefined;}-function asArray(value: unknown): unknown[] | undefined {- return Array.isArray(value) ? value : undefined;-}-function approvalDetail(event: ProviderEvent): string | undefined {const payload = asObject(event.payload);const command = asString(payload?.command);@@ -457,19 +440,11 @@ export function deriveWorkLogEntries(return entries;}-interface MutableTurnDiffFileChange {- path: string;- kind: string | undefined;- diff: string | undefined;-}-interface MutableTurnDiffSummary {turnId: string;completedAt: string | undefined;status: string | undefined;- unifiedDiff: string | undefined;assistantMessageId: string | undefined;- filesByPath: Map<string, MutableTurnDiffFileChange>;}function parsePathFromDiff(diff: string): string | undefined {@@ -485,7 +460,7 @@ function parsePathFromDiff(diff: string): string | undefined {return direct[1];}-function splitUnifiedDiffByFile(diff: string): Map<string, string> {+export function splitUnifiedDiffByFile(diff: string): Map<string, string> {const normalized = diff.replace(/\r\n/g, "\n");const byPath = new Map<string, string>();const headerMatches = [...normalized.matchAll(/^diff --git a\/(.+) b\/(.+)$/gm)];@@ -512,38 +487,71 @@ function splitUnifiedDiffByFile(diff: string): Map<string, string> {return byPath;}-function parseFileChangeEntriesFromEvent(event: ProviderEvent): TurnDiffFileChange[] {- if (event.method !== "item/started" && event.method !== "item/completed") {- return [];+export function deriveTurnDiffFilesFromUnifiedDiff(diff: string): TurnDiffFileChange[] {+ const fileDiffsByPath = splitUnifiedDiffByFile(diff);+ return Array.from(fileDiffsByPath.entries())+ .map(([path, fileDiff]) => {+ const stat = countDiffStat(fileDiff);+ return {+ path,+ diff: fileDiff,+ additions: stat.additions,+ deletions: stat.deletions,+ };+ })+ .toSorted((a, b) => a.path.localeCompare(b.path));+}++export function inferCheckpointTurnCountByTurnId(+ summaries: TurnDiffSummary[],+): Record<string, number> {+ if (summaries.length === 0) {+ return {};}- const payload = asObject(event.payload);- const item = asObject(payload?.item);- if (asString(item?.type) !== "fileChange") {- return [];- }-- const changes = asArray(item?.changes);- if (!changes || changes.length === 0) {- return [];- }-- const files: TurnDiffFileChange[] = [];- for (const rawChange of changes) {- const change = asObject(rawChange);- if (!change) continue;- const diff = normalizeDetail(asString(change.diff));- const path = normalizeDetail(asString(change.path)) ?? (diff ? parsePathFromDiff(diff) : undefined);- if (!path) continue;- const kind = normalizeDetail(asString(change.kind));- files.push({- path,- ...(kind ? { kind } : {}),- ...(diff ? { diff } : {}),- });+ const sorted = [...summaries].toSorted((a, b) => {+ const aTime = Date.parse(a.completedAt);+ const bTime = Date.parse(b.completedAt);+ if (Number.isNaN(aTime) || Number.isNaN(bTime)) {+ return a.completedAt.localeCompare(b.completedAt);+ }+ return aTime - bTime;+ });++ const next: Record<string, number> = {};+ let fallbackTurnCount = 1;+ for (const summary of sorted) {+ if (typeof summary.checkpointTurnCount === "number") {+ next[summary.turnId] = summary.checkpointTurnCount;+ fallbackTurnCount = Math.max(fallbackTurnCount, summary.checkpointTurnCount + 1);+ continue;+ }+ next[summary.turnId] = fallbackTurnCount;+ fallbackTurnCount += 1;+ }++ return next;+}++export function countDiffStat(patch: string | undefined): { additions: number; deletions: number } {+ if (!patch) {+ return { additions: 0, deletions: 0 };+ }++ let additions = 0;+ let deletions = 0;+ for (const line of patch.replace(/\r\n/g, "\n").split("\n")) {+ if (line.startsWith("+++ ") || line.startsWith("--- ")) continue;+ if (line.startsWith("+")) {+ additions += 1;+ continue;+ }+ if (line.startsWith("-")) {+ deletions += 1;+ }}- return files;+ return { additions, deletions };}export function deriveTurnDiffSummaries(events: ProviderEvent[]): TurnDiffSummary[] {@@ -557,9 +565,7 @@ export function deriveTurnDiffSummaries(events: ProviderEvent[]): TurnDiffSummarturnId,completedAt: undefined,status: undefined,- unifiedDiff: undefined,assistantMessageId: undefined,- filesByPath: new Map(),};byTurnId.set(turnId, next);return next;@@ -577,12 +583,6 @@ export function deriveTurnDiffSummaries(events: ProviderEvent[]): TurnDiffSummarcontinue;}- if (event.method === "turn/diff/updated") {- const diff = normalizeDetail(asString(asObject(event.payload)?.diff));- if (diff) summary.unifiedDiff = diff;- continue;- }-if (event.method === "item/completed") {const item = asObject(asObject(event.payload)?.item);if (asString(item?.type) === "agentMessage") {@@ -592,66 +592,17 @@ export function deriveTurnDiffSummaries(events: ProviderEvent[]): TurnDiffSummar}}}-- for (const change of parseFileChangeEntriesFromEvent(event)) {- const existing = summary.filesByPath.get(change.path);- if (!existing) {- summary.filesByPath.set(change.path, {- path: change.path,- kind: change.kind,- diff: change.diff,- });- continue;- }- summary.filesByPath.set(change.path, {- path: change.path,- kind: change.kind ?? existing.kind,- diff: change.diff ?? existing.diff,- });- }}const summaries: TurnDiffSummary[] = [];for (const summary of byTurnId.values()) {if (!summary.completedAt) continue;- const filesByPath = new Map(summary.filesByPath);- if (summary.unifiedDiff) {- const fileDiffs = splitUnifiedDiffByFile(summary.unifiedDiff);- for (const [path, diff] of fileDiffs) {- const existing = filesByPath.get(path);- if (!existing) {- filesByPath.set(path, { path, kind: undefined, diff });- continue;- }- if (!existing.diff) {- filesByPath.set(path, { ...existing, diff });- }- }- }-- const files: TurnDiffFileChange[] = [];- for (const file of Array.from(filesByPath.values()).toSorted((a, b) =>- a.path.localeCompare(b.path),- )) {- const nextFile: TurnDiffFileChange = { path: file.path };- if (file.kind) {- nextFile.kind = file.kind;- }- if (file.diff) {- nextFile.diff = file.diff;- }- files.push(nextFile);- }-- if (files.length === 0) continue;-summaries.push({turnId: summary.turnId,completedAt: summary.completedAt,...(summary.status ? { status: summary.status } : {}),- files,- ...(summary.unifiedDiff ? { unifiedDiff: summary.unifiedDiff } : {}),+ files: [],...(summary.assistantMessageId ? { assistantMessageId: summary.assistantMessageId } : {}),});}diff --git a/apps/web/src/store.test.ts b/apps/web/src/store.test.tsindex 983166fc8..13b7d96ed 100644--- a/apps/web/src/store.test.ts+++ b/apps/web/src/store.test.ts@@ -57,6 +57,7 @@ function makeThread(overrides: Partial<Thread> = {}): Thread {session: makeSession(),messages: [],events: [],+ turnDiffSummaries: [],error: null,createdAt: "2026-02-09T00:00:00.000Z",branch: null,@@ -517,6 +518,57 @@ describe("store reducer thread continuity", () => {expect(next.threads[0]?.session?.threadId).toBe("thr_new");});+ it("preserves persisted turn diffs when events were reset and appends new completed turn diffs", () => {+ const state = makeState(+ makeThread({+ events: [],+ turnDiffSummaries: [+ {+ turnId: "turn-1",+ completedAt: "2026-02-09T00:00:01.000Z",+ files: [{ path: "src/existing.ts", kind: "modified" }],+ },+ ],+ }),+ );++ const withFileChange = reducer(state, {+ type: "APPLY_EVENT",+ event: makeEvent({+ method: "item/completed",+ turnId: "turn-2",+ createdAt: "2026-02-09T00:00:02.000Z",+ payload: {+ item: {+ type: "fileChange",+ changes: [{ path: "src/new.ts", kind: "added" }],+ },+ },+ }),+ activeAssistantItemRef: { current: null },+ });++ expect(withFileChange.threads[0]?.turnDiffSummaries.map((summary) => summary.turnId)).toEqual([+ "turn-1",+ ]);++ const completed = reducer(withFileChange, {+ type: "APPLY_EVENT",+ event: makeEvent({+ method: "turn/completed",+ turnId: "turn-2",+ createdAt: "2026-02-09T00:00:03.000Z",+ payload: { turn: { id: "turn-2", status: "completed" } },+ }),+ activeAssistantItemRef: { current: null },+ });++ expect(completed.threads[0]?.turnDiffSummaries.map((summary) => summary.turnId)).toEqual([+ "turn-2",+ "turn-1",+ ]);+ });+it("reconciles project ids by cwd when syncing backend projects", () => {const state: AppState = {projects: [@@ -781,6 +833,20 @@ describe("store reducer thread continuity", () => {turnId: "turn-live",}),],+ turnDiffSummaries: [+ {+ turnId: "turn_1",+ completedAt: "2026-02-08T10:00:01.000Z",+ files: [{ path: "src/first.ts", kind: "modified" }],+ checkpointTurnCount: 1,+ },+ {+ turnId: "turn_2",+ completedAt: "2026-02-08T10:00:03.000Z",+ files: [{ path: "src/second.ts", kind: "modified" }],+ checkpointTurnCount: 2,+ },+ ],error: "temporary failure",latestTurnId: "turn-live",latestTurnStartedAt: "2026-02-08T10:00:03.000Z",@@ -792,6 +858,7 @@ describe("store reducer thread continuity", () => {threadId: "thread-local-1",sessionId: "sess-1",threadRuntimeId: "thr_after",+ turnCount: 1,messageCount: 2,});@@ -803,5 +870,77 @@ describe("store reducer thread continuity", () => {expect(next.threads[0]?.session?.activeTurnId).toBeUndefined();expect(next.threads[0]?.session?.threadId).toBe("thr_after");expect(next.threads[0]?.latestTurnId).toBeUndefined();+ expect(next.threads[0]?.turnDiffSummaries.map((summary) => summary.turnId)).toEqual(["turn_1"]);+ });++ it("keeps checkpoint-derived turn files when later events for the same turn arrive", () => {+ const state = makeState(+ makeThread({+ turnDiffSummaries: [+ {+ turnId: "turn-1",+ completedAt: "2026-02-09T00:00:03.000Z",+ files: [{ path: "src/from-checkpoint.ts", diff: "diff --git a/src/from-checkpoint.ts b/src/from-checkpoint.ts" }],+ unifiedDiff: "diff --git a/src/from-checkpoint.ts b/src/from-checkpoint.ts",+ checkpointDiffLoaded: true,+ },+ ],+ }),+ );++ const next = reducer(state, {+ type: "APPLY_EVENT",+ event: makeEvent({+ method: "turn/completed",+ turnId: "turn-1",+ createdAt: "2026-02-09T00:00:04.000Z",+ payload: { turn: { id: "turn-1", status: "completed" } },+ }),+ activeAssistantItemRef: { current: null },+ });++ expect(next.threads[0]?.turnDiffSummaries[0]?.files.map((file) => file.path)).toEqual([+ "src/from-checkpoint.ts",+ ]);+ expect(next.threads[0]?.turnDiffSummaries[0]?.checkpointDiffLoaded).toBe(true);+ expect(next.threads[0]?.turnDiffSummaries[0]?.unifiedDiff).toContain("from-checkpoint.ts");+ });++ it("updates turn summaries from checkpoint diffs and marks them as loaded", () => {+ const state = makeState(+ makeThread({+ turnDiffSummaries: [+ {+ turnId: "turn-1",+ completedAt: "2026-02-09T00:00:03.000Z",+ files: [],+ checkpointTurnCount: 1,+ },+ ],+ }),+ );++ const next = reducer(state, {+ type: "SET_THREAD_TURN_CHECKPOINT_DIFFS",+ threadId: "thread-local-1",+ checkpointDiffByTurnId: {+ "turn-1": [+ "diff --git a/src/a.ts b/src/a.ts",+ "@@ -1 +1 @@",+ "-old-a",+ "+new-a",+ "diff --git a/src/b.ts b/src/b.ts",+ "@@ -1 +1 @@",+ "-old-b",+ "+new-b",+ ].join("\n"),+ },+ });++ expect(next.threads[0]?.turnDiffSummaries[0]?.files.map((file) => file.path)).toEqual([+ "src/a.ts",+ "src/b.ts",+ ]);+ expect(next.threads[0]?.turnDiffSummaries[0]?.checkpointDiffLoaded).toBe(true);});});diff --git a/apps/web/src/store.ts b/apps/web/src/store.tsindex e37982043..f701f8101 100644--- a/apps/web/src/store.ts+++ b/apps/web/src/store.ts@@ -11,7 +11,15 @@ import {import { type ProviderEvent, type ProviderSession, type TerminalEvent, normalizeProjectScripts } from "@t3tools/contracts";import { resolveModelSlug } from "./model-logic";import { hydratePersistedState, toPersistedState } from "./persistenceSchema";-import { applyEventToMessages, asObject, asString, evolveSession } from "./session-logic";+import {+ applyEventToMessages,+ asObject,+ asString,+ deriveTurnDiffFilesFromUnifiedDiff,+ deriveTurnDiffSummaries,+ inferCheckpointTurnCountByTurnId,+ evolveSession,+} from "./session-logic";import {type ChatAttachment,DEFAULT_THREAD_TERMINAL_ID,@@ -77,8 +85,19 @@ type Action =threadId: string;sessionId: string;threadRuntimeId: string;+ turnCount: number;messageCount: number;}+ | {+ type: "SET_THREAD_TURN_CHECKPOINT_COUNTS";+ threadId: string;+ checkpointTurnCountByTurnId: Record<string, number>;+ }+ | {+ type: "SET_THREAD_TURN_CHECKPOINT_DIFFS";+ threadId: string;+ checkpointDiffByTurnId: Record<string, string>;+ }| {type: "SET_THREAD_BRANCH";threadId: string;@@ -179,6 +198,77 @@ function updateThread(return threads.map((t) => (t.id === threadId ? updater(t) : t));}+function mergeTurnDiffSummaries(+ existing: Thread["turnDiffSummaries"],+ next: Thread["turnDiffSummaries"],+): Thread["turnDiffSummaries"] {+ if (existing.length === 0) return next;+ if (next.length === 0) return existing;++ const existingByTurnId = new Map(existing.map((summary) => [summary.turnId, summary] as const));+ const merged = next.map((summary) => {+ const previous = existingByTurnId.get(summary.turnId);+ if (!previous) {+ return summary;+ }++ const prefersCheckpointDiff = previous.checkpointDiffLoaded || summary.checkpointDiffLoaded;+ const files =+ prefersCheckpointDiff ||+ (summary.files.length === 0 && previous.files.length > 0 && summary.unifiedDiff === undefined)+ ? previous.files+ : summary.files;+ const unifiedDiff =+ prefersCheckpointDiff || summary.unifiedDiff === undefined+ ? (previous.unifiedDiff ?? summary.unifiedDiff)+ : summary.unifiedDiff;++ return {+ ...summary,+ files,+ ...(unifiedDiff !== undefined ? { unifiedDiff } : {}),+ ...(summary.assistantMessageId+ ? {}+ : previous.assistantMessageId+ ? { assistantMessageId: previous.assistantMessageId }+ : {}),+ ...(typeof summary.checkpointTurnCount === "number"+ ? {}+ : typeof previous.checkpointTurnCount === "number"+ ? { checkpointTurnCount: previous.checkpointTurnCount }+ : {}),+ ...(summary.checkpointDiffLoaded || previous.checkpointDiffLoaded+ ? { checkpointDiffLoaded: true }+ : {}),+ };+ });++ const mergedTurnIds = new Set(merged.map((summary) => summary.turnId));+ for (const summary of existing) {+ if (!mergedTurnIds.has(summary.turnId)) {+ merged.push(summary);+ }+ }++ const sorted = merged.toSorted((a, b) => {+ const aTime = Date.parse(a.completedAt);+ const bTime = Date.parse(b.completedAt);+ if (Number.isNaN(aTime) || Number.isNaN(bTime)) {+ return b.completedAt.localeCompare(a.completedAt);+ }+ return bTime - aTime;+ });++ const inferredTurnCountByTurnId = inferCheckpointTurnCountByTurnId(sorted);+ return sorted.map((summary) =>+ typeof summary.checkpointTurnCount === "number"+ ? summary+ : Object.assign({}, summary, {+ checkpointTurnCount: inferredTurnCountByTurnId[summary.turnId],+ }),+ );+}+function normalizeTerminalIds(terminalIds: string[]): string[] {const ids = terminalIds.map((id) => id.trim()).filter((id) => id.length > 0);const unique = [...new Set(ids)].slice(0, MAX_THREAD_TERMINAL_COUNT);@@ -554,6 +644,7 @@ export function reducer(state: AppState, action: Action): AppState {...action.thread,model: resolveModelSlug(action.thread.model),lastVisitedAt: action.thread.lastVisitedAt ?? action.thread.createdAt,+ turnDiffSummaries: action.thread.turnDiffSummaries ?? [],});return {...state,@@ -800,27 +891,32 @@ export function reducer(state: AppState, action: Action): AppState {return {...state,- threads: updateThread(state.threads, target.id, (t) => ({- ...t,- ...(() => {- const eventThreadId = getEventThreadId(event);- const shouldRebindIdentity =- event.method === "thread/started" && t.session?.status === "connecting";- return {- codexThreadId: shouldRebindIdentity- ? (eventThreadId ?? t.codexThreadId)- : (t.codexThreadId ?? eventThreadId ?? null),- error: event.kind === "error" && event.message ? event.message : t.error,- };- })(),- session: t.session ? evolveSession(t.session, event) : t.session,- messages: applyEventToMessages(t.messages, event, activeAssistantItemRef),- events: [event, ...t.events],- ...updateTurnFields(t, event),- ...(event.method === "turn/completed" && t.id === state.activeThreadId- ? { lastVisitedAt: event.createdAt }- : {}),- })),+ threads: updateThread(state.threads, target.id, (t) => {+ const nextEvents = [event, ...t.events];+ const derivedTurnDiffSummaries = deriveTurnDiffSummaries(nextEvents);+ const turnDiffSummaries = mergeTurnDiffSummaries(+ t.turnDiffSummaries,+ derivedTurnDiffSummaries,+ );+ const eventThreadId = getEventThreadId(event);+ const shouldRebindIdentity =+ event.method === "thread/started" && t.session?.status === "connecting";+ return {+ ...t,+ codexThreadId: shouldRebindIdentity+ ? (eventThreadId ?? t.codexThreadId)+ : (t.codexThreadId ?? eventThreadId ?? null),+ error: event.kind === "error" && event.message ? event.message : t.error,+ session: t.session ? evolveSession(t.session, event) : t.session,+ messages: applyEventToMessages(t.messages, event, activeAssistantItemRef),+ events: nextEvents,+ turnDiffSummaries,+ ...updateTurnFields(t, event),+ ...(event.method === "turn/completed" && t.id === state.activeThreadId+ ? { lastVisitedAt: event.createdAt }+ : {}),+ };+ }),};}@@ -893,6 +989,7 @@ export function reducer(state: AppState, action: Action): AppState {...state,threads: updateThread(state.threads, action.threadId, (t) => {const nextMessageCount = Math.max(0, Math.floor(action.messageCount));+ const nextTurnCount = Math.max(0, Math.floor(action.turnCount));const now = new Date().toISOString();return {...t,@@ -910,6 +1007,11 @@ export function reducer(state: AppState, action: Action): AppState {: t.session,messages: t.messages.slice(0, nextMessageCount),events: [],+ turnDiffSummaries: t.turnDiffSummaries.filter(+ (summary) =>+ typeof summary.checkpointTurnCount === "number" &&+ summary.checkpointTurnCount <= nextTurnCount,+ ),error: null,latestTurnId: undefined,latestTurnStartedAt: undefined,@@ -920,6 +1022,83 @@ export function reducer(state: AppState, action: Action): AppState {}),};+ case "SET_THREAD_TURN_CHECKPOINT_COUNTS":+ return {+ ...state,+ threads: updateThread(state.threads, action.threadId, (t) => {+ const hasUpdates = t.turnDiffSummaries.some(+ (summary) =>+ action.checkpointTurnCountByTurnId[summary.turnId] !== undefined &&+ action.checkpointTurnCountByTurnId[summary.turnId] !== summary.checkpointTurnCount,+ );+ if (!hasUpdates) {+ return t;+ }+ return {+ ...t,+ turnDiffSummaries: t.turnDiffSummaries.map((summary) => {+ const turnCount = action.checkpointTurnCountByTurnId[summary.turnId];+ if (turnCount === undefined) {+ return summary;+ }+ return {+ ...summary,+ checkpointTurnCount: turnCount,+ };+ }),+ };+ }),+ };++ case "SET_THREAD_TURN_CHECKPOINT_DIFFS":+ return {+ ...state,+ threads: updateThread(state.threads, action.threadId, (t) => {+ let hasUpdates = false;+ const updatedSummaries = t.turnDiffSummaries.map((summary) => {+ const checkpointDiff = action.checkpointDiffByTurnId[summary.turnId];+ if (checkpointDiff === undefined) {+ return summary;+ }++ const files = deriveTurnDiffFilesFromUnifiedDiff(checkpointDiff);+ const filesUnchanged =+ files.length === summary.files.length &&+ files.every((file, index) => {+ const existing = summary.files[index];+ return (+ existing !== undefined &&+ existing.path === file.path &&+ existing.diff === file.diff &&+ existing.kind === file.kind &&+ existing.additions === file.additions &&+ existing.deletions === file.deletions+ );+ });+ if (summary.unifiedDiff === checkpointDiff && filesUnchanged && summary.checkpointDiffLoaded) {+ return summary;+ }++ hasUpdates = true;+ return {+ ...summary,+ unifiedDiff: checkpointDiff,+ files,+ checkpointDiffLoaded: true,+ };+ });++ if (!hasUpdates) {+ return t;+ }++ return {+ ...t,+ turnDiffSummaries: updatedSummaries,+ };+ }),+ };+case "SET_THREAD_BRANCH": {return {...state,diff --git a/apps/web/src/types.ts b/apps/web/src/types.tsindex 5ffd70bfb..4f33b891f 100644--- a/apps/web/src/types.ts+++ b/apps/web/src/types.ts@@ -37,6 +37,25 @@ export interface ChatMessage {streaming: boolean;}+export interface TurnDiffFileChange {+ path: string;+ kind?: string | undefined;+ diff?: string | undefined;+ additions?: number | undefined;+ deletions?: number | undefined;+}++export interface TurnDiffSummary {+ turnId: string;+ completedAt: string;+ status?: string | undefined;+ files: TurnDiffFileChange[];+ unifiedDiff?: string | undefined;+ assistantMessageId?: string | undefined;+ checkpointTurnCount?: number | undefined;+ checkpointDiffLoaded?: boolean | undefined;+}+export interface Project {id: string;name: string;@@ -71,4 +90,5 @@ export interface Thread {lastVisitedAt?: string | undefined;branch: string | null;worktreePath: string | null;+ turnDiffSummaries: TurnDiffSummary[];}diff --git a/apps/web/src/worktreeCleanup.test.ts b/apps/web/src/worktreeCleanup.test.tsindex 606717a02..d56270697 100644--- a/apps/web/src/worktreeCleanup.test.ts+++ b/apps/web/src/worktreeCleanup.test.ts@@ -25,6 +25,7 @@ function makeThread(overrides: Partial<Thread> = {}): Thread {session: null,messages: [],events: [],+ turnDiffSummaries: [],error: null,createdAt: "2026-02-13T00:00:00.000Z",branch: null,diff --git a/apps/web/src/wsNativeApi.ts b/apps/web/src/wsNativeApi.tsindex 80e1e8f72..9eacc9ed1 100644--- a/apps/web/src/wsNativeApi.ts+++ b/apps/web/src/wsNativeApi.ts@@ -92,6 +92,7 @@ export function createWsNativeApi(): NativeApi {stopSession: (input) => transport.request(WS_METHODS.providersStopSession, input),listSessions: () => transport.request(WS_METHODS.providersListSessions),listCheckpoints: (input) => transport.request(WS_METHODS.providersListCheckpoints, input),+ getCheckpointDiff: (input) => transport.request(WS_METHODS.providersGetCheckpointDiff, input),revertToCheckpoint: (input) =>transport.request(WS_METHODS.providersRevertToCheckpoint, input),onEvent: (callback) =>diff --git a/apps/web/src/wsTransport.ts b/apps/web/src/wsTransport.tsindex 20a40f8f0..e1cee484a 100644--- a/apps/web/src/wsTransport.ts+++ b/apps/web/src/wsTransport.ts@@ -37,6 +37,9 @@ export class WsTransport {}async request<T = unknown>(method: string, params?: unknown): Promise<T> {+ if (typeof method !== "string" || method.length === 0) {+ throw new Error("Request method is required");+ }const id = String(this.nextId++);const message: WsRequest = { id, method, ...(params !== undefined ? { params } : {}) };diff --git a/packages/contracts/package.json b/packages/contracts/package.jsonindex a2e4a1f71..bed19b011 100644--- a/packages/contracts/package.json+++ b/packages/contracts/package.json@@ -12,7 +12,7 @@"exports": {".": {"types": "./src/index.ts",- "import": "./dist/index.mjs",+ "import": "./src/index.ts","require": "./dist/index.cjs"}},diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.tsindex 317bff60a..c6b58563c 100644--- a/packages/contracts/src/ipc.ts+++ b/packages/contracts/src/ipc.ts@@ -17,6 +17,8 @@ import type {} from "./git";import type {ProviderEvent,+ ProviderGetCheckpointDiffInput,+ ProviderGetCheckpointDiffResult,ProviderInterruptTurnInput,ProviderListCheckpointsInput,ProviderListCheckpointsResult,@@ -94,6 +96,9 @@ export interface NativeApi {stopSession: (input: ProviderStopSessionInput) => Promise<void>;listSessions: () => Promise<ProviderSession[]>;listCheckpoints: (input: ProviderListCheckpointsInput) => Promise<ProviderListCheckpointsResult>;+ getCheckpointDiff: (+ input: ProviderGetCheckpointDiffInput,+ ) => Promise<ProviderGetCheckpointDiffResult>;revertToCheckpoint: (input: ProviderRevertToCheckpointInput,) => Promise<ProviderRevertToCheckpointResult>;diff --git a/packages/contracts/src/provider.test.ts b/packages/contracts/src/provider.test.tsindex bc406c370..df9c8e9b3 100644--- a/packages/contracts/src/provider.test.ts+++ b/packages/contracts/src/provider.test.ts@@ -4,6 +4,8 @@ import {PROVIDER_SEND_TURN_MAX_ATTACHMENTS,providerCheckpointSchema,providerEventSchema,+ providerGetCheckpointDiffInputSchema,+ providerGetCheckpointDiffResultSchema,providerListCheckpointsInputSchema,providerListCheckpointsResultSchema,providerRevertToCheckpointInputSchema,@@ -229,4 +231,31 @@ describe("provider checkpoint schemas", () => {}),).toThrow();});++ it("accepts checkpoint diff input/result", () => {+ const input = providerGetCheckpointDiffInputSchema.parse({+ sessionId: "sess_1",+ fromTurnCount: 1,+ toTurnCount: 2,+ });+ expect(input.fromTurnCount).toBe(1);++ const result = providerGetCheckpointDiffResultSchema.parse({+ threadId: "thr_1",+ fromTurnCount: 1,+ toTurnCount: 2,+ diff: "diff --git a/src/app.ts b/src/app.ts",+ });+ expect(result.toTurnCount).toBe(2);+ });++ it("rejects checkpoint diff ranges where start is after end", () => {+ expect(() =>+ providerGetCheckpointDiffInputSchema.parse({+ sessionId: "sess_1",+ fromTurnCount: 3,+ toTurnCount: 2,+ }),+ ).toThrow();+ });});diff --git a/packages/contracts/src/provider.ts b/packages/contracts/src/provider.tsindex ca599a347..65877a6a1 100644--- a/packages/contracts/src/provider.ts+++ b/packages/contracts/src/provider.ts@@ -142,6 +142,29 @@ export const providerRevertToCheckpointResultSchema = z.object({checkpoints: z.array(providerCheckpointSchema),});+export const providerGetCheckpointDiffInputSchema = z+ .object({+ sessionId: z.string().min(1),+ fromTurnCount: z.number().int().min(0),+ toTurnCount: z.number().int().min(0),+ })+ .superRefine((value, ctx) => {+ if (value.fromTurnCount > value.toTurnCount) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ message: "fromTurnCount must be less than or equal to toTurnCount",+ path: ["fromTurnCount"],+ });+ }+ });++export const providerGetCheckpointDiffResultSchema = z.object({+ threadId: z.string().min(1),+ fromTurnCount: z.number().int().min(0),+ toTurnCount: z.number().int().min(0),+ diff: z.string(),+});+export const providerRespondToRequestInputSchema = z.object({sessionId: z.string().min(1),requestId: z.string().min(1),@@ -189,6 +212,8 @@ export type ProviderRevertToCheckpointInput = z.input<typeof providerRevertToCheexport type ProviderRevertToCheckpointResult = z.infer<typeof providerRevertToCheckpointResultSchema>;+export type ProviderGetCheckpointDiffInput = z.input<typeof providerGetCheckpointDiffInputSchema>;+export type ProviderGetCheckpointDiffResult = z.infer<typeof providerGetCheckpointDiffResultSchema>;export type ProviderRespondToRequestInput = z.input<typeof providerRespondToRequestInputSchema>;export type ProviderEventKind = z.infer<typeof providerEventKindSchema>;export type ProviderEvent = z.infer<typeof providerEventSchema>;diff --git a/packages/contracts/src/ws.ts b/packages/contracts/src/ws.tsindex ef395962c..61f583354 100644--- a/packages/contracts/src/ws.ts+++ b/packages/contracts/src/ws.ts@@ -11,6 +11,7 @@ export const WS_METHODS = {providersStopSession: "providers.stopSession",providersListSessions: "providers.listSessions",providersListCheckpoints: "providers.listCheckpoints",+ providersGetCheckpointDiff: "providers.getCheckpointDiff",providersRevertToCheckpoint: "providers.revertToCheckpoint",// Project registry methods