Backscroll

Claude Code session history — search, read and measure your transcripts.

Claude Code lives in a terminal, and a terminal is a single column of scrolling text. That is fine while you are working and poor for finding your way back afterwards: everything looks alike, and the thing you are hunting for is somewhere in a wall of output.

This was built for the opposite way of reading. Colour separates who said what, failures announce themselves, file changes are gathered where they happened, and the whole history is searchable across every project at once. If you orient yourself by shape and colour rather than by scrolling, it turns an unstructured log into something you can navigate.

Everything runs locally. It reads the transcript files Claude Code already writes, and makes no network requests of any kind — with one exception you control: Read /usage for me runs your Claude Code to fetch your plan usage. That program talks to its provider; Backscroll holds no credential and sends nothing anywhere. It happens only when you press it, never on its own.

Reading a conversation

Speakers are colour-coded — your messages blue, Claude's end-of-task replies green, tool traffic untinted, failed tool results red, skill bodies amber. Five distinct meanings, so a glance tells you what you are looking at.

Only what you typed is labelled "You." A transcript stores tool results, skill bodies, slash commands, compaction preambles and image placeholders under the same role as your own messages. Each is labelled and tinted for what it actually is, and searching your own words returns only your own words.

Failures stand out. A tool result that errored gets a red border, a ⨯ marker and a failed chip, and the message containing it is flagged so you can spot it while scrolling.

Tool calls read as what they are — a shell command as shell, an edit as a diff, a written file as its content — rather than as JSON with every newline escaped. Calls and results are collapsed behind a one-line summary naming the tool and what it did, with a line count; Expand all opens every one.

Turn changes. At the end of each turn, a card lists every file Claude wrote, with +N −M per file and for the turn as a whole. Each file expands to a diff with real line numbers and surrounding context, and a Diff button opens the change in VS Code's own diff viewer. Files created in the turn are badged new; a file you edited yourself between Claude reading and writing it is badged edited by you.

Only Edit and Write record what they changed. If a file was rewritten by a shell command — sed -i, a redirect, a script — the transcript keeps the command but not the change, and the card says so rather than reporting an empty turn. Asking Claude to use Edit or Write for file changes, or putting that in a CLAUDE.md, makes them show up.

Recaps — Claude Code's own summary of what happened while you were away — render where they were written and are searchable.

Code blocks carry a Copy button and a language picker on hover, and are highlighted using your active colour theme's own token colours. Minified JSON in a tool result is expanded and highlighted, which matters when an MCP server answers with a single long line. Pasted images render inline, as do images a tool returned — reading a screenshot shows the screenshot. Each one can be folded away to read the text around it and unfolded again; the choice survives a refresh.

Finding your way around — a find bar with a live match count (Cmd+F) that opens the collapsed block containing each hit, a dated rule at every day boundary, and a Jump to… picker for moving between days, or straight to the start, your own last message, or the latest message. Its entries are Start, the dates, Your latest and Latest. The ↑ YOU ↓ control — or Alt+Up / Alt+Down — steps backwards and forwards through your own messages.

Live updating. A transcript being written while you read it keeps up, and your reading position and expanded blocks survive the refresh. Position is held against the message you are reading, so new messages do not shift it; if you are at the bottom, it follows the session as a terminal does. The Auto-refresh toggle pauses it when you would rather nothing moved.

Naming a conversation

Claude Code can rename a session you are in. It cannot reach one that exists only in Backscroll's archive — which is where a name helps most, since an archived list is what you scan months later.

Rename on any conversation in the sidebar, or Backscroll: Rename a conversation… from the Command Palette. Leave the box empty to clear the name and go back to whatever the transcript itself says.

Names are kept in the archive, alongside the transcripts, so they travel with your backup. Nothing is ever written into Claude Code's own files.

Finding a conversation

The sidebar (Activity Bar → clock icon) lists every conversation across every project, most recent first, and searches the full text of every message. Filter by project, by author, by tag, and optionally include subagent traffic.

