Time-travel

Your files and your conversation are separate axes — rewind either one, or both

Most coding tools give you undo for the transcript; the files they touched stay touched. visvoai-cli checkpoints your working tree and your conversation as two independent things — which means you choose which one travels back. That choice is the feature. Plain "undo everything" is just one of the options, and the least interesting.

The choice rewind actually gives you

/rewind (or Ctrl+B) opens a picker of the questions you've asked. Pick one and you're taken to the moment just before you asked it — then it asks what should move:

Choice	Files	Conversation	Use it when
Revert code + conversation	↩ back	↩ back	Clean slate — the ordinary undo
Revert conversation only	stay	↩ back	The work is good, the context is bloated
Revert code only	↩ back	stay	The approach failed, but the discussion was useful
Summarize up to here	stay	folded	Reclaim context without losing the thread
Branch from here	—	—	Keep both timelines and try the other way

"Revert code only" is the one with no equivalent elsewhere. The files go back to clean, the agent still remembers everything you discussed — so "that didn't work, try it with a decorator instead" lands with full context and none of the failed code in the way.

If reverting code would cross a point where files changed outside this session, the prompt says so before you commit to it:

⚠ Reverting code past here also discards changes made outside this session.

How checkpointing works

Before each tool batch runs — while the tree is quiescent, so parallel tool calls in the same batch never race each other for the snapshot — the CLI records a shadow git commit of your working directory and maps it to a message index. Another checkpoint lands at the end of every turn. The result is a fine-grained history: not just "before this message" but "before this specific batch of edits."

Your own git repository is never touched — snapshots live in a separate shadow repo, so your branches, staging area, and history stay exactly as you left them.

Checkpointing is best-effort — a CheckpointError or OSError is swallowed so a snapshotting hiccup never breaks your turn.

Two-level storage

The conversation owns an immutable registry (checkpoints.jsonl: checkpoint id → shadow commit) — the code mapping only.
Each branch owns its own timeline (branches/<name>/timeline.jsonl: ordered {checkpoint_id, message_index, kind, label} rows) — its own view of which checkpoint corresponds to which turn or tool call.

A branch reconstructs itself only from its own folder; it resolves a checkpoint id against the shared registry but never reads another branch's mutable state directly.

The commands

Command	Key	What it does
`/rewind`	`Ctrl+B`	Pick an earlier question, then choose what travels back — code, conversation, or both
`/branch`		Switch between saved timelines of this conversation, or start a new one from a checkpoint
`/fork`		Deep-copy a branch (truncated at a checkpoint) into a brand-new folder — explore two directions in parallel without losing either
`/log`		List the current timeline's full checkpoint chain
`/export`		Save the conversation as a shareable transcript, or a full bundle

Fork vs. branch: a branch lives inside the same project directory and switches which timeline you're viewing; a fork is a physical directory copy — useful when you want to keep working on both versions of the code simultaneously, in two terminals, without one's file writes touching the other. forked_from is recorded as provenance only — a fork never reconstructs itself from its parent branch's state, it's a real, independent copy from that point forward.

What the rewind picker shows you

Each turn is labeled with a one-line summary of what it actually did — "edited api.py · ran pytest" — derived from the tool calls in that turn's messages, not just a timestamp. That makes picking the right checkpoint out of a long session fast instead of a guessing game.