[BUG] /usage Stats tab counts message.usage per transcript row instead of per message.id, inflating token totals ~2x

Preflight Checklist

• [x] I have searched existing issues and this hasn't been reported yet
• [x] This is a single bug report (please file separate reports for different bugs)
• [x] I am using the latest version of Claude Code

What's Wrong?

/usage → Stats tab sums message.usage once per transcript row instead of once per API response, so every token figure it shows is roughly double.

One API response is written to the transcript as several assistant rows — one per content block (thinking, text, each tool_use) — and every one of those rows carries a byte-identical copy of the whole response's usage. The documented rule for any consumer summing that data is to count each message.id once:

When Claude uses tools in parallel, multiple messages share the same id with identical usage data. Track which IDs you've already counted and skip duplicates to avoid inflated totals. — Track cost and usage

That rule was reaffirmed when #87303 was closed as documented behaviour ("Consumers are expected to count each message.id once"). The Stats tab is a consumer and does not follow it.

Measured against the rendered screen

/usage → Stats → Overview → Last 7 days, against the same transcripts and window summed by a reimplementation of the scanner:

| field | Stats tab shows | naive (per row) | with documented dedup |
|---|---|---|---|
| Total tokens | 706.5m | 707.2m | 278.1m |
| Input | 731.4k | 731.4k | 135.9k |
| Output | 5.4m | 5.4m | 1.6m |
| Cache read | 670.2m | 670.8m | 267.4m |
| Cache write | 30.2m | 30.2m | 9.0m |

Input and Cache write match the per-row sum exactly at displayed precision; the other two differ by <0.1%, which is the session continuing to run between the screenshot and the replica run. The deduplicated column matches nothing on screen. Screenshot in Additional Information.

The adjacent tab in the same screen already does it correctly

Over the same 7-day window the Usage tab reports Last 7d · 1647 requests. Counting the same transcripts two ways:

Last 7d:   rows = 4,430     distinct message.id = 1,647

1,647 reported = 1,647 distinct message.ids. Exact.

So within one screen: Usage counts 1,647 API responses by deduplicating on message.id, while Stats sums token usage across all 4,430 rows those same responses were written as. Both cannot be right.

cost-state — Claude Code's own per-response record, written into the same transcript file — agrees with the deduplicated total (exactly, on 6 of 14 sessions tested) and sits ~2x below the per-row sum.

Scope

This is not a request to change the transcript format. #87303 and #6805 asked for that and the answer was no; the shape is intentional. This is a report that the first-party consumer doesn't follow the contract the docs define.

Impact

• Total tokens ~2x on every date range (1.87x all-time, 2.54x on 7d for this machine).
• The error is not a uniform factor — it scales with blocks-per-turn, so the Models tab mis-weights models against each other (a model used for tool-heavy agentic work is inflated relative to one used for chat, at identical real usage) and the daily graph is distorted unevenly. Users can't correct for it with a mental divide-by-two.
• Output tokens are hit hardest: 2.51x vs 1.95x overall.
• The inflated history is permanent. stats-cache.json is cumulative — Pl() merges new days forward and past days are never recomputed, gated by the lastComputedDate watermark. Fixing the scanner alone leaves every already-recorded day wrong.
• It undercuts the docs' own guidance: #87303 was closed by pointing third parties at a rule the first-party UI doesn't follow.

What Should Happen?

The Stats tab should count each API response once — the same rule the docs prescribe, the adjacent Usage tab already applies, and cost-state already records.

Concretely, for Last 7 days on the machine in this report, Overview should read approximately:

Total tokens: 278.1m
Input 135.9k · Output 1.6m · Cache read 267.4m · Cache write 9.0m

rather than the 706.5m currently shown. The Models tab percentages should shift too, since the inflation is not uniform across models — it scales with how many content blocks each turn produced.

More generally: /usage → Stats, /usage → Usage, and the cost-state record all read the same transcripts and should agree on how many API responses occurred. Today two of the three do, and the Stats tab doesn't.

Error Messages/Logs

$ python3 repro.py     # see "Steps to Reproduce" for the script

transcript files scanned: 168

