What shipped, in plain words.

Installing with npm 12 produced a Turnlog that died on its first command with Could not locate the bindings file. npm 12 no longer runs dependency install scripts by default, and the SQLite module Turnlog used needed one to fetch its native binary — so the install succeeded and the binary never arrived. Turnlog now uses the SQLite built into Node itself: nothing to compile, download or approve, on any npm.

No native module means updating on Windows can no longer trip the EPERM cleanup warning — there is no loaded library for npm to fight over. Updating from 0.13.0 or older may show it one last time; the update still succeeds.

Your index is untouched by the switch. The same file opens as before, and search, replay and spend read exactly what they did — verified by indexing one corpus with both engines and comparing every table byte for byte. Node.js 22.13 or newer is now required, which is where Node’s SQLite left its experimental flag behind. The one runtime dependency left is a file watcher.

A Commands screen, and a cmd: operator. Running commands is 40% of everything agents do, and it was the one big dimension without a cross-session home — “what was that ffmpeg invocation I finally got working in March” meant scrolling a session you first had to remember. Commands (next to Files) groups every command any agent ever ran, with paths, ids and numbers normalized away so reruns fold together — run counts, failure counts, and every verbatim run one click from its place in the replay. cmd:"ffmpeg -i" after:2026-03 is now a query, in the UI, the CLI and over MCP. Works for every agent, because the command is read per adapter: Claude Code’s Bash, Codex’s shell and exec calls, Cursor’s terminal tool.

A “notable” sort. Pins, notes, tags and bookmarks all exist — and if you are like most people you have barely used them. The sidebar now ranks sessions by what the index already knows: length, cost, errors hit, and how much of the work happened in files your other sessions keep touching — each as a percentile, summed. No model, no setup. Pins still outrank everything: a pin is the one notability signal you stated outright.

MCP calls read as “server · tool” instead of mcp__Server__tool_name — in the replay, in search hits, and on refine chips. tool: matches the bare tool name without the mangled prefix (which still matches too), and a new server: operator narrows to everything one MCP server did.

tool:Bash is:error matched nothing, ever — the error flag lives on a tool’s result and the name on its call, and the filter required both on one message. Scoped to a tool, is:error now means the failing runs of it, one hit per failure.

The index’s write-ahead log is trimmed as live sessions index, not only at startup — a machine that leaves Turnlog running no longer regrows it between launches.

The index was quietly taking about twice the disk it reported. SQLite keeps a log of recent writes beside the database, and Turnlog counted only the database — so a card reading 780 MB could be 1.5 GB on your drive. Nothing trimmed that log either: the automatic trims never shrink the file and give up whenever a search is mid-query, so on a machine that leaves Turnlog running it only ever grew. It is trimmed now after every indexing pass, after a prune, and after building or dropping deep search, and every place that reports a size counts the whole footprint. Nothing is lost in a trim — the space just comes back. Existing indexes shrink on their next scan; on a large one that is hundreds of megabytes.

Repack reports what it actually returned to your drive rather than what it rearranged inside the file, and turnlog doctor prints the same honest number.

Search by git branch. Every agent records the branch it worked on, and Turnlog threw it away. branch:feature/auth is a dimension now, composing with the whole grammar — branch:main is:error after:7d answers “what broke on main this week”, which no cost tracker or log scrubber can ask. It matches exactly, so branch:main never drags in main-experiment, and it joins the refine chips. Stored per message rather than per session: a session that crossed branches belongs to each of them, not to whichever it ended on.

“Have I solved this before?” Every replay carries a quiet related row — the other sessions that talk about what this one talks about, each link landing on the message where they say it rather than at the top of a 3,000-message replay. It is also an operator, like:<session-id>, so it combines with everything else and an agent using Turnlog as memory gets it through the existing search tool. Built from the session’s own rarest words — rarity is what separates a distinctive word from filler, so there is no stopword list and no model anywhere near it.

The sidebar keeps a rail when collapsed instead of vanishing: your sessions as tiles, in the same order and honouring the same filters, still showing which one you are reading, which are pinned and which are running. The open/close control stopped moving too — it used to jump to the header when closed, so it was never where you left it.

Public documentation at turnlog.dev/docs: a tour of every screen, guides for search, annotation, MCP setup and sharing, and reference pages for every search operator, CLI flag, settings key and MCP tool.

The files you edit by hand mid-session were unsearchable. Claude Code records the edit with a snippet of what you changed, and only the filename was indexed — so the change itself, the thing the agent then reacted to, was findable by nothing. The same was true of a file attached with @ and of an attached directory. All three are indexed now, and the replay folds open to show them.

