llm-cost-attribution 0.1.0

package/src/index.mjs

@@ -0,0 +1,243 @@
+/**
+ * Library API for `llm-cost-attribution`.
+ *
+ * Use this to compute per-issue token/turn/quota rollups from your own
+ * code. For a ready-to-run command, see the `llm-cost` binary
+ * (bin/llm-cost.mjs).
+ */
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { rollupSessions } from './aggregator.mjs';
+import { DEFAULT_CWD_PATTERN, issueFromClaudeProjectDirName, issueFromCwd } from './issue-pattern.mjs';
+import { findClaudeProjectDirs, listJsonlsRecursively, parseClaudeSession } from './transcripts/claude.mjs';
+import { listCodexRollouts, parseCodexSession } from './transcripts/codex.mjs';
+import { sessionToUsageRecords } from './transcript-to-usage.mjs';
+import { appendUsageRecords, readUsageRecords, validateUsageRecord } from './usage-jsonl.mjs';
+import { rollupUsageRecords } from './usage-aggregator.mjs';
+
+export { DEFAULT_CWD_PATTERN, issueFromCwd, issueFromClaudeProjectDirName } from './issue-pattern.mjs';
+export { rollupSessions } from './aggregator.mjs';
+export { rollupUsageRecords } from './usage-aggregator.mjs';
+export { sessionToUsageRecords } from './transcript-to-usage.mjs';
+export {
+  SCHEMA_VERSION,
+  findUsageFiles,
+  readUsageRecords,
+  appendUsageRecords,
+  validateUsageRecord,
+} from './usage-jsonl.mjs';
+export {
+  computeMultiIssueRollup,
+  expandAllIssueArgs,
+  expandIssueArg,
+} from './multi-issue.mjs';
+export {
+  PRICING_TABLE,
+  STALE_AFTER_DAYS,
+} from './pricing-rates.mjs';
+export {
+  calculateCost,
+  daysSincePricingVerified,
+  hypotheticalNoteFor,
+  isPricingStale,
+  normalizeModelName,
+  ratesForModel,
+} from './pricing.mjs';
+
+/**
+ * Read every Claude session whose encoded project directory name matches the
+ * given issue identifier, plus every Codex rollout whose `session_meta.cwd`
+ * matches it, and aggregate them into a single per-issue rollup.
+ *
+ * @param {string} issueIdentifier  e.g. "EPAC-1940"
+ * @param {object} [options]
+ * @param {RegExp}  [options.cwdPattern]         Default matches Symphony / Autopilot convention.
+ * @param {string}  [options.claudeProjectsDir]  Override `~/.claude/projects`.
+ * @param {string}  [options.codexSessionsDir]   Override `~/.codex/sessions`.
+ */
+export async function computeIssueCost(issueIdentifier, options = {}) {
+  const cwdPattern = options.cwdPattern ?? DEFAULT_CWD_PATTERN;
+  const claudeRootDir = options.claudeProjectsDir ?? join(homedir(), '.claude', 'projects');
+  const codexRootDir = options.codexSessionsDir ?? join(homedir(), '.codex', 'sessions');
+
+  const sessions = [];
+
+  // Claude: directory-name match.
+  const matchingProjectDirs = await findClaudeProjectDirs(
+    claudeRootDir,
+    (encoded) => issueFromClaudeProjectDirName(encoded, cwdPattern) === issueIdentifier,
+  );
+  for (const dir of matchingProjectDirs) {
+    for (const file of await listJsonlsRecursively(dir)) {
+      const session = await parseClaudeSession(file);
+      if (session !== null) sessions.push(session);
+    }
+  }
+
+  // Codex: session_meta.cwd match, scanned across all rollouts.
+  for (const file of await listCodexRollouts(codexRootDir)) {
+    const session = await parseCodexSession(file);
+    if (session === null) continue;
+    if (issueFromCwd(session.cwd, cwdPattern) === issueIdentifier) sessions.push(session);
+  }
+
+  return rollupSessions(issueIdentifier, sessions);
+}
+
+/**
+ * Compute token/turn cost for all sessions run from a specific worktree
+ * directory, regardless of any issue identifier or Symphony convention.
+ * Works with any directory a user ran `claude` or `codex` from — no Linear
+ * issue or symphonyd required.
+ *
+ * @param {string} worktreePath  Absolute path to the worktree directory.
+ * @param {object} [options]
+ * @param {string} [options.claudeProjectsDir]  Override `~/.claude/projects`.
+ * @param {string} [options.codexSessionsDir]   Override `~/.codex/sessions`.
+ */
+export async function computeWorktreeCost(worktreePath, options = {}) {
+  const claudeRootDir = options.claudeProjectsDir ?? join(homedir(), '.claude', 'projects');
+  const codexRootDir = options.codexSessionsDir ?? join(homedir(), '.codex', 'sessions');
+
+  const sessions = [];
+
+  // Claude: the project directory name is the absolute cwd with every `/` and
+  // `.` replaced by `-`. Look it up directly — no regex needed.
+  const encodedPath = worktreePath.replace(/[/.]/g, '-');
+  const claudeProjectDir = join(claudeRootDir, encodedPath);
+  for (const file of await listJsonlsRecursively(claudeProjectDir)) {
+    const session = await parseClaudeSession(file);
+    if (session !== null) sessions.push(session);
+  }
+
+  // Codex: scan all rollouts, keep those whose session_meta.cwd matches exactly.
+  for (const file of await listCodexRollouts(codexRootDir)) {
+    const session = await parseCodexSession(file);
+    if (session === null) continue;
+    if (session.cwd === worktreePath) sessions.push(session);
+  }
+
+  return rollupSessions(basename(worktreePath), sessions);
+}
+
+/**
+ * Same shape as `computeIssueCost`, but sources data from a usage.jsonl file
+ * (or a directory of `usage*.jsonl` files) instead of the CLI transcripts.
+ * Use this after backfilling so you can safely delete `~/.claude/projects`
+ * and `~/.codex/sessions` and still query historical cost.
+ *
+ * Records with `usageSource === "unavailable"` are skipped.
+ *
+ * @param {string} issueIdentifier
+ * @param {string} usageSource  A .jsonl file or a directory of `usage*.jsonl` files.
+ */
+export async function computeIssueCostFromUsage(issueIdentifier, usageSource) {
+  const records = [];
+  for await (const rec of readUsageRecords(usageSource)) {
+    if (validateUsageRecord(rec) !== null) continue;
+    records.push(rec);
+  }
+  return rollupUsageRecords(issueIdentifier, records);
+}
+
+/**
+ * Walk every Claude session + every Codex rollout, derive spec-compliant
+ * usage.jsonl records for each, and append them to a single output file.
+ *
+ * Sessions whose cwd doesn't match the configured pattern are skipped (they
+ * aren't attributable to any issue this tool understands).
+ *
+ * After backfilling, the operator can safely delete the source transcripts
+ * — the usage.jsonl file carries every field needed to reproduce the cost
+ * rollups via `computeIssueCostFromUsage`. The fidelity tradeoff is that
+ * usage.jsonl drops the cache-tier split, reasoning-vs-visible split, and
+ * Codex quota samples — see the package README for the full list.
+ *
+ * @param {object} options
+ * @param {string} options.outFile                       Destination .jsonl path. Created if missing; appended if present.
+ * @param {RegExp} [options.cwdPattern]
+ * @param {string} [options.claudeProjectsDir]
+ * @param {string} [options.codexSessionsDir]
+ * @param {(progress: { phase: string, file?: string, processed: number, total: number, recordsWritten: number }) => void} [options.onProgress]
+ * @returns {Promise<{ recordsWritten: number, sessionsProcessed: number, sessionsSkipped: number }>}
+ */
+export async function backfillUsageFromTranscripts(options) {
+  const outFile = options.outFile;
+  if (typeof outFile !== 'string' || outFile === '') {
+    throw new TypeError('backfillUsageFromTranscripts: options.outFile is required');
+  }
+  const cwdPattern = options.cwdPattern ?? DEFAULT_CWD_PATTERN;
+  const claudeRootDir = options.claudeProjectsDir ?? join(homedir(), '.claude', 'projects');
+  const codexRootDir = options.codexSessionsDir ?? join(homedir(), '.codex', 'sessions');
+  const onProgress = options.onProgress ?? (() => undefined);
+
+  let recordsWritten = 0;
+  let sessionsProcessed = 0;
+  let sessionsSkipped = 0;
+
+  // Phase 1: walk Claude project dirs and emit records for matching sessions.
+  const claudeDirs = await findClaudeProjectDirs(claudeRootDir, (encoded) => issueFromClaudeProjectDirName(encoded, cwdPattern) !== null);
+  for (let i = 0; i < claudeDirs.length; i++) {
+    const dir = claudeDirs[i];
+    const encoded = dir.split('/').pop() ?? '';
+    const issueIdentifier = issueFromClaudeProjectDirName(encoded, cwdPattern);
+    if (issueIdentifier === null) continue;
+    for (const file of await listJsonlsRecursively(dir)) {
+      const session = await parseClaudeSession(file);
+      if (session === null) { sessionsSkipped += 1; continue; }
+      const records = sessionToUsageRecords(session, issueIdentifier);
+      if (records.length === 0) { sessionsSkipped += 1; continue; }
+      await appendUsageRecords(outFile, records);
+      recordsWritten += records.length;
+      sessionsProcessed += 1;
+    }
+    onProgress({ phase: 'claude', file: dir, processed: i + 1, total: claudeDirs.length, recordsWritten });
+  }
+
+  // Phase 2: walk Codex rollouts.
+  const codexFiles = await listCodexRollouts(codexRootDir);
+  for (let i = 0; i < codexFiles.length; i++) {
+    const file = codexFiles[i];
+    const session = await parseCodexSession(file);
+    if (session === null) { sessionsSkipped += 1; continue; }
+    const issueIdentifier = issueFromCwd(session.cwd, cwdPattern);
+    if (issueIdentifier === null) { sessionsSkipped += 1; continue; }
+    const records = sessionToUsageRecords(session, issueIdentifier);
+    if (records.length === 0) { sessionsSkipped += 1; continue; }
+    await appendUsageRecords(outFile, records);
+    recordsWritten += records.length;
+    sessionsProcessed += 1;
+    if ((i + 1) % 100 === 0 || i + 1 === codexFiles.length) {
+      onProgress({ phase: 'codex', file, processed: i + 1, total: codexFiles.length, recordsWritten });
+    }
+  }
+
+  return { recordsWritten, sessionsProcessed, sessionsSkipped };
+}
+
+/**
+ * Enumerate every issue identifier that has at least one session in the
+ * configured transcript directories. Useful for `llm-cost list`.
+ *
+ * @param {object} [options]  Same shape as computeIssueCost options.
+ */
+export async function listKnownIssues(options = {}) {
+  const cwdPattern = options.cwdPattern ?? DEFAULT_CWD_PATTERN;
+  const claudeRootDir = options.claudeProjectsDir ?? join(homedir(), '.claude', 'projects');
+  const codexRootDir = options.codexSessionsDir ?? join(homedir(), '.codex', 'sessions');
+  const ids = new Set();
+
+  for (const dir of await findClaudeProjectDirs(claudeRootDir, () => true)) {
+    const dirName = dir.split('/').pop() ?? '';
+    const issue = issueFromClaudeProjectDirName(dirName, cwdPattern);
+    if (issue !== null) ids.add(issue);
+  }
+  for (const file of await listCodexRollouts(codexRootDir)) {
+    const session = await parseCodexSession(file);
+    if (session === null) continue;
+    const issue = issueFromCwd(session.cwd, cwdPattern);
+    if (issue !== null) ids.add(issue);
+  }
+
+  return [...ids].sort();
+}