Rows per distinct message.id:
  1 row(s):   9,048 responses
  2 row(s):   6,844 responses
  3 row(s):   5,228 responses
  4 row(s):     671 responses
  5 row(s):     130 responses
  6 row(s):      64 responses
  7 row(s):      23 responses
  8 row(s):      24 responses
  9 row(s):      14 responses
  10 row(s):       8 responses
  11 row(s):       7 responses
  12 row(s):       3 responses
  13 row(s):       7 responses
  15 row(s):       2 responses
  19 row(s):       1 responses
  22,074 API responses written as 42,950 rows  ->  inflation factor 1.95x

== 7d ==
  what /usage shows                       711,020,734
  with documented dedup applied           279,763,707
  over-count                                    2.54x

== 30d ==
  what /usage shows                    11,009,034,957
  with documented dedup applied         5,917,413,702
  over-count                                    1.86x

== all time (local files) ==
  what /usage shows                    11,657,599,469
  with documented dedup applied         6,240,231,408
  over-count                                    1.87x


--- and the request count the Usage tab reports, for the same window ---

$ claude -p "/usage"
Last 24h · 123 requests · 4 sessions
Last 7d · 1647 requests · 17 sessions

# 1647 == the "distinct message.id" count above for the same window.
# The Usage tab deduplicates. The Stats tab, one tab over, does not.

Steps to Reproduce

1. Use Claude Code normally for a few days, so ~/.claude/projects/**/*.jsonl holds sessions with tool use (i.e. responses with several content blocks). Any single tool-using session reproduces it; more data just makes the ratio steadier.

1. Open /usage → Stats tab → Overview. Press r until the range reads Last 7 days. Note Total tokens and the Input · Output · Cache read · Cache write line.

1. Switch to the Usage tab in that same screen. Note the Last 7d · N requests figure.

1. Save this as repro.py and run python3 repro.py. It reimplements the Stats scanner over the same files and window, then re-runs it applying the documented message.id dedup. Read-only; prints aggregates only.

#!/usr/bin/env python3
"""
Repro: /usage sums message.usage per transcript ROW instead of per message.id,
so its token stats are inflated. Reimplements Claude Code's stats scanner
(`ks()`), then re-runs it with the documented dedup applied.
"""
import json, os, glob, datetime
from collections import defaultdict

ROOT = os.path.expanduser("~/.claude/projects")
SEP  = os.sep

def stats_files():
    """Mirror of Om(): project *.jsonl + <session>/subagents/agent-*.jsonl"""
    out = []
    for d in sorted(glob.glob(os.path.join(ROOT, "*"))):
        if not os.path.isdir(d):
            continue
        out += sorted(glob.glob(os.path.join(d, "*.jsonl")))
        out += sorted(glob.glob(os.path.join(d, "*", "subagents", "agent-*.jsonl")))
    return out

def entries(path):
    for line in open(path, errors="ignore"):
        line = line.strip()
        if not line:
            continue
        try:
            r = json.loads(line)
        except ValueError:
            continue
        if isinstance(r, dict) and r.get("timestamp") and r.get("type"):
            yield r

def scan(from_date=None, dedupe=False):
    """Mirror of ks(). dedupe=True counts each message.id once, per the docs."""
    by_model, seen = defaultdict(lambda: defaultdict(int)), set()
    for path in stats_files():
        is_sub = (SEP + "subagents" + SEP) in path
        rows = list(entries(path))
        if not is_sub:
            rows = [r for r in rows if not r.get("isSidechain")]
        for r in rows:
            if from_date and r["timestamp"][:10] < from_date:
                continue
            if r.get("type") != "assistant":
                continue
            msg = r.get("message") or {}
            u = msg.get("usage")
            if not isinstance(u, dict):
                continue
            model = msg.get("model") or "unknown"
            if model == "<synthetic>":
                continue
            if dedupe:
                mid = msg.get("id")
                if mid:
                    if (path, mid) in seen:
                        continue
                    seen.add((path, mid))
            b = by_model[model]
            b["in"]  += u.get("input_tokens", 0) or 0
            b["out"] += u.get("output_tokens", 0) or 0
            b["cr"]  += u.get("cache_read_input_tokens", 0) or 0
            b["cw"]  += u.get("cache_creation_input_tokens", 0) or 0
    return by_model

def total(by_model):
    return sum(v for b in by_model.values() for v in b.values())