Search everything, the names, or an ID. All text looks inside every message and answers with the conversations that matched, each showing a few of its matches and how many it holds. Names only searches what conversations are listed under — including the name a conversation had before you renamed it — and answers with the list itself. ID only finds a conversation from its session id, and a few characters are enough: paste bd5040b6 from a note or a --resume command and you get that conversation, including when the id belongs to one of its forks.

Pin what you are coming back to. The list sorts by last activity, which says what you just did rather than what you intend to do next. The star beside a title pins that conversation to the top, above a rule separating it from the rest, and the pin is kept in the archive so it survives a reinstall. There is no limit, and nothing is ever unpinned for you — a pinned block that has grown into a second unsorted list is visible, which is the point.

Tags narrow the list. A row of chips offers whatever your history actually contains — one you have pinned, a background session, one held only in the archive, either half of a conversation that was split, one you have named, one recorded on another computer. Selecting two means both: continues → together with ← continued finds the middle of a split chain. With a search term active they narrow which conversations' matches are shown, and say how many were held back.

A conversation that was split is linked to its other half, at the top of the transcript, at the end of it, and as a chip on both rows in the list. When it ran out of context and carried on elsewhere, that reads continues → and ← continued. When Claude Code instead wrote one conversation into two files at once — which happens, and leaves the same messages in both — it reads ⇄ overlaps, says how many messages the two share, and which file the conversation went on in. The links come from a record in the files rather than from what the conversations are about, so a session you start fresh yourself is not linked to the one before it.

Work from another computer is marked. A transcript recorded under a different user account reads, searches and exports like any other, but is left out of every figure on the dashboard — so the list says which ones those are.

Subagent traffic means the reports a finished agent sends back. They are long, so a search excludes them unless you tick subagents — and when it does, it tells you how many matches were held back rather than hiding them silently.

Forked conversations are grouped. Branching copies a conversation into a new session, so one conversation can span several files; members are collapsed together and each stays individually resumable.

Each result offers Copy ID, Copy resume cmd (claude --resume <id>), Transcript and Delete. Clicking the title opens the transcript.

In an open transcript the session id in the toolbar copies itself when clicked.

Delete asks for confirmation in a modal naming the session, its directory, its last activity and its message count. It removes every copy — the transcript, anything archived for it, and its archived file versions — and says how many before you confirm. The session stops being resumable, and nothing is left that would bring it back.

Analytics

Cmd+Alt+A, or the button in the sidebar.

• Headline tiles: total tokens, prompt count, cache hit rate, notional cost.
• Token burn for the session and weekly windows, last-hour usage, when the five-hour window frees up, and per-hour usage across the last 24 hours.
• Token composition, per-project and per-model breakdowns, per-day volume.
• Safeguard fallbacks — see below.

When a safeguard changed the model. A model's safeguards can flag a message and Claude Code will retry the turn on a different one. Claude Code tells you at the time, in the terminal; the assistant never sees it. Read the conversation back later and the transcript would show only a change of model, with nothing to explain it. Backscroll marks the change in the transcript where it happens, says what caused it, and shows the verbatim note in its place. The dashboard counts them: how many fallbacks, which categories they were flagged under, which model gave way to which, and what share of your answers came from a fallback model — which can be surprisingly high if you work on security or biology topics. A single flag can account for a long run of replies, since the fallback stays in effect until the model is changed again; the bands in the transcript show exactly where each run began and ended. These figures cover every session in your history, live and archived, rather than only what this machine spent. Withdrawn replies are never displayed; Claude Code does not write them to the transcript at all.

Two percentages, while we work out which one is right. The meter counts raw tokens, because on a subscription that is what you actually spent — the cost figure is a "what if", not a bill. But a plan's allowance is not weighted like raw tokens: a cache read costs a tenth of fresh output and is most of a long conversation, so the same token count can be a very different share of your week. Beside the bar is that same window weighted the way cost is, and where the two disagree by more than a few points it says so. Whichever tracks your real usage across the next few calibrations is the one that will remain.

