ai-usage-analyzer 0.4.0 → 0.5.1

package/src/loaders.js

@@ -2,7 +2,6 @@
 //
 // Unified record shape:
 //   {
-//     tool:        'opencode' | 'codex' | 'mimocode' | string,
 //     sessionId:   string,
 //     project:     string,          // working directory or '(unknown)'
 //     title:       string,
@@ -16,9 +15,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 +70,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 || "";
@@ -77,7 +82,6 @@ function compactHome(p) {
 }
 
 // ---------------------------------------------------------------------------
-// SQLite loader (OpenCode + MimoCode share schema)
 // ---------------------------------------------------------------------------
 
 function loadOpencodeStyleSqlite(dbPath, toolKey) {
@@ -88,7 +92,6 @@ function loadOpencodeStyleSqlite(dbPath, toolKey) {
     return { records: [], error: `cannot open ${dbPath}: ${e.message}` };
   }
 
-  // Introspect session table for token columns (MimoCode schema is a subset)
   const cols = db.prepare(`PRAGMA table_info(session)`).all();
   const colSet = new Set(cols.map((c) => c.name));
   const hasTokens =
@@ -144,6 +147,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 +160,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 +175,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 +206,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 +285,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 +348,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 +370,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 +402,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 +428,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 +444,9 @@ async function parseClaudeSession(path) {
     tokensCacheWrite,
     tokensReasoning: 0,
     tokensTotal: tot,
-    cost: 0,
+    ...estimateUsage("claude", usageEvents),
     model,
+    usageEvents,
   };
 }
 
