Skip to content

Releases

v2.1.1

Choose a tag to compare

@github-actions github-actions released this 13 Nov 05:22

First v2 release go install can fetch: the module path is now github.com/kurofune/claudit/v2. Same features and prices as v2.1.0.

Changed

  • The Go module path is now github.com/kurofune/claudit/v2. Install with go install github.com/kurofune/claudit/v2/cmd/claudit@latest. v2.0.0 and v2.1.0 could not be installed with go install: their go.mod still named github.com/kurofune/claudit, and Go's major-version rule makes the module proxy reject a v2+ tag on a module path without /v2, so go install github.com/kurofune/claudit/cmd/claudit@latest kept installing v1.9.2. Those two tags stay uninstallable through go install for good (their GitHub Release binaries still work); this release is the first v2 tag go install can fetch. Code importing claudit's packages must add /v2 to the import path.

v2.1.0

Choose a tag to compare

@github-actions github-actions released this 13 Nov 04:47

Pricing refresh against the live pricing page on 2026-11-12: Claude Fable 5.2 and Claude Mythos 5.2 are added. This release also ships Codex session support, the Sessions list and the session page.

Upgrade if you run Fable 5.2 or Mythos 5.2. v2.0.0 and earlier price every Fable 5.2 and Mythos 5.2 turn at $0. Coming from v1.9.2? Read 2.0.0 below first: it removed the report and diff outputs.