package/src/issue-pattern.mjs

@@ -0,0 +1,58 @@
+/**
+ * Maps a working directory (the cwd at which a CLI session was launched) to
+ * an issue identifier. The mapping is convention-driven: the caller decides
+ * what shape their cwd takes; this module decides whether a given cwd
+ * belongs to a given issue.
+ *
+ * The default pattern matches the two most common `workspace.root` settings
+ * for a Symphony-conformant orchestrator
+ * (https://github.com/openai/symphony/blob/main/SPEC.md):
+ *
+ *   1. The spec default, `<system-temp>/symphony_workspaces/<ID>`
+ *      (e.g. `/tmp/symphony_workspaces/EPAC-1940`).
+ *   2. The in-repo override, `<repo>/.symphony/workspaces/<ID>`
+ *      (e.g. `/Users/x/code/repo/.symphony/workspaces/EPAC-1940`).
+ *
+ * Both place the workspace_key (the sanitized issue identifier) as the last
+ * path component of the cwd, satisfying the spec's Invariant 1
+ * (`cwd == workspace_path`). For other `workspace.root` settings, pass
+ * `--cwd-pattern '<regex>'` with one capture group for the issue ID.
+ *
+ * The pattern matches against either:
+ *   - the FULL cwd string (raw, as recorded in Codex `session_meta.cwd`), or
+ *   - the encoded Claude project directory name (where `/` and `.` have both
+ *     been replaced by `-`).
+ *
+ * Examples of caller-supplied patterns:
+ *   /\/issues\/([A-Z]+-\d+)$/    (matches `~/code/issues/PROJ-12`)
+ *   /-([A-Z]+-\d+)$/             (matches any cwd ending `-PROJ-12`)
+ */
+
+// Both Symphony-default `symphony_workspaces/<ID>` and the common in-repo
+// `.symphony/workspaces/<ID>` form, in either raw or Claude-encoded shape
+// (`/` and `.` both become `-` in Claude's project-dir encoding).
+export const DEFAULT_CWD_PATTERN =
+  /(?:symphony_workspaces|[.\-]symphony[/-]workspaces)[/-]([A-Za-z0-9._-]+)$/;
+
+/**
+ * Extract the issue identifier from a Codex-style raw cwd path
+ * (e.g. `/Users/sunny/code/repo/.symphony/workspaces/EPAC-1940`).
+ */
+export function issueFromCwd(cwd, pattern) {
+  const m = pattern.exec(cwd);
+  return m === null ? null : (m[1] ?? null);
+}
+
+/**
+ * Extract the issue identifier from a Claude-encoded project directory name
+ * (e.g. `-Users-sunny-code-repo--symphony-workspaces-EPAC-1940`).
+ *
+ * Claude Code stores sessions under `~/.claude/projects/<encoded-cwd>/` and
+ * encodes the absolute cwd by replacing every `/` and `.` with `-`. The
+ * default pattern's character class `[.\-]` matches both the raw and
+ * encoded path separators in one regex.
+ */
+export function issueFromClaudeProjectDirName(name, pattern) {
+  const m = pattern.exec(name);
+  return m === null ? null : (m[1] ?? null);
+}

