@cad0p/pi-usage 0.11.4 → 0.11.5

package/omarchy/cad0p.pi-usage/UsageLogic.js

@@ -141,15 +141,19 @@ function compactDuration(ms) {
 
 // ----------------------------------------------------------------- accounts
 
-// One row per account of a multi-account record, every window kept.
+// One row per account of a multi-account record, every window kept. The base
+// auth.json entry has no number, so its id stays empty (a blank, aligned column)
+// instead of an invented "#1"; a record cached before the fix is normalized.
 function accountRows(p) {
   var list = p && isList(p.accounts) ? p.accounts : []
   var rows = []
   for (var i = 0; i < list.length; i++) {
     var entry = list[i] || {}
     var windows = limitWindows(entry.limits)
+    var id = entry.id == null ? "" : String(entry.id)
+    if (id === "#1") id = ""
     rows.push({
-      id: String(entry.id || ("#" + (i + 1))),
+      id: id,
       ok: entry.ok === true,
       status: String(entry.status || ""),
       windows: windows,
@@ -172,7 +176,8 @@ function failedAccountCount(p) {
 // family are used one after another (pi rotates to the next slot when one is
 // exhausted), so what stops the next prompt is the account with the most
 // room left: the healthy account whose own fullest window is the emptiest.
-// That is the "lowest" figure /usage prints for the family.
+// /usage's panel lists every account instead of collapsing the family, so
+// this headline is the bar's own summary of those rows.
 function headline(p) {
   if (!p) return null
   var rows = accountRows(p)
@@ -186,7 +191,7 @@ function headline(p) {
         best = row
     }
     if (best) return {
-      title: best.id + " · " + best.binding.title,
+      title: (best.id === "" ? "" : best.id + " · ") + best.binding.title,
       percent: best.binding.percent,
       resetAt: best.binding.resetAt,
       accountId: best.id

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cad0p/pi-usage",
-  "version": "0.11.4",
+  "version": "0.11.5",
   "publishConfig": {
     "access": "public"
   },

package/src/cli/args.js

@@ -19,6 +19,7 @@
  * @property {boolean} status
  * @property {boolean} clearCache
  * @property {boolean} rebuildTotals
+ * @property {string | null} month      `stats --month YYYY-MM`, validated.
  * @property {number} ttlMs
  * @property {number} timeoutMs
  * @property {string[]} unknown          Flags this parser does not own.
@@ -72,6 +73,7 @@ export function parseArgs(argv, defaults = {}) {
     box: false,
     clearCache: false,
     rebuildTotals: false,
+    month: null,
     ttlMs: defaults.defaultTtlMs ?? 60_000,
     timeoutMs: defaults.defaultTimeoutMs ?? 15_000,
     unknown: [],
@@ -94,6 +96,17 @@ export function parseArgs(argv, defaults = {}) {
       continue;
     }
 
+    if (arg === "--month") {
+      const value = argv[index + 1];
+      if (!/^\d{4}-(0[1-9]|1[0-2])$/.test(value ?? "")) {
+        parsed.unknown.push(...flagWithValue(arg, value));
+        continue;
+      }
+      parsed.month = value;
+      index += 1;
+      continue;
+    }
+
     if (SUBCOMMAND_VALUE_FLAGS.has(arg)) {
       // The value is consumed here only so it cannot be mistaken for a
       // positional; the subcommand reads it from `raw` itself.

package/src/cli/commands/stats.js

@@ -3,16 +3,156 @@
  *
  * The history is the one place tokens accumulate across runs; this command is
  * the read-only view of it and the recovery path for a lost `totals.json`.
+ * `--json` never takes the history lock and never writes: it lists the months
+ * that have a file, one month's normalized days and the all-time rollup, and
+ * reports missing, quarantined or unreadable files as notes.
  */
 
-import { acquireHistoryLock, loadTotals, rebuildTotalsFromMonths, releaseHistoryLock, resolveHistoryDir } from "../../local/history.js";
+import { readFileSync } from "node:fs";
+
+import {
+  acquireHistoryLock,
+  bucketMessages,
+  bucketTokens,
+  listHistoryMonths,
+  loadTotals,
+  parseTotals,
+  readMonthFile,
+  rebuildTotalsFromMonths,
+  releaseHistoryLock,
+  resolveHistoryDir,
+  resolveTotalsPath,
+  totalsToJson,
+} from "../../local/history.js";
 import { resolveLocalStatsCachePath } from "../../local/pi-sessions.js";
 import { redact } from "../../http.js";
 import { err, out } from "../output.js";
 
+/** The local month key of now, matching how the history files are named. */
+function currentMonth(now = new Date()) {
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+}
+
+/**
+ * One month's day rows, normalized for consumers: per family and slot, the
+ * token and prompt totals plus the per-model split. Only aggregate counts.
+ *
+ * @param {Record<string, Record<string, any>>} days
+ * @returns {Record<string, Record<string, any>>}
+ */
+function daysToJson(days) {
+  const result = {};
+  for (const [date, families] of Object.entries(days ?? {})) {
+    const day = {};
+    for (const [family, familyRow] of Object.entries(families ?? {})) {
+      const slots = {};
+      let tokens = 0;
+      let prompts = 0;
+      for (const [slot, slotRow] of Object.entries(familyRow?.slots ?? {})) {
+        const models = {};
+        let slotTokens = 0;
+        let slotPrompts = 0;
+        for (const [model, bucket] of Object.entries(slotRow?.models ?? {})) {
+          const modelTokens = bucketTokens(bucket);
+          const messages = bucketMessages(bucket);
+          models[model] = { tokens: modelTokens, messages };
+          slotTokens += modelTokens;
+          slotPrompts += messages;
+        }
+        slots[slot] = { sessions: Number(slotRow?.sessions) || 0, tokens: slotTokens, prompts: slotPrompts, models };
+        tokens += slotTokens;
+        prompts += slotPrompts;
+      }
+      day[family] = { sessions: Number(familyRow?.sessions) || 0, tokens, prompts, slots };
+    }
+    result[date] = day;
+  }
+  return result;
+}
+
+/**
+ * Read totals.json without ever moving, rebuilding or writing it: a corrupt
+ * file is reported as a note and left exactly where it is, because a read-only
+ * command must not take a lock or race the writer.
+ *
+ * @param {string} historyDir
+ * @param {string[]} notes
+ * @returns {Record<string, unknown> | null}
+ */
+function readTotalsReadOnly(historyDir, notes) {
+  const path = resolveTotalsPath(historyDir);
+  let raw;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch (error) {
+    if (/** @type {{ code?: string }} */ (error)?.code !== "ENOENT") {
+      notes.push(`could not read ${path} (${redact(/** @type {{ message?: string }} */ (error)?.message)}); it is left untouched and all-time totals are unavailable`);
+    } else {
+      notes.push(`no all-time totals at ${path} yet`);
+    }
+    return null;
+  }
+  try {
+    const totals = parseTotals(JSON.parse(raw));
+    if (!totals) {
+      notes.push(`${path} is unreadable or from another version; it is left untouched and all-time totals are unavailable`);
+      return null;
+    }
+    return totalsToJson(totals);
+  } catch {
+    notes.push(`${path} is not valid JSON; it is left untouched and all-time totals are unavailable`);
+    return null;
+  }
+}
+
+/**
+ * `stats --json`: the read-only history feed. Lists the browsable months, returns
+ * the requested (default: the live local month) month's days, the all-time
+ * rollup and the notes for anything missing or damaged.
+ *
+ * The live month is always in `months` and is the default, even when it has no
+ * file yet: its open day is not frozen, and on the 1st of a month — or on a
+ * fresh install with older files present — a files-only list would make the
+ * current month unreachable from the /usage History page.
+ *
+ * @param {{ historyDir: string, month?: string | null, now?: Date }} input
+ * @returns {Record<string, unknown>}
+ */
+export function historyJson(input) {
+  const { historyDir } = input;
+  const notes = [];
+  const listed = listHistoryMonths(historyDir);
+  const requested = typeof input.month === "string" && input.month !== "" ? input.month : null;
+  const live = currentMonth(input.now instanceof Date ? input.now : new Date());
+  const months = Array.from(new Set([...listed.months, live])).sort();
+  const selected = requested ?? live;
+  const quarantinedRequest = requested === null ? null : listed.quarantined.find((entry) => entry.month === requested);
+  if (requested !== null && !months.includes(requested) && !quarantinedRequest) {
+    notes.push(`no frozen days for ${requested} in ${historyDir}`);
+  }
+  // One note per damaged month: readMonthFile explains the quarantine or the
+  // corruption once, in the reader's terms, instead of the writer's recovery
+  // instructions on top of a second note from here.
+  const month = readMonthFile(historyDir, selected, notes, { canWrite: false, concise: true });
+  return {
+    schemaVersion: 1,
+    historyDir,
+    generatedAt: new Date().toISOString(),
+    months,
+    quarantined: listed.quarantined.map((entry) => entry.month),
+    month: selected,
+    days: daysToJson(month.days),
+    totals: readTotalsReadOnly(historyDir, notes),
+    notes,
+  };
+}
+
 /**
  * @param {{
  *   rebuild?: boolean,
+ *   json?: boolean,
+ *   month?: string | null,
+ *   now?: Date,
  *   env?: Record<string, string | undefined>,
  *   home?: string,
  *   historyDir?: string,
@@ -26,6 +166,14 @@ export function runStatsCommand(options = {}) {
   /** @type {string[]} */
   const warnings = [];
 
+  if (options.json) {
+    // No lock, no writes: a concurrent scan may be freezing a day while this
+    // reads, and every history file is replaced atomically, so a reader only
+    // ever sees a whole file.
+    out(JSON.stringify(historyJson({ historyDir, month: options.month, now: options.now }), null, 2));
+    return 0;
+  }
+
   if (options.rebuild) {
     // The rebuild rewrites the same file a scan freezes into, so it takes the
     // same lock: a concurrent scan must not interleave its freeze with it.

package/src/engine.js

@@ -149,6 +149,47 @@ export function resolveClaudeCredentials(input) {
   };
 }
 
+/** Default number of accounts of one family queried at the same time. */
+export const DEFAULT_ACCOUNT_CONCURRENCY = 8;
+
+/**
+ * `PI_QUOTA_ACCOUNT_CONCURRENCY` (1-32) bounds the parallel account requests of
+ * one family; 1 restores the sequential behaviour.
+ *
+ * @param {Record<string, string | undefined>} env
+ * @returns {number}
+ */
+export function accountConcurrency(env) {
+  const value = Number.parseInt(env.PI_QUOTA_ACCOUNT_CONCURRENCY ?? "", 10);
+  if (!Number.isFinite(value) || value < 1) return DEFAULT_ACCOUNT_CONCURRENCY;
+  return Math.min(32, value);
+}
+
+/**
+ * Map with at most `limit` calls in flight, results in input order.
+ *
+ * @template T, R
+ * @param {T[]} items
+ * @param {number} limit
+ * @param {(item: T, index: number) => Promise<R>} fn
+ * @returns {Promise<R[]>}
+ */
+export async function mapBounded(items, limit, fn) {
+  /** @type {R[]} */
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await fn(items[index], index);
+    }
+  };
+  // A non-numeric limit would otherwise start no worker and return holes.
+  const bounded = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 1;
+  await Promise.all(Array.from({ length: Math.min(bounded, items.length) }, worker));
+  return results;
+}
+
 /** @type {Record<string, (credential: any, options?: any) => Promise<import("./model.js").QuotaResult>>} */
 const PROVIDERS = {
   claude: fetchClaude,
@@ -314,17 +355,18 @@ export async function collectQuota(options = {}) {
         return;
       }
 
-      /** @type {import("./model.js").QuotaResult[]} */
-      const results = [];
-      const familyWarnList = [];
-      for (const credential of credentials) {
+      // Accounts of one family are independent requests, so they run in
+      // parallel (bounded): with 14 OpenCode Go keys a sequential loop cost
+      // ~3.8 s, a parallel one costs about one round trip. Results keep the
+      // credential order, and the backoff bookkeeping is replayed in that same
+      // order afterwards, so the final backoff state is exactly what the
+      // sequential loop produced.
+      const fetchQuota = PROVIDERS[family];
+      const outcomes = await mapBounded(credentials, accountConcurrency(env), async (credential) => {
         const freshness = checkFreshness(credential, now);
-        if (!freshness.fresh) {
-          familyWarnList.push(
-            `${family}: the ${expiredTokenName(credential)} expired ${Math.abs(freshness.expiresInMin ?? 0)}m ago; ${refreshHint(credential)}`,
-          );
-        }
-        const fetchQuota = PROVIDERS[family];
+        const warning = freshness.fresh
+          ? null
+          : `${family}: the ${expiredTokenName(credential)} expired ${Math.abs(freshness.expiresInMin ?? 0)}m ago; ${refreshHint(credential)}`;
         try {
           const result = await fetchQuota(credential, {
             now,
@@ -341,18 +383,7 @@ export async function collectQuota(options = {}) {
           // The renderers group siblings by family; the record builder needs the
           // slot to label each account without re-parsing its display string.
           result.slot = credential.slot ?? null;
-          if (isThrottled(result.error)) {
-            const seconds = recordBackoff(family, {
-              retryAfterSec: retryAfterFromError(result.error),
-              now,
-              env,
-              home: options.home,
-            }).seconds;
-            familyWarnList.push(`${family}: throttled upstream; pausing that family for ${seconds}s`);
-          } else if (result.ok || isAuthFailure(result.error)) {
-            clearBackoff(family, { env, home: options.home });
-          }
-          results.push(result);
+          return { result, warning, crashed: false };
         } catch (error) {
           // A provider must never take the whole report down.
           const crashed = degradedResult({
@@ -365,8 +396,35 @@ export async function collectQuota(options = {}) {
             expiresInMin: freshness.expiresInMin,
           });
           crashed.slot = credential.slot ?? null;
-          results.push(crashed);
+          return { result: crashed, warning, crashed: true };
+        }
+      });
+
+      /** @type {import("./model.js").QuotaResult[]} */
+      const results = [];
+      const familyWarnList = [];
+      for (const { result, warning, crashed } of outcomes) {
+        if (warning) familyWarnList.push(warning);
+        if (!crashed) {
+          // Bookkeeping must degrade like the provider call it follows: a
+          // failing backoff write is a warning, never a rejected family.
+          try {
+            if (isThrottled(result.error)) {
+              const seconds = recordBackoff(family, {
+                retryAfterSec: retryAfterFromError(result.error),
+                now,
+                env,
+                home: options.home,
+              }).seconds;
+              familyWarnList.push(`${family}: throttled upstream; pausing that family for ${seconds}s`);
+            } else if (result.ok || isAuthFailure(result.error)) {
+              clearBackoff(family, { env, home: options.home });
+            }
+          } catch (error) {
+            familyWarnList.push(`${family}: could not update the backoff state: ${/** @type {{ message?: string }} */ (error)?.message ?? String(error)}`);
+          }
         }
+        results.push(result);
       }
       byFamily[family] = results;
       familyWarnings[family] = familyWarnList;

package/src/http.js

@@ -5,8 +5,41 @@
  * redaction of secrets and error normalization stay in one place.
  */
 
+import { readFileSync } from "node:fs";
+
 const DEFAULT_TIMEOUT_MS = 15000;
 
+/**
+ * The package's own User-Agent, sent on every request that does not set one.
+ *
+ * Without it Node's fetch announces itself as `node`, a generic HTTP-library
+ * name. OpenCode Go's terms ask clients for their own User-Agent and have warned
+ * and banned accounts over generic ones, and a usage poller that runs every few
+ * minutes against every key of a user is exactly the traffic that gets looked
+ * at. Providers that need a specific client string (Antigravity's CLI agent,
+ * the dashboard's browser agent) keep setting their own.
+ */
+export const PACKAGE_USER_AGENT = (() => {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+    return `pi-usage/${pkg.version} (+https://github.com/cad0p/pi-usage)`;
+  } catch {
+    return "pi-usage (+https://github.com/cad0p/pi-usage)";
+  }
+})();
+
+/**
+ * Copy `headers` and add `User-Agent` unless one is already set (any case).
+ *
+ * @param {Record<string, string> | undefined} headers
+ * @returns {Record<string, string>}
+ */
+export function withUserAgent(headers) {
+  const out = { ...(headers ?? {}) };
+  if (!Object.keys(out).some((name) => name.toLowerCase() === "user-agent")) out["User-Agent"] = PACKAGE_USER_AGENT;
+  return out;
+}
+
 /**
  * Redact credential-looking substrings from arbitrary text before it can reach
  * a log, a terminal or an error message.
@@ -96,7 +129,7 @@ export async function requestJson(url, options = {}) {
   try {
     const response = await fetchFn(url, {
       method: options.method ?? "GET",
-      headers: options.headers,
+      headers: withUserAgent(options.headers),
       body: options.body,
       signal: controller.signal,
     });

package/src/local/history.js

@@ -151,6 +151,39 @@ function quarantinedMonthPath(historyDir, month) {
   }
 }
 
+/**
+ * The months with a month file on disk, plus any quarantined copies, read-only:
+ * `stats --json` and the overlay use this to know what can be browsed without
+ * taking the history lock or touching a file.
+ *
+ * @param {string} historyDir
+ * @returns {{ months: string[], quarantined: Array<{ month: string, path: string }> }}
+ */
+export function listHistoryMonths(historyDir) {
+  /** @type {string[]} */
+  let names;
+  try {
+    names = readdirSync(historyDir);
+  } catch {
+    return { months: [], quarantined: [] };
+  }
+  const months = new Set();
+  const quarantined = new Map();
+  for (const name of names) {
+    const month = MONTH_FILE.exec(name)?.[1];
+    if (month) {
+      months.add(month);
+      continue;
+    }
+    const backup = /^tokens-(\d{4}-\d{2})\.json\.corrupt-/.exec(name);
+    if (backup && !quarantined.has(backup[1])) quarantined.set(backup[1], join(historyDir, name));
+  }
+  return {
+    months: Array.from(months).sort(),
+    quarantined: Array.from(quarantined, ([month, path]) => ({ month, path })).sort((a, b) => a.month.localeCompare(b.month)),
+  };
+}
+
 /**
  * Whether the history directory holds any frozen month file at all.
  *
@@ -167,10 +200,11 @@ export function hasMonthFiles(historyDir) {
 
 /**
  * @param {string} slot
- * @returns {string} "#1" for the base entry, "#<slot>" for a numbered sibling.
+ * @returns {string} "" for the base entry (it has no number), "#<slot>" for a
+ * real sibling slot.
  */
 export function accountLabel(slot) {
-  return slot === "" ? "#1" : `#${slot}`;
+  return slot === "" || slot === null || slot === undefined ? "" : `#${slot}`;
 }
 
 /**
@@ -485,8 +519,11 @@ export function parseTotals(raw) {
       for (const day of entry.activeDates) if (typeof day === "string" && day !== "") familyTotals.activeDates.add(day);
     }
     if (entry.accounts && typeof entry.accounts === "object" && !Array.isArray(entry.accounts)) {
-      for (const [label, accountValue] of Object.entries(entry.accounts)) {
+      for (const [rawLabel, accountValue] of Object.entries(entry.accounts)) {
         if (!accountValue || typeof accountValue !== "object") continue;
+        // Files written before the base entry lost its invented "#1" carry that
+        // key; normalize on read so one account never shows up twice.
+        const label = rawLabel === "#1" ? "" : rawLabel;
         const account = /** @type {Record<string, unknown>} */ (accountValue);
         familyTotals.accounts.set(label, {
           totalPrompts: count(account.totalPrompts),
@@ -805,13 +842,18 @@ export function loadTotals(input) {
  * daily detail stays missing until the quarantined copy is restored. The
  * all-time totals it already fed are untouched.
  *
+ * `concise` is for a read-only reader (`stats --json`): it gets one short note
+ * per damaged month, not the writer's recovery instructions.
+ *
  * @param {string} historyDir
  * @param {string} month
  * @param {string[]} warnings
+ * @param {{ canWrite?: boolean, concise?: boolean }} [options]
  * @returns {{ days: Record<string, DayRows>, writable: boolean, exists: boolean, path: string }}
  */
 export function readMonthFile(historyDir, month, warnings, options = {}) {
   const canWrite = options.canWrite !== false;
+  const concise = options.concise === true;
   const path = resolveMonthPath(historyDir, month);
   let raw;
   try {
@@ -821,8 +863,10 @@ export function readMonthFile(historyDir, month, warnings, options = {}) {
       const backup = quarantinedMonthPath(historyDir, month);
       if (backup) {
         warnings.push(
-          `local token stats: ${path} was quarantined as ${backup}; its frozen days are missing from recentDays (shown as 0), ` +
-            `while totals.json keeps the all-time counts. Copy ${backup} back to ${path} if recoverable, or delete that backup to abandon those counts; days after it stay open until then`,
+          concise
+            ? `local token stats: ${path} is quarantined as ${backup}; its frozen days are unavailable while totals.json keeps the all-time counts`
+            : `local token stats: ${path} was quarantined as ${backup}; its frozen days are missing from recentDays (shown as 0), ` +
+                `while totals.json keeps the all-time counts. Copy ${backup} back to ${path} if recoverable, or delete that backup to abandon those counts; days after it stay open until then`,
         );
       }
       return { days: {}, writable: true, exists: false, unreadable: false, quarantined: backup !== null, path };
@@ -848,8 +892,10 @@ export function readMonthFile(historyDir, month, warnings, options = {}) {
   if (!shapeOk) {
     if (!canWrite) {
       warnings.push(
-        `local token stats: ${path} is corrupt or from another version; leaving it in place because this run does not hold the history lock. ` +
-          "Its days are missing from recentDays (shown as 0), while totals.json keeps the all-time counts; a lock owner can quarantine it for restoration",
+        concise
+          ? `local token stats: ${path} is corrupt or from another version; it is left untouched and its frozen days are unavailable`
+          : `local token stats: ${path} is corrupt or from another version; leaving it in place because this run does not hold the history lock. ` +
+              "Its days are missing from recentDays (shown as 0), while totals.json keeps the all-time counts; a lock owner can quarantine it for restoration",
       );
       return { days: {}, writable: false, exists: true, unreadable: true, quarantined: false, path };
     }

package/src/local/pi-sessions.js

@@ -58,6 +58,7 @@ import { dirname, join } from "node:path";
 import { FAMILY_BY_PROVIDER, resolveProviderSlot } from "../auth/pi-auth.js";
 import { redact } from "../http.js";
 import {
+  accountLabel,
   acquireHistoryLock,
   addToModels,
   applyDurable,
@@ -114,7 +115,7 @@ const RECENT_DAYS = 7;
  * @property {number} activeDays
  * @property {string[]} activeDates
  * @property {Record<string, { inputTokens: number, outputTokens: number, cacheReadInputTokens: number, cacheCreationInputTokens: number }>} modelUsage
- * @property {Record<string, { todayTokens: number, weekTokens: number, todayPrompts: number, totalPrompts: number, totalTokens: number }>} byAccount
+ * @property {Record<string, { todayTokens: number, weekTokens: number, todayPrompts: number, totalPrompts: number, totalTokens: number, todayTokensByModel: Record<string, number> }>} byAccount
  */
 
 /**
@@ -910,7 +911,9 @@ function tokensByModel(models) {
  * @returns {number}
  */
 function labelOrder(label) {
-  if (label === "#1") return -1;
+  // "" is the base entry; "#1" is the old invented label for it, kept so a
+  // totals.json written before the fix still sorts first.
+  if (label === "" || label === "#1") return -1;
   const numeric = Number.parseInt(String(label).replace(/^#/, ""), 10);
   return Number.isFinite(numeric) ? numeric : Number.MAX_SAFE_INTEGER;
 }
@@ -959,7 +962,7 @@ export function buildLocalStats(input = {}) {
       openDates.add(day);
       openSessions += count(familyRow.sessions);
       for (const [slot, slotRow] of Object.entries(familyRow.slots ?? {})) {
-        const label = slot === "" ? "#1" : `#${slot}`;
+        const label = accountLabel(slot);
         const account = openAccounts.get(label) ?? { prompts: 0, sessions: 0, models: new Map() };
         account.sessions += count(slotRow.sessions);
         for (const [model, bucket] of Object.entries(slotRow.models ?? {})) {
@@ -994,7 +997,7 @@ export function buildLocalStats(input = {}) {
       /** @type {Map<string, { tokens: number, prompts: number }>} */
       const slots = new Map();
       for (const [slot, slotRow] of Object.entries(familyRow.slots ?? {})) {
-        const label = slot === "" ? "#1" : `#${slot}`;
+        const label = accountLabel(slot);
         let tokens = 0;
         let prompts = 0;
         for (const [model, bucket] of Object.entries(slotRow.models ?? {})) {
@@ -1022,6 +1025,18 @@ export function buildLocalStats(input = {}) {
         todayModels.set(model, (todayModels.get(model) ?? 0) + bucketTokens(bucket));
       }
     }
+    // The same split per account, so the History page can name the model behind
+    // an account's live (unfrozen) today row instead of leaving it blank.
+    /** @type {Map<string, Map<string, number>>} */
+    const todayAccountModels = new Map();
+    for (const [slot, slotRow] of Object.entries(todayRows?.slots ?? {})) {
+      const label = accountLabel(slot);
+      const models = todayAccountModels.get(label) ?? new Map();
+      for (const [model, bucket] of Object.entries(slotRow.models ?? {})) {
+        models.set(model, (models.get(model) ?? 0) + bucketTokens(bucket));
+      }
+      todayAccountModels.set(label, models);
+    }
 
     /** @type {Map<string, number>} */
     const weekModels = new Map();
@@ -1057,6 +1072,7 @@ export function buildLocalStats(input = {}) {
         todayPrompts: daySlots.get(today)?.get(label)?.prompts ?? 0,
         totalPrompts: (historyAccount?.totalPrompts ?? 0) + (openAccount?.prompts ?? 0),
         totalTokens,
+        todayTokensByModel: Object.fromEntries(todayAccountModels.get(label) ?? []),
       };
     }