Added

  • Codex sessions. claudit serve reads Codex CLI rollouts ($CODEX_HOME/sessions, else ~/.codex/sessions; --codex-root overrides, an empty value turns it off) beside Claude Code's logs. Each model response is one turn with provider codex; exec / exec_command shell calls are reported as Bash calls, bucketed by their shell command (an exec whose command cannot be read statically keeps the name exec), and a non-zero exit code marks the call failed. A subagent rollout is flagged sidechain and nests under its parent thread's session in the Agents view. Compressed rollout-*.jsonl.zst archives are not read yet.
  • GPT-6 prices. The bundled table prices codex/gpt-6-astra, codex/gpt-6-sol, codex/gpt-6.1-sol and codex/gpt-5.5 at OpenAI's Standard rates (fetched 2026-10-31), with the long-context rates for a turn whose prompt exceeds 272K input tokens. codex-auto-review is priced at $0 because OpenAI's Codex FAQ (https://help.openai.com/en/articles/11369540-openai-codex-faq) states auto-review checks are free, so it no longer appears in the unpriced-model warning.
  • Provider filter. A Provider control under the date range (All · Claude Code · Codex) narrows every view to one agent tool. Like the date range, it lives in the URL (?provider=claude-code or ?provider=codex; All drops the key), so a reload or a shared link keeps it; any other value is a 400. Tab reaches it and the arrow keys switch it. /_claudit/api/cost and /_claudit/api/tools gain a sessions count, and each Agents session a provider field.
  • Per-provider totals on the Overview. With All selected, one tile per provider shows its sessions, turns, dollars and share of the window's dollars. Every provider's dollars, on each tile and on the headline Total cost, are labelled API-equivalent, with one tooltip for all of them: the tokens priced at API list rates, while the subscription bills differently. /_claudit/api/overview gains providers.
  • Codex in the Agents view. Codex sessions carry a Codex badge in the Feed, Tree, Timeline and Conversation; the Conversation shows Codex's assistant replies, and every reply now lists its tool calls with their input, an output snippet and a failed mark.
  • Session index and paged story endpoints. GET /_claudit/api/sessions answers one light row per session in the filter window (no steps or tool snippets): its prompt-family key (the first line of its first real prompt with wrapper blocks stripped and bead ids, file paths, hashes and numbers blanked to _), the blanked remainder, title, outcome, model, cost, turns, commands, unresolved failures and whether it was active in the last minute. GET /_claudit/api/sessions/story?session=<id>&prompt=<i>&offset=<n> pages one session's story by user prompt, 200 turns at a time, with the sub-agents started in that span, each Codex command's exit code split off its output, and counts of the turns the window or replay dedup hid. An unknown session, prompt or offset is a 404. web/api.js gains fetchSessions() and fetchSessionStory().
  • Session story ("What happened"). web/session-story.js exports paintStory(host, sessionId, turnUuid): one user prompt at a time, the prompt and each agent message verbatim, each message's commands under a counted header (7 commands · 2 unresolved · 1m 12s, the model cost of those turns beside it), one row per call with its clock time, ✓ / ✕ / …, the command on one line and its duration, idle gaps over five minutes as rows, sub-agents nested under the step that spawned them (or placed by start time as "parent step unknown", overlapping ones under one "N agents in parallel" header), wrapper blocks folded into a disclosure, and the date-filter and replay counts disclosed at the top. A step row expands on click or Enter to the turn's thinking and the call's exact input and output, with Show full fetching the untruncated text and a Codex exit-code chip. Previous / Next prompt, a jump list of every prompt, a row that loads the next 200 turns, an in-page search and a turn deep link that opens the page carrying the turn. The story endpoint accepts ?turn=<uuid> in place of ?prompt/?offset to answer that page, and each page carries every prompt and agent message whole (read back from the session log past the 2,000-rune parse snippet, Claude Code and Codex alike), each call on its own row with input_key (the whole input's identity, which decides whether a failed command later succeeded) and input_full when input is cut. Overlapping sub-agents spawned by successive turns share one parallel header, each linking back to the call that spawned it. /_claudit/api/agents/full finds a Codex sub-agent thread's turns and calls under its root session id, reads Codex turn text, and reads .jsonl.zst rollouts. The Sessions route mounts it (pending).
  • Sessions list. The Agents nav entry opens a list of every session in the window grouped by prompt family: each header shows the family key (blanked tokens drawn as …) and its count, groups ordered by their newest session, and each row the blanked remainder (or the title), the agent's last line verbatim, a provider chip, cost, duration and N failed for unresolved failures. A search over key, remainder, title, outcome and project; All / Active in the last minute / Had unresolved failures chips with counts; Newest / Cost / Duration sorts within each family; an "Active in the last minute" row pinned on top with each session's elapsed time; groups over 20 rows behind "Show N more". Arrow keys walk the rows, Enter or a click opens the session. The list refreshes in place on new data, keeping search, filter, sort, focus and scroll. #agents/<session-id>[/<turn-uuid>] opens a session page with the story, and Overview hotspot examples link there.
  • Session header. A session page opens with its title, project, provider chip, model, short id and last-activity time, then four tiles: Cost (the sum of every turn, marked API-equivalent), Duration (with N turns · M commands across the main agent and its sub-agents), Tokens (with the share re-read from cache) and Failed (unresolved failures: an errored call no later call with the same whole input (input_key) fixed in the same agent, naming up to two). Below them a strip draws one bar per model turn in time order, sized by what the turn added to context (Cost) or its duration (Time), failed turns in the danger color; past 120 turns consecutive turns share a bar. Hovering or focusing a bar names the turn, its time, its sub-agent and first command; a click or Enter opens the story at that turn, a sub-agent's turn opening its sub-agent there. Up to three Worth a look notes come from the five per-session detectors, dropping a retry storm or error cascade the same command later fixed and putting first a note on the turn the session ended on; a session with no tool calls has none. "Copy explain-this-session prompt" copies a fixed-template prompt for the agent that ran the session: its log paths, each unresolved failure (time, command, first output line) and the three costliest turns. The story endpoint gains context_cost_usd on every step, ?turn= of a sub-agent's turn answering the page its sub-agent started on, source_files on every page and ?whole=1, which answers every turn of the session in one payload with its title, project, provider, model and span.
  • Prices per provider. prices.yaml accepts a providers: map (provider name → models:), so a provider other than Claude Code can carry its own prices; a user entry replaces or adds one (provider, model) pair. Files in today's bare models: form keep working and price Claude Code.
  • Pricing: Claude Fable 5.2 and Claude Mythos 5.2. claude-fable-5-2, claude-fable-5-2[1m], claude-mythos-5-2 and claude-mythos-5-2[1m] are added at $8 input / $40 output, with 5m/1h cache writes of $10 / $16 and cache hits at $0.20/MTok, 0.025x input (the Fable 5.1 ratio). Fast mode prices them at $16 input / $80 output, with cache hits $0.40 and writes $20 / $32 at the same ratios off the fast input rate. Earlier builds had no entry for these ids, so every Fable 5.2 and Mythos 5.2 turn landed in unknown_models and added $0 to reported spend.