package/src/multi-issue.mjs

@@ -0,0 +1,217 @@
+/**
+ * Multi-issue rollup: aggregate cost across a set of issues specified as
+ * either explicit IDs (`EPAC-1940`) or inclusive ranges (`EPAC-1990-1999`).
+ *
+ * Range syntax exploits the fact that Linear issue keys are strictly
+ * `<TEAM>-<NUMBER>` (no other hyphens permitted in the key), so a
+ * positional matching `<PREFIX>-<START>-<END>` is unambiguously a range.
+ */
+
+const SINGLE_ISSUE_PATTERN = /^([A-Z][A-Z0-9]*)-(\d+)$/;
+const RANGE_PATTERN = /^([A-Z][A-Z0-9]*)-(\d+)-(\d+)$/;
+
+/**
+ * Expand a single positional into a list of issue IDs.
+ *
+ *   "EPAC-1940"       → ["EPAC-1940"]
+ *   "EPAC-1990-1999"  → ["EPAC-1990", "EPAC-1991", ..., "EPAC-1999"]
+ *
+ * Throws if the positional doesn't match either shape, or if a range
+ * has start > end, or if the range is unreasonably large (> 10,000).
+ *
+ * @param {string} arg
+ * @returns {string[]}
+ */
+export function expandIssueArg(arg) {
+  if (typeof arg !== 'string' || arg.length === 0) {
+    throw new Error(`empty issue argument`);
+  }
+  const normalized = arg.trim().toUpperCase();
+
+  const rangeMatch = RANGE_PATTERN.exec(normalized);
+  if (rangeMatch !== null) {
+    const prefix = rangeMatch[1];
+    const start = Number.parseInt(rangeMatch[2], 10);
+    const end = Number.parseInt(rangeMatch[3], 10);
+    if (start > end) {
+      throw new Error(`range start > end: ${arg} (parsed as ${start}..${end})`);
+    }
+    const count = end - start + 1;
+    if (count > 10_000) {
+      throw new Error(`range too large: ${arg} would expand to ${count} issues (cap is 10,000)`);
+    }
+    const out = new Array(count);
+    for (let i = 0; i < count; i++) out[i] = `${prefix}-${start + i}`;
+    return out;
+  }
+
+  const singleMatch = SINGLE_ISSUE_PATTERN.exec(normalized);
+  if (singleMatch !== null) {
+    return [normalized];
+  }
+
+  throw new Error(
+    `unrecognized issue argument: ${arg}` +
+    ` (expected <TEAM>-<N> or <TEAM>-<N>-<M>, e.g. EPAC-1940 or EPAC-1990-1999)`,
+  );
+}
+
+/**
+ * Expand and deduplicate a list of positionals into a stable-ordered set.
+ *
+ * Order is: first appearance of each unique ID across the args. This way
+ * `./cost EPAC-1990-1999 EPAC-1995` doesn't double-count or shuffle.
+ *
+ * @param {readonly string[]} args
+ * @returns {{ ids: string[], requestedCount: number }}
+ *   - ids: ordered unique issue identifiers
+ *   - requestedCount: total IDs after range expansion (before dedup). Useful
+ *     for "10 issues requested, 7 had data" framing when ranges are involved.
+ */
+export function expandAllIssueArgs(args) {
+  const seen = new Set();
+  const ids = [];
+  let requestedCount = 0;
+  for (const arg of args) {
+    const expanded = expandIssueArg(arg);
+    requestedCount += expanded.length;
+    for (const id of expanded) {
+      if (!seen.has(id)) {
+        seen.add(id);
+        ids.push(id);
+      }
+    }
+  }
+  return { ids, requestedCount };
+}
+
+/**
+ * @typedef {object} PerIssueRow
+ * @property {string} issueIdentifier
+ * @property {number} sessionCount
+ * @property {number} turnCount
+ * @property {number} tokens                Combined input + output across providers.
+ * @property {number|null} apiCostUsd       Null if no rates known for any model used.
+ * @property {Record<string, {sessions: number, turns: number, tokens: number, costUsd: number|null}>} byProvider
+ */
+
+/**
+ * @typedef {object} MultiIssueRollup
+ * @property {string} label                 Human-readable summary (e.g. "EPAC-1990-1999" or "3 issues").
+ * @property {string[]} positionals         The raw args the user passed.
+ * @property {string[]} requestedIds        Every unique ID after expansion.
+ * @property {number} requestedCount        Sum of expanded args before dedup.
+ * @property {PerIssueRow[]} issues         One row per ID that had any data.
+ * @property {string[]} missing             IDs in requestedIds with no data.
+ * @property {PerIssueRow} totals           Aggregate across `issues`.
+ */
+
+/**
+ * Compute a rollup across multiple issue IDs.
+ *
+ * `loader` is `(issueId) => Promise<IssueRollup>` so this function works
+ * against either CLI transcripts or a usage.jsonl source — the caller
+ * passes whichever loader they want.
+ *
+ * @param {readonly string[]} positionals     The user's raw positional args.
+ * @param {(id: string) => Promise<import('./aggregator.js').IssueRollup>} loader
+ * @returns {Promise<MultiIssueRollup>}
+ */
+export async function computeMultiIssueRollup(positionals, loader) {
+  const { ids, requestedCount } = expandAllIssueArgs(positionals);
+
+  const issues = [];
+  const missing = [];
+
+  for (const id of ids) {
+    const rollup = await loader(id);
+    if (rollup.combinedSessions === 0 && rollup.combinedTurns === 0) {
+      missing.push(id);
+      continue;
+    }
+    issues.push(rollupToRow(id, rollup));
+  }
+
+  return {
+    label: labelFor(positionals),
+    positionals: [...positionals],
+    requestedIds: ids,
+    requestedCount,
+    issues,
+    missing,
+    totals: sumRows(issues),
+  };
+}
+
+function rollupToRow(issueIdentifier, rollup) {
+  const byProvider = {};
+  let totalCost = null;
+  let costKnown = true;
+  for (const provider of ['claude', 'codex']) {
+    const t = rollup.providerTotals[provider];
+    const cost = t.pricing?.totalUsd ?? null;
+    byProvider[provider] = {
+      sessions: t.sessionCount,
+      turns: t.turnCount,
+      tokens: t.tokensGrandTotal,
+      costUsd: cost,
+    };
+    if (t.sessionCount > 0 && cost === null) costKnown = false;
+    if (cost !== null) totalCost = (totalCost ?? 0) + cost;
+  }
+  return {
+    issueIdentifier,
+    sessionCount: rollup.combinedSessions,
+    turnCount: rollup.combinedTurns,
+    tokens: rollup.combinedTokens,
+    apiCostUsd: costKnown ? totalCost : null,
+    byProvider,
+  };
+}
+
+function sumRows(rows) {
+  let sessionCount = 0;
+  let turnCount = 0;
+  let tokens = 0;
+  let apiCostUsd = null;
+  let costKnown = true;
+  const byProvider = {
+    claude: { sessions: 0, turns: 0, tokens: 0, costUsd: null },
+    codex: { sessions: 0, turns: 0, tokens: 0, costUsd: null },
+  };
+  let claudeCost = null;
+  let codexCost = null;
+  for (const r of rows) {
+    sessionCount += r.sessionCount;
+    turnCount += r.turnCount;
+    tokens += r.tokens;
+    if (r.apiCostUsd === null) costKnown = false;
+    else apiCostUsd = (apiCostUsd ?? 0) + r.apiCostUsd;
+    for (const provider of ['claude', 'codex']) {
+      byProvider[provider].sessions += r.byProvider[provider].sessions;
+      byProvider[provider].turns += r.byProvider[provider].turns;
+      byProvider[provider].tokens += r.byProvider[provider].tokens;
+      const c = r.byProvider[provider].costUsd;
+      if (c !== null) {
+        if (provider === 'claude') claudeCost = (claudeCost ?? 0) + c;
+        else codexCost = (codexCost ?? 0) + c;
+      }
+    }
+  }
+  byProvider.claude.costUsd = claudeCost;
+  byProvider.codex.costUsd = codexCost;
+  return {
+    issueIdentifier: 'TOTAL',
+    sessionCount,
+    turnCount,
+    tokens,
+    apiCostUsd: costKnown ? apiCostUsd : null,
+    byProvider,
+  };
+}
+
+function labelFor(positionals) {
+  if (positionals.length === 1) return positionals[0].toUpperCase();
+  if (positionals.length <= 3) return positionals.map((p) => p.toUpperCase()).join(', ');
+  return `${positionals.length} arguments`;
+}

