Navigating history: from a goal to the exact transcript

This page is about drilling in. The Map shows you the shape of your project; the detail panel and the right-click menu are how you answer the questions that matter: what exactly happened here, why was it written, and can I go back to it?

The detail panel: goal -> prompts -> steps

Click a goal on the map and the detail panel opens with that goal's contents:

The goal's prompts, stacked as a timeline; each prompt is one significant exchange with an AI agent which resulted in changes occuring to the files in the codebase ("implement the login form," "fix the flaky test").
Click a prompt to see its steps - the individual committed checkpoints, each with the files it changed.
Click a step to see its diff (added lines in green, removed in red), and open its transcript - the structured event log behind the change (more on that below).

This chain is Merget's core promise: every line of code traces back through a step and a prompt to the transcript behind it. When someone asks "why is this code like this?", the answer is one click away instead of an archaeology project.

Under the hood

Steps, transcripts, and file snapshots are all content-addressed objects - the same step always has the same ID everywhere, and history can't be silently edited without the IDs changing. A transcript is attached to each committed change, so provenance isn't a comment convention; it's part of the data model. The CLI calls steps "subprompts"; same thing, see the glossary.

Reading a transcript

View transcript (from the right-click menu, or from a step in the detail panel) opens a structured, per-step event log - not a chat-style replay of the conversation. It's a table of the raw events behind the step: your prompts, the agent's events, the tools it ran, and any human edits, with token counts and cost for each. Think of it as a detailed view of what a step did and what it cost, more than a place to read the agent's prose back.

Human edits and agent edits are listed separately, so you can usually tell which lines a person wrote. One caveat: if you edit a file by hand while an agent tool is running and the tool changes that same file, your edit can be folded into the agent's edit for that step instead of showing as a separate human edit.

Remember that transcripts are part of your synced history - they go where your repo goes. See Sync & privacy.

Right-click any goal node:

Check out - set your working files to that goal's latest state.
Set bookmark - point an existing bookmark here, or Add Bookmark to create a new one. See Bookmarks.
View transcript - open the goal's transcripts.

Fork nodes can be right-clicked too: Check out there puts you at the exact fork point.

Checking out: moving your working files through time

Checking out rewrites your working files to match the chosen point in history. The map updates immediately: the filled HEAD indicator moves to the goal you checked out, and if you picked a step partway through a goal, the hollow checkout marker shows your exact position on the edge.

If the GIF doesn't load: after the checkout, the previously-current goal loses its filled indicator, the chosen goal gains it, and the brightened path on the map re-routes to end there.

Two safety properties worth knowing:

You can't check out while an agent is working. If a coding agent is actively making changes, finish or stop that session before you check out - Merget won't move your working files out from under a running agent.
Untracked files are left alone. Files Merget has never committed survive a checkout untouched.

Detached: standing on an old step

If you check out an old step rather than a goal's tip, you're detached: you're viewing real history, but new work committed here would start a new fork rather than extending the original line. The map makes this visible: the hollow checkout marker sits mid-edge instead of the filled indicator sitting on a tip.

To get back, check out the goal's tip (right-click the goal, then Check out), or use a bookmark to find your way to a place you named. The four HEAD states and what each means are explained in The history model.

"Why was this written?": three ways to ask

Walk the chain by hand: map -> goal -> prompt -> step -> transcript. Best when you already know roughly where to look.
Start from a file: open the Editor in diff mode on a step to see exactly what it changed, then jump to its transcript.
Just ask: the chat agent answers questions like "why does the retry logic use exponential backoff?" in plain language, with citations that click through to the goals and steps on the map.