Changed

  • claudit describes itself as auditing Claude Code and Codex sessions. The --help banner, the README tagline and intro (which now name both log roots, ~/.claude/projects/ and ~/.codex/sessions, and the --codex-root flag), the AGENTS.md brief (which also drops the removed --json/--html outputs in favour of claudit serve and claudit watch) and the Agents view's guide paragraph no longer call it a Claude Code tool.

  • Codex shell calls fold into Bash. A Codex exec / exec_command call is named Bash at parse time, so grep is one Overview hotspot row (Bash: \grep`, its examples naming each call's provider), one Tools row and one Agents tool kind (exec, not other`) across Claude Code and Codex. The session's provider badge and each hotspot example's provider still say which agent ran the call.

  • Codex tool results carry context cost. Codex writes no prompt cache (a token is billed once as uncached input, then re-read at the cached-input rate), so its tool results used to cost $0 and never ranked as an Overview hotspot or a Tools-view context cost. A Codex tool result's context cost is now its share, by output size, of the next response's uncached input, priced at the model's input rate, plus every later response's cached re-...

Read more

v2.0.0

Choose a tag to compare

@github-actions github-actions released this 13 Nov 04:47

claudit is now a local daemon plus a TUI: claudit serve hosts the live dashboard and the Agents trace view, and claudit watch tails a session in the terminal. The one-shot file outputs — HTML, markdown and JSON reports, and diffs — are gone, along with everything that existed only to support them.

Migration: run claudit serve (or bare claudit) instead of claudit > report.html or claudit diff. Re-bookmark #cost, #tokens and #cache links as #spend (#spend/<tab>/tokens for token counts); the old hashes still redirect, but bookmarks should name the view that exists. Drop --redact from any scripts — it is now an unknown-flag error.

Removed

  • The report and diff subcommands. Bare claudit no longer writes a report to stdout, and claudit report / claudit diff exit 1 with unknown command. The HTML, markdown and JSON report renderers and the diff renderer are deleted.
  • --redact and ?redact. Redaction existed to make report files safe to share; with no report files it has no purpose. claudit serve --redact is an unknown-flag error, and ?redact in a URL is ignored like any unknown query key.
  • The /_claudit/api/sessions, /_claudit/api/sessions/{id}/timeline and /_claudit/api/cache routes. No dashboard view called the first two; the third backed the Cache view.
  • The Tokens and Cache views. Tokens merge into the new Spend view behind a Dollars / Tokens toggle; the cache hit ratio stays on the Overview.
  • The SPA's offline/static mode. The dashboard always fetches from the running daemon; there is no baked-data fallback.

Changed

  • Bare claudit runs serve. claudit and claudit --port=9000 start the daemon; claudit help lists exactly serve, watch and version.
  • #cost, #tokens and #cache redirect to #spend. #cost/<tab> lands on #spend/<tab>, #tokens/<tab> on #spend/<tab>/tokens, and #cache on #spend. The redirect replaces the history entry, so Back skips it.
  • Projects are grouped by git repo root. Every by-project surface — Spend by project, project trends, the ?project= filter and the Agents view's session labels — keys on the repo a session's cwd belongs to, so a repo's linked worktrees and subdirectories roll up into one project. Claude Code scratch directories that decode to nothing on disk, and deleted cwds with no surviving ancestor in a repo, fall into scratch and missing buckets.

v1.9.2

Choose a tag to compare

@github-actions github-actions released this 25 Oct 02:31

Pricing refresh against the live pricing page on 2026-10-24: Claude Haiku 5.5 is added, and the Sonnet 5.5 cache-read cut of 2026-10-07 is applied. Every other rate on the page was re-checked and is unchanged.