def fan_out_histogram():
    hist, per_file = defaultdict(int), defaultdict(lambda: defaultdict(int))
    for path in stats_files():
        for r in entries(path):
            if r.get("type") != "assistant":
                continue
            msg = r.get("message") or {}
            if isinstance(msg.get("usage"), dict) and msg.get("id"):
                per_file[path][msg["id"]] += 1
    for _, ids in per_file.items():
        for _, n in ids.items():
            hist[n] += 1
    return hist

print(f"transcript files scanned: {len(stats_files())}\n")
print("Rows per distinct message.id:")
hist = fan_out_histogram()
ids  = sum(hist.values())
rows = sum(n * c for n, c in hist.items())
for n in sorted(hist):
    print(f"  {n} row(s): {hist[n]:>7,} responses")
print(f"  {ids:,} API responses written as {rows:,} rows"
      f"  ->  inflation factor {rows/ids:.2f}x\n")

today = datetime.date.today()
for days in (7, 30, None):
    frm = (today - datetime.timedelta(days=days - 1)).isoformat() if days else None
    print(f"== {days}d ==" if days else "== all time (local files) ==")
    a = total(scan(frm, dedupe=False)); print(f"  {'what /usage shows':<34} {a:>16,}")
    b = total(scan(frm, dedupe=True));  print(f"  {'with documented dedup applied':<34} {b:>16,}")
    if b:
        print(f"  {'over-count':<34} {a/b:>15.2f}x")
    print()

1. Compare the three:

• Step 4's "what /usage shows" for 7d ≈ step 2's Total tokens → the Stats tab is showing the per-row sum. (In my run: 711.0m computed vs 706.5m on screen, the gap being tokens spent between the two.)
• Step 4's distinct message.id count for 7d == step 3's request count → the Usage tab deduplicates. (In my run: 1,647 == 1,647, exact.)
• The two differ by ~2x.

One-line version, for a single transcript — prints total rows carrying usage vs. distinct message.ids:

python3 -c '
import json,sys
rows=set();n=0
for l in open(sys.argv[1]):
    try: r=json.loads(l)
    except: continue
    m=r.get("message") or {}
    if r.get("type")=="assistant" and isinstance(m.get("usage"),dict) and m.get("id"):
        n+=1; rows.add(m["id"])
print(f"rows={n}  distinct message.id={len(rows)}  inflation={n/len(rows):.2f}x")
' ~/.claude/projects/<project>/<sessionId>.jsonl

Any output with inflation > 1.00x means the Stats tab is over-counting that session by that factor.

Claude Model

Not sure / Multiple models

Is this a regression?

I don't know

Last Working Version

_No response_

Claude Code Version

2.1.259 (Claude Code)

Platform

Anthropic API

Operating System

macOS

Terminal/Shell

Other

Additional Information

Screenshot

/usage → Stats → Overview, Last 7 days. Total tokens: 706.5m, Input 731.4k · Output 5.4m · Cache read 670.2m · Cache write 30.2m — every field matching the per-row sum in the table above. Note the Usage tab sitting immediately to the left, which counts the same responses correctly.

<img width="983" height="741" alt="/usage Stats tab, Overview, Last 7 days: Total tokens 706.5m; Input 731.4k, Output 5.4m, Cache read 670.2m, Cache write 30.2m" src="https://github.com/user-attachments/assets/15f07d4f-1b56-416d-8f82-06bc7c22ee78" />

Where it happens

Symbol names below are the minified ones from the 2.1.259 bundle; annotations are mine. Pointers only — everything above was measured from Claude Code's own outputs and needs no reference to this to verify.

The scanner behind the Stats tab, accumulation block:

if (Re.type === "assistant") {
  /* ... */
  if (Re.message?.usage) {
    let Fe = Re.message.usage,
        Ye = Re.message.model || "unknown";
    if (Ye === ru || _i(Ye)) continue;                // ru === "<synthetic>"
    if (!A[Ye]) A[Ye] = { inputTokens: 0, outputTokens: 0, cacheReadInputTokens: 0,
                          cacheCreationInputTokens: 0, webSearchRequests: 0,
                          costUSD: 0, contextWindow: 0, maxOutputTokens: 0 };
    let ct = Ee(Fe.input_tokens) ?? 0,
        et = Ee(Fe.output_tokens) ?? 0,
        Gt = Ee(Fe.cache_read_input_tokens) ?? 0,
        Bs = Ee(Fe.cache_creation_input_tokens) ?? 0,
        _o = A[Ye];
    _o.inputTokens  += ct;                            // unconditional, per ROW
    _o.outputTokens += et;
    _o.cacheReadInputTokens     += Gt;
    _o.cacheCreationInputTokens += Bs;
    let Jo = ct + et + Gt + Bs;
    if (Jo > 0) {
      let Po = R.get(lt) || {};
      Po[Ye] = (Po[Ye] || 0) + Jo;                    // daily bucket, also per ROW
      R.set(lt, Po);
    }
  }
}

