ccgauge 0.3.1 → 1.0.0

package/dist/report/index.mjs

@@ -0,0 +1,2098 @@
+// lib/providers/claude/index.ts
+import path from "node:path";
+import os from "node:os";
+
+// lib/data-loader/parse-jsonl.ts
+import { createReadStream } from "node:fs";
+import readline from "node:readline";
+var TEXT_PREVIEW_MAX = 200;
+async function parseJsonlFile(file) {
+  const stream = createReadStream(file, { encoding: "utf8" });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  const assistant = [];
+  const user = [];
+  const parentLinks = [];
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!raw || typeof raw !== "object") continue;
+    if (raw.uuid) parentLinks.push([raw.uuid, raw.parentUuid ?? null]);
+    if (raw.type === "assistant") {
+      const a = parseAssistant(raw, file);
+      if (a) assistant.push(a);
+    } else if (raw.type === "user") {
+      const u = parseUser(raw, file);
+      if (u) user.push(u);
+    }
+  }
+  return { assistant, user, parentLinks };
+}
+function parseAssistant(raw, file) {
+  const msg = raw.message;
+  if (!msg) return null;
+  const usage = msg.usage;
+  if (!usage) return null;
+  const model = msg.model ?? "";
+  if (!model || model === "<synthetic>") return null;
+  const messageId = msg.id ?? raw.uuid ?? "";
+  if (!messageId && !raw.requestId) return null;
+  const cacheCreation = usage.cache_creation;
+  const content = Array.isArray(msg.content) ? msg.content : [];
+  const toolNames = [];
+  let hasThinking = false;
+  let textPreview = "";
+  for (const c of content) {
+    if (c.type === "tool_use" && typeof c.name === "string") {
+      toolNames.push(c.name);
+    } else if (c.type === "thinking") {
+      hasThinking = true;
+    } else if (c.type === "text" && typeof c.text === "string" && !textPreview) {
+      textPreview = c.text.slice(0, TEXT_PREVIEW_MAX);
+    }
+  }
+  return {
+    type: "assistant",
+    source: "claude",
+    uuid: raw.uuid ?? messageId,
+    parentUuid: raw.parentUuid ?? null,
+    timestamp: raw.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: raw.sessionId ?? "",
+    requestId: raw.requestId ?? "",
+    cwd: raw.cwd ?? "",
+    gitBranch: raw.gitBranch,
+    version: raw.version,
+    model,
+    messageId,
+    usage: {
+      input_tokens: Number(usage.input_tokens) || 0,
+      output_tokens: Number(usage.output_tokens) || 0,
+      cache_creation_input_tokens: Number(usage.cache_creation_input_tokens) || 0,
+      cache_read_input_tokens: Number(usage.cache_read_input_tokens) || 0,
+      cache_creation_5m: Number(cacheCreation?.ephemeral_5m_input_tokens) || 0,
+      cache_creation_1h: Number(cacheCreation?.ephemeral_1h_input_tokens) || 0
+    },
+    toolNames,
+    hasThinking,
+    textPreview,
+    filePath: file
+  };
+}
+function parseUser(raw, file) {
+  if (!raw.uuid) return null;
+  const msg = raw.message;
+  let textPreview = "";
+  if (msg) {
+    const content = msg.content;
+    if (typeof content === "string") {
+      textPreview = content.slice(0, TEXT_PREVIEW_MAX);
+    } else if (Array.isArray(content)) {
+      for (const c of content) {
+        if (c.type === "text" && typeof c.text === "string") {
+          textPreview = c.text.slice(0, TEXT_PREVIEW_MAX);
+          break;
+        }
+      }
+    }
+  }
+  const isSynthetic = !!textPreview && isSyntheticUserText(textPreview);
+  return {
+    type: "user",
+    source: "claude",
+    uuid: raw.uuid,
+    parentUuid: raw.parentUuid ?? null,
+    timestamp: raw.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: raw.sessionId ?? "",
+    cwd: raw.cwd ?? "",
+    textPreview,
+    isSynthetic,
+    filePath: file
+  };
+}
+function isSyntheticUserText(text) {
+  const t = text.trimStart();
+  if (t.startsWith("Base directory for this skill:")) return true;
+  if (t.startsWith("<system-reminder>")) return true;
+  if (t.startsWith("Caveat: The messages below were generated by")) return true;
+  return false;
+}
+
+// lib/pricing/builtin.ts
+var BUILTIN_PRICING = {
+  "claude-opus-4-7": {
+    input: 5,
+    output: 25,
+    cacheCreation5m: 6.25,
+    cacheCreation1h: 10,
+    cacheRead: 0.5
+  },
+  "claude-opus-4-6": {
+    input: 5,
+    output: 25,
+    cacheCreation5m: 6.25,
+    cacheCreation1h: 10,
+    cacheRead: 0.5
+  },
+  "claude-opus-4-5": {
+    input: 5,
+    output: 25,
+    cacheCreation5m: 6.25,
+    cacheCreation1h: 10,
+    cacheRead: 0.5
+  },
+  "claude-sonnet-4-6": {
+    input: 3,
+    output: 15,
+    cacheCreation5m: 3.75,
+    cacheCreation1h: 6,
+    cacheRead: 0.3
+  },
+  "claude-sonnet-4-5": {
+    input: 3,
+    output: 15,
+    cacheCreation5m: 3.75,
+    cacheCreation1h: 6,
+    cacheRead: 0.3
+  },
+  "claude-haiku-4-5": {
+    input: 1,
+    output: 5,
+    cacheCreation5m: 1.25,
+    cacheCreation1h: 2,
+    cacheRead: 0.1
+  },
+  "claude-haiku-3-5": {
+    input: 0.8,
+    output: 4,
+    cacheCreation5m: 1,
+    cacheCreation1h: 1.6,
+    cacheRead: 0.08
+  },
+  "claude-opus-4-1": {
+    input: 15,
+    output: 75,
+    cacheCreation5m: 18.75,
+    cacheCreation1h: 30,
+    cacheRead: 1.5
+  },
+  "claude-opus-4": {
+    input: 15,
+    output: 75,
+    cacheCreation5m: 18.75,
+    cacheCreation1h: 30,
+    cacheRead: 1.5
+  },
+  "claude-sonnet-4": {
+    input: 3,
+    output: 15,
+    cacheCreation5m: 3.75,
+    cacheCreation1h: 6,
+    cacheRead: 0.3
+  },
+  "claude-sonnet-3-7": {
+    input: 3,
+    output: 15,
+    cacheCreation5m: 3.75,
+    cacheCreation1h: 6,
+    cacheRead: 0.3
+  },
+  "claude-haiku-3": {
+    input: 0.25,
+    output: 1.25,
+    cacheCreation5m: 0.3,
+    cacheCreation1h: 0.5,
+    cacheRead: 0.03
+  }
+};
+var FALLBACK_BY_FAMILY = {
+  opus: BUILTIN_PRICING["claude-opus-4-7"],
+  sonnet: BUILTIN_PRICING["claude-sonnet-4-6"],
+  haiku: BUILTIN_PRICING["claude-haiku-4-5"]
+};
+
+// lib/pricing/cost-from-usage.ts
+var PER_MTOK = 1e6;
+function costFromUsage(usage, pricing) {
+  if (!pricing) {
+    return {
+      input: 0,
+      output: 0,
+      cacheCreation5m: 0,
+      cacheCreation1h: 0,
+      cacheRead: 0,
+      total: 0,
+      saved: 0
+    };
+  }
+  const input = usage.input_tokens / PER_MTOK * pricing.input;
+  const output = usage.output_tokens / PER_MTOK * pricing.output;
+  let cc5 = usage.cache_creation_5m / PER_MTOK * pricing.cacheCreation5m;
+  const cc1 = usage.cache_creation_1h / PER_MTOK * pricing.cacheCreation1h;
+  if (cc5 + cc1 === 0 && usage.cache_creation_input_tokens > 0) {
+    cc5 = usage.cache_creation_input_tokens / PER_MTOK * pricing.cacheCreation5m;
+  }
+  const cacheRead = usage.cache_read_input_tokens / PER_MTOK * pricing.cacheRead;
+  const total = input + output + cc5 + cc1 + cacheRead;
+  const saved = usage.cache_read_input_tokens / PER_MTOK * (pricing.input - pricing.cacheRead);
+  return {
+    input,
+    output,
+    cacheCreation5m: cc5,
+    cacheCreation1h: cc1,
+    cacheRead,
+    total,
+    saved
+  };
+}
+
+// lib/providers/claude/shorten-model.ts
+function capitalize(s) {
+  return s.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function shortenClaudeModel(model) {
+  if (!model) return "(unknown)";
+  let m = model.replace(/-(\d{8})$/, "").replace(/^(vertex_ai|bedrock|anthropic)\//, "");
+  m = m.replace(/^claude-/, "");
+  const parts = m.split("-");
+  if (parts.length >= 2) {
+    const family = parts[0];
+    const version = parts.slice(1).join(".");
+    return capitalize(family) + " " + version;
+  }
+  return capitalize(m.replace(/-/g, " "));
+}
+
+// lib/providers/claude/index.ts
+var dateSuffix = /-\d{8}$/;
+var prefixRe = /^(vertex_ai|bedrock|anthropic)\//;
+function resolvePricing(model) {
+  if (!model) return { pricing: null, matchType: "none", matchedKey: null };
+  if (BUILTIN_PRICING[model]) {
+    return { pricing: BUILTIN_PRICING[model], matchType: "exact", matchedKey: model };
+  }
+  const stripped = model.replace(dateSuffix, "");
+  if (BUILTIN_PRICING[stripped]) {
+    return {
+      pricing: BUILTIN_PRICING[stripped],
+      matchType: "date-stripped",
+      matchedKey: stripped
+    };
+  }
+  const noPrefix = stripped.replace(prefixRe, "");
+  if (BUILTIN_PRICING[noPrefix]) {
+    return {
+      pricing: BUILTIN_PRICING[noPrefix],
+      matchType: "prefix-stripped",
+      matchedKey: noPrefix
+    };
+  }
+  for (const family of ["opus", "sonnet", "haiku"]) {
+    if (model.toLowerCase().includes(family)) {
+      return {
+        pricing: FALLBACK_BY_FAMILY[family],
+        matchType: "family-fallback",
+        matchedKey: `claude-${family}-(latest)`
+      };
+    }
+  }
+  return { pricing: null, matchType: "none", matchedKey: null };
+}
+function getDirs() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, ".claude", "projects"),
+    path.join(home, ".config", "claude", "projects")
+  ];
+  if (process.env.CCGAUGE_CONFIG_DIR) {
+    candidates.push(path.join(process.env.CCGAUGE_CONFIG_DIR, "projects"));
+  }
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    candidates.push(path.join(process.env.CLAUDE_CONFIG_DIR, "projects"));
+  }
+  return Array.from(new Set(candidates));
+}
+var claudeAdapter = {
+  id: "claude",
+  displayName: { en: "Claude", zh: "Claude" },
+  shortLabel: "C",
+  color: { fg: "#b45309", bg: "#fef3c7" },
+  // v2: blank textPreview on synthetic user messages (skill metadata,
+  //     <system-reminder> blocks) so they don't split a single conversation
+  //     into multiple "turns" in the usage table.
+  // v3: keep textPreview but add an `isSynthetic` flag — child rows in the
+  //     usage table show skill metadata as their per-call "prompt"; only
+  //     turn-boundary detection skips synthetic users.
+  parserVersion: "claude-v3-synthetic-flag",
+  capabilities: {
+    hasCacheCreation: true,
+    hasReasoningTokens: false,
+    blockWindowMs: 5 * 60 * 60 * 1e3
+  },
+  getDirs,
+  shouldSkipDir: (name) => name === "tool-results" || name === "memory",
+  parseFile: async (file) => {
+    const parsed = await parseJsonlFile(file);
+    return parsed;
+  },
+  resolvePricing,
+  shortenModel: shortenClaudeModel,
+  costFromUsage,
+  costFootnoteKey: null
+};
+
+// lib/providers/codex/index.ts
+import path2 from "node:path";
+import os2 from "node:os";
+
+// lib/providers/codex/parse-codex-jsonl.ts
+import { createReadStream as createReadStream2, promises as fs } from "node:fs";
+import readline2 from "node:readline";
+var TEXT_PREVIEW_MAX2 = 200;
+async function fileMtimeIso(file) {
+  try {
+    const stat = await fs.stat(file);
+    return new Date(stat.mtimeMs).toISOString();
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+}
+function asString(v) {
+  return typeof v === "string" ? v : "";
+}
+function asNumber(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+function extractMessageText(payload) {
+  const msg = payload.message;
+  if (typeof msg === "string") return msg;
+  const content = payload.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    for (const c of content) {
+      const t = c?.type;
+      if ((t === "input_text" || t === "output_text" || t === "text") && typeof c.text === "string") {
+        return c.text;
+      }
+    }
+  }
+  return "";
+}
+async function parseCodexJsonlFile(file) {
+  const stream = createReadStream2(file, { encoding: "utf8" });
+  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+  const assistant = [];
+  const user = [];
+  const parentLinks = [];
+  let sessionId = "";
+  let cliVersion;
+  let defaultCwd = "";
+  let userIdx = 0;
+  let assistantIdx = 0;
+  let prevTotal = null;
+  const fileMtime = await fileMtimeIso(file);
+  let lastValidTs = fileMtime;
+  const turn = {
+    turnId: null,
+    cwd: "",
+    model: "gpt-unknown",
+    userUuid: null,
+    toolNames: [],
+    hasThinking: false,
+    pendingTextPreview: ""
+  };
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let evt;
+    try {
+      evt = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!evt || typeof evt !== "object" || !evt.type) continue;
+    const payload = evt.payload ?? {};
+    const rawTs = asString(evt.timestamp);
+    const ts = rawTs || lastValidTs;
+    if (rawTs) lastValidTs = rawTs;
+    if (evt.type === "session_meta") {
+      sessionId = asString(payload.id);
+      defaultCwd = asString(payload.cwd);
+      cliVersion = asString(payload.cli_version) || void 0;
+      const metaTs = asString(payload.timestamp);
+      if (metaTs) lastValidTs = metaTs;
+      if (!turn.cwd) turn.cwd = defaultCwd;
+      continue;
+    }
+    if (evt.type === "turn_context") {
+      turn.turnId = asString(payload.turn_id) || turn.turnId;
+      turn.cwd = asString(payload.cwd) || defaultCwd;
+      const m = asString(payload.model);
+      if (m) turn.model = m;
+      const eff = asString(payload.effort);
+      if (eff) turn.effort = eff;
+      turn.toolNames = [];
+      turn.hasThinking = false;
+      turn.pendingTextPreview = "";
+      continue;
+    }
+    if (evt.type === "event_msg") {
+      const sub = asString(payload.type);
+      if (sub === "user_message") {
+        const text = extractMessageText(payload);
+        if (!text) continue;
+        const uuid = `${sessionId}::u${userIdx++}`;
+        user.push({
+          type: "user",
+          source: "codex",
+          uuid,
+          parentUuid: null,
+          timestamp: ts,
+          sessionId,
+          cwd: turn.cwd || defaultCwd,
+          textPreview: text.slice(0, TEXT_PREVIEW_MAX2),
+          filePath: file
+        });
+        parentLinks.push([uuid, null]);
+        turn.userUuid = uuid;
+        continue;
+      }
+      if (sub === "agent_message") {
+        const text = extractMessageText(payload);
+        if (text && !turn.pendingTextPreview) {
+          turn.pendingTextPreview = text.slice(0, TEXT_PREVIEW_MAX2);
+        }
+        continue;
+      }
+      if (sub === "agent_reasoning") {
+        turn.hasThinking = true;
+        continue;
+      }
+      if (sub === "token_count") {
+        const info = payload.info;
+        if (!info) continue;
+        const total = info.total_token_usage;
+        const last = info.last_token_usage;
+        const cur = total ? {
+          input: asNumber(total.input_tokens),
+          cached: asNumber(total.cached_input_tokens),
+          output: asNumber(total.output_tokens),
+          reasoning: asNumber(total.reasoning_output_tokens)
+        } : null;
+        let deltaInput;
+        let deltaCached;
+        let deltaOutput;
+        let deltaReasoning;
+        if (cur) {
+          if (prevTotal === null) {
+            deltaInput = cur.input;
+            deltaCached = cur.cached;
+            deltaOutput = cur.output;
+            deltaReasoning = cur.reasoning;
+          } else {
+            deltaInput = Math.max(0, cur.input - prevTotal.input);
+            deltaCached = Math.max(0, cur.cached - prevTotal.cached);
+            deltaOutput = Math.max(0, cur.output - prevTotal.output);
+            deltaReasoning = Math.max(0, cur.reasoning - prevTotal.reasoning);
+          }
+          if (deltaInput === 0 && deltaCached === 0 && deltaOutput === 0 && deltaReasoning === 0) {
+            continue;
+          }
+          if (prevTotal === null) {
+            prevTotal = { ...cur };
+          } else {
+            prevTotal = {
+              input: Math.max(prevTotal.input, cur.input),
+              cached: Math.max(prevTotal.cached, cur.cached),
+              output: Math.max(prevTotal.output, cur.output),
+              reasoning: Math.max(prevTotal.reasoning, cur.reasoning)
+            };
+          }
+        } else if (last) {
+          deltaInput = asNumber(last.input_tokens);
+          deltaCached = asNumber(last.cached_input_tokens);
+          deltaOutput = asNumber(last.output_tokens);
+          deltaReasoning = asNumber(last.reasoning_output_tokens);
+          if (deltaInput === 0 && deltaCached === 0 && deltaOutput === 0 && deltaReasoning === 0) {
+            continue;
+          }
+        } else {
+          continue;
+        }
+        const uuid = `${sessionId}::a${assistantIdx++}`;
+        const requestId = turn.turnId ? `${turn.turnId}::a${assistantIdx}` : `${sessionId}::a${assistantIdx}`;
+        assistant.push({
+          type: "assistant",
+          source: "codex",
+          uuid,
+          parentUuid: turn.userUuid,
+          timestamp: ts,
+          sessionId,
+          requestId,
+          cwd: turn.cwd || defaultCwd,
+          version: cliVersion,
+          model: turn.model || "gpt-unknown",
+          messageId: requestId,
+          usage: {
+            input_tokens: Math.max(0, deltaInput - deltaCached),
+            // output_tokens already includes reasoning (per OpenAI API
+            // billing convention). reasoning_tokens below is a display-only
+            // breakdown that MUST NOT be added again to total/cost.
+            output_tokens: deltaOutput + deltaReasoning,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: deltaCached,
+            cache_creation_5m: 0,
+            cache_creation_1h: 0,
+            reasoning_tokens: deltaReasoning
+          },
+          toolNames: [...turn.toolNames],
+          hasThinking: turn.hasThinking,
+          textPreview: turn.pendingTextPreview,
+          filePath: file,
+          effort: turn.effort
+        });
+        parentLinks.push([uuid, turn.userUuid]);
+        turn.toolNames = [];
+        turn.hasThinking = false;
+        turn.pendingTextPreview = "";
+        continue;
+      }
+      continue;
+    }
+    if (evt.type === "response_item") {
+      const sub = asString(payload.type);
+      if (sub === "function_call" || sub === "custom_tool_call") {
+        const name = asString(payload.name);
+        if (name) turn.toolNames.push(name);
+        continue;
+      }
+      if (sub === "reasoning") {
+        turn.hasThinking = true;
+        continue;
+      }
+      if (sub === "message") {
+        const role = asString(payload.role);
+        if (role === "assistant") {
+          const text = extractMessageText(payload);
+          if (text && !turn.pendingTextPreview) {
+            turn.pendingTextPreview = text.slice(0, TEXT_PREVIEW_MAX2);
+          }
+        }
+        continue;
+      }
+      continue;
+    }
+  }
+  return { assistant, user, parentLinks };
+}
+
+// lib/providers/codex/pricing.ts
+var BUILTIN_PRICING_OPENAI = {
+  "gpt-5": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.13,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-5-mini": {
+    input: 0.25,
+    output: 2,
+    cacheRead: 0.025,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-5-nano": {
+    input: 0.05,
+    output: 0.4,
+    cacheRead: 5e-3,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-5.4": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.13,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-5.5": {
+    input: 1.25,
+    output: 10,
+    cacheRead: 0.13,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-5.5-mini": {
+    input: 0.25,
+    output: 2,
+    cacheRead: 0.025,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-5.5-nano": {
+    input: 0.05,
+    output: 0.4,
+    cacheRead: 5e-3,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-4.1": {
+    input: 2,
+    output: 8,
+    cacheRead: 0.5,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "gpt-4.1-mini": {
+    input: 0.4,
+    output: 1.6,
+    cacheRead: 0.1,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "o3": {
+    input: 2,
+    output: 8,
+    cacheRead: 0.5,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  },
+  "o4-mini": {
+    input: 1.1,
+    output: 4.4,
+    cacheRead: 0.275,
+    cacheCreation5m: 0,
+    cacheCreation1h: 0
+  }
+};
+var FALLBACK_FAMILY_OPENAI = {
+  gpt: BUILTIN_PRICING_OPENAI["gpt-5"],
+  o: BUILTIN_PRICING_OPENAI["o3"]
+};
+var dateSuffix2 = /-\d{8}$/;
+var prefixRe2 = /^(openai)\//;
+function resolveCodexPricing(model) {
+  if (!model) return { pricing: null, matchType: "none", matchedKey: null };
+  if (BUILTIN_PRICING_OPENAI[model]) {
+    return {
+      pricing: BUILTIN_PRICING_OPENAI[model],
+      matchType: "exact",
+      matchedKey: model
+    };
+  }
+  const stripped = model.replace(dateSuffix2, "");
+  if (BUILTIN_PRICING_OPENAI[stripped]) {
+    return {
+      pricing: BUILTIN_PRICING_OPENAI[stripped],
+      matchType: "date-stripped",
+      matchedKey: stripped
+    };
+  }
+  const noPrefix = stripped.replace(prefixRe2, "");
+  if (BUILTIN_PRICING_OPENAI[noPrefix]) {
+    return {
+      pricing: BUILTIN_PRICING_OPENAI[noPrefix],
+      matchType: "prefix-stripped",
+      matchedKey: noPrefix
+    };
+  }
+  const lower = model.toLowerCase();
+  if (lower.startsWith("gpt-") || lower === "gpt") {
+    return {
+      pricing: FALLBACK_FAMILY_OPENAI.gpt,
+      matchType: "family-fallback",
+      matchedKey: "gpt-(latest)"
+    };
+  }
+  if (/^o\d/.test(lower)) {
+    return {
+      pricing: FALLBACK_FAMILY_OPENAI.o,
+      matchType: "family-fallback",
+      matchedKey: "o-(latest)"
+    };
+  }
+  return { pricing: null, matchType: "none", matchedKey: null };
+}
+
+// lib/providers/codex/shorten-model.ts
+function capitalize2(s) {
+  return s.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+var FAMILY_LABEL = {
+  mini: "Mini",
+  nano: "Nano",
+  pro: "Pro",
+  turbo: "Turbo",
+  preview: "Preview"
+};
+function shortenCodexModel(model) {
+  if (!model) return "(unknown)";
+  const m = model.replace(/^openai\//, "");
+  if (m.toLowerCase().startsWith("gpt-")) {
+    const rest = m.slice(4);
+    const parts = rest.split("-").map((p) => FAMILY_LABEL[p.toLowerCase()] ?? p);
+    return "GPT-" + parts.join(" ");
+  }
+  if (m.toLowerCase().startsWith("o")) {
+    return m.toUpperCase();
+  }
+  return capitalize2(m.replace(/-/g, " "));
+}
+
+// lib/providers/codex/index.ts
+function getDirs2() {
+  const home = os2.homedir();
+  const candidates = [
+    path2.join(home, ".codex", "sessions"),
+    path2.join(home, ".codex", "archived_sessions")
+  ];
+  if (process.env.CCGAUGE_CODEX_DIR) {
+    candidates.push(process.env.CCGAUGE_CODEX_DIR);
+  }
+  if (process.env.CODEX_HOME) {
+    candidates.push(path2.join(process.env.CODEX_HOME, "sessions"));
+    candidates.push(path2.join(process.env.CODEX_HOME, "archived_sessions"));
+  }
+  return Array.from(new Set(candidates));
+}
+var codexAdapter = {
+  id: "codex",
+  displayName: { en: "Codex", zh: "Codex" },
+  shortLabel: "X",
+  color: { fg: "#047857", bg: "#d1fae5" },
+  // v2: switched from last_token_usage to total_token_usage delta (fixed
+  //     ~26% over-counting from duplicate/refresh token_count events).
+  // v3: split reasoning_tokens out as a display-only breakdown alongside
+  //     output_tokens (which still includes reasoning for billing).
+  // v4: persist `effort` from turn_context onto each emitted record so the
+  //     UI can tag the model column (e.g. `gpt-5.2-codex · high`).
+  parserVersion: "codex-v4-effort",
+  capabilities: {
+    hasCacheCreation: false,
+    hasReasoningTokens: true,
+    blockWindowMs: 5 * 60 * 60 * 1e3
+  },
+  getDirs: getDirs2,
+  shouldSkipDir: () => false,
+  parseFile: parseCodexJsonlFile,
+  resolvePricing: resolveCodexPricing,
+  shortenModel: shortenCodexModel,
+  costFromUsage,
+  costFootnoteKey: "cost.footnote.codex"
+};
+
+// lib/providers/index.ts
+var PROVIDERS = {
+  claude: claudeAdapter,
+  codex: codexAdapter
+};
+var ALL_PROVIDER_IDS = ["claude", "codex"];
+function getProvider(id) {
+  return PROVIDERS[id];
+}
+function listProviders() {
+  return ALL_PROVIDER_IDS.map((id) => PROVIDERS[id]);
+}
+function isProviderId(v) {
+  return typeof v === "string" && (v === "claude" || v === "codex");
+}
+
+// lib/data-loader/indexer.ts
+import { promises as fs3, watch as fsWatch } from "node:fs";
+import path4 from "node:path";
+import os4 from "node:os";
+
+// lib/dedup.ts
+function dedupKey(r) {
+  const prefix = `${r.source}:`;
+  if (r.messageId && r.requestId) return `${prefix}${r.messageId}::${r.requestId}`;
+  if (r.messageId) return `${prefix}mid:${r.messageId}`;
+  if (r.requestId) return `${prefix}req:${r.requestId}`;
+  return `${prefix}uuid:${r.uuid}`;
+}
+function dedupAssistantRecords(records) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const k = dedupKey(r);
+    const existing = seen.get(k);
+    if (!existing) {
+      seen.set(k, r);
+      continue;
+    }
+    if (r.timestamp < existing.timestamp) {
+      seen.set(k, r);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+// lib/data-loader/index-persist.ts
+import { promises as fs2 } from "node:fs";
+import path3 from "node:path";
+import os3 from "node:os";
+var SCHEMA_VERSION = 2;
+var DEFAULT_INDEX_NAME = "default";
+function getStateDir() {
+  if (process.env.CCGAUGE_STATE_DIR) return process.env.CCGAUGE_STATE_DIR;
+  return path3.join(os3.homedir(), ".ccgauge");
+}
+function getIndexPath(name) {
+  const fileName = name === DEFAULT_INDEX_NAME ? `index-v${SCHEMA_VERSION}.json` : `index-${name}-v${SCHEMA_VERSION}.json`;
+  return path3.join(getStateDir(), "cache", fileName);
+}
+async function loadPersistedIndex(name = DEFAULT_INDEX_NAME) {
+  const filePath = getIndexPath(name);
+  try {
+    const raw = await fs2.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== SCHEMA_VERSION) return null;
+    if (!Array.isArray(parsed.files)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function savePersistedIndex(payload, name = DEFAULT_INDEX_NAME) {
+  const filePath = getIndexPath(name);
+  const dir = path3.dirname(filePath);
+  await fs2.mkdir(dir, { recursive: true });
+  const data = {
+    schemaVersion: SCHEMA_VERSION,
+    savedAt: payload.savedAt,
+    files: payload.files
+  };
+  const tmp = `${filePath}.tmp-${process.pid}`;
+  await fs2.writeFile(tmp, JSON.stringify(data));
+  await fs2.rename(tmp, filePath);
+}
+
+// lib/data-loader/indexer.ts
+var RECONCILE_DEBOUNCE_MS = 200;
+var SNAPSHOT_REBUILD_DEBOUNCE_MS = 100;
+var POLL_INTERVAL_MS = 3e4;
+var PERSIST_DEBOUNCE_MS = 2e3;
+var SCAN_DEPTH_LIMIT = 8;
+var MAX_ERROR_HISTORY = 20;
+var FileIndexer = class {
+  /** Cache namespace — different consumers (web vs MCP) use different
+   *  names so they don't fight over the same on-disk persisted file. */
+  cacheName;
+  files = /* @__PURE__ */ new Map();
+  snapshot = null;
+  watchers = /* @__PURE__ */ new Map();
+  pollTimer = null;
+  snapshotRebuildTimer = null;
+  persistTimer = null;
+  fileDebouncers = /* @__PURE__ */ new Map();
+  initPromise = null;
+  isIndexing = false;
+  lastIndexedAt = null;
+  indexDurationMs = null;
+  existingDirs = [];
+  dirToProvider = /* @__PURE__ */ new Map();
+  errors = [];
+  loadedFromDisk = false;
+  /** When set, rebuildSnapshotNow uses this as duration start so stats.durationMs
+   *  reflects the full operation (parse + dedup + sort), not just snapshot rebuild. */
+  lastWorkStart = null;
+  /** In-flight forceRescan promise. Concurrent callers coalesce onto this so we
+   *  never have two full scans clobbering each other's `files` map. */
+  rescanPromise = null;
+  constructor(cacheName = DEFAULT_INDEX_NAME) {
+    this.cacheName = cacheName;
+  }
+  init() {
+    if (!this.initPromise) {
+      this.initPromise = this.doInit();
+    }
+    return this.initPromise;
+  }
+  async doInit() {
+    const start = Date.now();
+    this.isIndexing = true;
+    this.lastWorkStart = start;
+    try {
+      await this.detectProviderDirs();
+      const persisted = await loadPersistedIndex(this.cacheName);
+      this.loadedFromDisk = persisted !== null;
+      const persistedMap = /* @__PURE__ */ new Map();
+      if (persisted) {
+        for (const entry of persisted.files) persistedMap.set(entry.filePath, entry);
+      }
+      await this.fullScan(persistedMap);
+      this.rebuildSnapshotNow();
+      this.indexDurationMs = Date.now() - start;
+      this.lastIndexedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.syncWatchersToDirs();
+      this.setupPolling();
+      this.schedulePersist();
+    } finally {
+      this.isIndexing = false;
+    }
+  }
+  /** Re-detect provider data directories. Updates `dirToProvider` and `existingDirs`
+   *  in place. Returns the diff so callers can act on added/removed dirs. */
+  async detectProviderDirs() {
+    const wanted = /* @__PURE__ */ new Map();
+    const dirs = [];
+    for (const provider of listProviders()) {
+      for (const dir of provider.getDirs()) {
+        if (await dirExists(dir)) {
+          if (!wanted.has(dir)) {
+            wanted.set(dir, provider);
+            dirs.push(dir);
+          }
+        }
+      }
+    }
+    const added = [];
+    const removed = [];
+    for (const dir of wanted.keys()) {
+      if (!this.dirToProvider.has(dir)) added.push(dir);
+    }
+    for (const dir of this.dirToProvider.keys()) {
+      if (!wanted.has(dir)) removed.push(dir);
+    }
+    this.dirToProvider = wanted;
+    this.existingDirs = dirs;
+    return { added, removed };
+  }
+  async fullScan(persistedMap) {
+    const fileTasks = [];
+    for (const [dir, provider] of this.dirToProvider) {
+      const files = await listJsonlFiles(dir, provider);
+      for (const f of files) fileTasks.push({ file: f, provider });
+    }
+    const seenPaths = new Set(fileTasks.map((t) => t.file));
+    await Promise.all(
+      fileTasks.map(async ({ file, provider }) => {
+        try {
+          const stat = await fs3.stat(file);
+          const persistedEntry = persistedMap.get(file);
+          if (persistedEntry && persistedEntry.source === provider.id && persistedEntry.parserVersion === provider.parserVersion && persistedEntry.mtimeMs === stat.mtimeMs && persistedEntry.size === stat.size) {
+            this.files.set(file, {
+              source: provider.id,
+              parserVersion: provider.parserVersion,
+              mtimeMs: stat.mtimeMs,
+              size: stat.size,
+              assistantRecords: persistedEntry.assistantRecords,
+              userRecords: persistedEntry.userRecords,
+              parentLinks: persistedEntry.parentLinks
+            });
+            return;
+          }
+          const parsed = await provider.parseFile(file);
+          this.files.set(file, {
+            source: provider.id,
+            parserVersion: provider.parserVersion,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+            assistantRecords: parsed.assistant,
+            userRecords: parsed.user,
+            parentLinks: parsed.parentLinks
+          });
+        } catch (err) {
+          this.recordError(`parse ${file}: ${err.message}`);
+        }
+      })
+    );
+    for (const tracked of Array.from(this.files.keys())) {
+      if (!seenPaths.has(tracked)) this.files.delete(tracked);
+    }
+  }
+  /** Reconcile watchers to currently-known dirs. Adds watchers for new dirs,
+   *  closes watchers for dirs that no longer exist. Idempotent. */
+  syncWatchersToDirs() {
+    for (const [dir, watcher] of this.watchers) {
+      if (!this.dirToProvider.has(dir)) {
+        try {
+          watcher.close();
+        } catch {
+        }
+        this.watchers.delete(dir);
+      }
+    }
+    for (const [dir, provider] of this.dirToProvider) {
+      if (this.watchers.has(dir)) continue;
+      try {
+        const watcher = fsWatch(dir, { recursive: true }, (_eventType, filename) => {
+          if (!filename || typeof filename !== "string") return;
+          if (!filename.endsWith(".jsonl")) return;
+          const fullPath = path4.join(dir, filename);
+          this.scheduleFileReconcile(fullPath, provider);
+        });
+        watcher.on("error", (err) => {
+          this.recordError(`watcher ${dir}: ${err.message}`);
+        });
+        this.watchers.set(dir, watcher);
+      } catch (err) {
+        this.recordError(`watch ${dir}: ${err.message}`);
+      }
+    }
+  }
+  setupPolling() {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.pollTimer = setInterval(() => {
+      this.pollOnce().catch((err) => this.recordError(`poll: ${err.message}`));
+    }, POLL_INTERVAL_MS);
+    this.pollTimer.unref?.();
+  }
+  async pollOnce() {
+    const start = Date.now();
+    const dirDiff = await this.detectProviderDirs();
+    let changed = dirDiff.added.length > 0 || dirDiff.removed.length > 0;
+    if (changed) this.syncWatchersToDirs();
+    const fileTasks = [];
+    for (const [dir, provider] of this.dirToProvider) {
+      const files = await listJsonlFiles(dir, provider);
+      for (const f of files) fileTasks.push({ file: f, provider });
+    }
+    const seenPaths = new Set(fileTasks.map((t) => t.file));
+    await Promise.all(
+      fileTasks.map(async ({ file, provider }) => {
+        try {
+          const stat = await fs3.stat(file);
+          const existing = this.files.get(file);
+          if (existing && existing.mtimeMs === stat.mtimeMs && existing.size === stat.size) {
+            return;
+          }
+          const parsed = await provider.parseFile(file);
+          this.files.set(file, {
+            source: provider.id,
+            parserVersion: provider.parserVersion,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+            assistantRecords: parsed.assistant,
+            userRecords: parsed.user,
+            parentLinks: parsed.parentLinks
+          });
+          changed = true;
+        } catch (err) {
+          this.recordError(`poll-parse ${file}: ${err.message}`);
+        }
+      })
+    );
+    for (const tracked of Array.from(this.files.keys())) {
+      if (!seenPaths.has(tracked)) {
+        this.files.delete(tracked);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.lastWorkStart = start;
+      this.scheduleSnapshotRebuild();
+      this.schedulePersist();
+    }
+  }
+  scheduleFileReconcile(filePath, provider) {
+    const existing = this.fileDebouncers.get(filePath);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.fileDebouncers.delete(filePath);
+      this.reconcileFile(filePath, provider).catch(
+        (err) => this.recordError(`reconcile ${filePath}: ${err.message}`)
+      );
+    }, RECONCILE_DEBOUNCE_MS);
+    timer.unref?.();
+    this.fileDebouncers.set(filePath, timer);
+  }
+  async reconcileFile(filePath, provider) {
+    const workStart = Date.now();
+    let stat = null;
+    try {
+      stat = await fs3.stat(filePath);
+    } catch {
+    }
+    if (!stat || !stat.isFile()) {
+      if (this.files.has(filePath)) {
+        this.files.delete(filePath);
+        this.lastWorkStart = workStart;
+        this.scheduleSnapshotRebuild();
+        this.schedulePersist();
+      }
+      return;
+    }
+    const existing = this.files.get(filePath);
+    if (existing && existing.mtimeMs === stat.mtimeMs && existing.size === stat.size) {
+      return;
+    }
+    try {
+      const parsed = await provider.parseFile(filePath);
+      this.files.set(filePath, {
+        source: provider.id,
+        parserVersion: provider.parserVersion,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        assistantRecords: parsed.assistant,
+        userRecords: parsed.user,
+        parentLinks: parsed.parentLinks
+      });
+      this.lastWorkStart = workStart;
+      this.scheduleSnapshotRebuild();
+      this.schedulePersist();
+    } catch (err) {
+      this.recordError(`parse ${filePath}: ${err.message}`);
+    }
+  }
+  scheduleSnapshotRebuild() {
+    if (this.snapshotRebuildTimer) clearTimeout(this.snapshotRebuildTimer);
+    this.snapshotRebuildTimer = setTimeout(() => {
+      this.snapshotRebuildTimer = null;
+      this.rebuildSnapshotNow();
+    }, SNAPSHOT_REBUILD_DEBOUNCE_MS);
+    this.snapshotRebuildTimer.unref?.();
+  }
+  rebuildSnapshotNow() {
+    const snapshotStart = Date.now();
+    const workStart = this.lastWorkStart ?? snapshotStart;
+    const assistant = [];
+    const user = [];
+    const parentMap = {};
+    let recordsParsed = 0;
+    const bySource = {
+      claude: {
+        source: "claude",
+        filesScanned: 0,
+        recordsParsed: 0,
+        assistantRecords: 0,
+        scannedDirs: []
+      },
+      codex: {
+        source: "codex",
+        filesScanned: 0,
+        recordsParsed: 0,
+        assistantRecords: 0,
+        scannedDirs: []
+      }
+    };
+    for (const [dir, provider] of this.dirToProvider) {
+      bySource[provider.id].scannedDirs.push(dir);
+    }
+    for (const entry of this.files.values()) {
+      assistant.push(...entry.assistantRecords);
+      user.push(...entry.userRecords);
+      for (const [uuid, parent] of entry.parentLinks) parentMap[uuid] = parent;
+      recordsParsed += entry.assistantRecords.length + entry.userRecords.length;
+      bySource[entry.source].filesScanned += 1;
+      bySource[entry.source].recordsParsed += entry.assistantRecords.length + entry.userRecords.length;
+    }
+    const dedupedAssistants = dedupAssistantRecords(assistant).sort(
+      (a, b) => a.timestamp.localeCompare(b.timestamp)
+    );
+    const dedupedUsers = dedupUserRecords(user).sort(
+      (a, b) => a.timestamp.localeCompare(b.timestamp)
+    );
+    for (const rec of dedupedAssistants) bySource[rec.source].assistantRecords += 1;
+    const stats = {
+      filesScanned: this.files.size,
+      recordsParsed,
+      assistantRecords: dedupedAssistants.length,
+      // Wall-clock from when this work started (parse/poll/init) to snapshot ready.
+      // Falls back to snapshot rebuild duration if no parse work preceded.
+      durationMs: Date.now() - workStart,
+      scannedDirs: this.existingDirs
+    };
+    this.snapshot = {
+      records: dedupedAssistants,
+      userRecords: dedupedUsers,
+      parentMap,
+      stats,
+      bySource: Object.values(bySource)
+    };
+    this.lastWorkStart = null;
+  }
+  getSnapshot() {
+    if (!this.snapshot) {
+      throw new Error("Indexer not initialized \u2014 call init() first.");
+    }
+    return this.snapshot;
+  }
+  async forceRescan() {
+    if (!this.initPromise) {
+      await this.init();
+      return this.snapshot;
+    }
+    if (this.rescanPromise) return this.rescanPromise;
+    this.rescanPromise = this.runRescan();
+    try {
+      return await this.rescanPromise;
+    } finally {
+      this.rescanPromise = null;
+    }
+  }
+  async runRescan() {
+    const start = Date.now();
+    this.isIndexing = true;
+    this.lastWorkStart = start;
+    try {
+      this.files.clear();
+      await this.detectProviderDirs();
+      await this.fullScan(/* @__PURE__ */ new Map());
+      this.rebuildSnapshotNow();
+      this.indexDurationMs = Date.now() - start;
+      this.lastIndexedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.syncWatchersToDirs();
+      this.schedulePersist();
+      return this.snapshot;
+    } finally {
+      this.isIndexing = false;
+    }
+  }
+  getStatus() {
+    const snap = this.snapshot;
+    return {
+      initialized: snap !== null,
+      isIndexing: this.isIndexing,
+      lastIndexedAt: this.lastIndexedAt,
+      indexDurationMs: this.indexDurationMs,
+      filesIndexed: this.files.size,
+      recordsIndexed: snap?.stats.assistantRecords ?? 0,
+      bySource: snap?.bySource ?? [],
+      watchers: this.watchers.size,
+      errors: this.errors.slice(-MAX_ERROR_HISTORY),
+      pendingReconciles: this.fileDebouncers.size,
+      loadedFromDisk: this.loadedFromDisk
+    };
+  }
+  schedulePersist() {
+    if (this.persistTimer) clearTimeout(this.persistTimer);
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      const entries = [];
+      for (const [filePath, entry] of this.files) {
+        entries.push({
+          filePath,
+          source: entry.source,
+          parserVersion: entry.parserVersion,
+          mtimeMs: entry.mtimeMs,
+          size: entry.size,
+          assistantRecords: entry.assistantRecords,
+          userRecords: entry.userRecords,
+          parentLinks: entry.parentLinks
+        });
+      }
+      savePersistedIndex(
+        {
+          savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          files: entries
+        },
+        this.cacheName
+      ).catch((err) => this.recordError(`persist: ${err.message}`));
+    }, PERSIST_DEBOUNCE_MS);
+    this.persistTimer.unref?.();
+  }
+  recordError(msg) {
+    const stamped = `${(/* @__PURE__ */ new Date()).toISOString()} ${sanitizeForUser(msg)}`;
+    this.errors.push(stamped);
+    if (this.errors.length > MAX_ERROR_HISTORY * 2) {
+      this.errors.splice(0, this.errors.length - MAX_ERROR_HISTORY);
+    }
+    if (process.env.CCGAUGE_DEBUG) {
+      console.error(`[ccgauge:indexer] ${(/* @__PURE__ */ new Date()).toISOString()} ${msg}`);
+    }
+  }
+  disposeWatchers() {
+    for (const w of this.watchers.values()) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+    this.watchers.clear();
+  }
+  dispose() {
+    this.disposeWatchers();
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.snapshotRebuildTimer) clearTimeout(this.snapshotRebuildTimer);
+    if (this.persistTimer) clearTimeout(this.persistTimer);
+    for (const t of this.fileDebouncers.values()) clearTimeout(t);
+    this.fileDebouncers.clear();
+  }
+};
+function sanitizeForUser(s) {
+  const home = os4.homedir();
+  if (!home) return s;
+  const escaped = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return s.replace(new RegExp(escaped, "g"), "~");
+}
+async function dirExists(p) {
+  try {
+    const s = await fs3.stat(p);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function listJsonlFiles(rootDir, provider) {
+  const out = [];
+  async function walk(dir, depth) {
+    if (depth > SCAN_DEPTH_LIMIT) return;
+    let entries;
+    try {
+      entries = await fs3.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path4.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (provider.shouldSkipDir(e.name)) continue;
+        await walk(full, depth + 1);
+      } else if (e.isFile() && e.name.endsWith(".jsonl")) {
+        out.push(full);
+      }
+    }
+  }
+  await walk(rootDir, 0);
+  return out;
+}
+function dedupUserRecords(records) {
+  const seen = /* @__PURE__ */ new Set();
+  return records.filter((r) => {
+    const k = r.uuid;
+    if (!k) return true;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+function indexerRegistry() {
+  if (!globalThis.__ccgaugeIndexers) {
+    globalThis.__ccgaugeIndexers = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__ccgaugeIndexers;
+}
+function getIndexer(cacheName = DEFAULT_INDEX_NAME) {
+  const reg = indexerRegistry();
+  let inst = reg.get(cacheName);
+  if (!inst) {
+    inst = new FileIndexer(cacheName);
+    reg.set(cacheName, inst);
+  }
+  return inst;
+}
+var indexer = getIndexer();
+
+// lib/data-loader/scan.ts
+async function getCachedScan(opts = {}) {
+  if (opts.force) {
+    return indexer.forceRescan();
+  }
+  await indexer.init();
+  return indexer.getSnapshot();
+}
+
+// lib/pricing/calculate.ts
+function costOfRecord(rec) {
+  const provider = getProvider(rec.source);
+  const { pricing } = provider.resolvePricing(rec.model);
+  return provider.costFromUsage(rec.usage, pricing);
+}
+
+// lib/utils.ts
+function formatNumber(n, opts) {
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: opts?.maxFrac ?? 0
+  }).format(n);
+}
+function formatTokensCompact(n, locale = "en") {
+  if (!Number.isFinite(n)) return "0";
+  if (locale === "zh") {
+    if (n >= 1e8) return (n / 1e8).toFixed(2) + "\u4EBF";
+    if (n >= 1e4) return (n / 1e4).toFixed(1) + "\u4E07";
+    return formatNumber(n);
+  }
+  if (n >= 1e9) return (n / 1e9).toFixed(2) + "B";
+  if (n >= 1e6) return (n / 1e6).toFixed(2) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+  return formatNumber(n);
+}
+function formatUSD(n, opts) {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: opts?.minFrac ?? 2,
+    maximumFractionDigits: opts?.maxFrac ?? 2
+  }).format(n);
+}
+function formatPct(n, frac = 1) {
+  if (!Number.isFinite(n)) return "0%";
+  return `${(n * 100).toFixed(frac)}%`;
+}
+function projectNameFromCwd(cwd) {
+  if (!cwd) return "(unknown)";
+  const trimmed = cwd.replace(/[/\\]+$/, "");
+  const parts = trimmed.split(/[/\\]+/);
+  return parts[parts.length - 1] || cwd;
+}
+
+// lib/aggregator/index.ts
+var GRANULARITIES = ["hour", "day", "week", "month"];
+function isGranularity(v) {
+  return typeof v === "string" && GRANULARITIES.includes(v);
+}
+function bucketKey(ts, gran) {
+  const d = new Date(ts);
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  const hh = String(d.getHours()).padStart(2, "0");
+  if (gran === "hour") {
+    return { key: `${yyyy}-${mm}-${dd}T${hh}`, label: `${mm}/${dd} ${hh}:00` };
+  }
+  if (gran === "day") {
+    return { key: `${yyyy}-${mm}-${dd}`, label: `${mm}/${dd}` };
+  }
+  if (gran === "week") {
+    const monday = new Date(d);
+    const day = monday.getDay() || 7;
+    monday.setDate(monday.getDate() - day + 1);
+    const wm = String(monday.getMonth() + 1).padStart(2, "0");
+    const wd = String(monday.getDate()).padStart(2, "0");
+    return {
+      key: `${monday.getFullYear()}-W${wm}${wd}`,
+      label: `Wk ${wm}/${wd}`
+    };
+  }
+  return { key: `${yyyy}-${mm}`, label: `${yyyy}-${mm}` };
+}
+function withinRange(rec, opts) {
+  if (rec.source !== opts.source) return false;
+  if (opts.from && rec.timestamp < opts.from.toISOString()) return false;
+  if (opts.to && rec.timestamp > opts.to.toISOString()) return false;
+  if (opts.models && opts.models.length && !opts.models.includes(rec.model)) return false;
+  if (opts.projects && opts.projects.length && !opts.projects.includes(rec.cwd)) return false;
+  return true;
+}
+function aggregateByTime(records, gran, opts) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    if (!withinRange(rec, opts)) continue;
+    const { key, label } = bucketKey(rec.timestamp, gran);
+    let b = buckets.get(key);
+    if (!b) {
+      b = makeBucket(key, label);
+      buckets.set(key, b);
+    }
+    pushRecord(b, rec);
+  }
+  return Array.from(buckets.values()).sort((a, b) => a.key.localeCompare(b.key));
+}
+function makeBucket(key, label) {
+  return {
+    key,
+    label,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    totalTokens: 0,
+    cost: 0,
+    saved: 0,
+    requests: 0,
+    models: {}
+  };
+}
+function pushRecord(b, rec) {
+  const cost = costOfRecord(rec);
+  b.inputTokens += rec.usage.input_tokens;
+  b.outputTokens += rec.usage.output_tokens;
+  b.cacheReadTokens += rec.usage.cache_read_input_tokens;
+  b.cacheCreationTokens += rec.usage.cache_creation_input_tokens;
+  b.totalTokens = b.inputTokens + b.outputTokens + b.cacheReadTokens + b.cacheCreationTokens;
+  b.cost += cost.total;
+  b.saved += cost.saved;
+  b.requests += 1;
+  const m = b.models[rec.model] ?? { tokens: 0, cost: 0, requests: 0 };
+  m.tokens += rec.usage.input_tokens + rec.usage.output_tokens + rec.usage.cache_read_input_tokens + rec.usage.cache_creation_input_tokens;
+  m.cost += cost.total;
+  m.requests += 1;
+  b.models[rec.model] = m;
+}
+function aggregateByModel(records, opts) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    if (!withinRange(rec, opts)) continue;
+    let s = map.get(rec.model);
+    if (!s) {
+      const { pricing, matchType } = getProvider(rec.source).resolvePricing(rec.model);
+      s = {
+        model: rec.model,
+        source: rec.source,
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        totalTokens: 0,
+        cost: 0,
+        saved: 0,
+        pricing,
+        pricingResolved: matchType === "exact" || matchType === "date-stripped" || matchType === "prefix-stripped"
+      };
+      map.set(rec.model, s);
+    }
+    const cost = costOfRecord(rec);
+    s.requests += 1;
+    s.inputTokens += rec.usage.input_tokens;
+    s.outputTokens += rec.usage.output_tokens;
+    s.cacheReadTokens += rec.usage.cache_read_input_tokens;
+    s.cacheCreationTokens += rec.usage.cache_creation_input_tokens;
+    s.totalTokens = s.inputTokens + s.outputTokens + s.cacheReadTokens + s.cacheCreationTokens;
+    s.cost += cost.total;
+    s.saved += cost.saved;
+  }
+  return Array.from(map.values()).sort((a, b) => b.cost - a.cost);
+}
+function aggregateByProject(records, opts) {
+  const map = /* @__PURE__ */ new Map();
+  const sessionsByProject = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    if (!withinRange(rec, opts)) continue;
+    const cwd = rec.cwd || "(unknown)";
+    let s = map.get(cwd);
+    if (!s) {
+      s = {
+        cwd,
+        projectName: projectNameFromCwd(cwd),
+        sessions: 0,
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        totalTokens: 0,
+        cost: 0,
+        saved: 0,
+        firstActivity: rec.timestamp,
+        lastActivity: rec.timestamp,
+        models: []
+      };
+      map.set(cwd, s);
+      sessionsByProject.set(cwd, /* @__PURE__ */ new Set());
+    }
+    sessionsByProject.get(cwd).add(rec.sessionId);
+    const cost = costOfRecord(rec);
+    s.requests += 1;
+    s.inputTokens += rec.usage.input_tokens;
+    s.outputTokens += rec.usage.output_tokens;
+    s.cacheReadTokens += rec.usage.cache_read_input_tokens;
+    s.cacheCreationTokens += rec.usage.cache_creation_input_tokens;
+    s.totalTokens = s.inputTokens + s.outputTokens + s.cacheReadTokens + s.cacheCreationTokens;
+    s.cost += cost.total;
+    s.saved += cost.saved;
+    if (rec.timestamp < s.firstActivity) s.firstActivity = rec.timestamp;
+    if (rec.timestamp > s.lastActivity) s.lastActivity = rec.timestamp;
+    if (!s.models.includes(rec.model)) s.models.push(rec.model);
+  }
+  for (const [cwd, set] of sessionsByProject) {
+    const s = map.get(cwd);
+    s.sessions = set.size;
+  }
+  return Array.from(map.values()).sort((a, b) => b.cost - a.cost);
+}
+function aggregateBySession(records, userRecords, opts) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    if (!withinRange(rec, opts)) continue;
+    const sid = rec.sessionId || rec.uuid;
+    let s = map.get(sid);
+    if (!s) {
+      s = {
+        sessionId: sid,
+        cwd: rec.cwd,
+        projectName: projectNameFromCwd(rec.cwd),
+        startTime: rec.timestamp,
+        endTime: rec.timestamp,
+        durationMs: 0,
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        totalTokens: 0,
+        cost: 0,
+        saved: 0,
+        models: [],
+        modelBreakdown: {}
+      };
+      map.set(sid, s);
+    }
+    const cost = costOfRecord(rec);
+    s.requests += 1;
+    s.inputTokens += rec.usage.input_tokens;
+    s.outputTokens += rec.usage.output_tokens;
+    s.cacheReadTokens += rec.usage.cache_read_input_tokens;
+    s.cacheCreationTokens += rec.usage.cache_creation_input_tokens;
+    s.totalTokens = s.inputTokens + s.outputTokens + s.cacheReadTokens + s.cacheCreationTokens;
+    s.cost += cost.total;
+    s.saved += cost.saved;
+    if (rec.timestamp < s.startTime) s.startTime = rec.timestamp;
+    if (rec.timestamp > s.endTime) s.endTime = rec.timestamp;
+    if (!s.models.includes(rec.model)) s.models.push(rec.model);
+    const mb = s.modelBreakdown[rec.model] ?? { tokens: 0, cost: 0, requests: 0 };
+    mb.tokens += rec.usage.input_tokens + rec.usage.output_tokens + rec.usage.cache_read_input_tokens + rec.usage.cache_creation_input_tokens;
+    mb.cost += cost.total;
+    mb.requests += 1;
+    s.modelBreakdown[rec.model] = mb;
+  }
+  const firstUserBySession = /* @__PURE__ */ new Map();
+  for (const u of userRecords) {
+    const existing = firstUserBySession.get(u.sessionId);
+    if (!existing || u.timestamp < existing.timestamp) {
+      firstUserBySession.set(u.sessionId, u);
+    }
+  }
+  for (const s of map.values()) {
+    s.durationMs = Math.max(0, new Date(s.endTime).getTime() - new Date(s.startTime).getTime());
+    const u = firstUserBySession.get(s.sessionId);
+    if (u && u.textPreview) {
+      s.firstUserMessage = u.textPreview;
+      s.title = u.textPreview.slice(0, 80);
+    }
+  }
+  return Array.from(map.values()).sort((a, b) => b.endTime.localeCompare(a.endTime));
+}
+function aggregateTotals(records, opts) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheCreationTokens = 0;
+  let cost = 0;
+  let saved = 0;
+  let requests = 0;
+  for (const rec of records) {
+    if (!withinRange(rec, opts)) continue;
+    const c = costOfRecord(rec);
+    inputTokens += rec.usage.input_tokens;
+    outputTokens += rec.usage.output_tokens;
+    cacheReadTokens += rec.usage.cache_read_input_tokens;
+    cacheCreationTokens += rec.usage.cache_creation_input_tokens;
+    cost += c.total;
+    saved += c.saved;
+    requests += 1;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheCreationTokens,
+    cost,
+    saved,
+    requests
+  };
+}
+
+// lib/range.ts
+var USAGE_RANGES = ["1d", "7d", "30d", "90d", "all"];
+function isUsageRange(v) {
+  return typeof v === "string" && USAGE_RANGES.includes(v);
+}
+function rangeToDates(range) {
+  const now = /* @__PURE__ */ new Date();
+  if (range === "all") return {};
+  if (range === "1d") {
+    const from2 = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    return { from: from2 };
+  }
+  const m = range.match(/^(\d+)([dwm])$/);
+  if (!m) return {};
+  const n = parseInt(m[1], 10);
+  const unit = m[2];
+  const from = new Date(now);
+  if (unit === "d") from.setDate(from.getDate() - n);
+  else if (unit === "w") from.setDate(from.getDate() - n * 7);
+  else if (unit === "m") from.setMonth(from.getMonth() - n);
+  return { from };
+}
+
+// lib/cli-report/index.ts
+var REPORT_RANGES = ["today", "1d", "7d", "30d", "90d", "all"];
+var DIMS = ["model", "project", "session"];
+var DATE_ONLY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+var DEFAULT_REPORT = {
+  range: "7d",
+  source: "all",
+  by: "model",
+  gran: "day",
+  limit: 10,
+  json: false,
+  color: true,
+  showTrend: true,
+  showBreakdown: true
+};
+async function runReport(opts) {
+  const filled = normalizeReportOptions(opts);
+  const scan = await getCachedScan();
+  const sources = filled.source === "all" ? ALL_PROVIDER_IDS : [filled.source];
+  const data = computeReportData(scan.records, sources, filled);
+  if (filled.json) return JSON.stringify(data, null, 2);
+  return renderText(data, filled);
+}
+function normalizeReportOptions(opts) {
+  const filled = { ...DEFAULT_REPORT, ...opts };
+  if (!isReportRange(filled.range)) {
+    throw new Error(invalidOptionMessage("range", filled.range, REPORT_RANGES));
+  }
+  if (filled.source !== "all" && !isProviderId(filled.source)) {
+    throw new Error(invalidOptionMessage("source", filled.source, ["claude", "codex", "all"]));
+  }
+  if (!isDim(filled.by)) {
+    throw new Error(invalidOptionMessage("by", filled.by, DIMS));
+  }
+  if (!isGranularity(filled.gran)) {
+    throw new Error(invalidOptionMessage("gran", filled.gran, ["hour", "day", "week", "month"]));
+  }
+  if (filled.since) parseReportDate(filled.since, "since");
+  if (filled.until) parseReportDate(filled.until, "until");
+  const dates = resolveRange(filled);
+  if (dates.from && dates.until && dates.from.getTime() > dates.until.getTime()) {
+    throw new Error("invalid date range: --since must be before or equal to --until");
+  }
+  return filled;
+}
+function isReportRange(v) {
+  return typeof v === "string" && REPORT_RANGES.includes(v);
+}
+function isDim(v) {
+  return typeof v === "string" && DIMS.includes(v);
+}
+function invalidOptionMessage(name, value, expected) {
+  return `invalid ${name}: ${JSON.stringify(value)}. Expected one of: ${expected.join(", ")}`;
+}
+function computeReportData(allRecords, sources, o) {
+  const dates = resolveRange(o);
+  const baseOpts = {
+    from: dates.from ?? void 0,
+    to: dates.until ?? void 0,
+    models: o.model ? void 0 : void 0,
+    // handled post-filter
+    projects: o.project ? void 0 : void 0
+  };
+  const totals = {
+    input: 0,
+    output: 0,
+    reasoning: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    total: 0,
+    cost: 0,
+    saved: 0,
+    requests: 0
+  };
+  const trendBuckets = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const opts = { ...baseOpts, source };
+    const sourceRecs = allRecords.filter((r) => withinSrcAndFilters(r, opts, o));
+    const t = aggregateTotals(sourceRecs, opts);
+    totals.input += t.inputTokens;
+    totals.output += t.outputTokens;
+    totals.cacheRead += t.cacheReadTokens;
+    totals.cacheWrite += t.cacheCreationTokens;
+    totals.total += t.totalTokens;
+    totals.cost += t.cost;
+    totals.saved += t.saved;
+    totals.requests += t.requests;
+    for (const r of sourceRecs) totals.reasoning += r.usage.reasoning_tokens ?? 0;
+    const buckets = aggregateByTime(sourceRecs, o.gran, opts);
+    for (const b of buckets) {
+      const ex = trendBuckets.get(b.key);
+      if (ex) {
+        ex.cost += b.cost;
+        ex.tokens += b.totalTokens;
+      } else {
+        trendBuckets.set(b.key, { label: b.label, cost: b.cost, tokens: b.totalTokens });
+      }
+    }
+  }
+  const trend = Array.from(trendBuckets.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([, v]) => v);
+  const breakdown = buildBreakdown(allRecords, sources, baseOpts, o);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    range: o.range,
+    source: o.source,
+    by: o.by,
+    gran: o.gran,
+    fromIso: dates.from?.toISOString() ?? null,
+    untilIso: dates.until?.toISOString() ?? null,
+    totals,
+    trend,
+    breakdown
+  };
+}
+function buildBreakdown(allRecords, sources, base, o) {
+  if (o.by === "model") {
+    const rows2 = [];
+    for (const source of sources) {
+      const opts = { ...base, source };
+      const filtered = allRecords.filter((r) => withinSrcAndFilters(r, opts, o));
+      const models = aggregateByModel(filtered, opts);
+      const provider = getProvider(source);
+      for (const m of models) {
+        rows2.push({
+          key: `${source}::${m.model}`,
+          label: provider.shortenModel(m.model),
+          requests: m.requests,
+          tokens: m.totalTokens,
+          cost: m.cost,
+          share: 0,
+          // filled after total
+          sub: m.model
+        });
+      }
+    }
+    return finalizeShare(rows2, o.limit);
+  }
+  if (o.by === "project") {
+    const rows2 = [];
+    for (const source of sources) {
+      const opts = { ...base, source };
+      const filtered = allRecords.filter((r) => withinSrcAndFilters(r, opts, o));
+      const projects = aggregateByProject(filtered, opts);
+      for (const p of projects) {
+        rows2.push({
+          key: `${source}::${p.cwd}`,
+          label: p.projectName,
+          requests: p.requests,
+          tokens: p.totalTokens,
+          cost: p.cost,
+          share: 0,
+          sub: p.cwd
+        });
+      }
+    }
+    return finalizeShare(rows2, o.limit);
+  }
+  const rows = [];
+  for (const source of sources) {
+    const opts = { ...base, source };
+    const filtered = allRecords.filter((r) => withinSrcAndFilters(r, opts, o));
+    const sessions = aggregateBySession(filtered, [], opts);
+    for (const s of sessions) {
+      rows.push({
+        key: `${source}::${s.sessionId}`,
+        label: s.title ?? s.sessionId.slice(0, 8),
+        requests: s.requests,
+        tokens: s.totalTokens,
+        cost: s.cost,
+        share: 0,
+        sub: s.projectName
+      });
+    }
+  }
+  return finalizeShare(rows, o.limit);
+}
+function finalizeShare(rows, limit) {
+  const total = rows.reduce((s, r) => s + r.cost, 0);
+  rows.sort((a, b) => b.cost - a.cost);
+  const top = rows.slice(0, Math.max(1, limit));
+  if (total > 0) for (const r of top) r.share = r.cost / total;
+  return top;
+}
+function withinSrcAndFilters(rec, opts, o) {
+  if (rec.source !== opts.source) return false;
+  if (opts.from && rec.timestamp < opts.from.toISOString()) return false;
+  if (opts.to && rec.timestamp > opts.to.toISOString()) return false;
+  if (o.model && !rec.model.toLowerCase().includes(o.model.toLowerCase())) return false;
+  if (o.project) {
+    const needle = o.project.toLowerCase();
+    const cwd = (rec.cwd || "").toLowerCase();
+    const leaf = cwd.split(/[/\\]+/).pop() ?? "";
+    if (!cwd.includes(needle) && !leaf.includes(needle)) return false;
+  }
+  return true;
+}
+function resolveRange(o) {
+  if (o.since || o.until) {
+    return {
+      from: o.since ? parseReportDate(o.since, "since") : null,
+      until: o.until ? parseReportDate(o.until, "until") : null
+    };
+  }
+  const r = o.range === "today" ? "1d" : o.range;
+  if (!isUsageRange(r)) {
+    throw new Error(invalidOptionMessage("range", o.range, REPORT_RANGES));
+  }
+  const d = rangeToDates(r);
+  return { from: d.from ?? null, until: d.to ?? null };
+}
+function parseReportDate(raw, boundary) {
+  const m = raw.match(DATE_ONLY_RE);
+  if (m) {
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    const date2 = boundary === "since" ? new Date(year, month - 1, day, 0, 0, 0, 0) : new Date(year, month - 1, day, 23, 59, 59, 999);
+    if (date2.getFullYear() !== year || date2.getMonth() !== month - 1 || date2.getDate() !== day) {
+      throw new Error(`invalid ${boundary} date: ${raw}`);
+    }
+    return date2;
+  }
+  const date = new Date(raw);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`invalid ${boundary} date: ${raw}`);
+  }
+  return date;
+}
+function makeColors(enabled) {
+  const wrap = (code) => (s) => enabled ? `\x1B[${code}m${s}\x1B[0m` : String(s);
+  return {
+    bold: wrap("1"),
+    dim: wrap("2"),
+    cyan: wrap("36"),
+    green: wrap("32"),
+    yellow: wrap("33"),
+    red: wrap("31"),
+    blue: wrap("34"),
+    magenta: wrap("35"),
+    brand: wrap("38;2;129;140;248")
+  };
+}
+function renderText(d, o) {
+  const c = makeColors(o.color !== false);
+  const lines = [];
+  const ts = new Date(d.generatedAt).toLocaleString();
+  lines.push("");
+  lines.push(`${c.brand(c.bold("ccgauge"))} ${c.bold("report")}`);
+  lines.push(
+    c.dim(
+      [
+        `range: ${d.range}`,
+        `source: ${d.source}`,
+        `by: ${d.by}`,
+        `gran: ${d.gran}`,
+        `generated ${ts}`
+      ].join("  \xB7  ")
+    )
+  );
+  lines.push("");
+  lines.push(c.brand("\u25B8") + " " + c.bold("Tokens"));
+  const t = d.totals;
+  const tokenRows = [
+    ["Input", formatTokensCompact(t.input), "Output", formatTokensCompact(t.output)],
+    [
+      "Cache R",
+      c.green(formatTokensCompact(t.cacheRead)),
+      "Cache W",
+      formatTokensCompact(t.cacheWrite)
+    ]
+  ];
+  if (t.reasoning > 0) {
+    tokenRows.push([
+      "Reasoning",
+      c.dim(formatTokensCompact(t.reasoning)),
+      "Requests",
+      t.requests.toLocaleString()
+    ]);
+    tokenRows.push(["Total", c.bold(formatTokensCompact(t.total)), "", ""]);
+  } else {
+    tokenRows.push([
+      "Total",
+      c.bold(formatTokensCompact(t.total)),
+      "Requests",
+      t.requests.toLocaleString()
+    ]);
+  }
+  lines.push(renderPairedKv(tokenRows, c));
+  lines.push("");
+  lines.push(c.brand("\u25B8") + " " + c.bold("Cost"));
+  const totalInputForCache = t.input + t.cacheRead + t.cacheWrite;
+  const cacheHit = totalInputForCache > 0 ? t.cacheRead / totalInputForCache : 0;
+  const avgPerReq = t.requests > 0 ? t.cost / t.requests : 0;
+  const costRows = [
+    ["Total", c.bold(formatUSD(t.cost)), "Saved by cache", c.green(formatUSD(t.saved))],
+    [
+      "Avg / request",
+      avgPerReq < 0.01 ? `$${avgPerReq.toFixed(4)}` : formatUSD(avgPerReq),
+      "Cache hit",
+      c.green(formatPct(cacheHit, 1))
+    ]
+  ];
+  lines.push(renderPairedKv(costRows, c));
+  lines.push("");
+  if (o.showTrend !== false && d.trend.length > 0) {
+    lines.push(c.brand("\u25B8") + " " + c.bold("Trend") + " " + c.dim(`(${o.gran}, by cost)`));
+    const maxCost = Math.max(...d.trend.map((b) => b.cost), 1e-9);
+    const maxLabelLen = Math.max(...d.trend.map((b) => b.label.length));
+    const maxCostStr = Math.max(...d.trend.map((b) => formatUSD(b.cost).length));
+    for (const b of d.trend) {
+      const bar = barString(b.cost / maxCost, 44);
+      const label = b.label.padEnd(maxLabelLen);
+      const cost = formatUSD(b.cost).padStart(maxCostStr);
+      lines.push(`  ${c.dim(label)}  ${cost}  ${c.brand(bar)}`);
+    }
+    lines.push("");
+  }
+  if (o.showBreakdown !== false && d.breakdown.length > 0) {
+    const dimLabel = d.by[0].toUpperCase() + d.by.slice(1);
+    lines.push(
+      c.brand("\u25B8") + " " + c.bold(`Top ${d.breakdown.length} ${dimLabel}s`) + " " + c.dim("(by cost)")
+    );
+    const headers = ["#", dimLabel, "Reqs", "Tokens", "Cost", "Share"];
+    const rows = d.breakdown.map((r, i) => [
+      String(i + 1),
+      truncate(r.label, 28),
+      r.requests.toLocaleString(),
+      formatTokensCompact(r.tokens),
+      formatUSD(r.cost),
+      formatPct(r.share, 1)
+    ]);
+    lines.push(renderTable(headers, rows, c, [false, false, true, true, true, true]));
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderPairedKv(rows, c) {
+  const w = [0, 0, 0, 0];
+  for (const r of rows) for (let i = 0; i < 4; i += 1) {
+    const cell = r[i];
+    if (visibleLen(cell) > w[i]) w[i] = visibleLen(cell);
+  }
+  const lines = [];
+  for (const [lk, lv, rk, rv] of rows) {
+    const left = `${c.dim(padEnd(lk, w[0]))}  ${padEnd(lv, w[1])}`;
+    const right = rk ? `${c.dim(padEnd(rk, w[2]))}  ${rv}` : "";
+    lines.push(`  ${left}    ${right}`.replace(/\s+$/, ""));
+  }
+  return lines.join("\n");
+}
+function renderTable(headers, rows, c, rightAlign) {
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => visibleLen(r[i] ?? "")))
+  );
+  const headLine = "  " + headers.map((h, i) => rightAlign[i] ? padStart(h, widths[i]) : padEnd(h, widths[i])).map((s) => c.dim(s)).join("  ");
+  const sepLine = "  " + widths.map((w) => "\u2500".repeat(w)).map((s) => c.dim(s)).join("  ");
+  const bodyLines = rows.map(
+    (row) => "  " + row.map((cell, i) => rightAlign[i] ? padStart(cell, widths[i]) : padEnd(cell, widths[i])).join("  ")
+  );
+  return [headLine, sepLine, ...bodyLines].join("\n");
+}
+function barString(ratio, width) {
+  const r = Math.max(0, Math.min(1, ratio));
+  const filled = Math.round(r * width);
+  return "\u2587".repeat(filled) + "\u2500".repeat(width - filled);
+}
+var ESC = String.fromCharCode(27);
+var ANSI_RE = new RegExp(ESC + "\\[[0-9;]*m", "g");
+function visibleLen(s) {
+  return s.replace(ANSI_RE, "").length;
+}
+function padEnd(s, w) {
+  return s + " ".repeat(Math.max(0, w - visibleLen(s)));
+}
+function padStart(s, w) {
+  return " ".repeat(Math.max(0, w - visibleLen(s))) + s;
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+export {
+  DEFAULT_REPORT,
+  runReport
+};