Upgrade if you run Haiku 5.5 or Sonnet 5.5. v1.9.1 and earlier price every Haiku 5.5 turn at $0 and over-report Sonnet 5.5 cache reads since 2026-10-07 by 2x.

Added

  • Pricing: Claude Haiku 5.5, with a prompt-length price tier. claude-haiku-5-5 and claude-haiku-5-5[1m] are added. Haiku 5.5 is priced by prompt length: a request whose prompt (input + cache reads + cache writes) is up to 100,000 tokens pays $0.10 input / $0.50 output, with 5m/1h cache writes of $0.125 / $0.20 and cache hits at $0.01/MTok; a prompt over 100,000 tokens pays $0.50 input / $2.50 output, with 5m/1h cache writes of $0.625 / $1.00 and cache hits at $0.05/MTok, on every token of that request, output included. Each turn is priced on its own. prices.yaml gains an optional long_prompt: block (threshold_tokens plus the five rate fields) to express this; fast mode still wins over it. Before this, every Haiku 5.5 turn landed in unknown_models and added $0 to reported spend.

Fixed

  • Pricing: Sonnet 5.5 cache reads cut from $0.20 to $0.10 per MTok on 2026-10-07. Anthropic cut claude-sonnet-5-5 and claude-sonnet-5-5[1m] cache hits from 0.10x to 0.05x input on 2026-10-07; claudit still priced them at $0.20/MTok, over-reporting every Sonnet 5.5 cache read since then. Turns from 2026-10-07 on now price cache reads at $0.10/MTok; earlier turns keep the $0.20 they were billed at, through a rates: period ending 2026-10-06. Cache writes and every other Sonnet 5.5 rate are unchanged.

v1.9.1

Choose a tag to compare

@github-actions github-actions released this 03 Oct 06:45

Pricing refresh against the live pricing page on 2026-10-02: Claude Sonnet 5.5 is added. Every other rate on the page was re-checked and is unchanged.

Upgrade if you run Sonnet 5.5. v1.9.0 and earlier have no entry for it, so every Sonnet 5.5 turn adds $0 to reported spend. Heads-up: this release also removes claudit watch --notify; drop the flag from any scripts that pass it.

Added

  • Pricing: Claude Sonnet 5.5. claude-sonnet-5-5 and claude-sonnet-5-5[1m] are added at $2 input / $10 output, with 5m/1h cache writes of $2.50 / $4 and cache hits at $0.20/MTok, the same card as Sonnet 5. Before this, every Sonnet 5.5 turn landed in unknown_models and added $0 to reported spend.

Removed

  • claudit watch --notify is gone. Desktop notifications on budget crosses and cost spikes (osascript / notify-send / PowerShell) are removed along with the internal/notify package. Budget and spike alerts still print in the watch UI. Passing --notify is now an unknown-flag error.

v1.9.0

Choose a tag to compare

@github-actions github-actions released this 24 Sep 08:04

Fast-mode turns are now priced at the fast rate. Upgrade if you use fast mode: earlier releases report those turns at half their real cost.

Changed

  • Fast-mode turns now price at the fast rate. claudit reads message.usage.speed from each assistant turn; when it is "fast", the turn prices from the model's new optional fast: rate block, with that model's own cache ratios applied on top. Bundled fast rates: Opus 5.5 at $8 / $40 (cache hits $0.40), Opus 5 and Opus 4.8 at $10 / $50. Earlier releases priced fast turns at the standard rate, so reported spend for fast-mode sessions roughly doubles after upgrading; that is the correction, not a regression. A fast turn on a model with no fast: block still prices at the standard rate. A prices.yaml overlay that replaces a model without a fast: block drops that model's bundled fast rate, consistent with per-model replacement.

v1.8.2

Choose a tag to compare

@github-actions github-actions released this 24 Sep 06:31

Pricing refresh against the live pricing page on 2026-09-23: Claude Opus 5.5 is added. Every other rate on the page, Fable 5.1 included, was re-checked and is unchanged.

Upgrade if you run Opus 5.5. v1.8.1 and earlier have no entry for it, so every Opus 5.5 turn lands in unknown_models and adds $0 to reported spend.

