Rewind the conversation on /undo, staged so a redo can lift it (part 3 of #944)

[KazenDev]

Stacked on #1344 (itself stacked on #1343). The four engine files and the picker in the diff below come from those two and are unchanged here between them; this PR's own change is 6 files, +466/-5.

/undo reverts files, but the model keeps the memory of the turn. So the agent looks at the disk, does not find the file it believes it just wrote, and writes it again — the undo undoes itself. Observed live in the CLI:

> create new.py with print("hola")
• Create new.py
Undid the last change:
🗑 new.py (deleted)
> (next turn) I see new.py is not in the directory listing. The earlier write
  may not have completed — let me create it again.
• Create new.py

This PR is the conversation half: an undo can now take the turn out of the model's memory as well as off the disk.

The two memories, and the one door

	What	Who reads it
Transcript	useChatStore.messages	the UI
Model memory	runState.sessionState.mainAgentState.messageHistory	the next run — and only the next run, through previousRunState

createRunConfig is called in exactly one place (cli/src/hooks/use-send-message.ts, the previousRunState argument), so cutting the model's history is one slice at one call site. The SDK never reads the stored output of a previous run (only sessionState, traceSessionId and inference), so nothing else needs to move.

The cut is staged, not applied

Nothing is deleted when you undo. The journal records a boundary and the history is slice-copied on the way into the run:

• /undo puts the files back and sets rewind in the chat's undo.json — {recordId, historyLength, transcriptIndex}.
• The next run starts from messageHistory.slice(0, historyLength).
• /redo deletes that mark, so the conversation comes back for free.
• A turn that runs afterwards absorbs the cut: the state it persists was built from the cut history, and the mark is cleared then. An interrupted or failed run keeps it, because nothing absorbed it.

That is why a redo cannot lose a message here: there was never a copy to get wrong. It also matches what the tools everyone compares us to do — see the prior art below.

Each turn records where it started, in both memories, captured as its run begins (next to the stamp that already guards the entry against a newer turn): {historyLength, transcriptIndex}. An entry written before this existed has no anchor, and an undo of it still reverts its files but stages no cut — a guess would be worse than a file-only undo.

What each file does

File	Change
cli/src/state/undo-rewind.ts (new)	the pure helpers: the transcript anchor, the anchor reader, and the history cut (same reference when there is nothing to cut)
cli/src/state/undo-store.ts	anchor on the record, RewindBoundary on the journal, getRewindBoundary/setRewindBoundary/clearRewindBoundary, undoToRecord(..., { conversation }) stages the cut, redoToRecord lifts it
cli/src/hooks/use-send-message.ts	capture the anchor as the turn starts, pass it to recordUndoEntry, apply the staged cut at the run config, clear it once a run has absorbed it
cli/src/app.tsx	the picker's selection asks for both halves
tests	undo-rewind.test.ts (new, 10) and 6 more in undo-store.test.ts

Prior art (this is the shape the field settled on)

• Claude Code /rewind offers Restore code and conversation / Restore conversation / Restore code, and "the original prompt from the selected message is restored into the input field so you can re-send or edit it." It also keeps checkpoints with the conversation so /rewind still works after a resume. https://code.claude.com/docs/en/checkpointing
• OpenCode stages the rollback: "OpenCode stages the rollback, restores the affected files, and puts the removed prompt back in the composer… Submitting the edited prompt commits the staged rollback. Before submitting, run /redo to cancel it." https://opencode.ai/v2/docs/snapshots
• Hermes implements the same soft-delete: "soft-deletes the truncated rows on disk, and prefills the composer with the backed-up message for editing" — rewound rows stay on disk for audit and are hidden from re-prompts. feat(undo): /undo [N] backs up N user turns with prefill + soft-delete (#21910) NousResearch/hermes-agent#36229
• Roo-Code fixed the opposite design: deleting condensed messages permanently lost them on a rewind, so they tag instead and filter at read time. fix: restore context when rewinding after condense (#8295) RooCodeInc/Roo-Code#9665
• zerostack states the rule this PR follows for the staged mark: "It is dropped as soon as the conversation moves forward again (a new message), so /redo only ever reverses the cut it directly follows." feat: /rewind to an earlier turn and a reversible /undo gi-dellav/zerostack#151

Not in this PR, on purpose

• The picker still lists the reverted turns, and your prompt does not come back to the input. Hiding the tampered tail on screen and prefilling the composer for editing is the UI half, and the mode toggle that this default implies (code only vs code and conversation, both of which the tools above offer) goes with it.
• The worktree is still the only thing with a snapshot. This PR is about the model's memory; the files half is Add the /undo snapshot engine, anchored so it survives cleanup (part 1 of #944) #1343's, unchanged.
• Not secure erasure. The cut messages stay in the chat's saved transcript until you send the next prompt; the same is true of the tools above, and they say so too.
• The cut is exact only as far as compaction allows. If a turn triggered mechanical compaction, the history that remains is the compacted one — coherent, but not byte-identical to what the turn saw. Declared rather than hidden.
• creditsUsed is not rewound. The conversation goes back; the bill does not.

Verification

bun test cli/src, with the baseline taken by stashing exactly this PR's files (not from memory):

	Files	Tests	Failures
Baseline (#1344)	203	3155	21
With this PR	204	3171	21 — the identical set (diff empty)

+16 tests = exactly the new ones. bun run typecheck in cli/: 10 errors, the exact baseline, 0 of them in these files.

Red before green, measured: with the staging switched off (false && …), 2 of the 6 journal tests fail — an undo takes the turn out of the model conversation too and a redo lifts the staged cut. The other 4 assert absence (no cut when it is not asked for, no cut without an anchor, a newer turn does not lift a staged cut, lifting twice is safe), so they pass either way — the pair is what pins the flag.

What these tests do not claim: the user-visible bug is a model behaviour (it prefers to rewrite a file it believes is missing), so no unit test reproduces it. The reproduction is the CLI transcript above; the tests pin the mechanism that removes the model's reason to rewrite.

How to try it

cd <a git project>
# one turn that edits, creates and deletes files
/undo            # Enter on a row
git diff         # the files are back
# then send a follow-up prompt: the agent no longer knows that turn happened
/redo            # the conversation half comes back too