fix: accurate Live session cost (rate + whole-transcript) — v2.6.16

Two compounding inaccuracies made the Live "$ spent" wrong:

1. Pricing bug: opus-4-7 / opus-4-8 matched the 4.0/4.1 legacy regex
   (/opus-4(?:-[01])?\b/ — the \b also matches "opus-4-7"), so they were
   charged $15/$75 instead of the current $5/$25 — a 3× overcharge across ALL
   cost calcs. Broaden the reduced-rate row to /opus-4-(?:[5-9]|[1-9]\d)/ so
   4.5+ (incl. two-digit minors) get current rates; legacy stays 4.0/4.1 only.

2. The Live estimate summed tokens from only the last 1MB of the JSONL and
   applied a single blended 0.1× rate — undercounting large sessions and
   mis-blending cache-creation vs cache-read, and the message count was
   tail-only too (e.g. 188 shown vs 915 actual). Replace it with computeCost()
   over the whole transcript using per-type rates, cached by file mtime+size so
   unchanged sessions aren't re-read on each 3s refresh.

Verified live: a session independently calculated at ~$79.66 now reports
$80.08 (was $101.91); message counts are now full-transcript accurate.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: sorlen008

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-command-center",
-  "version": "2.6.15",
+  "version": "2.6.16",
   "description": "Dashboard for visualizing and managing your Claude Code ecosystem",
   "license": "MIT",
   "type": "module",

package.json

@@ -61,7 +61,7 @@ function getGitBranch(cwd: string): string | undefined {
   }
 }
 
-import { getPricing as getModelPricingShared, getMaxTokens, getUsableContext } from "./pricing";
+import { getPricing as getModelPricingShared, getMaxTokens, getUsableContext, computeCost } from "./pricing";
 
 /** Find the session JSONL file across all project dirs.
  *  Claude Code creates a new JSONL file (with a new session ID) after context
@@ -148,6 +148,50 @@ interface SessionDetails {
 }
 
 /** Extract all session details in a single pass over the tail of the JSONL */