Added

  • Pricing: Claude Opus 5.5. claude-opus-5-5 and claude-opus-5-5[1m] are added at $4 input / $20 output, with 5m/1h cache writes of $5 / $8 and cache hits at $0.20/MTok. That hit rate is 0.05x input, not the standard 0.1x.

v1.8.1

Choose a tag to compare

@github-actions github-actions released this 02 Sep 05:16

Pricing refresh against the live pricing page on 2026-09-01: Claude Fable 5.1 and Claude Mythos 5.1 are added, and Claude Sonnet 5's scheduled price increase — which this project encoded ahead of time — was cancelled, so the table drops it.

Upgrade if you run Sonnet 5. v1.8.0 correctly encoded a rate increase that Anthropic then called off, so from 2026-09-01 an un-upgraded binary reports Sonnet 5 turns at $3 / $15 instead of the $2 / $10 actually billed. Nothing else in the tool changed.

Added

  • Pricing: Claude Fable 5.1 and Claude Mythos 5.1. claude-fable-5-1, claude-mythos-5-1 and their [1m] variants were absent from the bundled table, so those turns landed in unknown_models and contributed nothing to reported spend. Added at $10 / $50 base with 5m/1h cache writes of $12.50 / $20 — the Fable 5 card — but with cache hits at $0.25/MTok, a 0.025x multiplier off input rather than the 0.1x every other model uses. On a cache-heavy agent session that difference is most of the bill, so it is not a rounding detail.

Changed

  • Sonnet 5 is a flat $2 / $10 at every date; the 2026-08-31 rate cliff is gone. Anthropic cancelled the increase to $3 / $15 that was scheduled for 2026-09-01 and made the introductory rate standard. v1.8.0 shipped the cliff encoded as a dated rate period, which means an un-upgraded claudit over-reports Sonnet 5 spend from 2026-09-01 onward by 50%. The bundled entry now carries $2 / $10 with no rate history, so every turn prices the same regardless of date. Date-effective pricing itself is unchanged and still exercised by tests — no bundled model happens to need it right now.

v1.8.0

Choose a tag to compare

@github-actions github-actions released this 26 Jul 04:41

This release gives the price table a time dimension: each turn is priced at the rate that was in effect when it ran, rather than at today's rate. That closes a silent-error class arriving on 2026-09-01, when Claude Sonnet 5's introductory pricing expires — until now there was no correct value to put in the table, since one number had to serve both historical and future turns. It also adds Claude Opus 5 (previously missing, and therefore free), and makes the unpriced-model warning report what the gap is actually costing you.

Changed

  • unknown_models changed shape in JSON output — update any script that reads it. It was an array of model-name strings; it is now an array of objects, {"model": "…", "turns": N, "tokens": N}, sorted by unpriced token volume descending. This affects both claudit report --json and the /_claudit/api/overview endpoint. A script reading .unknown_models[] should now read .unknown_models[].model.
  • Sonnet 5 turns dated 2026-09-01 or later price at the standard $3/$15 automatically. The bundled entry now carries the standard rate, with the introductory $2/$10 recorded as a dated period ending 2026-08-31. Existing spend is unaffected — July and August turns still price at the introductory rate they were actually billed at — and no upgrade is needed when the cliff passes.

