ai-usage-analyzer 0.4.0 → 0.5.0

package/README.md

@@ -1,17 +1,11 @@
 # ai-usage-analyzer
 
-TUI analyzer for local AI coding agent token consumption. Auto-detects
+A local web dashboard for AI coding agent token consumption. Auto-detects
 **Claude Code**, **Codex**, **OpenCode**, **MimoCode**, **GitHub Copilot**,
-**Antigravity**, and **Gemini CLI** data directories — no hardcoded paths.
+**Antigravity**, and **Gemini CLI** data directories.
 
-```
-╭──────────────────────────────────────────────────────╮
-│               ◆  AI TOKEN ANALYZER  ◆                │
-│                                                      │
-│  411 sessions  •  1.56B total tokens  •  $29.40 USD  │
-│            range: 2026-04-01  →  2026-06-27          │
-╰──────────────────────────────────────────────────────╯
-```
+The default command starts a local server and opens the dashboard in your browser.
+Usage data stays on your device. Press Ctrl+C in the terminal to stop the server.
 
 ## Install
 
@@ -31,18 +25,19 @@ The short alias `ai-usage` is also installed and works identically.
 ## Usage
 
 ```bash
-ai-usage-analyzer                  # default TUI
-ai-usage-analyzer --top 10         # show top 10 heaviest sessions
+ai-usage-analyzer                  # open the dashboard
+ai-usage-analyzer --static --top 10 # terminal report with top 10 sessions
 ai-usage-analyzer --json           # machine-readable JSON
 ai-usage-analyzer --md > report.md # save as markdown
+ai-usage-analyzer --json --quota    # include a live quota snapshot
 ```
 
 ## Supported tools
 
 | Tool | Default path | Tokens |
 |---|---|---|
-| Claude Code    | `~/.claude/projects`                | presence only |
-| Codex          | `~/.codex/sessions/YYYY/MM/DD/`    | yes |
+| Claude Code    | `~/.claude/projects`                | yes (estimated cost) |
+| Codex          | `~/.codex/sessions/` and `archived_sessions/` | yes (estimated cost) |
 | OpenCode       | `~/.local/share/opencode/opencode.db` | yes (+cost) |
 | MimoCode       | `~/.local/share/mimocode/mimocode.db` | yes (+cost) |
 | GitHub Copilot | `~/.copilot/session-state/`        | presence only |
@@ -65,14 +60,34 @@ For tools that record token data, the analyzer shows input, output, cache
 read, cache write, and reasoning tokens. Cache hits are cheap; reasoning is
 the extended-thinking/chain-of-thought cost.
 
+## Quotas
+
+Reports stay offline unless `--quota` is supplied. This requests Claude and Codex
+usage limits using your existing logins. Vendor endpoints are internal and can
+change. Codex credentials may be refreshed and written back to `auth.json`.
+
+## Costs
+
+Claude and Codex costs use bundled API rates per model and are estimates,
+not subscription charges or invoices. `~` marks an estimate, `*` marks a
+partial total, and `n/a` means unavailable. Unknown models are listed rather
+than assigned a fallback price. OpenCode and MimoCode costs are read from
+their local databases. Pricing uses standard public API rates and the
+five-minute Claude cache-write rate; regional, batch, and other modifiers may
+differ. Rates are versioned with the app and can become outdated.
+
 ## How it works
 
 ```
 src/
 ├── detectors.js   auto-path discovery (env → well-known locations)
 ├── loaders.js     SQLite + JSONL parsers → unified session record
+├── quota.js       Claude and Codex quota snapshots
+├── pricing.js     bundled model pricing and estimates
+├── live.js        incremental live usage monitor
 ├── aggregate.js   per-project / per-week / per-month grouping
-├── render.js      TUI  •  markdown.js  →  Markdown report
+├── server.js      local dashboard server
+├── render.js      static terminal report  •  markdown.js  →  Markdown report
 bin/
 └── ai-usage.js    entry point
 ```

package/bin/ai-usage.js

@@ -18,7 +18,8 @@ import {
     renderPerWeek,
     renderTopSessions,
 } from "../src/render.js";
-import { runInteractive } from "../src/tui.js";
+import { startDashboard } from "../src/server.js";
+import { collectQuotas, renderQuota } from "../src/quota.js";
 
 const args = process.argv.slice(2);
 const hasFlag = (name) =>