Side-by-side diffs had uneven halves. The columns were sized from the hunk header rather than from the widths declared for each side, so “before” and “after” got whatever space was left over. Equal now, at any window size. The bookmark toggle in a replay also sat above the line it marks — on compact rows by half a row.

A new Turnlog mark, in the header, the sidebar and the browser tab, still inverting with your theme. And the startup banner names each log source for the agent that wrote it, saying read-only on every line — Claude Code’s was labelled “Projects”, which now reads as Turnlog’s own Projects screen.

Every repo gets a page, and a Projects screen to find them. One place per project: every agent’s sessions interleaved newest-first, who worked there and how much, what it cost, the files it touched most, its tags, and a live row when something is running in it right now. The header’s new Projects screen lists them all — filterable, sortable by recency, sessions or spend. Project pages existed before; they were reachable only if you already knew to search for one. If a folder has since moved or been deleted the page says so — the history is unaffected, because agent logs never lived in the repo.

A bookmarks page. The bookmark button in the header, or ⌘K → Bookmarks: every moment you ever marked, across every session, newest first. Bookmarks now carry a caption written from the replay, because thirty unlabelled marks are thirty message prefixes to re-read. Captions travel with your annotations export and survive re-indexing.

Recurring failures. Search is:error and the same failure appears grouped across runs above the results, ranked by how many sessions hit it — “this happened in 13 sessions across 3 projects”. Click one to land on a real occurrence. The grouping is mechanical — paths, ids, numbers and quoted payloads replaced, first sentence as the key — so it is a rule you can read, and no model is involved.

Screenshots show in the replay. The images were always in your logs — and in the index — but the replay only ever said [image]. They render as thumbnails you click to enlarge, both what you pasted into a prompt and what a tool handed back. Decoded from the record you already have: nothing is fetched, nothing new is stored.

Diffs read side by side. A unified | split toggle sits wherever diffs are the point — the replay’s diffs lens and the file-history screen — and every diff in the app follows the choice, remembered between launches. Unified stays the default.

A copy button on every prompt, on hover. Finding what you asked three weeks ago is usually the first half of asking it again.

Codex and Cursor sessions replay as richly as Claude Code ones. Their tool calls show what they actually ran — Codex’s exec as highlighted code, Cursor’s tools with their real arguments — and pair with their results; Codex reasoning becomes a collapsible thinking block. The replay used to understand only Claude Code’s record shape and fall back to plain text for everyone else. It now recognises each agent from the record itself, and an unfamiliar shape still degrades to plain text rather than breaking.

Codex tool output was missing from the index entirely. Codex writes a tool’s result as a list of text blocks, a shape the adapter did not read, so every exec result was stored with empty search text — command output, file contents, test results, none of it findable. It is indexed now, and the next scan after updating repairs existing indexes automatically.

Turnlog reads Cursor. Both kinds: cursor-agent CLI transcripts under ~/.cursor/projects index like any other agent’s logs (subagent runs included), and the IDE’s chats are extracted from a copy of Cursor’s own state database — the original is never even opened. Every era of the IDE’s storage format is read; each conversation becomes a session with its title, its workspace’s project, and the cost Cursor itself recorded. agent:cursor narrows any search, and Cursor work on a repo lands in the same project as the Claude Code and Codex work on it — one timeline per repo, whichever agent you pointed at it.

Codex sessions showed no costs at all. The pricing table only knew Claude models; it now covers OpenAI’s — the gpt-5.6 family through the o3 era, with OpenAI’s own cache economics — so the modelPricing workaround is no longer required. Existing indexes reprice themselves on the next scan. Costs stay labeled estimates.

turnlog doctor. Everything a bug report needs in one paste: versions, resolved paths, settings, index facts per agent, SQLite’s own integrity verdict, index-vs-disk drift. Strictly read-only — safe to run against a broken index.

Shared HTML exports fold like the app. Each prompt is a collapsible turn with its tool and error counts, so a 300-turn session arrives as 300 scannable lines instead of an endless scroll. Native <details>, no script — works with JavaScript off.

A sixth MCP tool, get_context. An agent using Turnlog as memory can ask how full a past session’s context window was and where it was compacted — worth checking before trusting that session’s late answers. Read-only, like the other five.

Agent badges wear the official brand marks. Cursor’s is monochrome by brand, so it flips with your theme — black on light, white on dark.