@@ -398,7 +461,7 @@ export async function loadAll(detections) {
   const tasks = detections
     .filter((d) => d.status === "present")
     .map((d) => {
-      if (d.key === "opencode" || d.key === "mimocode") {
+      if (d.key === "opencode") {
         return Promise.resolve({
           d,
           r: loadOpencodeStyleSqlite(d.path, d.key),

package/src/markdown.js

@@ -31,9 +31,10 @@ export function fmtCompact(n) {
   return String(n || 0);
 }
 
-function fmtCost(n) {
+function fmtCost(n, status) {
+  if (status === "unavailable") return "unavailable";
   if (!n) return "—";
-  return "$" + Number(n).toFixed(2);
+  return (status === "estimated" || status === "partial" ? "~" : "") + "$" + Number(n).toFixed(2) + (status === "partial" ? " (partial)" : "");
 }
 
 function compactHome(p) {
@@ -131,9 +132,9 @@ export function renderMarkdown({
     out.push(`**Range**: ${dateRange[0] ?? "—"} → ${dateRange[1] ?? "—"}  `);
     out.push(`**Sessions**: ${fmtInt(records.length)}  `);
     out.push(`**Total tokens**: ${fmtCompact(tot.tokensTotal)}  `);
-    if (tot.cost > 0) {
-      out.push(`**Cost**: ${fmtCost(tot.cost)} (opencode only)  `);
-    }
+    out.push(`**Average daily tokens**: ${fmtCompact(tot.avgDailyTokens)}  `);
+    out.push(`**Cost**: ${fmtCost(tot.cost, tot.costStatus)}  `);
+    if (tot.unknownModels.length) out.push(`**Unpriced models**: ${tot.unknownModels.map(mdEscape).join(", ")}  `);
   } else {
     out.push(`**No session data available** — only detection status below.`);
   }
@@ -174,11 +175,11 @@ export function renderMarkdown({
   out.push(`|---|---:|---:|---:|---:|`);
   for (const t of tools) {
     out.push(
-      `| ${mdEscape(t.tool)} | ${fmtInt(t.n)} | ${fmtCompact(t.tokensTotal)} | ${fmtCompact(t.avg)} | ${fmtCost(t.cost)} |`,
+      `| ${mdEscape(t.tool)} | ${fmtInt(t.n)} | ${fmtCompact(t.tokensTotal)} | ${fmtCompact(t.avg)} | ${fmtCost(t.cost, t.costStatus)} |`,
     );
   }
   out.push(
-    `| **TOTAL** | **${fmtInt(records.length)}** | **${fmtCompact(tot.tokensTotal)}** | **${fmtCompact(tot.avg)}** | **${fmtCost(tot.cost)}** |`,
+    `| **TOTAL** | **${fmtInt(records.length)}** | **${fmtCompact(tot.tokensTotal)}** | **${fmtCompact(tot.avg)}** | **${fmtCost(tot.cost, tot.costStatus)}** |`,
   );
   out.push(``);
 
@@ -245,7 +246,7 @@ export function renderMarkdown({
     for (const p of toolRows) {
       const cache = p.tokensCacheRead + p.tokensCacheWrite;
       out.push(
-        `| ${mdEscape(p.tool)} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${fmtCost(p.cost)} | ${fmtCompact(p.avg)} | ${bar(p.tokensTotal, max, 20)} |`,
+        `| ${mdEscape(p.tool)} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${fmtCost(p.cost, p.costStatus)} | ${fmtCompact(p.avg)} | ${bar(p.tokensTotal, max, 20)} |`,
       );
     }
     out.push(``);
@@ -316,7 +317,7 @@ export function renderMarkdown({
     top.forEach((r, i) => {
       const proj = compactHome(r.project);
       out.push(
-        `| ${i + 1} | ${fmtCompact(r.tokensTotal)} | ${fmtCompact(r.tokensInput)} | ${fmtCompact(r.tokensOutput)} | ${r.cost ? "$" + r.cost.toFixed(4) : "—"} | ${mdEscape(shortModel(r.model))} | \`${mdEscape(proj)}\` | ${mdEscape(r.title || "—")} |`,
+        `| ${i + 1} | ${fmtCompact(r.tokensTotal)} | ${fmtCompact(r.tokensInput)} | ${fmtCompact(r.tokensOutput)} | ${fmtCost(r.cost, r.costStatus)} | ${mdEscape(shortModel(r.model))} | \`${mdEscape(proj)}\` | ${mdEscape(r.title || "—")} |`,
       );
     });
     out.push(``);
@@ -325,6 +326,8 @@ export function renderMarkdown({
   // Notes ---------------------------------------------------------------
   out.push(`## Notes`);
   out.push(``);
+  out.push(`Costs marked ~ are API-equivalent estimates; partial totals exclude unpriced usage. Recorded costs come from local tool data and are not necessarily subscription charges.`);
+  out.push(``);
   out.push(`### Token Definitions`);
   out.push(``);
   out.push(`- **Input** — prompt tokens sent to the model`);
@@ -333,7 +336,7 @@ export function renderMarkdown({
     `- **Cache Read** — prompt tokens served from the provider's cache (cheap)`,
   );
   out.push(
-    `- **Cache Write** — prompt tokens cached for future use (OpenCode only)`,
+    `- **Cache Write** — prompt tokens cached for future use`,
   );
   out.push(`- **Reasoning** — extended thinking / chain-of-thought tokens`);
   out.push(``);

package/src/pricing.js

@@ -0,0 +1,49 @@
+export const PRICING_VERSION = '2026-10-27';
+
+const PRICES = {
+  claude: [
+    [/^claude-opus-4-[5678](?:-\d{8})?$/, [5, 25, 0.5, 6.25]],
+    [/^claude-sonnet-4-6(?:-\d{8})?$/, [3, 15, 0.3, 3.75]],
+    [/^claude-sonnet-4-5(?:-\d{8})?$/, [3, 15, 0.3, 3.75], 200000],
+    [/^claude-sonnet-4(?:-\d{8})?$/, [3, 15, 0.3, 3.75], 200000],
+    [/^claude-haiku-4-5(?:-\d{8})?$/, [1, 5, 0.1, 1.25]],
+    [/^claude-3-5-haiku(?:-\d{8})?$/, [0.8, 4, 0.08, 1]],
+  ],
+  codex: [
+    [/^gpt-5-5(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [5, 30, 0.5, 0], 272000],
+    [/^gpt-5-4-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.75, 4.5, 0.075, 0]],
+    [/^gpt-5-4-nano(?:-\d{4}-\d{2}-\d{2})?$/, [0.2, 1.25, 0.02, 0]],
+    [/^gpt-5-4-pro(?:-\d{4}-\d{2}-\d{2})?$/, [30, 180, 0, 0], 272000],
+    [/^gpt-5-4(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [2.5, 15, 0.25, 0], 272000],
+    [/^gpt-5-[23](?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [1.75, 14, 0.175, 0]],
+    [/^gpt-5-1(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [1.25, 10, 0.125, 0]],
+    [/^gpt-5-1-codex-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.25, 2, 0.025, 0]],
+    [/^gpt-5-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.25, 2, 0.025, 0]],
+    [/^gpt-5-nano(?:-\d{4}-\d{2}-\d{2})?$/, [0.05, 0.4, 0.005, 0]],
+    [/^gpt-5(?:(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?)$/, [1.25, 10, 0.125, 0]],
+  ],
+};
+
+export function estimateUsage(tool, events) {
+  let cost = 0;
+  let priced = 0;
+  const unknown = new Set();
+  for (const { model, usage, provider, aggregated, ambiguousModel } of events) {
+    const name = String(model || '').toLowerCase().replace(/[._ ]/g, '-').split('/').pop();
+    const price = (PRICES[tool] || []).find(([pattern]) => pattern.test(name));
+    if (!price || (tool === 'codex' && provider && provider.toLowerCase() !== 'openai')) { unknown.add(model || '(unknown model)'); continue; }
+    if (aggregated || ambiguousModel) { unknown.add(`${model || '(unknown model)'} (aggregate usage)`); continue; }
+    const [inputRate, outputRate, cacheRate, writeRate] = price[1];
+    const nonnegative = value => Number.isFinite(Number(value)) ? Math.max(0, Number(value)) : 0;
+    const rawInput = nonnegative(usage.input_tokens);
+    const cache = nonnegative(tool === 'codex' ? usage.cached_input_tokens : usage.cache_read_input_tokens);
+    const input = tool === 'codex' ? Math.max(0, rawInput - cache) : rawInput;
+    const output = nonnegative(usage.output_tokens);
+    const write = nonnegative(usage.cache_creation_input_tokens);
+    const prompt = rawInput + (tool === "claude" ? cache + write : 0);
+    const long = price[2] && prompt > price[2];
+    cost += (input * inputRate * (long ? 2 : 1) + output * outputRate * (long ? 1.5 : 1) + cache * cacheRate * (long ? 2 : 1) + write * writeRate * (long ? 2 : 1)) / 1000000;
+    priced++;
+  }
+  return { cost, costStatus: unknown.size ? (priced ? 'partial' : 'unavailable') : 'estimated', unknownModels: [...unknown] };
+}

package/src/quota.js

@@ -0,0 +1,194 @@
+import { readFile, open, rename, unlink, stat } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+function number(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function resetTime(value) {
+  const seconds = number(value);
+  if (seconds === null || seconds <= 0) return null;
+  const date = new Date(seconds * 1000);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+
+export function parseCodexQuota(data) {
+  const windows = [];
+  function add(rate, prefix = '') {
+    for (const w of [rate?.primary_window, rate?.secondary_window]) {
+      if (!w || number(w.used_percent) === null) continue;
+      const duration = number(w.limit_window_seconds);
+      const name = duration === 18000 ? 'Session' : duration === 604800 ? 'Weekly' : 'Limit';
+      windows.push({ label: prefix ? `${prefix} ${name}` : name, usedPercent: number(w.used_percent), resetAt: resetTime(w.reset_at) });
+    }
+  }
+  add(data.rate_limit);
+  for (const extra of data.additional_rate_limits || []) {
+    const name = extra.limit_name || extra.metered_feature || 'Additional';
+    add(extra.rate_limit, /spark/i.test(name) ? 'Codex Spark' : name);
+  }
+  const spend = data.spend_control?.individual_limit;
+  if (spend) {
+    const used = number(spend.used), limit = number(spend.limit);
+    const percent = number(spend.used_percent) ?? (limit > 0 && used !== null ? used / limit * 100 : null);
+    if (percent !== null) windows.push({ label: 'Monthly spend', usedPercent: percent, resetAt: resetTime(spend.reset_at) });
+  }
+  return { windows, plan: data.plan_type || null };
+}
+
+export function parseClaudeQuota(data) {
+  const windows = [];
+  for (const [field, label] of [['five_hour', 'Session'], ['seven_day', 'Weekly'], ['seven_day_oauth_apps', 'OAuth Apps'], ['seven_day_sonnet', 'Sonnet'], ['seven_day_opus', 'Opus']]) {
+    const w = data[field];
+    if (w && number(w.utilization) !== null) windows.push({ label, usedPercent: number(w.utilization), resetAt: w.resets_at || null });
+  }
+  for (const [fields, label] of [
+    [['seven_day_design', 'seven_day_claude_design', 'claude_design', 'design', 'seven_day_omelette', 'omelette', 'omelette_promotional'], 'Designs'],
+    [['seven_day_routines', 'seven_day_claude_routines', 'claude_routines', 'routines', 'routine', 'seven_day_cowork', 'cowork'], 'Daily Routines'],
+  ]) {
+    const w = fields.map(field => data[field]).find(Boolean);
+    if (w && number(w.utilization) !== null) windows.push({ label, usedPercent: number(w.utilization), resetAt: w.resets_at || null });
+  }
+  const extra = data.extra_usage;
+  const limit = number(extra?.monthly_limit), used = number(extra?.used_credits);
+  const percent = number(extra?.utilization) ?? (limit > 0 && used !== null ? used / limit * 100 : null);
+  if (extra?.is_enabled && percent !== null) windows.push({ label: 'Extra usage', usedPercent: percent, resetAt: null, used: used === null ? null : used / 100, limit: limit === null ? null : limit / 100, currency: extra.currency || 'USD' });
+  return { windows };
+}
+
+export async function fetchQuota(provider, credentials, fetcher = fetch, signal, versionReader) {
+  if (provider !== 'claude' && provider !== 'codex') throw new Error('Unsupported quota provider');
+  if (!credentials?.accessToken) throw new Error('No OAuth access token available');
+  const claude = provider === 'claude';
+  const headers = { Authorization: `Bearer ${credentials.accessToken}`, Accept: 'application/json' };
+  if (claude) {
+    headers['anthropic-beta'] = 'oauth-2025-04-20';
+    let version = '2.1.0';
+    try {
+      const reader = versionReader || (async () => (await execFileAsync('claude', ['--version'], { timeout: 1000, maxBuffer: 4096, signal })).stdout);
+      const output = await reader();
+      version = String(output).match(/\b\d+\.\d+\.\d+\b/)?.[0] || version;
+    } catch {}
+    signal?.throwIfAborted();
+    headers['User-Agent'] = `claude-code/${version}`;
+  } else if (credentials.accountId) {
+    headers['ChatGPT-Account-Id'] = credentials.accountId;
+  }
+  const response = await fetcher(claude ? 'https://api.anthropic.com/api/oauth/usage' : 'https://chatgpt.com/backend-api/wham/usage', { headers, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000) });
+  if (response.status === 401 || response.status === 403) {
+    throw new Error(claude ? 'Claude login is invalid or lacks access; run claude to log in again' : 'Codex login is invalid; run codex login');
+  }
+  if (!response.ok) throw new Error(`Quota request failed (HTTP ${response.status})`);
+  const data = await response.json();
+  const result = { provider, ...(claude ? parseClaudeQuota(data) : parseCodexQuota(data)) };
+  if (!claude && credentials.idToken && credentials.idToken.length < 65536) {
+    try {
+      const claims = JSON.parse(Buffer.from(credentials.idToken.split('.')[1], 'base64url').toString('utf8'));
+      if (typeof claims.email === 'string') result.email = claims.email;
+      if (!result.plan && typeof claims['https://api.openai.com/auth']?.chatgpt_plan_type === 'string') result.plan = claims['https://api.openai.com/auth'].chatgpt_plan_type;
+    } catch {}
+  }
+  return result;
+}
+
+export async function readCredentials(provider, env = process.env, options = {}) {
+  if (provider === 'codex') {
+    const file = join(env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json');
+    const auth = JSON.parse(await readFile(file, 'utf8'));
+    if (auth.OPENAI_API_KEY) throw new Error('OAuth usage limits require codex login');
+    return { accessToken: auth.tokens?.access_token, refreshToken: auth.tokens?.refresh_token, idToken: auth.tokens?.id_token, accountId: auth.tokens?.account_id, lastRefresh: auth.last_refresh, authPath: file };
+  }
+  if (provider !== 'claude') throw new Error('Unsupported quota provider');
+  const token = env.TOKCAT_CLAUDE_OAUTH_TOKEN || env.CODEXBAR_CLAUDE_OAUTH_TOKEN;
+  if (token) return { accessToken: token };
+  let raw;
+  if ((options.platform || process.platform) === 'darwin') {
+    const getKeychain = options.getKeychain || (async () => (await execFileAsync('/usr/bin/security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], { timeout: 5000, maxBuffer: 1024 * 1024, signal: options.signal })).stdout);
+    try { raw = await getKeychain(); }
+    catch (error) {
+      if (options.signal?.aborted) throw error;
+      if (error.killed || error.code === 'ETIMEDOUT') throw new Error('Claude Keychain access timed out; check the permission prompt');
+    }
+  }
+  if (!raw) {
+    const file = join(env.CLAUDE_HOME || join(homedir(), '.claude'), '.credentials.json');
+    raw = await readFile(file, 'utf8');
+  }
+  const oauth = JSON.parse(raw).claudeAiOauth || {};
+  if (oauth.expiresAt && oauth.expiresAt <= Date.now()) throw new Error('Claude token expired; run claude to refresh it');
+  if (oauth.scopes && !oauth.scopes.includes('user:profile')) throw new Error('Claude login lacks user:profile scope');
+  return { accessToken: oauth.accessToken };
+}
+
+export async function refreshCodexCredentials(path, fetcher = fetch, signal) {
+  const original = await readFile(path, 'utf8');
+  const auth = JSON.parse(original);
+  if (!auth.tokens?.refresh_token) throw new Error('Codex refresh token unavailable; run codex login');
+  const response = await fetcher('https://auth.openai.com/oauth/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    body: JSON.stringify({ client_id: 'app_EMoamEEZ73f0CkXaXp7hrann', grant_type: 'refresh_token', refresh_token: auth.tokens.refresh_token, scope: 'openid profile email' }),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000),
+  });
+  if (!response.ok) throw new Error('Codex refresh failed; run codex login');
+  const tokens = await response.json();
+  if (!tokens.access_token) throw new Error('Codex refresh returned incomplete credentials; run codex login');
+  auth.tokens = { ...auth.tokens, access_token: tokens.access_token, refresh_token: tokens.refresh_token || auth.tokens.refresh_token, ...(tokens.id_token ? { id_token: tokens.id_token } : {}) };
+  auth.last_refresh = new Date().toISOString();
+  const temp = `${path}.${randomUUID()}.tmp`;
+  let handle;
+  try {
+    const mode = (await stat(path)).mode & 0o600;
+    handle = await open(temp, 'wx', mode || 0o600);
+    await handle.writeFile(JSON.stringify(auth, null, 2));
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    if (await readFile(path, 'utf8') !== original) throw new Error('Codex credentials changed during refresh; run codex login if needed');
+    await rename(temp, path);
+  } finally {
+    if (handle) await handle.close();
+    await unlink(temp).catch(() => {});
+  }
+  return { accessToken: auth.tokens.access_token, refreshToken: auth.tokens.refresh_token, idToken: auth.tokens.id_token, accountId: auth.tokens.account_id, lastRefresh: auth.last_refresh, authPath: path };
+}
+
+export async function collectQuotas(options = {}) {
+  const read = options.read || ((provider) => readCredentials(provider, process.env, { signal: options.signal }));
+  const refresh = options.refresh || ((path) => refreshCodexCredentials(path, fetch));
+  const request = options.fetch || ((provider, credentials) => fetchQuota(provider, credentials, fetch, options.signal));
+  return Promise.all(['claude', 'codex'].map(async (provider) => {
+    try {
+      let credentials = await read(provider);
+      options.signal?.throwIfAborted();
+      const refreshedAt = Date.parse(credentials.lastRefresh);
+      if (provider === 'codex' && (!Number.isFinite(refreshedAt) || Date.now() - refreshedAt > 8 * 86400000)) {
+        credentials = await refresh(credentials.authPath);
+      }
+      options.signal?.throwIfAborted();
+      return await request(provider, credentials);
+    } catch (error) {
+      const safe = /^(Claude token expired|Claude login lacks|Claude login is invalid|Codex login is invalid|Claude Keychain access|OAuth usage limits|Codex refresh|Codex credentials changed|No OAuth access token|Quota request failed)/;
+      const message = safe.test(error.message || '') ? error.message : 'Quota unavailable; check your login and network connection';
+      return { provider, windows: [], error: message };
+    }
+  }));
+}
+
+export function renderQuota(quotas) {
+  if (!quotas) return 'Loading quota information…';
+  return quotas.map(({ provider, windows, error, email, plan }) => {
+    const name = provider === 'claude' ? 'Claude' : 'Codex';
+    const lines = error ? [error] : windows.length ? windows.map((w) => `${w.label}: ${w.usedPercent}% used${w.used != null && w.limit != null ? ` · ${w.currency} ${w.used.toFixed(2)} / ${w.limit.toFixed(2)}` : ''}${w.resetAt ? ` · resets ${w.resetAt}` : ''}`) : ['No quota windows available'];
+    const identity = [email, plan].filter(Boolean).join(' · ');
+    return `${name}${identity ? ` (${identity})` : ''}\n${lines.map((line) => `  ${line}`).join('\n')}`;
+  }).join('\n\n').replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g, '');
+}