feat(codex): conversation rewind via thread/rollback

Wires codex's native thread/rollback RPC to the rewind affordance: the pencil
rewind on a user turn confirms directly (no checkpoint_view round-trip), sends
/rewind <numTurns> which the adapter maps to thread/rollback, and mirrors the
truncation in the projected transcript. Flips the codex checkpoints cap on.

Conversation-only for now — codex's rollback deliberately doesn't touch files
(the app-server schema says the client must); git-checkpoint file restore is a
follow-up phase. Also guards the claude adapter so desktop-only commands
(/rewind, /tree, …) are never forwarded to the CLI as text.

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

Author: gaoyu06

src/lib/backends/caps.test.ts

@@ -55,6 +55,7 @@ describe('caps() gating helper', () => {
 		expect(cx.goals).toBe(true);
 		expect(cx.transcriptReplay).toBe(true);
 		expect(cx.slashCommands).toBe(false);
+		expect(cx.checkpoints).toBe(true); // conversation rewind via thread/rollback
 	});
 
 	it('every backend declares the full flag set', () => {

src/lib/backends/claude.ts

@@ -1033,8 +1033,10 @@ export function createClaudeAdapter(): EngineAdapter {
 							];
 						default:
 							// /resume is page-driven for claude (session listing needs fs
-							// access via the claude_sessions command).
-							if (cmd === '/resume') return null;
+							// access via the claude_sessions command); desktop/jucode-only
+							// commands aren't claude CLI commands, so never forward them.
+							if (['/resume', '/rewind', '/tree', '/checkout', '/fork', '/undo'].includes(cmd))
+								return null;
 							// Any other slash command comes from the CLI's own slash_commands
 							// list (built-ins like /context, /doctor or a user's custom
 							// command) — forward it verbatim as stream-json user text for the

src/lib/backends/codex-types.ts

@@ -101,6 +101,14 @@ export interface ThreadResumeParams {
 	sandbox?: SandboxMode | null;
 }
 
+/** thread/rollback: drop `numTurns` turns from the end of the thread's history
+ *  (must be >= 1). Per the app-server schema this only rewinds the *conversation*
+ *  — local file changes are the client's responsibility (a git checkpoint). */
+export interface ThreadRollbackParams {
+	threadId: string;
+	numTurns: number;
+}
+
 export type UserInput =
 	| { type: 'text'; text: string; text_elements: unknown[] }
 	| { type: 'localImage'; path: string };

src/lib/backends/codex.test.ts

@@ -51,6 +51,22 @@ describe('codex adapter: caps', () => {
 	});
 });
 