Updating on Windows no longer strands the old version. npm can’t delete the old install while a running Turnlog has it open, and used to leave it behind as a stray directory with a scary warning. The next start cleans it up, and doctor reports any it finds.

turnlog demo failed on Windows — the bundled sample sessions were resolved through a file URL’s pathname, which on Windows points nowhere. Nothing else was affected.

turnlog demo. The real app against bundled sample sessions, in a scratch index rebuilt fresh each run. Your own history is never read, and an undismissable banner says “demo data” the whole time. Exists so you can see what Turnlog does before you have any agent history.

Deep search. An opt-in index that matches inside words — half an error string, a fragment like eWebSock, part of a UUID. Costs several times the index’s usual size, which is why it’s a choice; a words | inside-words toggle appears once built, and every operator still narrows it.

Session tags. Free-form labels — refactor, billing, wip — on any session, from any agent. Filter the sidebar to one, narrow any search with tag:billing, and they survive re-indexes and travel with annotation export.

Refine chips and agent:. Under the result count, a row of what your matches actually contain — agents, tools, kinds, projects, with counts; click to narrow. Plus agent:codex / agent:claude as a first-class operator.

The Now card. While any session is being written, the home screen shows what your agents are doing this minute — agent, project, your last ask, cost so far, context fullness — and clicks through to the live-tailing replay. Two agents at once show side by side.

The spine is keyboard-navigable. j/k move between turns, enter expands, e cycles through errors. A fresh index also seeds three example saved searches, because the operator grammar is the most useful and least discoverable thing in the app.

“Turns” that were never turns. A session’s message count was labelled “turns” everywhere it appeared; the number was always right and the word always wrong. It now says events. The Spend screen’s query filter also learned the full operator language, and quoted values with spaces (tag:"needs review") now work.

The MCP tools caught up: list_sessions says which agent wrote each session and lists its tags, and search advertises agent: and tag: — an agent recalling past work can now tell whether the work was its own.

The README caught up with the app — it still described a Claude-Code-only tool, two releases after that stopped being true. npm renders the README from the published tarball, so shipping the correction needed a version. No changes to Turnlog itself.

Turnlog reads OpenAI Codex sessions. Rollouts under ~/.codex/sessions index automatically when the directory exists — read-only, like everything else. Search, spine, replay, spend and disk all work; sessions wear a CODEX badge; the resume button copies codex resume <id>. Codex work on a repo lands in the same project as your Claude Code work: one timeline per repo, whichever agent you pointed at it. Codex token counts are exact (read per-response from the rollouts); GPT pricing isn’t bundled, so costs appear once you add rates via modelPricing.

A visual overhaul. New type — Plus Jakarta Sans for the app’s own voice, Space Mono for anything quoted from your logs — and a reworked palette where colour means one thing at a time: green is success and nothing else, diffs moved to teal, errors got their own red. Every button in the app frame is now one control instead of six near-identical implementations.

The sidebar got a quick filter — type a few letters and the list narrows by name, title, or project across your whole history — with every other control in a filter popover behind one button, dotted whenever something hidden is narrowing the list.

Light-theme controls sitting on the bare background were nearly invisible; agent badges were below the legible floor; inline code was four shapes. All one language now.

Search-anchored timeline. A hits | timeline toggle turns every matching session into a dot on a time axis — project-colored, sized by hit count — answering “when did this keep coming up?” over the full match set. Clicking one lands at its first hit.

Context-window timeline. The stats panel draws how full the window was at every response, with the peak called out, compaction boundaries marked on the curve and as jump chips, and a “compacted” chip on the spine turn where it happened.

Command palette. ⌘K / Ctrl-K anywhere: a fuzzy switcher over sessions, screens, and saved searches — and anything typed is one Enter from a full-text search.

Files joined the query language. path:api.ts narrows any search to sessions that touched a matching file; the Files screen gained the reverse filter. Date operators take plain words now: after:7d, before:today.

Your curation travels. turnlog annotations export|import moves pins, names, notes, bookmarks and saved searches between machines. A third export format for scripts: --format json. Open-in-editor from the diffs pivot via editorCommand. Press ? anywhere for a real shortcut cheat sheet.

List rows everywhere dropped their hairline rules for rounded hover pills, content uses the full window width, and find-in-session is fully keyboard-driven.

Sessions wear Claude Code’s own titles — the name CC generates (or the one you set there) shows everywhere and is searchable. A Turnlog custom name still wins.

