Skip to content

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.ts
index 01722a696..73af81bbe 100644
--- a/apps/server/src/codexAppServerManager.ts
+++ b/apps/server/src/codexAppServerManager.ts
@@ -148,19 +148,20 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
async 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<CodexAppServerManagerEve
const 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.tsx
index 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 && (
<Suspense
fallback={
<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.tsx
index 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 thread
if (!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>
<Button
type="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.tsx
index 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",
+ )}
+ >
<div
className={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.tsx
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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[]): TurnDiffSummar
turnId,
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[]): TurnDiffSummar
continue;
}
- 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.json
index 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.ts
index 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.ts
index 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.ts
index 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 providerRevertToChe
export 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.ts
index 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