Added

  • Date-effective pricing. A model entry may now carry an optional rates: list of historical periods alongside its current rate:

    claude-sonnet-5:
      input_per_mtok: 3.00          # the rate in effect now
      output_per_mtok: 15.00
      rates:
        - until: 2026-08-31         # inclusive, UTC — introductory pricing
          input_per_mtok: 2.00
          output_per_mtok: 10.00

    Each turn is priced by its own timestamp. until is inclusive through 23:59:59 UTC on that date; periods may be listed in any order (the narrowest one covering the turn wins), so there is no oldest- or newest-first convention to get wrong; and a turn with no usable timestamp falls back to the current rate. The key is optional and purely additive — existing flat ~/.config/claudit/prices.yaml overlays keep working unchanged, and per-model replacement still swaps the whole entry, rate history included.

  • Pricing: Claude Opus 5. claude-opus-5 and claude-opus-5[1m] were absent from the bundled table, so those turns landed in unknown_models and contributed nothing to reported spend. Added at the Opus 4.8 rate card ($5 / $25 base; cache 0.50 / 6.25 / 10.00). Every other bundled rate was re-verified against the live pricing page on 2026-07-26 and none had drifted.

  • Unpriced-model warnings now quantify the gap. Every surface that lists unpriced models — HTML, markdown, and JSON — now reports the turn count and token volume behind each one, worst first, and says plainly that those turns count as $0 and the totals are therefore understated. Three unpriced turns and thirty thousand are very different problems, and the old warning couldn't tell them apart.

  • An unpriced-model warning on stderr. The default HTML path writes the report to stdout and previously said nothing in the terminal, so a stale price table surfaced only as totals that were quietly low. claudit report now prints the affected models and their volume to stderr.

Fixed

  • Flaky claudit watch painter test under -race on Windows. The Windows resize watcher polls TerminalSize on a ticker — Unix uses SIGWINCH and has no polling goroutine — so the test's deferred pipe close raced with that read and intermittently failed the windows-latest CI leg. Teardown now drains the reader to unpark the parked paint goroutine, so the painter stops the watcher before the pipe closes. Test-only; watch behavior is unchanged.

v1.7.0

Choose a tag to compare

@github-actions github-actions released this 16 Jul 00:50

This release grows the Agents trace viewer from a flat Gantt into a genuine trace waterfall — a session narrative strip, prompt-segmented bands, nested sub-agent rows, and a where-did-the-time-go breakdown — and corrects a class of cost double-counting for resumed/forked sessions so headline spend and every drill-down now reconcile exactly. It also adds Claude Sonnet 5 and legacy pre-Opus-4.5 pricing, ships prebuilt release binaries, and hardens claudit serve's memory footprint.

Changed

  • Reported cost drops for anyone with resumed or forked sessions. A resumed or forked session replays the prior transcript into a new JSONL file — same message.id and identical usage, but a fresh uuid/sessionId — and the old per-file dedup billed every replayed generation once per file it appeared in. Spend is now deduplicated by message.id at every aggregation point, so if you resume or fork sessions your totals will read lower than before (they were previously inflated). This is a correction, not a regression — see the three Fixed entries below for the mechanics. Single-session raw traces still show a forked session's full replayed context.

Added

  • Timeline is now a trace waterfall. The flat Gantt became a nested, prompt-segmented waterfall over three changes:
    • Prompt bands. Each prompt's turns render inside a labeled full-height band, so you can see which prompt a stretch of activity belongs to. Segmentation reuses the same boundaries as the Conversation lens, so the two always agree.
    • Nested sub-agents. Sub-agent rows now re-parent under the exact turn that spawned them (via parent_tool_use_id), with connector elbows and real depth indent — grandchildren nest one level deeper.
    • Progressive disclosure. Rows collapse by default (agent bar → turn spans → tool sub-spans), dropping a 13-agent / 754-tool session from ~1,300 always-on SVG nodes to ~210. Expansion state survives live repaints, and a cross-lens jump auto-discloses its target.
  • Session narrative strip. Above each session's waterfall, one clickable row per prompt segment shows the prompt snippet, turn/tool counts, spawned-agent chips with a pass/fail glyph, duration, and cost. Clicking scrolls the waterfall to that prompt's band and flashes it. Sub-agents attribute wholly to the segment that spawned them (spawn chain walked to the root prompt, time-containment as fallback); the outcome glyph reads the same error_count the waterfall's error pips do, so the strip can never disagree with it.
  • Where-did-the-time-go rollup. Each Timeline session card gains a stacked generation / tool / idle time bar (colors shared with the waterfall segments), and a new Insights → Time panel breaks the same split down per session (graph scope) or per agent, top-10 with an overflow note. Sub-agent waterfall rows also gain a pass/fail outcome chip.
  • Full turn reasoning and message on demand. The detail drawer's Reasoning and Message fields get the same show-full affordance tool I/O already has — the untruncated thinking and narration stream from the session JSONL on request, and stay sticky across live repaints. Static reports degrade to the snippet-only note.
  • Pricing: Claude Sonnet 5. claude-sonnet-5 and claude-sonnet-5[1m] added at the introductory $2/$10 base rates (in effect through 2026-08-31; a comment flags the revert to $3/$15 on 2026-09-01). Verified against the pricing page on 2026-07-03.
  • Pricing: legacy pre-Opus-4.5 rates. Sessions from before ~late 2025 were pricing at $0 because the exact-match table had no entries for the dated legacy ids. Added Opus 4.1/4 ($15/$75), Sonnet 4 ($3/$15), Haiku 3.5 ($0.80/$4), and the retired 3.x models at their last published rates (marked historical).
  • Prebuilt release binaries. Every v* tag now attaches cross-compiled archives for darwin / linux / windows on amd64 / arm64 to the GitHub Release — no local go build required.
  • net/http/pprof endpoints on the serve mux. Registered explicitly on the server mux (not http.DefaultServeMux); loopback-only bind is already the default and the report already exposes prompt text, so this adds no new exposure class.