The biggest unknown-record types are now understood. File and directory attachments render as searchable chips, permission-mode switches and plan-mode entry/exit are visible. Unrecognized events on a real corpus dropped from ~35% to ~12% — and the health panel’s count now means actual format drift.

Share panel. The three loose export buttons became one popover: pick markdown or web page, flip redaction on with the scrub list spelled out, and export a turn range instead of the whole session — partial exports are labeled “excerpt”.

Continue a session from Turnlog. A play button copies the ready-to-paste cd <project> && claude --resume <id> — for a resumed conversation it targets the part that carries the whole history. Annotations joined the search language too: is:pinned, has:note, has:bookmark.

Spend no longer double-bills resumed conversations. A 3-part chain’s shared prefix used to count 3× in every number; money and tokens now count each message once, on the day it actually ran. Interrupting Claude and retyping also no longer leaves a ghost turn — abandoned attempts fold into a marker you can open.

Resume chains are stitched together. Parts of one conversation are linked: the sidebar lists the latest part with a badge for the count, and the replay header gains part-by-part navigation.

Subagent transcripts nested in replay, folded under the Task call that spawned them.

Static HTML export — any session as one self-contained styled page, nothing loaded from the network — and redaction (--redact) on every export format.

Index health panel: files and events indexed, index size, files the scan couldn’t read and why, and the unrecognized-record count. Format drift as a number instead of silent loss.

Preferences survive restarts — theme, sidebar, filters and view choices now live in the local index instead of a localStorage the random port kept resetting.

Agent memory over MCP. turnlog mcp serves your session history to any MCP client as read-only memory over stdio, with five tools. Register: claude mcp add turnlog -- npx turnlog mcp. No network, no writes.

Message bookmarks with a jump rail, stored in the local index.

turnlog search from the terminal — the same operators as the UI, grouped hits, --json, and deep links that open the UI at the match when the app is running.

Disk usage view — sessions ranked by what they weigh on disk, reveal-in-file-manager per row. Read-only; deleting stays yours.

Search operators — tool:, kind:, is:error, project:, model:, before:, after: — combinable with text, plus saved searches as one-click chips.

Cross-session file history: pick a path, see every session that touched it, expanding into the edits in order with jumps back into context.

What’s New in the app — release notes in plain language, shipped inside the package.

The diffs lens opens as a per-file pivot instead of a chronological filtered log.

Stop Turnlog from the browser — a power button that arms first, shuts the CLI down cleanly, and leaves a copyable npx turnlog to start again.

Spend periods for one year and all time; the chart starts at your first recorded day.

Session notes surface as a sticky-note marker; pinned sessions get a warm row wash.

Pin sessions, give them custom names and notes — stored in the local index, surviving reindexes — and reveal any session’s file in your file manager.

The hide-empty filter now catches real-world empties; sessions with recorded cost are never hidden.

Empty sessions can be hidden, remembered across launches.

A consistency pass: one emphasis weight, unified label tracking, radii snapped to the scale.

The sort menu lists “by activity” first, matching the default.

Republished to npm. The package was fully unpublished on 20 July; npm permanently retires every version number it has seen, so the return required a new one. Functionally identical to 0.2.4.

New bundled typeface and a browser-tab icon matching turnlog.dev; the smallest text sizes went up a point.

The sidebar became a floating card sorted by activity; text arrows gave way to real icons; micro-interactions eased.

Sort by activity, and a pulsing dot on sessions active in the last five minutes.

Tooltips near the right edge no longer squeeze and wrap word by word.

Live updates, pushed. A dependency-free event stream refreshes the UI about a second after a session file changes; the old seven-second blind poll is gone. Token usage surfaced wherever money already was.

Spend zero-fill used UTC days while the server bucketed local ones — now local and DST-safe.

Cost and token estimates were roughly 2.5–3× too high. Claude Code repeats the same usage object on every content-block line of a response — Turnlog summed them all. Usage is now counted once per API response, and existing indexes rebuild automatically.

Subagent transcripts are indexed — searchable, with usage counted toward the parent session.

Injected-context records classified as meta rather than prompts, so they stop creating false turns.

npx turnlog starts a localhost-only server and opens the web UI: full-text search and session replay over your Claude Code history, with a turn spine, lenses, and in-session find.

Incremental indexing with live file watching, and crash-free parsing of an undocumented format — unrecognized records are kept, never dropped.

Markdown export, a spend view priced from a shipped table (all costs labeled estimates), and localhost hardening from day one: loopback-only bind, Host and Origin validation, a per-launch token.