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.

Emit checkpoint captured events after turn checkpointing

Julius Marminge79382b272c02
diff --git a/apps/server/src/providerManager.test.ts b/apps/server/src/providerManager.test.ts
index e21b079e5..c26f34cb6 100644
--- a/apps/server/src/providerManager.test.ts
+++ b/apps/server/src/providerManager.test.ts
@@ -296,6 +296,82 @@ describe("ProviderManager", () => {
manager.dispose();
});
+ it("emits checkpoint/captured after turn completion checkpoint capture", async () => {
+ const manager = new ProviderManager();
+ const events: Array<{ method: string; payload?: unknown; threadId?: string }> = [];
+ manager.on("event", (event) => {
+ events.push({
+ method: event.method,
+ ...(event.payload !== undefined ? { payload: event.payload } : {}),
+ ...(event.threadId ? { threadId: event.threadId } : {}),
+ });
+ });
+
+ const internals = manager as unknown as {
+ onCodexEvent: (event: {
+ id: string;
+ kind: "notification";
+ provider: "codex";
+ sessionId: string;
+ createdAt: string;
+ method: string;
+ threadId: string;
+ }) => void;
+ codex: {
+ hasSession: (sessionId: string) => boolean;
+ readThread: (sessionId: string) => Promise<{
+ threadId: string;
+ turns: Array<{ id: string; items: unknown[] }>;
+ }>;
+ };
+ filesystemCheckpointStore: {
+ captureCheckpoint: (input: {
+ cwd: string;
+ threadId: string;
+ turnCount: number;
+ }) => Promise<void>;
+ };
+ sessionCheckpointCwds: Map<string, string>;
+ };
+
+ internals.codex.hasSession = () => true;
+ internals.codex.readThread = async () => ({
+ threadId: "thr_1",
+ turns: [{ id: "turn_1", items: [] }],
+ });
+ const captureCheckpoint = vi.fn(async () => undefined);
+ internals.filesystemCheckpointStore.captureCheckpoint = captureCheckpoint;
+ internals.sessionCheckpointCwds.set("sess_1", "/repo");
+
+ internals.onCodexEvent({
+ id: "evt-turn-complete",
+ kind: "notification",
+ provider: "codex",
+ sessionId: "sess_1",
+ createdAt: "2026-02-19T00:00:00.000Z",
+ method: "turn/completed",
+ threadId: "thr_1",
+ });
+
+ await vi.waitFor(() => {
+ expect(captureCheckpoint).toHaveBeenCalledWith({
+ cwd: "/repo",
+ threadId: "thr_1",
+ turnCount: 1,
+ });
+ expect(events.some((event) => event.method === "checkpoint/captured")).toBe(true);
+ });
+
+ const checkpointCapturedEvent = events.find((event) => event.method === "checkpoint/captured");
+ expect(checkpointCapturedEvent?.threadId).toBe("thr_1");
+ expect(checkpointCapturedEvent?.payload).toEqual({
+ threadId: "thr_1",
+ turnCount: 1,
+ });
+
+ manager.dispose();
+ });
+
it("lazily initializes filesystem checkpoints before diffing when cache 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 532f32f7f..d8442e6c7 100644
--- a/apps/server/src/providerManager.ts
+++ b/apps/server/src/providerManager.ts
@@ -477,11 +477,19 @@ 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);
- });
+ void this.getOrInitializeFilesystemCheckpointCwd(event.sessionId)
+ .then(async (initializedCwd) => {
+ if (!initializedCwd || !this.codex.hasSession(event.sessionId)) {
+ return;
+ }
+ const snapshot = await this.codex.readThread(event.sessionId);
+ this.emitCheckpointCaptured(event.sessionId, snapshot.threadId, snapshot.turns.length);
+ })
+ .catch((error) => {
+ const message =
+ error instanceof Error ? error.message : "Failed to initialize filesystem checkpoints.";
+ this.emitFilesystemCheckpointError(event.sessionId, message, event.threadId);
+ });
return;
}
@@ -496,12 +504,29 @@ export class ProviderManager extends EventEmitter<ProviderManagerEvents> {
threadId: snapshot.threadId,
turnCount: snapshot.turns.length,
});
+ this.emitCheckpointCaptured(event.sessionId, snapshot.threadId, snapshot.turns.length);
}).catch((error) => {
const message = error instanceof Error ? error.message : "Failed to capture checkpoint.";
this.emitFilesystemCheckpointError(event.sessionId, message, event.threadId);
});
}
+ private emitCheckpointCaptured(sessionId: string, threadId: string, turnCount: number): void {
+ this.emit("event", {
+ id: randomUUID(),
+ kind: "notification",
+ provider: "codex",
+ sessionId,
+ createdAt: new Date().toISOString(),
+ method: "checkpoint/captured",
+ threadId,
+ payload: {
+ threadId,
+ turnCount,
+ },
+ });
+ }
+
private emitFilesystemCheckpointError(
sessionId: string,
message: string,
diff --git a/apps/web/src/routes/__root.tsx b/apps/web/src/routes/__root.tsx
index 57c608534..866da47eb 100644
--- a/apps/web/src/routes/__root.tsx
+++ b/apps/web/src/routes/__root.tsx
@@ -6,6 +6,7 @@ import { AnchoredToastProvider, ToastProvider } from "../components/ui/toast";
import { isElectron } from "../env";
import { useNativeApi } from "../hooks/useNativeApi";
import { invalidateGitQueries } from "../lib/gitReactQuery";
+import { providerQueryKeys } from "../lib/providerReactQuery";
import { DEFAULT_MODEL } from "../model-logic";
import { useStore } from "../store";
import { onServerWelcome } from "../wsNativeApi";
@@ -57,6 +58,9 @@ function EventRouter() {
if (event.method === "turn/completed") {
void invalidateGitQueries(queryClient);
}
+ if (event.method === "checkpoint/captured") {
+ void queryClient.invalidateQueries({ queryKey: providerQueryKeys.all });
+ }
if (!activeThreadId) return;
dispatch({
type: "APPLY_EVENT",
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index d07219639..24fe2b73d 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -891,13 +891,7 @@ export function reducer(state: AppState, action: Action): AppState {
...state,
threads: updateThread(state.threads, target.id, (t) => {
const nextEvents = [event, ...t.events];
- const itemType = asString(asObject(asObject(event.payload)?.item)?.type);
- const normalizedItemType = itemType?.replace(/[_-]/g, "").toLowerCase();
- const shouldRederiveDiffs =
- event.method === "turn/completed" ||
- event.method === "turn/diff/updated" ||
- (event.method === "item/completed" &&
- (normalizedItemType === "agentmessage" || normalizedItemType === "filechange"));
+ const shouldRederiveDiffs = event.method === "turn/completed";
const turnDiffSummaries = shouldRederiveDiffs
? mergeTurnDiffSummaries(t.turnDiffSummaries, deriveTurnDiffSummaries(nextEvents))
: t.turnDiffSummaries;