Plan limits. Your plan's ceiling is not recorded anywhere on disk, so the dashboard learns it from you: run /usage in Claude Code, paste the whole output into Recalibrate from /usage, and press the button. Reset times and percentages are read from it and the limits worked out from the tokens already counted in those windows. /usage reports whole percentages, so a limit is a range rather than a point — calibrating late in a window gives a tighter estimate. The limits in effect, and when they were last calibrated, are shown on the page.

If the terminal will not give up a clean selection, two other routes are there: type the two percentages by hand, or press Read /usage for me, which runs claude -p "/usage" for you — your Claude Code, your login, and the only thing in Backscroll that reaches the network. Two things to know about it. Its output is shorter than the panel's: it carries the percentages and reset times but no promotion line, so a promotion already recorded is left untouched rather than guessed at — pasting stays the better path, and the only one that keeps promotions right. And each run leaves a short session in your history, which the sidebar hides under /usage runs; Backscroll: Delete usage readings… sweeps them when you have had enough of them.

Free and paid

Reading is free and always will be. Every conversation, however old, with search across all of them — no cut-off date, no history held back. Backscroll's whole point is that Claude Code deletes transcripts on a timer; putting your own past behind a paywall would be a strange way to make that point.

The free export is a real trial, not a demo: export a conversation you actually care about. Re-exporting that conversation never counts as a second use, so you can adjust and run it again.

A licence is two things: your Order ID and a key. The Order ID is on your Gumroad receipt, and the key is sent to you. Run Backscroll: Enter licence key… and give it each in turn — copy and paste both, since the Order ID is case-sensitive.

The key is a signature over the Order ID, so neither half means anything alone — and the key does not contain the ID. That is deliberate: passing on a licence takes a conscious act rather than an innocent paste, and nobody hands over something identifying without realising it.

It is checked on your machine. No account, no activation, no network request — the same guarantee as everything else here. It never expires, works on every machine you own, and keeps working offline.

A licence can be withdrawn if it is published. Your key is issued to you, and sharing or posting it publicly is not permitted. If a key and its Order ID appear in public, a later version can decline that pair, so that one published licence cannot serve everyone who finds it. A version you have already installed keeps working under the terms it came with.

Being declined is not an accusation — a licence can be published by someone other than the person who bought it. If it ever happens to yours, get in touch and a replacement will be issued once your purchase is confirmed.

If you use Settings Sync, your licence travels with it. VS Code carries the Order ID and key to your other machines under your own sync account, so a second machine does not ask for a receipt you may no longer have. Backscroll itself still makes no network request — VS Code does the syncing, and turning it off leaves each machine to be entered by hand.

Keep the key alongside your receipt anyway: entering the licence on a machine that does not sync needs both halves.

Install

Install the .vsix from VS Code:

Extensions view (Cmd+Shift+X) → ⋯ menu → Install from VSIX… → choose the file → Reload Window

or from a terminal:

code --install-extension backscroll-<version>.vsix

Updating is the same step with a newer file — it replaces the installed version in place, and there is no need to uninstall first.

If you used this under its former name, remove local.claude-history-plus afterwards: VS Code treats the renamed extension as a separate one, so both would otherwise be installed at once. Your settings carry over.

Commands

Everything is reachable from the Command Palette (Cmd+Shift+P / Ctrl+Shift+P), typing Backscroll.

Settings

Two things to know about the numbers

The cost figure is notional. It applies Anthropic's published list API rates to your local token counts. On a Claude subscription you are not billed per token, so read it as a measure of workload rather than a bill. What you have consumed of your plan is what /usage reports.

Only surviving transcripts are counted. Claude Code deletes transcripts after cleanupPeriodDays, which defaults to 30. Raising it in ~/.claude/settings.json keeps more history; anything already deleted cannot be recovered or counted.