Re.message.id is never read — no Set, no guard, nothing equivalent to the documented dedup.

The 7d/30d ranges rescan the files through that same function, so this is not a stale-cache artifact:

async function Bi(i, c) {
  if (i === "all") return Iy(c);                        // cumulative stats-cache path
  let { files: m, mtimeMsByFile: D } = await Om(c);
  let E = new Date(), T = i === "7d" ? 7 : 30;
  let x = new Date(E);
  x.setDate(E.getDate() - T + 1);
  let R = await ks(m, { fromDate: wo(x) }, c, D);       // same scanner, no dedup
  return _y(R);
}

The correct accumulator already exists — cost-state, called once per API response:

function MZr(e, n, r) {                                 // (costUSD, usage, model)
  let o = ELn(r) ?? { inputTokens: 0, outputTokens: 0, /* ... */ };
  return o.inputTokens  += n.input_tokens,
         o.outputTokens += n.output_tokens,
         o.thinkingTokens = (o.thinkingTokens ?? 0) + (n.output_tokens_details?.thinking_tokens ?? 0),
         o.cacheReadInputTokens     += n.cache_read_input_tokens ?? 0,
         o.cacheCreationInputTokens += n.cache_creation_input_tokens ?? 0,
         o.costUSD += e,
         /* ... */ o;
}

It writes the cost-state record's modelUsage — the CLI's analogue of the SDK result message's modelUsage, which the docs point to as authoritative. It lands in the same transcript file the Stats tab reads, and the Stats tab ignores it.

Supporting measurements

cost-state vs. both summations, per session

Only sessions whose entire transcript lies inside a single cost-state run (startTime unique, first record ≥ startTime), with each session's subagents/agent-*.jsonl included since cost-state covers subagent calls too:

 sub        rows       dedup  cost-state   dedup/truth
   0  11,601,839   2,897,389   2,897,389        1.000x
   0  10,778,979   1,989,666   1,989,666        1.000x
   0  12,221,314   2,324,120   2,324,120        1.000x
   0  13,362,186   2,237,106   2,237,106        1.000x
   7 203,967,142  72,576,243  86,580,760        0.838x
   0   9,673,344   1,984,224   1,984,224        1.000x
   0  24,453,963  11,644,952  13,318,243        0.874x
   0  21,109,391  10,673,649  12,110,235        0.881x
   0   4,406,003   2,560,611   2,647,980        0.967x
   0 150,039,126  62,701,339  66,478,011        0.943x
   0 117,566,151  64,167,780  67,801,253        0.946x
   0   2,642,596   1,381,637   1,519,099        0.910x
   0 133,430,467  57,934,454 107,710,942        0.538x
   0  36,807,432  13,428,659  15,432,187        0.870x

TOTAL   rows/cost-state = 1.95x     dedup/cost-state = 0.80x
OUTPUT  rows/cost-state = 2.51x     dedup/cost-state = 0.77x

Six sessions land on cost-state to the token once deduplicated, while row-summing runs 4.0x–6.0x high on those same sessions.

The rows below 1.000x are dedup under-counting, for a separate and expected reason: cost-state also covers API calls never written to any transcript (auto-titler, compaction summarizer, quota probes, retries). Transcript-derived stats structurally can't see those. Much smaller than the 2x, and an argument for fix option 2.

The persisted cache matches a non-deduplicated replica on every intact day

Diffing my scanner reimplementation against ~/.claude/stats-cache.json:

date         model                           replica      stats-cache  verdict
2026-08-15   claude-opus-5               550,634,995      550,634,995  EXACT
2026-08-18   claude-fable-5              163,604,740      163,604,740  EXACT
2026-08-19   claude-opus-4-8              34,760,251       34,760,251  EXACT
2026-08-20   claude-fable-5              293,964,168      293,964,168  EXACT
2026-08-24   claude-fable-5              770,637,214      770,637,214  EXACT
2026-08-28   claude-opus-5               150,039,126      150,039,126  EXACT
2026-09-01   claude-opus-5               174,377,234      174,377,234  EXACT
2026-09-02   claude-fable-5-1            187,366,448      187,366,448  EXACT
...
exact matches: 47   mismatches: 25 (all days whose transcripts have since been deleted by retention)

47/47 exact on every day whose transcripts still exist.

One response, four rows

{"type":"assistant","uuid":"cef9c465…","message":{"id":"msg_011CeALkiJn3uTavAHtzQYKr","model":"claude-fable-5","content":"[1 block: thinking]","usage":{"input_tokens":2,"output_tokens":10611,"cache_creation_input_tokens":21999,"cache_read_input_tokens":24363}}}
{"type":"assistant","uuid":"2a218497…","message":{"id":"msg_011CeALkiJn3uTavAHtzQYKr","model":"claude-fable-5","content":"[1 block: text]","usage":{"input_tokens":2,"output_tokens":10611,"cache_creation_input_tokens":21999,"cache_read_input_tokens":24363}}}
{"type":"assistant","uuid":"2dcdbfb0…","message":{"id":"msg_011CeALkiJn3uTavAHtzQYKr","model":"claude-fable-5","content":"[1 block: tool_use]","usage":{"input_tokens":2,"output_tokens":10611,"cache_creation_input_tokens":21999,"cache_read_input_tokens":24363}}}
{"type":"assistant","uuid":"a9f46e3b…","message":{"id":"msg_011CeALkiJn3uTavAHtzQYKr","model":"claude-fable-5","content":"[1 block: tool_use]","usage":{"input_tokens":2,"output_tokens":10611,"cache_creation_input_tokens":21999,"cache_read_input_tokens":24363}}}

Real cost 56,975 tokens; the Stats tab adds up 227,900.

Suggested fix

1. Apply the documented dedup. A per-file Set is enough and keeps memory bounded:

const seenMessageIds = new Set();               // per transcript file
for (let Re of ze) {
  /* ... */
  if (Re.type === "assistant" && Re.message?.usage) {
    const mid = Re.message.id;
    if (mid) {
      if (seenMessageIds.has(mid)) continue;    // same API response, another content block
      seenMessageIds.add(mid);
    }
    /* ...existing accumulation... */
  }
}

Pair it with a dailyModelTokensVersion bump so recorded history is rebuilt rather than merged forward — the rebuild path already exists and is gated on that version. Note modelUsage and totalMessages are merged by Pl() and are not covered by that rebuild; they need a reset or their own version gate, or the Overview total stays wrong even after dailyModelTokens is rebuilt.

2. Better — read cost-state where it exists. The docs already tell SDK consumers to prefer the result message's modelUsage over per-step summation:

The deduplicated per-step values are accurate for input and cache tokens. Per-step output_tokens is a placeholder, so read output tokens from the result message.

The CLI's equivalent of that result message is the cost-state record, already in the transcript. Using it fixes the 2x and closes the ~20% gap from calls that never reach the transcript. A hybrid — cost-state where present, deduplicated summation for older transcripts written before it — would cover the whole history.

An open question worth confirming

In my measurements the deduplicated per-step output_tokens matched cost-state exactly in the six clean sessions above, which suggests the persisted transcript carries final output counts rather than the message_start placeholder the docs describe for the live SDK stream. There is a backfill in the normalizer that looks related:

if (p.type === "assistant" && I.normalized[0]?.type === "assistant" &&
    I.normalized[0].message.stop_reason !== p.message.stop_reason) {
  for (let F of I.normalized)
    if (F.type === "assistant")
      F.message.stop_reason  = p.message.stop_reason,
      F.message.stop_details = p.message.stop_details,
      F.message.usage        = p.message.usage;      // final usage backfilled
}

I'd rather have that confirmed than assume it. If on-disk output_tokens really is authoritative, fix 1 is sufficient for output totals; if it isn't, fix 2 is required — and either way the docs' placeholder warning could usefully say which surface it applies to.

Secondary observation