@@ -26,6 +27,7 @@ const hasFlag = (name) =>
 const showHelp = hasFlag("help") || hasFlag("h");
 const jsonOut = hasFlag("json");
 const mdOut = hasFlag("markdown") || hasFlag("md");
+const quotaOut = hasFlag("quota");
 const staticOut = hasFlag("static") || hasFlag("no-interactive");
 const topN = (() => {
   const i = args.indexOf("--top");
@@ -42,7 +44,7 @@ const yearFilter = (() => {
 
 if (showHelp) {
   console.log(`
-ai-usage-analyzer — local AI coding agent token consumption TUI
+ai-usage-analyzer — local AI coding agent usage dashboard
 
 Usage:
   ai-usage [options]
@@ -52,15 +54,16 @@ Options:
   --json                   Output machine-readable JSON instead of TUI
   --markdown, --md         Output as a Markdown report (GitHub-flavored tables)
   --static, --no-interactive  Disable interactive mode; dump all sections at once
-  --top N                  Show top N heaviest sessions (default: 5)
-  --year YYYY              Filter records to a single year (e.g. --year 2026)
+  --quota                  Include live quota in JSON, Markdown, or static reports
+  --top N                  Show top N sessions in reports (default: 5)
+  --year YYYY              Filter reports to a single year (e.g. --year 2026)
 
 Examples:
-  ai-usage                       # default TUI
-  ai-usage --year 2026           # TUI, only 2026 sessions
+  ai-usage                       # open dashboard
+  ai-usage --static --year 2026  # report, only 2026 sessions
   ai-usage --json | jq .summary  # pipe to jq
   ai-usage --md > report.md      # save as markdown
-  ai-usage --top 20              # show top 20 sessions
+  ai-usage --static --top 20     # show top 20 sessions
 
 Environment overrides (per-tool data path):
   CLAUDE_HOME, CODEX_HOME, OPENCODE_HOME, MIMOCODE_HOME,
@@ -85,6 +88,10 @@ if (jsonOut && mdOut) {
 }
 
 async function main() {
+  if (!jsonOut && !mdOut && !staticOut) {
+    await startDashboard();
+    return;
+  }
   const t0 = Date.now();
   const detections = detectAll();
   const { records: allRecords, errors } = await loadAll(detections);
@@ -101,9 +108,13 @@ async function main() {
   const range = dateRange(records);
   const tot = overall(records);
 
+  const quotaPromise = quotaOut ? collectQuotas() : null;
+
   if (jsonOut) {
+    const quotas = quotaPromise ? await quotaPromise : null;
     const out = {
       detections,
+      ...(quotas ? { quotas } : {}),
       summary: tot,
       dateRange: range,
       sessions: records,
@@ -125,22 +136,18 @@ async function main() {
       topN,
       generatedAt: new Date().toISOString(),
     });
-    process.stdout.write(out);
+    const quota = quotaPromise ? await quotaPromise : null;
+    process.stdout.write(out + (quota ? `\n## Quotas\n\n\`\`\`\n${renderQuota(quota)}\n\`\`\`\n` : ""));
     return;
   }
 
-  // Interactive TUI (default when stdout is a TTY and --static not given)
-  if (!staticOut) {
-    const handled = await runInteractive({ records, detections, errors, topN });
-    if (handled) return;
-  }
-
   // Static fallback (--static, --no-interactive, or piped output)
   const sections = [
     renderHeader({
       totalSessions: records.length,
       totalTokens: tot.tokensTotal,
       totalCost: tot.cost,
+      costStatus: tot.costStatus,
       dateRange: range,
     }),
     renderDetections(detections),
@@ -157,6 +164,7 @@ async function main() {
     );
   }
   sections.push(renderNotes(detections, errors));
+  if (quotaPromise) sections.push(renderQuota(await quotaPromise));
 
   console.log(sections.join("\n\n"));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-usage-analyzer",
-  "version": "0.4.0",
-  "description": "TUI analyzer for local AI coding agent token usage. Auto-detects Claude Code, Codex, OpenCode, MimoCode, Copilot, Antigravity, and Gemini.",
+  "version": "0.5.0",
+  "description": "Local web dashboard for AI coding agent token usage.",
   "type": "module",
   "packageManager": "pnpm@10.33.0",
   "bin": {
@@ -11,7 +11,8 @@
   "files": [
     "bin",
     "src",
-    "README.md"
+    "README.md",
+    "web"
   ],
   "scripts": {
     "start": "node bin/ai-usage.js",
@@ -31,8 +32,8 @@
     "copilot",
     "antigravity",
     "gemini",
-    "tui",
-    "cli"
+    "cli",
+    "dashboard"
   ],
   "author": "ade",
   "license": "MIT",
@@ -48,6 +49,7 @@
     "boxen": "^7.1.1",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
-    "gradient-string": "^2.0.2"
+    "gradient-string": "^2.0.2",
+    "gsap": "^3.15.0"
   }
 }

package/src/aggregate.js

@@ -34,6 +34,11 @@ export function groupBy(records, keyFn) {
 }
 
 function summarize(records) {
+  const statuses = records.map(r => r.costStatus || 'recorded');
+  const incomplete = statuses.some(status => status === 'partial' || status === 'unavailable');
+  const known = statuses.some(status => status !== 'unavailable');
+  const costStatus = !statuses.length ? 'unavailable' : incomplete ? (known ? 'partial' : 'unavailable') : statuses.includes('estimated') ? 'estimated' : 'recorded';
+  const unknownModels = [...new Set(records.flatMap(r => r.unknownModels || []))];
   return {
     n: records.length,
     tokensTotal: sum(records, "tokensTotal"),
@@ -43,6 +48,8 @@ function summarize(records) {
     tokensCacheWrite: sum(records, "tokensCacheWrite"),
     tokensReasoning: sum(records, "tokensReasoning"),
     cost: sum(records, "cost"),
+    costStatus,
+    unknownModels,
     avg: avg(records, "tokensTotal"),
   };
 }

package/src/live.js

@@ -0,0 +1,132 @@
+import { openSync, closeSync, fstatSync, readSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const FIELDS = ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens'];
+const count = value => Number.isFinite(Number(value)) ? Math.max(0, Number(value)) : 0;
+
+export class LiveUsageTailer {
+  constructor(detections) {
+    this.roots = [];
+    for (const d of detections) {
+      if (!d.path || !['claude', 'codex'].includes(d.key) || d.status === 'absent') continue;
+      if (d.key === 'codex' && basename(d.path) === 'archived_sessions') continue;
+      this.roots.push({ path: d.path, tool: d.key });
+    }
+    this.directories = new Map();
+    this.files = new Map();
+    this.events = [];
+    this.started = false;
+    this.lastFull = 0;
+  }
+
+  tick(now = Date.now()) {
+    const full = !this.started || now - this.lastFull >= 60000;
+    if (full) this.lastFull = now;
+    const discovered = new Set();
+    const walk = (dir, tool) => {
+      let st;
+      try { st = statSync(dir); } catch { return; }
+      if (!st.isDirectory()) return;
+      const key = `${tool}:${dir}`;
+      let cached = this.directories.get(key);
+      if (!cached || cached.mtime !== st.mtimeMs || full) {
+        let entries;
+        try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        cached = { mtime: st.mtimeMs, dirs: [], files: [] };
+        for (const entry of entries) {
+          if (entry.isDirectory() && !(tool === 'claude' && entry.name === 'subagents') && !(tool === 'codex' && entry.name === 'archived_sessions')) cached.dirs.push(join(dir, entry.name));
+          else if (entry.isFile() && entry.name.endsWith('.jsonl') && (tool !== 'codex' || entry.name.startsWith('rollout-'))) cached.files.push(join(dir, entry.name));
+        }
+        this.directories.set(key, cached);
+      }
+      for (const child of cached.dirs) walk(child, tool);
+      for (const file of cached.files) {
+        const id = `${tool}:${file}`;
+        discovered.add(id);
+        if (!this.files.has(id)) this.files.set(id, { path: file, tool, offset: null, partial: Buffer.alloc(0), seen: new Map(), total: null, mtime: 0 });
+      }
+    };
+    for (const root of this.roots) walk(root.path, root.tool);
+    for (const [key, file] of this.files) {
+      if (!discovered.has(key)) { this.files.delete(key); continue; }
+      if (file.offset !== null && !full && now - file.mtime > 600000) continue;
+      this.readFile(file, now);
+    }
+    this.started = true;
+    this.events = this.events.filter(e => e.ts > now - 3600000);
+    return this.rate(now, 600);
+  }
+
+  readFile(file, now) {
+    let fd;
+    try {
+      fd = openSync(file.path, 'r');
+      const st = fstatSync(fd);
+      const identity = `${st.dev}:${st.ino}`;
+      let changedBoundary = false;
+      if (file.offset !== null && file.offset > 0 && file.boundary && st.size >= file.offset) {
+        const sample = Buffer.alloc(file.boundary.length);
+        const size = readSync(fd, sample, 0, sample.length, file.offset - sample.length);
+        changedBoundary = size !== sample.length || !sample.equals(file.boundary);
+      }
+      if (file.offset === null) {
+        file.offset = this.started ? 0 : st.size;
+        file.identity = identity;
+      } else if (file.identity !== identity || st.size < file.offset || changedBoundary) {
+        file.offset = 0;
+        file.identity = identity;
+        file.partial = Buffer.alloc(0);
+        file.seen.clear();
+        file.total = null;
+      }
+      file.mtime = st.mtimeMs;
+      while (file.offset < st.size) {
+        const buffer = Buffer.allocUnsafe(Math.min(65536, st.size - file.offset));
+        const size = readSync(fd, buffer, 0, buffer.length, file.offset);
+        if (!size) break;
+        file.offset += size;
+        const data = Buffer.concat([file.partial, buffer.subarray(0, size)]);
+        let from = 0, end;
+        while ((end = data.indexOf(10, from)) !== -1) {
+          this.consume(file, data.subarray(from, end).toString('utf8'), now);
+          from = end + 1;
+        }
+        file.partial = data.subarray(from);
+      }
+      const sample = Buffer.alloc(Math.min(64, file.offset));
+      if (sample.length) {
+        const size = readSync(fd, sample, 0, sample.length, file.offset - sample.length);
+        file.boundary = sample.subarray(0, size);
+      } else file.boundary = sample;
+    } catch {} finally { if (fd !== undefined) closeSync(fd); }
+  }
+
+  consume(file, line, now) {
+    let event;
+    try { event = JSON.parse(line); } catch { return; }
+    let tokens = 0;
+    if (file.tool === 'claude' && event.type === 'assistant' && event.message?.usage) {
+      const usage = event.message.usage;
+      const id = event.message.id ? JSON.stringify([event.message.id, event.requestId || null]) : null;
+      const previous = id ? file.seen.get(id) || {} : {};
+      const next = {};
+      for (const field of FIELDS) {
+        next[field] = Math.max(count(previous[field]), count(usage[field]));
+        tokens += next[field] - count(previous[field]);
+      }
+      if (id) file.seen.set(id, next);
+    } else if (file.tool === 'codex' && event.type === 'event_msg' && event.payload?.type === 'token_count') {
+      const info = event.payload.info || {};
+      const total = info.total_token_usage;
+      const key = total ? JSON.stringify(total) : null;
+      if (key && key === file.total) return;
+      if (key) file.total = key;
+      if (info.last_token_usage) tokens = count(info.last_token_usage.input_tokens) + count(info.last_token_usage.output_tokens);
+    }
+    if (tokens > 0) this.events.push({ ts: now, tokens });
+  }
+
+  rate(now = Date.now(), seconds = 600) {
+    return this.events.filter(e => e.ts > now - seconds * 1000 && e.ts <= now).reduce((sum, e) => sum + e.tokens, 0) * 60 / seconds;
+  }
+}

package/src/loaders.js

@@ -16,9 +16,10 @@
 //   }
 
 import { createReadStream, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import { DatabaseSync } from "node:sqlite";
+import { estimateUsage } from "./pricing.js";
 
 // Run fn over every item in items with at most `limit` in-flight at once.
 async function mapConcurrent(items, fn, limit) {
@@ -70,6 +71,11 @@ function parseIsoMs(s) {
   return Number.isFinite(t) ? t : null;
 }
 
+function tokenCount(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+
 function compactHome(p) {
   if (!p) return "(unknown)";
   const home = process.env.HOME || "";
@@ -144,6 +150,7 @@ function loadOpencodeStyleSqlite(dbPath, toolKey) {
       tokensReasoning: r.tokens_reasoning || 0,
       tokensTotal: tot,
       cost: r.cost || 0,
+      costStatus: r.cost == null ? "unavailable" : "recorded",
       model: r.model || "",
     });
   }
@@ -156,7 +163,9 @@ function loadOpencodeStyleSqlite(dbPath, toolKey) {
 
 async function loadCodexRollouts(rootDir) {
   const errors = [];
-  const files = walkJsonl(rootDir, "rollout-");
+  const roots = basename(rootDir) === "sessions" ? [rootDir, join(dirname(rootDir), "archived_sessions")] : [rootDir];
+  const files = [...new Set(roots.flatMap((root) => walkJsonl(root, "rollout-")))];
+  files.sort((a, b) => Number(a.split(/[\\/]/).includes("archived_sessions")) - Number(b.split(/[\\/]/).includes("archived_sessions")) || a.localeCompare(b));
   const results = await mapConcurrent(
     files,
     async (f) => {
@@ -169,15 +178,20 @@ async function loadCodexRollouts(rootDir) {
     },
     48,
   );
-  return { records: results.filter(Boolean), errors };
+  const sessions = new Map();
+  for (const record of results) if (record && !sessions.has(record.sessionId)) sessions.set(record.sessionId, record);
+  return { records: [...sessions.values()], errors };
 }
 
 async function parseCodexRollout(path) {
   // Use a streaming reader to avoid loading huge files into memory.
-  // The 'token_count' event accumulates usage; we take the LAST one (final snapshot).
   let sessionMeta = null;
-  let lastUsage = null;
+  let previous = null;
+  let forkWaiting = false;
+  let inheritedTotal = null;
+  const usageEvents = [];
   let lastModel = "";
+  let provider = "openai";
   let lastEvTs = null;
 
   const stream = createReadStream(path, { encoding: "utf8" });
@@ -195,31 +209,73 @@ async function parseCodexRollout(path) {
     const evTs = parseIsoMs(ev.timestamp);
     if (evTs) lastEvTs = evTs;
     if (t === "session_meta") {
-      sessionMeta = { ts: ev.timestamp, cwd: p.cwd || p.CWD || "" };
+      sessionMeta = { ts: ev.timestamp, cwd: p.cwd || p.CWD || "", id: typeof p.id === "string" ? p.id : null };
+      forkWaiting = Boolean(p.forked_from_id);
+      if (typeof p.model_provider === "string" && p.model_provider) provider = p.model_provider;
+    } else if (t === "turn_context") {
+      forkWaiting = false;
+      lastModel = p.model_info?.slug || p.model || p.model_name || lastModel;
     } else if (t === "event_msg" && p.type === "token_count") {
       const info = p.info || {};
-      const u = info.total_token_usage;
-      if (u) lastUsage = u;
-      const m = info.model || p.model;
+      const fields = ['input_tokens', 'output_tokens', 'cached_input_tokens', 'reasoning_output_tokens'];
+      const normalize = (u) => u && Object.fromEntries(fields.map((field) => [field, tokenCount(u[field] ?? (field === 'cached_input_tokens' ? u.cache_read_input_tokens : 0))]));
+      const total = normalize(info.total_token_usage);
+      const last = normalize(info.last_token_usage);
+      if (forkWaiting) {
+        if (total) {
+          previous = total;
+          inheritedTotal = info.total_token_usage.total_tokens ?? null;
+        }
+        continue;
+      }
+      if (inheritedTotal !== null && info.total_token_usage?.total_tokens === inheritedTotal) {
+        if (total) previous = total;
+        inheritedTotal = null;
+        continue;
+      }
+      inheritedTotal = null;
+      let delta = null;
+      if (total && previous) {
+        if (fields.every((field) => total[field] === previous[field])) continue;
+        const regressed = fields.some((field) => total[field] < previous[field]);
+        if (regressed) {
+          const sum = (u) => fields.reduce((n, field) => n + u[field], 0);
+          if (last && sum(total) > 0 && sum(last) > 0 && (sum(total) * 100 >= sum(previous) * 98 || sum(total) + sum(last) * 2 >= sum(previous))) continue;
+          delta = last;
+        } else {
+          delta = last || Object.fromEntries(fields.map((field) => [field, total[field] - previous[field]]));
+        }
+      } else {
+        delta = last || total;
+      }
+      if (total) previous = total;
+      else if (last && previous) previous = Object.fromEntries(fields.map((field) => [field, previous[field] + last[field]]));
+      const m = info.model || info.model_name || p.model;
       if (m) lastModel = m;
+      if (delta) usageEvents.push({ model: lastModel, provider, aggregated: !last, usage: delta });
     }
   }
-  if (!sessionMeta || !lastUsage) return null;
+  if (!sessionMeta || !usageEvents.length) return null;
 
   const ts = parseIsoMs(sessionMeta.ts);
   if (!ts) return null;
   const durationMs = lastEvTs && lastEvTs > ts ? lastEvTs - ts : 0;
 
-  const tokensInput = lastUsage.input_tokens || 0;
-  const tokensOutput = lastUsage.output_tokens || 0;
-  const tokensCacheRead = lastUsage.cached_input_tokens || 0;
-  const tokensReasoning = lastUsage.reasoning_output_tokens || 0;
+  let tokensInput = 0, tokensOutput = 0, tokensCacheRead = 0, tokensReasoning = 0;
+  for (const { usage } of usageEvents) {
+    const cached = Math.min(usage.input_tokens, usage.cached_input_tokens);
+    const reasoning = Math.min(usage.output_tokens, usage.reasoning_output_tokens);
+    tokensInput += usage.input_tokens - cached;
+    tokensOutput += usage.output_tokens - reasoning;
+    tokensCacheRead += cached;
+    tokensReasoning += reasoning;
+  }
   const tot = tokensInput + tokensOutput + tokensCacheRead + tokensReasoning;
   if (tot === 0) return null;
 
   return {
     tool: "codex",
-    sessionId: path.split("-").pop().replace(".jsonl", ""),
+    sessionId: sessionMeta.id || basename(path).match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?=\.jsonl$)/i)?.[0] || basename(path, ".jsonl"),
     project: compactHome(sessionMeta.cwd),
     title: "",
     week: isoWeekKey(ts),
@@ -232,8 +288,9 @@ async function parseCodexRollout(path) {
     tokensCacheWrite: 0, // codex doesn't expose cache_write separately
     tokensReasoning,
     tokensTotal: tot,
-    cost: 0,
+    ...estimateUsage("codex", usageEvents),
     model: lastModel,
+    usageEvents,
   };
 }
 
@@ -294,8 +351,7 @@ function walkClaudeSessions(root) {
 //
 // Each top-level file under projects/<encoded-cwd>/<UUID>.jsonl is one session.
 // Per assistant line, `message.usage` carries the per-turn token counts; we
-// dedupe by `message.id` (Claude Code emits streaming duplicates) and sum
-// across unique messages. cwd / model / timestamp come from the line itself.
+// merge streamed usage by message and request, then sum unique responses. cwd / model / timestamp come from the line itself.
 
 async function loadClaudeJsonl(rootDir) {
   const errors = [];
@@ -317,7 +373,9 @@ async function loadClaudeJsonl(rootDir) {
 
 async function parseClaudeSession(path) {
   const sessionId = path.split("/").pop().replace(".jsonl", "");
-  const seenIds = new Set();
+  const usages = new Map();
+  const usageModels = new Map();
+  let anonymous = 0;
   let cwd = "";
   let model = "";
   let firstTs = null;
@@ -347,15 +405,21 @@ async function parseClaudeSession(path) {
     const usage = msg.usage;
     if (!usage) continue;
     const id = msg.id;
-    if (id) {
-      if (seenIds.has(id)) continue;
-      seenIds.add(id);
+    const key = id ? JSON.stringify([id, ev.requestId || null]) : `anonymous:${anonymous++}`;
+    const previous = usages.get(key) || {};
+    const merged = {};
+    for (const field of ["input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"]) {
+      merged[field] = Math.max(tokenCount(previous[field]), tokenCount(usage[field]));
     }
+    usages.set(key, merged);
+    if (msg.model) usageModels.set(key, msg.model);
     if (!cwd && typeof ev.cwd === "string") cwd = ev.cwd;
     if (!model && typeof msg.model === "string") model = msg.model;
     const evTs = parseIsoMs(ev.timestamp);
     if (firstTs === null && evTs !== null) firstTs = evTs;
     if (evTs !== null) lastTs = evTs;
+  }
+  for (const usage of usages.values()) {
     tokensInput += usage.input_tokens || 0;
     tokensOutput += usage.output_tokens || 0;
     tokensCacheRead += usage.cache_read_input_tokens || 0;
@@ -367,6 +431,7 @@ async function parseClaudeSession(path) {
   const ts = firstTs ?? Date.now();
   const durationMs = firstTs !== null && lastTs !== null ? lastTs - firstTs : 0;
 
+  const usageEvents = [...usages].map(([key, usage]) => ({ model: usageModels.get(key) || "", usage }));
   return {
     tool: "claude",
     sessionId,
@@ -382,8 +447,9 @@ async function parseClaudeSession(path) {
     tokensCacheWrite,
     tokensReasoning: 0,
     tokensTotal: tot,
-    cost: 0,
+    ...estimateUsage("claude", usageEvents),
     model,
+    usageEvents,
   };
 }