Exporting

Export a conversation as Markdown… writes the transcript to a file you choose. It is the same Markdown the Raw view shows, so what you read is what you get.

A conversation with images is written into a folder of its own, holding the .md and an images folder beside it, so the two cannot be separated by moving one of them. Links are relative, so the folder works anywhere you put it. Images are not embedded: a conversation with many screenshots would produce a file too large to open. A conversation without images is written as a single .md file, since there is nothing to keep together.

File history

Claude Code keeps a copy of every file it edits. Backscroll reads those copies, so you can see what a file looked like earlier in a conversation and put it back.

To get an earlier version of a file:

1. Cmd+Shift+P → Backscroll: File history…
2. Choose the file. The list shows how many versions are kept for each.
3. Choose a version. It opens as a diff against the file as it is now, so you can see exactly what would change.
4. A notification appears with two choices:
   • Save as a copy… — writes the old version to a new file you pick, leaving the current one alone. Start here if you are unsure.
   • Restore over the file — replaces the current file with that version.

If you dismiss the notification before choosing, run the command again — the diff on its own changes nothing.

Restoring safely

Restoring is the only thing in Backscroll that writes to your own files, so it is deliberate at every step:

• You always see the diff before the offer appears.
• Before overwriting, whatever is in the file now is copied to <name>.before-restore-<time>.<ext> in the same folder. The confirmation names that file, so you know where your work went.
• Undo appears after restoring and puts the file back as it was.
• A file that already matches the chosen version is left untouched.

If a file has been renamed or deleted since, there is nothing to compare against, so the chosen version is shown against the one before it instead.

What is kept, and for how long

Claude Code prunes these backups within weeks. With archiving on, Backscroll keeps its own copy of every version — a version Claude Code has since removed is read from the archive and marked from archive. Without archiving, versions disappear as Claude Code removes them; those are still listed, marked no longer kept, rather than quietly omitted, because a safety net you can see the holes in is worth more than one you cannot.

Archiving

Claude Code removes transcripts on a timer, and once one is gone it cannot be recovered. Backscroll can keep its own copy outside that directory, where the timer cannot reach.

Turn on backscroll.autoArchive and everything worth keeping is copied shortly after VS Code starts, and again whenever a transcript changes on disk: every transcript, every version of every file Claude Code has edited, and your CLAUDE.md, settings, custom themes and memory files — a session already current costs nothing, since only changed files are copied. Backscroll: Archive all sessions now does it on demand, and Backscroll: Reveal the archive folder opens it.

Configuration is taken by an explicit list — CLAUDE.md, settings.json, settings.local.json, themes, agents, commands, skills, the CLI history and the memory files — rather than by copying the directory. Caches, job scratch space and daemon state stay where they are, and nothing that looks like a credential is ever copied.

Archiving needs VS Code to be running — it happens shortly after startup and then follows changes as they are written. Work done while VS Code is closed is archived the next time it opens, so the only history at risk is a session Claude Code deletes before VS Code is next started.

Archived sessions appear in the list and read exactly like live ones, so a conversation stays searchable long after Claude Code has forgotten it. Copies are never moved, so claude --resume keeps working until Claude Code itself removes the original.

A session Claude Code has since deleted is marked archived in the list and carries a Restore button; one that is merely backed up looks no different from any other, because nothing about it has changed.

Restoring is only needed to make claude --resume work again on a session Claude Code has already deleted — reading one never requires it. The button on the card does it, as does Backscroll: Restore an archived session…, which lists every session held only in the archive. It will not overwrite a transcript that is already there, since that could be a session in progress. Whether the restored session appears in claude --resume is Claude Code's own behaviour; a restart may be needed.

Compatibility

Transcripts are an internal format of Claude Code and may change between its releases. If an update ever breaks how a conversation renders, that is where to look first.