package/src/pricing-rates.mjs

@@ -0,0 +1,140 @@
+/**
+ * Per-model API pricing for Anthropic and OpenAI, expressed as USD per
+ * million tokens for each bucket the cost-telemetry spec breaks input
+ * tokens into (uncached / cache read / cache write 5m / cache write 1h)
+ * plus the single output rate.
+ *
+ * Rates are *list* prices from the respective providers' public pricing
+ * pages on `verifiedOn`. They DO NOT reflect:
+ *   - Subscription plans (Claude Max, Codex Pro, etc.) — those are flat-rate
+ *     and have no per-token component. API-equivalent dollars from this
+ *     table are a *counterfactual*: what a token volume would have cost on
+ *     pay-as-you-go API.
+ *   - Volume discounts, enterprise rates, batch API discounts.
+ *   - Provider promotional pricing or beta-tier rates.
+ *
+ * Update when providers change pricing. The CLI warns if a table entry's
+ * verifiedOn is more than STALE_AFTER_DAYS old.
+ */
+
+export const STALE_AFTER_DAYS = 90;
+const VERIFIED_ON = '2026-05-22';
+
+/**
+ * @typedef {object} PricingEntry
+ * @property {'anthropic'|'openai'} provider
+ * @property {string} model                       Canonical model name as it appears in the table.
+ * @property {number} inputPerMillionUsd          USD per 1M uncached input tokens.
+ * @property {number|null} cachedInputPerMillionUsd  USD per 1M cache-read input tokens (null = provider doesn't price separately).
+ * @property {number|null} cacheWrite5mPerMillionUsd USD per 1M tokens written to the 5-minute ephemeral cache (Anthropic only).
+ * @property {number|null} cacheWrite1hPerMillionUsd USD per 1M tokens written to the 1-hour ephemeral cache (Anthropic only).
+ * @property {number} outputPerMillionUsd         USD per 1M output tokens (reasoning + visible both billed at this rate).
+ * @property {string} verifiedOn                  ISO date string when the rate was checked against the source URL.
+ * @property {string} sourceUrl                   Provider's public pricing page.
+ * @property {string} [notes]
+ */
+
+/** @type {readonly PricingEntry[]} */
+export const PRICING_TABLE = Object.freeze([
+  // ── Anthropic — https://www.anthropic.com/pricing ─────────────────────
+  {
+    provider: 'anthropic', model: 'claude-opus-4.7',
+    inputPerMillionUsd: 5, cachedInputPerMillionUsd: 0.5,
+    cacheWrite5mPerMillionUsd: 6.25, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 25,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-sonnet-4.6',
+    inputPerMillionUsd: 3, cachedInputPerMillionUsd: 0.3,
+    cacheWrite5mPerMillionUsd: 3.75, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 15,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-haiku-4.5',
+    inputPerMillionUsd: 1, cachedInputPerMillionUsd: 0.1,
+    cacheWrite5mPerMillionUsd: 1.25, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 5,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-sonnet-4.5',
+    inputPerMillionUsd: 3, cachedInputPerMillionUsd: 0.3,
+    cacheWrite5mPerMillionUsd: 3.75, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 15,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-opus-4.6',
+    inputPerMillionUsd: 5, cachedInputPerMillionUsd: 0.5,
+    cacheWrite5mPerMillionUsd: 6.25, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 25,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-opus-4.5',
+    inputPerMillionUsd: 5, cachedInputPerMillionUsd: 0.5,
+    cacheWrite5mPerMillionUsd: 6.25, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 25,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-opus-4.1',
+    inputPerMillionUsd: 15, cachedInputPerMillionUsd: 1.5,
+    cacheWrite5mPerMillionUsd: 18.75, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 75,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-sonnet-4',
+    inputPerMillionUsd: 3, cachedInputPerMillionUsd: 0.3,
+    cacheWrite5mPerMillionUsd: 3.75, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 15,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+  {
+    provider: 'anthropic', model: 'claude-opus-4',
+    inputPerMillionUsd: 15, cachedInputPerMillionUsd: 1.5,
+    cacheWrite5mPerMillionUsd: 18.75, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 75,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://www.anthropic.com/pricing',
+  },
+
+  // ── OpenAI — https://platform.openai.com/docs/pricing ─────────────────
+  {
+    provider: 'openai', model: 'gpt-5.5',
+    inputPerMillionUsd: 5, cachedInputPerMillionUsd: 0.5,
+    cacheWrite5mPerMillionUsd: null, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 30,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://platform.openai.com/docs/pricing',
+  },
+  {
+    provider: 'openai', model: 'gpt-5.4',
+    inputPerMillionUsd: 2.5, cachedInputPerMillionUsd: 0.25,
+    cacheWrite5mPerMillionUsd: null, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 15,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://platform.openai.com/docs/pricing',
+  },
+  {
+    provider: 'openai', model: 'gpt-5.4-mini',
+    inputPerMillionUsd: 0.75, cachedInputPerMillionUsd: 0.075,
+    cacheWrite5mPerMillionUsd: null, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 4.5,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://platform.openai.com/docs/pricing',
+  },
+  {
+    provider: 'openai', model: 'gpt-5.4-nano',
+    inputPerMillionUsd: 0.2, cachedInputPerMillionUsd: 0.02,
+    cacheWrite5mPerMillionUsd: null, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 1.25,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://platform.openai.com/docs/pricing',
+  },
+  {
+    provider: 'openai', model: 'gpt-5.3-codex',
+    inputPerMillionUsd: 1.75, cachedInputPerMillionUsd: 0.175,
+    cacheWrite5mPerMillionUsd: null, cacheWrite1hPerMillionUsd: null,
+    outputPerMillionUsd: 14,
+    verifiedOn: VERIFIED_ON, sourceUrl: 'https://platform.openai.com/docs/pricing',
+  },
+]);