Fixed

  • Resumed/forked replays no longer double-count in the headline. Dedup by message.id at each cost/token aggregation point — report, serve, diff, and the watch rolling-totals and watch --all combined panels. On the real corpus this removed exactly the duplicated volume (−53M tokens, −291 turns). Legacy single-line transcripts with an empty message.id can't be keyed and always count.
  • Drill-downs now reconcile with the deduped headline. The per-session (BuildSessionTimelines) and Agents (BuildAgentGraph) views still summed straight from raw turns, so expanding either showed spend that didn't match the headline (+291 turns / +$36 on the corpus). A new deterministic ReplaySet — the lexicographically-smallest source file is canonical, the rest are flagged replays — is now shared by both builders; every drill-down reconciles to the penny.
  • Per-session attribution is now deterministic across views. The headline aggregator deduped by first-Add-order, but snapshot turn order is non-deterministic (concurrent parse), so a forked session's cost could land on a different session in the Cache-by-session view than in the drill-downs, and shift run-to-run. The aggregator now dedups via the same ReplaySet the drill-downs use, making per-session/project attribution stable and consistent everywhere. (Also disclosed in the Tools guide: per-tool cost attribution overlaps by design — a multi-tool turn counts under each tool, so the column sums to more than total spend.)
  • claudit serve memory no longer balloons on large corpora. Two leaks: the render cache evicted by entry-count only while its (query, section, generation) keys stranded every older-generation entry as permanently-unreachable dead weight — on a corpus where the Agents payload is ~186 MB per entry, a handful of stranded entries pushed RSS past 3 GB. The cache now tracks total resident bytes and evicts to a byte budget (default 256 MiB) in addition to the count cap, and each store eagerly sweeps entries from older generations. Additionally, turn thinking/text and prompt text are now capped to 2000-rune snippets in the snapshot and on the wire (the dominant share of that 186 MB payload), with the full text one request away. And serve mode now sets a 1.5 GiB soft memory limit (debug.SetMemoryLimit) so Go returns cached-payload headroom to the OS; an explicit GOMEMLIMIT is respected.
  • --bind values that already carry a port are rejected up front. --bind 127.0.0.1:8791 used to be silently composed into 127.0.0.1:8791:8787 and fail at listen time with a confusing too-many-colons error (and a false non-loopback warning). It's now validated right after flag parsing and points you at --port. The listen address is composed with net.JoinHostPort, so bare and bracketed IPv6 hosts both keep working.
  • Client-canceled API requests are no longer logged as errors. A browser fires one request per report section and cancels them on reload/navigation; that surfaced as context.Canceled logged at ERROR with a 500 written to an already-closed socket. Those are now swallowed — no ERROR log, no 500.
  • SDK badge standardized. The SDK-origin pill is pinned to the top-right of the Tree/Timeline/Conversation left session menus and dropped from the Timeline Gantt header (it was shown twice); the Insights token-composition bar is reordered to the canonical input → output → cache-write → cache-read.