+/**
+ * Accurate per-session cost + message count over the WHOLE transcript, using
+ * per-token-type rates (input/output/cache-read/cache-creation) — not the old
+ * blended estimate over just the tail. Cached by file mtime+size so unchanged
+ * sessions aren't re-read on every 3s live refresh; only growing (active)
+ * sessions recompute.
+ */
+const costCache = new Map<string, { mtimeMs: number; size: number; cost: number; messageCount: number }>();
+function computeSessionCostAndCount(filePath: string): { cost: number; messageCount: number } {
+  try {
+    const st = fs.statSync(filePath);
+    const hit = costCache.get(filePath);
+    if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+      return { cost: hit.cost, messageCount: hit.messageCount };
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    let input = 0, output = 0, cc = 0, cr = 0, model = "", messageCount = 0;
+    for (const line of content.split("\n")) {
+      if (!line) continue;
+      try {
+        const r = JSON.parse(line);
+        if (r.type !== "assistant") continue;
+        messageCount++;
+        const u = r.message?.usage;
+        if (u) {
+          input += u.input_tokens || 0;
+          output += u.output_tokens || 0;
+          cc += u.cache_creation_input_tokens || 0;
+          cr += u.cache_read_input_tokens || 0;
+          if (!model && r.message?.model) model = r.message.model;
+        }
+      } catch {}
+    }
+    const cost = Math.round(computeCost(getModelPricingShared(model), input, output, cr, cc) * 100) / 100;
+    const result = { cost, messageCount };
+    costCache.set(filePath, { mtimeMs: st.mtimeMs, size: st.size, ...result });
+    // Keep the cache from growing unbounded across many sessions.
+    if (costCache.size > 500) { const k = costCache.keys().next().value; if (k) costCache.delete(k); }
+    return result;
+  } catch {
+    return { cost: 0, messageCount: 0 };
+  }
+}
+
 /** Collapse a model id to its family for context-window tracking. */
 function modelFamily(model: string): string {
   const m = (model || "").toLowerCase();
@@ -250,13 +294,10 @@ function getSessionDetails(filePath: string): SessionDetails {
     contextUsage = { tokensUsed, maxTokens, usableTokens, percentage, model };
   }
 
-  // Estimate cost (note: we only have partial data from the tail chunk)
-  // totalInputTokens here includes input + cache_create + cache_read from the tail chunk.
-  // Most tokens are cache reads (90% cheaper). Use a blended rate.
-  const pricing = getModelPricing(model);
-  const cacheReadRate = pricing.input * 0.1;
-  const blendedInputRate = totalInputTokens > 0 ? cacheReadRate : 0; // Most input is cache reads
-  const costEstimate = (totalInputTokens / 1_000_000 * blendedInputRate) + (totalOutputTokens / 1_000_000 * pricing.output);
+  // Accurate cost + message count over the whole transcript with per-type rates
+  // (mtime-cached). Replaces the old tail-only blended estimate, which both
+  // undercounted large sessions and mis-blended cache-creation vs cache-read.
+  const { cost: costEstimate, messageCount: accurateMessageCount } = computeSessionCostAndCount(filePath);
 
   // Per-session permission mode from the last "permission-mode" record. It's
   // usually written at session start (head), but can be toggled mid-session
@@ -277,9 +318,9 @@ function getSessionDetails(filePath: string): SessionDetails {
   return {
     contextUsage,
     lastMessage,
-    messageCount,
+    messageCount: accurateMessageCount || messageCount,
     sizeBytes,
-    costEstimate: Math.round(costEstimate * 1000) / 1000, // 3 decimal places
+    costEstimate,
     permissionMode: mapPermissionMode(permRaw),
   };
 }

server/scanner/live-scanner.ts

@@ -15,8 +15,10 @@ export interface ModelPricing {
 
 // Regex-matched in order. First match wins.
 const MODEL_RATE_TABLE: Array<{ match: RegExp; pricing: ModelPricing; note: string }> = [
-  // Opus 4.5 / 4.6 — current pricing (reduced from 4.0/4.1)
-  { match: /opus-4-[56]/i, pricing: { input: 5, output: 25, cacheRead: 0.5, cacheCreation: 6.25 }, note: "opus-4.5/4.6" },
+  // Opus 4.5 and up (4.5, 4.6, 4.7, 4.8, … incl. two-digit minors) — current
+  // reduced pricing. MUST precede the 4.0/4.1 legacy row, whose \b would
+  // otherwise also match "opus-4-7"/"opus-4-8" and overcharge them 3×.
+  { match: /opus-4-(?:[5-9]|[1-9]\d)/i, pricing: { input: 5, output: 25, cacheRead: 0.5, cacheCreation: 6.25 }, note: "opus-4.5+" },
   // Opus 4.0 / 4.1 — legacy, original Claude 4 pricing
   { match: /opus-4(?:-[01])?\b/i, pricing: { input: 15, output: 75, cacheRead: 1.5, cacheCreation: 18.75 }, note: "opus-4.0/4.1 legacy" },
   // Opus 3 — legacy

server/scanner/pricing.ts

@@ -16,6 +16,18 @@ describe("getPricing — 2026-04 rate update", () => {
     expect(p.output).toBe(25);
   });
 
+  // Regression: opus-4-7/4-8 matched the 4.0/4.1 legacy "\b" pattern and were
+  // overcharged 3× ($15 vs $5). They must use the current reduced rates.
+  it("Opus 4.7 / 4.8 use current reduced rates (not legacy $15)", () => {
+    for (const m of ["claude-opus-4-7", "claude-opus-4-8", "claude-opus-4-9", "claude-opus-4-10"]) {
+      const p = getPricing(m);
+      expect(p.input, m).toBe(5);
+      expect(p.output, m).toBe(25);
+      expect(p.cacheRead, m).toBe(0.5);
+      expect(p.cacheCreation, m).toBe(6.25);
+    }
+  });
+
   it("Opus 4 / 4.1 keeps legacy $15/$75 rates for historical accuracy", () => {
     expect(getPricing("claude-opus-4").input).toBe(15);
     expect(getPricing("claude-opus-4-0").input).toBe(15);