The All time range reads the cumulative stats-cache.json, which retains days whose transcripts have since been deleted by retention, while 7d/30d rescan the files live. On this machine that's 48,838,567,442 all-time tokens across 153 days of dailyActivity versus 11,657,599,469 across the 63 days of transcripts still on disk.

Defensible as a design choice, but all-time and the ranged views then come from different sources and can't be reconciled by a user — and it's why the version bump in fix 1 matters: without it, today's inflated all-time figure is permanent.

date        model                          per line       per request    stats-cache   cache/line
2026-09-08  claude-fable-5-1               212,181,208    103,437,549    212,181,208    1.00x
2026-09-08  claude-haiku-4-5-20251001        1,061,871        456,177      1,061,871    1.00x
2026-09-08  claude-opus-5                  406,696,418    250,685,741    406,696,418    1.00x
2026-09-08  claude-sonnet-5                  2,615,489      1,374,821      2,615,489    1.00x
2026-09-09  claude-fable-5-1               266,977,161    118,532,250    266,977,161    1.00x
2026-09-09  claude-haiku-4-5-20251001           34,000         17,000         34,000    1.00x
2026-09-09  claude-opus-5                1,150,890,237    750,510,968  1,150,890,237    1.00x
2026-09-09  claude-sonnet-5                  2,121,903        683,586      2,121,903    1.00x
2026-09-10  claude-fable-5-1                 1,296,443        777,124      1,296,443    1.00x
2026-09-10  claude-haiku-4-5-20251001           16,608          8,304         16,608    1.00x
2026-09-10  claude-sonnet-5                  1,715,888        719,014      1,715,888    1.00x
2026-09-11  claude-fable-5-1                80,966,124     36,003,917     80,966,124    1.00x
2026-09-11  claude-opus-5                    9,650,125      4,582,058      9,650,125    1.00x
2026-09-12  claude-fable-5-1               101,289,963     57,825,854    101,289,963    1.00x
2026-09-12  claude-opus-5                  321,633,689    182,226,858    321,633,689    1.00x

#!/usr/bin/env node
// check-usage-duplicates.mjs - read-only audit of Claude Code transcript token accounting.
// Node >= 18, no dependencies. Prints aggregates only: no file paths, no ids, no content.
// Usage: node check-usage-duplicates.mjs

import { readFileSync, readdirSync, existsSync } from "node:fs";
import { join } from "node:path";
import { homedir } from "node:os";

const ROOT = join(homedir(), ".claude", "projects");
const CACHE = join(homedir(), ".claude", "stats-cache.json");
const FIELDS = ["input_tokens", "output_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"];

const zero = () => ({ input_tokens: 0, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 });
const add = (acc, u) => { for (const f of FIELDS) acc[f] += Number(u[f]) || 0; };
const total = (a) => FIELDS.reduce((s, f) => s + a[f], 0);
const n = (v) => Number(v).toLocaleString("en-US");
const pad = (s, w) => String(s).padStart(w);

function walk(dir, out = []) {
  let entries;
  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return out; }
  for (const e of entries) {
    const p = join(dir, e.name);
    if (e.isDirectory()) walk(p, out);
    else if (e.isFile() && e.name.endsWith(".jsonl")) out.push(p);
  }
  return out;
}

const files = walk(ROOT);
const naive = zero(), dedup = zero();
const seen = new Set();
const days = new Map();            // `${date}^@${model}` -> { naive, dedup }
let lines = 0, dupLines = 0, noRequestId = 0, noMessageId = 0, uid = 0;

for (const file of files) {
  let text;
  try { text = readFileSync(file, "utf8"); } catch { continue; }
  for (const line of text.split("\n")) {
    if (!line || !line.includes('"usage"')) continue;
    let rec; try { rec = JSON.parse(line); } catch { continue; }
    if (!rec || rec.type !== "assistant") continue;
    const msg = rec.message, usage = msg && msg.usage;
    if (!usage || typeof usage !== "object") continue;
    const model = msg.model || "unknown";
    if (model === "<synthetic>") continue;
    lines++;
    if (!msg.id) noMessageId++;
    if (!rec.requestId) noRequestId++;
    const key = msg.id ? `${msg.id}^@${rec.requestId || ""}` : `^A${uid++}`;
    const date = typeof rec.timestamp === "string" ? rec.timestamp.slice(0, 10) : "unknown";
    const bucketKey = `${date}^@${model}`;
    let bucket = days.get(bucketKey);
    if (!bucket) days.set(bucketKey, bucket = { naive: zero(), dedup: zero() });
    add(naive, usage); add(bucket.naive, usage);
    if (seen.has(key)) { dupLines++; continue; }
    seen.add(key);
    add(dedup, usage); add(bucket.dedup, usage);
  }
}

