Claude Code

Checkpoints and rewind

How Claude Code captures edits, restores code or conversation with /rewind, summarizes context, and handles changes it does not track.

Checkpointing is Claude Code's session-level undo mechanism. It records changes made through Claude's file-editing tools so you can return to earlier code and conversation states when an approach fails or context becomes too long.

Use checkpoints to undo operations in the current session quickly. They do not replace Git branches, commits or shared project history.

#What it records

Claude Code captures code state automatically as you work:

Action	Result
Each new user prompt	Creates a new checkpoint
Claude uses file-editing tools such as Edit/Write	Includes the file changes in the restore scope
Resume a saved session	Its checkpoints remain accessible
Session cleanup	Removes checkpoints with the session, normally after about 30 days; configurable

You do not need to create checkpoints manually. Changes made through Claude Code's own editing tools can generally be restored from the rewind menu.

Entry point	Behavior
`/rewind`	Opens rewind in the current session
Press `Esc` twice with an empty input	Opens the same menu

If the input contains text, pressing Esc twice clears it instead. The cleared text enters input history and can be recovered with Up.

The menu lists prompts you sent in this session. Select a point, then choose what to do with the code, conversation or context summary.

#Available actions

Action	Result	When to use it
Restore code and conversation	Returns both to the selected point	Restart from the prompt before an incorrect implementation
Restore conversation	Rewinds conversation while keeping files on disk	Rewrite the discussion without losing file changes
Restore code	Rewinds file edits while keeping the conversation	Recover files while retaining the analysis
Summarize from here	Summarizes the selected message and everything after it; earlier content stays intact	Compress a side discussion while retaining the initial context
Summarize up to here	Summarizes content before the selected message; that message and later content stay intact	Compress early preparation while continuing recent work
Never mind	Returns to the message list	Make no changes

After Restore conversation or Summarize from here, the selected prompt returns to the input for editing or resending. After Summarize up to here, you remain at the end of the session with an empty input.

#Restore versus summarize

Action	Changes files on disk?	Changes conversation?	Purpose
Restore code	Yes	No	Undo file changes
Restore conversation	No	Yes	Return to an earlier conversation state
Restore code and conversation	Yes	Yes	Undo both
Summarize from/up to here	No	Replaces part of the context with a summary	Free context capacity

Summarize does not roll back files. It compresses a chosen part of the conversation into a Claude-generated summary, like a more targeted /compact. Original messages remain in the session transcript, and Claude may still refer to their details when needed.

To try a different approach while retaining the original session, use session branching or:

claude --continue --fork-session

#Return after /clear

After /clear within the same Claude Code process, the top of the rewind menu may show:

/resume <session-id> (previous session)

Select it to resume the session from before /clear. This entry remains until you exit Claude Code or resume another session. The official guide requires Claude Code v2.1.191 or later for this menu entry. Earlier versions can locate the session manually with /resume.

#Typical workflow

Try a larger change

Ask Claude to plan first, then implement. Each prompt creates a restore point, making it easier to compare approaches.

Rewind when the direction is wrong

Rather than adding repeated undo instructions to the context, open /rewind, select the prompt before the problem, and restore code, conversation or both.

Summarize a long detour

If research or a discarded discussion is the problem, use Summarize from here or Summarize up to here without changing files.

Commit stable work to Git

Checkpoints follow the session cleanup lifecycle. Preserve long-term states with a Git commit, branch or PR.

#Limits

Limit	Effect
Bash file changes are not tracked	`rm`, `mv`, `cp` and generated files cannot be undone reliably with rewind
External edits generally are not tracked	Manual edits, other terminals and other Claude sessions are usually outside the checkpoint
Scope covers files edited in this session	Files never edited by this session generally have no restore state
Not long-term history	Checkpoints expire with sessions and do not resolve collaboration conflicts

Check Git status before running generators, formatters, migrations or deletion commands. Checkpointing is useful for direct Claude edits, but does not fully protect filesystem changes made by shell commands.

#With Passion8

Checkpointing is managed by Claude Code locally. With Passion8, /rewind, summarization and restoration remain client features; model requests use your ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN configuration.