+describe('codex adapter: rewind', () => {
+	it('rewinds the conversation with thread/rollback by turn count', () => {
+		const { lines } = makeIo();
+		const adapter = createCodexAdapter();
+		handshake(adapter, lines);
+		const frames = adapter.encodeOp({ op: 'command', input: '/rewind 2' });
+		expect(parse(frames![0])).toMatchObject({
+			method: 'thread/rollback',
+			params: { threadId: 'thread-1', numTurns: 2 }
+		});
+		// A non-positive / missing count is a no-op.
+		expect(adapter.encodeOp({ op: 'command', input: '/rewind 0' })).toEqual([]);
+		expect(adapter.encodeOp({ op: 'command', input: '/rewind' })).toEqual([]);
+	});
+});
+
 describe('codex adapter: handshake', () => {
 	it('onStart sends only the initialize request', () => {
 		const { lines, io } = makeIo();

src/lib/backends/codex.ts

@@ -74,6 +74,7 @@ import type {
 	ThreadGoalUpdatedParams,
 	ThreadItem,
 	ThreadListParams,
+	ThreadRollbackParams,
 	ThreadListResponse,
 	ThreadResumeParams,
 	ThreadStartResponse,
@@ -93,7 +94,7 @@ export const CODEX_CAPS: BackendCaps = {
 	goals: true, // thread/goal/set|get|clear + thread/goal/updated|cleared
 	skills: false,
 	mcpManage: false,
-	checkpoints: false,
+	checkpoints: true, // conversation rewind via thread/rollback (files handled desktop-side)
 	contextUsage: true, // thread/tokenUsage/updated
 	compact: true, // thread/compact/start + contextCompaction item lifecycle
 	modelPicker: true, // model/list catalog + per-turn model/effort overrides
@@ -920,8 +921,17 @@ export function createCodexAdapter(): EngineAdapter {
 								return [request('thread/goal/set', { threadId, status: 'active' })];
 							return [request('thread/goal/set', { threadId, objective: arg })];
 						}
+						case '/rewind': {
+							// Conversation rewind: drop N turns from the thread history. The
+							// page computes N from the target turn and truncates its own view;
+							// files are the client's job (see checkpoints cap note).
+							const n = parseInt(arg, 10);
+							return threadId && n > 0
+								? [request('thread/rollback', { threadId, numTurns: n } satisfies ThreadRollbackParams)]
+								: [];
+						}
 						default:
-							return null; // /tree, /rewind, … — unsupported, UI notifies
+							return null; // /tree, … — unsupported, UI notifies
 					}
 				}
 				case 'shutdown':

src/lib/chat.svelte.ts

@@ -240,6 +240,27 @@ export class ChatState {
 		return out;
 	}
 
+	/** Number of user turns in the transcript (one per sent message). */
+	get userTurns() {
+		return this.messages.filter((m) => m.kind === 'user').length;
+	}
+
+	/** Drop the `userIndex`-th user turn and everything after it — used by codex's
+	 *  local view truncation on a thread/rollback rewind (the engine rewinds its
+	 *  own history; we mirror it in the projected transcript). */
+	truncateToUserTurn(userIndex: number) {
+		let count = 0;
+		for (let i = 0; i < this.messages.length; i++) {
+			if (this.messages[i].kind === 'user') {
+				if (count === userIndex) {
+					this.messages = this.messages.slice(0, i);
+					return;
+				}
+				count++;
+			}
+		}
+	}
+
 	/** Whether this session has something the engine actually persisted to resume.
 	 *  A fresh session (id assigned at startup but no user turn yet) was never saved,
 	 *  so `/resume <id>` would fail with "No such file". Gates restart/switch resume

src/lib/chat.test.ts

@@ -170,6 +170,19 @@ describe('ChatState.handle', () => {
 		expect(c.cost).toBe(0.42);
 	});
 
+	it('truncateToUserTurn drops the target turn and everything after (codex rewind)', () => {
+		const c = new ChatState();
+		c.handle({ type: 'user_message', content: 'first' });
+		c.handle({ type: 'assistant_delta', delta: 'a1' });
+		c.handle({ type: 'user_message', content: 'second' });
+		c.handle({ type: 'assistant_delta', delta: 'a2' });
+		c.handle({ type: 'user_message', content: 'third' });
+		expect(c.userTurns).toBe(3);
+		c.truncateToUserTurn(1); // rewind to the 2nd user turn
+		expect(userTexts(c)).toEqual(['first']);
+		expect(c.messages.map((m) => m.kind)).toEqual(['user', 'assistant']);
+	});
+
 	it('tracks busy state from engine status', () => {
 		const c = new ChatState();
 		c.handle({ type: 'model_status', state: 'streaming' });

src/routes/+page.svelte

@@ -982,13 +982,27 @@
 	// engine lists user turns in order, so the i-th turn matches the i-th message.
 	function rewindToMessage(text: string, userIndex: number) {
 		if (!chat) return;
+		// codex rewinds its conversation with thread/rollback (by turn count), which
+		// has no checkpoint_view round-trip — confirm directly from the turn index.
+		if (chat.backendId === 'codex') {
+			chat.pendingRewind = { id: `codex:${userIndex}`, text };
+			return;
+		}
 		chat.rewindIntent = { userIndex, text };
 		send({ op: 'command', input: '/rewind' });
 	}
 	function confirmRewind() {
 		const pr = chat?.pendingRewind;
 		if (!pr || !chat) return;
-		send({ op: 'command', input: `/rewind ${pr.id}` });
+		if (pr.id.startsWith('codex:')) {
+			const userIndex = Number(pr.id.slice('codex:'.length));
+			const numTurns = chat.userTurns - userIndex;
+			if (numTurns > 0) send({ op: 'command', input: `/rewind ${numTurns}` });
+			// codex rolls back its own history; mirror it in our projected transcript.
+			chat.truncateToUserTurn(userIndex);
+		} else {
+			send({ op: 'command', input: `/rewind ${pr.id}` });
+		}
 		input = pr.text;
 		chat.pendingRewind = null;
 		composerEl?.focus();