console.log(`transcript files scanned      ${n(files.length)}`);
console.log(`assistant lines with usage    ${n(lines)}`);
console.log(`unique (message.id, requestId) ${n(seen.size)}`);
console.log(`duplicate lines               ${n(dupLines)}  (${lines ? (100 * dupLines / lines).toFixed(1) : "0.0"}% of lines)`);
console.log(`lines missing message.id      ${n(noMessageId)}`);
console.log(`lines missing requestId       ${n(noRequestId)}`);
console.log("");
console.log(`${"field".padEnd(30)}${pad("naive (per line)", 20)}${pad("deduped (per msg)", 20)}${pad("factor", 9)}`);
for (const f of FIELDS.concat(["TOTAL"])) {
  const a = f === "TOTAL" ? total(naive) : naive[f];
  const b = f === "TOTAL" ? total(dedup) : dedup[f];
  console.log(`${f.padEnd(30)}${pad(n(a), 20)}${pad(n(b), 20)}${pad(b ? (a / b).toFixed(2) + "x" : "-", 9)}`);
}

if (!existsSync(CACHE)) { console.log("\nno stats-cache.json on this machine; skipping comparison"); process.exit(0); }
let cache; try { cache = JSON.parse(readFileSync(CACHE, "utf8")); } catch { console.log("\nstats-cache.json unreadable"); process.exit(0); }
const cacheDays = new Map();
for (const d of cache.dailyModelTokens || [])
  for (const [model, tok] of Object.entries(d.tokensByModel || {}))
    cacheDays.set(`${d.date}^@${model}`, Number(tok) || 0);

console.log(`\nstats-cache.json  version ${cache.version}  dailyModelTokensVersion ${cache.dailyModelTokensVersion}  lastComputedDate ${cache.lastComputedDate}`);
console.log(`today (local) ${new Date().toISOString().slice(0, 10)}\n`);
console.log(`${"date".padEnd(12)}${"model".padEnd(26)}${pad("naive", 16)}${pad("deduped", 16)}${pad("stats-cache", 16)}${pad("cache/naive", 12)}${pad("cache/dedup", 12)}`);
const overlap = [...days.keys()].filter((k) => cacheDays.has(k)).sort();
for (const k of overlap) {
  const [date, model] = k.split("^@");
  const a = total(days.get(k).naive), b = total(days.get(k).dedup), c = cacheDays.get(k);
  console.log(`${date.padEnd(12)}${model.padEnd(26)}${pad(n(a), 16)}${pad(n(b), 16)}${pad(n(c), 16)}${pad(a ? (c / a).toFixed(2) + "x" : "-", 12)}${pad(b ? (c / b).toFixed(2) + "x" : "-", 12)}`);
}
if (!overlap.length) console.log("(no overlapping days between transcripts on disk and stats-cache)");
const mu = cache.modelUsage || {};
const muTotal = Object.values(mu).reduce((s, m) => s + (Number(m.inputTokens) || 0) + (Number(m.outputTokens) || 0) + (Number(m.cacheReadInputTokens) || 0) + (Number(m.cacheCreationInputTokens) || 0), 0);
console.log(`\nsum of stats-cache modelUsage (all time, ${Object.keys(mu).length} models): ${n(muTotal)}`);

let { files: u, mtimeMsByFile: h } = await Ip(o);          // transcript files still on disk
// ...
if ((v.dailyModelTokensVersion ?? 0) < ir && !j) {         // j: watermark ahead of today
  // ...
  I = (await Is(u, { toDate: K }, o, h)).dailyModelTokens; // recounted from those files only
  v = { ...v, lastComputedDate: K, dailyModelTokens: I, dailyModelTokensVersion: ir };
  await Un(v, o);                                          // and saved
}

git clone https://github.com/marliechorgan/token-usage-graph && cd token-usage-graph
python3 src/token_usage_graph/report.py --no-chart