The transcript

A terminal shows an agent's work as one long scroll of text. Vitrino gives every kind of thing Claude does its own row, with its own icon, shape and typography — so a long session is skimmable rather than merely readable.

Rows

Each step is a row. What you see depends on what happened:

Your message sits on the right, as a bubble.
Claude's reply is rendered Markdown — headings, lists, tables, code.
Thinking is collapsed to a single line. Open it if you want to see the reasoning.
A tool call gets a row shaped for that tool: a command with its output, a file read with a line count, an edit with a diff. See Tools.
A turn footer closes each turn with how long it took, how many turns, tokens in and out, and what it cost.

Run the retry tests

pnpm vitest run src/net

A shell command: what ran, and what it printed.

Thinking, collapsed. Open it to read the reasoning.

The footer that closes a turn:

The turn footer: how long it took, and what it cost.

Rows that are noise most of the time — hook output, Claude Code's own housekeeping — are grouped into one muted line saying how many there were. Open it if you need it.

Nothing is thrown away

Vitrino reshapes what Claude Code says; it never summarises or cleans it up. If a message arrives in a shape Vitrino does not recognise, it is shown as raw JSON rather than dropped — ugly, but never silently missing.

Every row is independently contained, so one malformed step degrades that row and nothing else.

Detail is one click away

Long output is collapsed with a summary of what is inside: 142 lines, All arguments, Raw error. Click to open.

What starts open and what starts closed is up to you, per kind of block, in Settings → Transcript. See Settings.

Diffs

Edits are shown as a diff, not as before‑and‑after text: syntax highlighted, per file, with word‑level changes marked inside a changed line. A turn that touched several files also gets a summary of everything it changed.

11 export async function withRetry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {

2+ let lastError: unknown;

23 for (let i = 0; i < attempts; i++) {

34 try {

45 return await fn();

5− } catch {

6− await sleep(backoff(i));

6+ } catch (error) {

7+ lastError = error;

8+ if (i < attempts - 1) await sleep(backoff(i));

79 }

810 }

9− return undefined as T;

11+ throw lastError;

1012 }

An edit, shown as the diff it made rather than as its arguments.

Line endings are normalised before diffing, so a file written on Windows does not show up as rewritten from top to bottom.

Turn boundaries

A turn starts when you send something and ends with the footer. Between those, Claude may take many steps.

Two markers are worth knowing:

History compacted — the conversation got long and Claude Code summarised the earlier part to make room. What is above the line is gone from Claude's view except through that summary.
Conversation cleared — you ran /clear. Nothing above the line reaches Claude any more. This one is drawn to be impossible to miss, because it is easy to keep typing and wonder why Claude has forgotten everything.

Warning

/clear is not undoable. Nothing above that line ever reaches Claude again — not in this session, and not if you reopen the tab later.

Permissions covers the cards that stop the transcript until you answer.