fix(cli): stop storing Codex model_provider as the model

`session_meta` carries `model_provider` (the API provider id — `openai`,
or whatever name a proxy gives itself) and no model at all; the model
lives in `turn_context.model`. Reading the former into `model` is why
`openai`, `crs` and `custom` showed up in the model leaderboard and
priced at $0. The model is now seeded by scanning ahead for the first
`turn_context`, so usage lines that precede it are still attributed.

Two more names the pricing catalogue cannot resolve are normalized here:
`codex-auto-review` (a label Codex stamps on automatic review turns)
resolves to the review model shipping on that date, ported from
ccusage's codex-auto-review-fallbacks.json, and a proxy-appended effort
parenthetical (`gpt-5.5(xhigh)`) is stripped.

Bumps BACKFILL_STATE_SCHEMA_VERSION to 8 so the next sync re-parses
existing rollouts and rewrites the affected rows.

Claude-Session: https://claude.ai/code/session_019u3RKiNJY1sRknveHJy9iJ

Author: Jannchie

packages/cli/src/adapters/codex.ts

@@ -48,7 +48,9 @@ async function parseCodexSessionFile(
   let sessionId = sessionIdFromFilePath(filePath, 'codex')
   let cwd: string | undefined
   let project: string | undefined
-  let model: string | undefined
+  // `session_meta` has no model — only `model_provider` — so seed from the
+  // first `turn_context` up front. See firstCodexTurnContextModel.
+  let model: string | undefined = firstCodexTurnContextModel(lines)
   // Headless `codex exec` files have no session_meta; emit a synthetic
   // session.started on the first usage line so rollups still get a boundary.
   let sessionStartEmitted = false
@@ -149,7 +151,8 @@ async function parseCodexSessionFile(
       sessionId = stringField(payload, 'id') || sessionId
       cwd = stringField(payload, 'cwd') || cwd
       project = cwd ? path.basename(cwd) : project
-      model = stringField(payload, 'model_provider') || model
+      // Deliberately NOT reading `model_provider` here — see
+      // firstCodexTurnContextModel; `model` was seeded from it above.
       events.push(withBackfillRefs({
         schemaVersion: AGENT_TIME_SCHEMA_VERSION,
         ts,
@@ -171,7 +174,7 @@ async function parseCodexSessionFile(
       currentTurnId = stringField(payload, 'turn_id') || currentTurnId
       cwd = stringField(payload, 'cwd') || cwd
       project = cwd ? path.basename(cwd) : project
-      model = stringField(payload, 'model') || model
+      model = normalizeCodexModel(stringField(payload, 'model'), ts) || model
       // Codex hasn't shipped service_tier inside turn_context yet, but the field
       // is the natural per-turn location and the upstream protocol allows it.
       // Honor it when present so future Codex builds get accurate fast/priority
@@ -189,12 +192,9 @@ async function parseCodexSessionFile(
     if (topType === 'turn.completed' || topType === 'result' || topType === undefined) {
       const usage = headlessCodexUsage(raw)
       if (usage) {
-        const parsedModel = headlessCodexModel(raw)
-        if (parsedModel) {
-          model = parsedModel
-        }
-        const eventModel = parsedModel || model || 'gpt-5'
         const headlessTs = headlessCodexTimestamp(raw) || ts
+        model = normalizeCodexModel(headlessCodexModel(raw), headlessTs) || model
+        const eventModel = model || 'gpt-5'
         if (!sessionStartEmitted) {
           pushEvent(baseCodexEvent({
             ts: headlessTs,
@@ -566,6 +566,78 @@ async function parseCodexSessionFile(
 
 // ── Codex-specific helpers ──
 
+// Codex stamps `codex-auto-review` as the model on its automatic code-review
+// turns. It is a label, not a model — the tokens are billed against whichever
+// review model Codex shipped on that date. Ported from ccusage's
+// codex_log_model_fallback + codex-auto-review-fallbacks.json
+// (rust/crates/ccusage/src/adapter/codex/parser.rs). Newest first; keep in
+// sync when ccusage refreshes its snapshot. Note the table stops at gpt-5.5,
+// so any review turn after 2026-04-23 resolves to it — upstream has not
+// published a gpt-5.6-era row. That is not cost-neutral (gpt-5.6-sol carries
+// an explicit cache-creation rate gpt-5.5 does not), just the best available
+// evidence about which model actually ran.
+const CODEX_AUTO_REVIEW_MODEL = 'codex-auto-review'
+const CODEX_AUTO_REVIEW_FALLBACKS: ReadonlyArray<{ releasedOn: string, model: string }> = [
+  { releasedOn: '2026-04-23', model: 'gpt-5.5' },
+  { releasedOn: '2026-03-05', model: 'gpt-5.4' },
+  { releasedOn: '2026-02-05', model: 'gpt-5.3-codex' },
+  { releasedOn: '2025-12-11', model: 'gpt-5.2-codex' },
+  { releasedOn: '2025-11-13', model: 'gpt-5.1-codex' },
+  { releasedOn: '2025-09-15', model: 'gpt-5-codex' },
+  { releasedOn: '2025-08-07', model: 'gpt-5' },
+]
+
+// Turn a raw Codex model string into a name the backend pricing catalogue can
+// resolve:
+//   - `gpt-5.5(xhigh)` / `gpt-5.4 (high)` — some third-party Codex proxies
+//     append the reasoning effort. It is not part of any catalogue id and
+//     pricing never varies by effort, so drop it.
+//   - `codex-auto-review` — resolve to the review model shipping at `ts`.
+function normalizeCodexModel(model: string | undefined, ts: string | undefined): string | undefined {
+  if (!model) {
+    return model
+  }
+  const cleaned = model.replace(/\s*\([^)]*\)\s*$/, '').trim() || model
+  if (cleaned !== CODEX_AUTO_REVIEW_MODEL) {
+    return cleaned
+  }
+  const date = ts?.slice(0, 10)
+  const fallback = date && /^\d{4}-\d{2}-\d{2}$/.test(date)
+    ? CODEX_AUTO_REVIEW_FALLBACKS.find(entry => date >= entry.releasedOn)
+    : undefined
+  // Pre-dating the whole table (or an unparseable ts) means the oldest
+  // release is the best guess — same default ccusage uses.
+  return fallback?.model ?? 'gpt-5'
+}
+
+// `session_meta` carries `model_provider` (an API provider id — `openai`, or
+// whatever name a proxy gives itself), never a model; the model lives in
+// `turn_context.model`. Scan ahead for the first one so events emitted before
+// the first turn_context (session.started, plus any usage line that precedes
+// it) still carry the real model. Reading `model_provider` into `model` is
+// how `openai` / `crs` / `custom` used to reach the model leaderboard.
+function firstCodexTurnContextModel(lines: string[]): string | undefined {
+  for (const line of lines) {
+    // Cheap reject first — re-parsing every line of a large rollout is not
+    // worth it when turn_context normally sits within the first few lines.
+    if (!line.includes('"turn_context"')) {
+      continue
+    }
+    const raw = parseJsonLine(line)
+    if (!raw || stringField(raw, 'type') !== 'turn_context') {
+      continue
+    }
+    const model = normalizeCodexModel(
+      stringField(objectField(raw, 'payload'), 'model'),
+      timestampFrom(raw.timestamp),
+    )
+    if (model) {
+      return model
+    }
+  }
+  return undefined
+}
+
 function rewriteCodexModelForTier(model: string | undefined, serviceTier: string | undefined): string | undefined {
   if (!model) {
     return model

packages/cli/src/lib/types.ts

@@ -37,13 +37,17 @@ export interface BackfillSourceFile {
 // and the pi/gemini edge cases, and the v6 Codex UUIDv7 creation-anchor
 // that skips copied branch/goal rollout history, and the v7 realpath
 // canonicalization of source file paths so symlinked agent homes stop
-// producing duplicate rollup identities). The CLI compares the
+// producing duplicate rollup identities, and the v8 Codex model-name
+// fixes — `session_meta.model_provider` is no longer stored as the model,
+// the model is seeded from the first `turn_context`, `codex-auto-review`
+// resolves to the review model shipping on that date, and a proxy's
+// effort parenthetical is stripped). The CLI compares the
 // constant against the on-disk schema; on a mismatch it drops every
 // watermark so the next sync silently re-parses all jsonl from scratch
 // and upserts the rebuilt rollups (`replace: true` is already set) — no
 // purge, nothing deleted. Users get the fix transparently the next time
 // their agent runs.
-export const BACKFILL_STATE_SCHEMA_VERSION = 7
+export const BACKFILL_STATE_SCHEMA_VERSION = 8
 
 export interface BackfillIncrementalState {
   version: typeof BACKFILL_STATE_SCHEMA_VERSION

packages/cli/test/codex.test.ts

@@ -549,3 +549,97 @@ test('the same-second thread_spawn replay skip still works in a UUIDv7-named fil
   assert.equal(usages.length, 1)
   assert.equal(usages[0].metrics?.tokensInput, 100)
 })
+
+// ── model naming ──
+//
+// The model that gets stored is the pricing key the backend looks up, so a
+// wrong name is a silently-$0 (or silently-mispriced) row rather than a
+// visible error.
+
+// Token numbers are irrelevant to these tests — only the model stamped on
+// the resulting usage event is.
+function tokenCount(timestamp: string): unknown {
+  return {
+    timestamp,
+    type: 'event_msg',
+    payload: { type: 'token_count', info: { last_token_usage: { input_tokens: 100, cached_input_tokens: 10, output_tokens: 50, total_tokens: 150 } } },
+  }
+}
+
+test('session_meta.model_provider is never used as the model', async () => {
+  // `model_provider` is the API provider id — `openai` for the real thing,
+  // or whatever a third-party proxy calls itself. Reading it into `model`
+  // is how `openai` / `crs` / `custom` used to reach the model leaderboard.
+  const events = await parse([
+    { timestamp: '2026-01-02T00:00:00.000Z', type: 'session_meta', payload: { id: 'session', cwd: '/w', model_provider: 'openai' } },
+    { timestamp: '2026-01-02T00:00:01.000Z', type: 'turn_context', payload: { model: 'gpt-5.6-sol' } },
+    tokenCount('2026-01-02T00:00:02.000Z'),
+  ])
+
+  assert.equal(events.every(event => event.model !== 'openai'), true)
+  assert.equal(usageEvents(events)[0].model, 'gpt-5.6-sol')
+})
+
+test('usage recorded before the first turn_context still carries the real model', async () => {
+  // The model is seeded by scanning ahead for the first turn_context, so a
+  // token_count that lands before it is not left model-less (or, previously,
+  // stamped with the provider id).
+  const events = await parse([
+    { timestamp: '2026-01-02T00:00:00.000Z', type: 'session_meta', payload: { id: 'session', cwd: '/w', model_provider: 'openai' } },
+    tokenCount('2026-01-02T00:00:01.000Z'),
+    { timestamp: '2026-01-02T00:00:02.000Z', type: 'turn_context', payload: { model: 'gpt-5.6-sol' } },
+  ])
+
+  assert.equal(usageEvents(events)[0].model, 'gpt-5.6-sol')
+  assert.equal(events.find(event => event.type === 'session.started')?.model, 'gpt-5.6-sol')
+})
+
+test('a rollout with no turn_context leaves the model unset rather than guessing', async () => {
+  const events = await parse([
+    { timestamp: '2026-01-02T00:00:00.000Z', type: 'session_meta', payload: { id: 'session', cwd: '/w', model_provider: 'crs' } },
+    tokenCount('2026-01-02T00:00:01.000Z'),
+  ])
+
+  assert.equal(usageEvents(events)[0].model, undefined)
+})
+
+test('the reasoning-effort parenthetical some proxies append is stripped', async () => {
+  // `gpt-5.5(xhigh)` is not a catalogue id, and pricing does not vary by
+  // effort — the effort is already carried by other fields.
+  const usages = usageEvents(await parse([
+    { timestamp: '2026-01-02T00:00:00.000Z', type: 'turn_context', payload: { model: 'gpt-5.5(xhigh)' } },
+    tokenCount('2026-01-02T00:00:01.000Z'),
+  ]))
+
+  assert.equal(usages[0].model, 'gpt-5.5')
+})
+
+test('parity: ccusage codex_log_model_fallback — codex-auto-review resolves by date', async () => {
+  // Codex stamps `codex-auto-review` on its automatic review turns; the
+  // tokens bill against whichever review model shipped on that date.
+  // Mirrors ccusage's codex-auto-review-fallbacks.json snapshot.
+  const cases: Array<[string, string]> = [
+    ['2026-05-01T00:00:00.000Z', 'gpt-5.5'],
+    ['2026-04-23T00:00:00.000Z', 'gpt-5.5'],
+    ['2026-04-22T00:00:00.000Z', 'gpt-5.4'],
+    ['2026-02-10T00:00:00.000Z', 'gpt-5.3-codex'],
+    ['2025-09-20T00:00:00.000Z', 'gpt-5-codex'],
+    ['2025-01-01T00:00:00.000Z', 'gpt-5'],
+  ]
+  for (const [ts, expected] of cases) {
+    const usages = usageEvents(await parse([
+      { timestamp: ts, type: 'turn_context', payload: { model: 'codex-auto-review' } },
+      tokenCount(ts),
+    ]))
+    assert.equal(usages[0].model, expected, `${ts} → ${expected}`)
+  }
+})
+
+test('the fast tier still suffixes the resolved model, not the raw label', async () => {
+  const usages = usageEvents(await parse([
+    { timestamp: '2026-05-01T00:00:00.000Z', type: 'turn_context', payload: { model: 'codex-auto-review', service_tier: 'priority' } },
+    tokenCount('2026-05-01T00:00:01.000Z'),
+  ]))
+
+  assert.equal(usages[0].model, 'gpt-5.5-fast')
+})