fix(cli): drop Codex last_token_usage repeats the cumulative does not back

Codex re-emits a last_token_usage snapshot when only the metadata around
it changed (rate limits, service tier). The existing dedup only caught
consecutive identical records, so a snapshot re-emitted after other
token_count events was counted as a second turn.

Treat total_token_usage as the authority: when the cumulative has not
advanced, no tokens were spent and the snapshot is a repeat. Track the
baseline as optional so the first event of a file is never mistaken for
a repeat of a zeroed one.

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

Author: Jannchie

packages/cli/src/adapters/codex.ts

@@ -96,8 +96,10 @@ async function parseCodexSessionFile(
   // carry only info.total_token_usage (a cumulative), with no per-turn
   // last_token_usage. For those we derive the turn's usage as current-minus-previous
   // cumulative — so we must track the last cumulative we saw. Mirrors ccusage's
-  // previous_totals in subtract_codex_raw_usage.
-  let previousTotals: CodexCumulative = { input: 0, cached: 0, output: 0, reasoning: 0, total: 0 }
+  // previous_totals in subtract_codex_raw_usage. `undefined` means no cumulative
+  // has been seen yet, which is distinct from an all-zero one: the first event of
+  // a file must never look like a repeat of the baseline (ccusage's Option).
+  let previousTotals: CodexCumulative | undefined
   const pendingToolCalls = new Map<string, { tool: string, startedAt: string, turnId: string | undefined }>()
   // Per-turn last activity timestamp and turn start timestamp. When we close a
   // turn implicitly (next user_message, or EOF fallback), turn.completed must
@@ -311,7 +313,17 @@ async function parseCodexSessionFile(
         // events that carry only a cumulative total are counted instead of dropped.
         const totalUsage = objectField(info, 'total_token_usage')
         const hasTotal = Object.keys(totalUsage).length > 0
-        const usage = tokenUsageFromPayload(payload)
+        // Codex re-emits a last_token_usage snapshot when only metadata around it
+        // changed (rate limits, service tier). The cumulative is the authority: if
+        // total_token_usage did not advance, no new tokens were spent, so the
+        // snapshot is a repeat of one already counted. The lastTokenUsageKey dedup
+        // below only catches *consecutive* repeats; this also catches re-emissions
+        // separated by other token_count events. Mirrors ccusage's
+        // cumulative_advanced filter (adapter/codex/parser.rs).
+        const cumulativeAdvanced = !hasTotal
+          || previousTotals === undefined
+          || !sameCodexCumulative(previousTotals, readCodexCumulative(totalUsage))
+        const usage = (cumulativeAdvanced ? tokenUsageFromPayload(payload) : undefined)
           ?? (hasTotal ? codexUsageDelta(totalUsage, previousTotals, info) : undefined)
         // Advance the baseline from every total_token_usage we see — including
         // replayed events we skip — so the first real event's delta is measured
@@ -829,20 +841,28 @@ function readCodexCumulative(usage: Record<string, unknown>): CodexCumulative {
   }
 }
 
+function sameCodexCumulative(a: CodexCumulative, b: CodexCumulative): boolean {
+  return a.input === b.input
+    && a.cached === b.cached
+    && a.output === b.output
+    && a.reasoning === b.reasoning
+    && a.total === b.total
+}
+
 // Per-turn delta from a cumulative total_token_usage minus the prior cumulative
 // baseline (ccusage subtract_codex_raw_usage). Returns undefined when the delta is
 // entirely zero (e.g. a repeated cumulative) so no empty usage event is emitted.
 function codexUsageDelta(
   totalUsage: Record<string, unknown>,
-  previous: CodexCumulative,
+  previous: CodexCumulative | undefined,
   info: Record<string, unknown>,
 ) {
   const cur = readCodexCumulative(totalUsage)
-  const input = Math.max(0, cur.input - previous.input)
-  const cached = Math.max(0, cur.cached - previous.cached)
-  const output = Math.max(0, cur.output - previous.output)
-  const reasoning = Math.max(0, cur.reasoning - previous.reasoning)
-  const total = Math.max(0, cur.total - previous.total)
+  const input = Math.max(0, cur.input - (previous?.input ?? 0))
+  const cached = Math.max(0, cur.cached - (previous?.cached ?? 0))
+  const output = Math.max(0, cur.output - (previous?.output ?? 0))
+  const reasoning = Math.max(0, cur.reasoning - (previous?.reasoning ?? 0))
+  const total = Math.max(0, cur.total - (previous?.total ?? 0))
   if (input === 0 && cached === 0 && output === 0 && reasoning === 0 && total === 0) {
     return
   }

packages/cli/test/codex.test.ts

@@ -307,6 +307,57 @@ test('parity: ccusage codex dedupes consecutive identical last_token_usage', asy
   assert.equal(usageEvents(events).length, 1)
 })
 
+test('parity: ccusage codex skips repeated last_token_usage when the cumulative total is unchanged', async () => {
+  // From ccusage adapter/codex/loader.rs
+  // skips_repeated_last_usage_when_cumulative_total_is_unchanged (#1435).
+  const info = {
+    model: 'gpt-5.5',
+    last_token_usage: { input_tokens: 100, cached_input_tokens: 20, output_tokens: 10, total_tokens: 110 },
+    total_token_usage: { input_tokens: 100, cached_input_tokens: 20, output_tokens: 10, total_tokens: 110 },
+  }
+  const events = await parse([
+    { timestamp: '2026-07-10T08:00:00.000Z', type: 'session_meta', payload: { id: 'session-a', cwd: '/w', model_provider: 'gpt-5.5' } },
+    { timestamp: '2026-07-10T08:00:01.000Z', type: 'event_msg', payload: { type: 'token_count', info } },
+    { timestamp: '2026-07-10T08:00:02.000Z', type: 'event_msg', payload: { type: 'token_count', info } },
+  ])
+
+  assert.equal(usageEvents(events).length, 1)
+})
+
+test('parity: ccusage codex skips a stale last_token_usage the cumulative does not back', async () => {
+  // The cumulative check catches what the consecutive-duplicate dedup cannot:
+  // a re-emitted snapshot whose last_token_usage differs from the record right
+  // before it, while total_token_usage stands still. The differing value slips
+  // past lastTokenUsageKey, so only the cumulative proves no tokens were spent.
+  const events = await parse([
+    { timestamp: '2026-07-10T08:00:00.000Z', type: 'session_meta', payload: { id: 'session-a', cwd: '/w', model_provider: 'gpt-5.5' } },
+    // Turn 1.
+    { timestamp: '2026-07-10T08:00:01.000Z', type: 'event_msg', payload: { type: 'token_count', info: { model: 'gpt-5.5', last_token_usage: { input_tokens: 100, cached_input_tokens: 20, output_tokens: 10, total_tokens: 110 }, total_token_usage: { input_tokens: 100, cached_input_tokens: 20, output_tokens: 10, total_tokens: 110 } } } },
+    // Turn 2 — cumulative advances.
+    { timestamp: '2026-07-10T08:00:02.000Z', type: 'event_msg', payload: { type: 'token_count', info: { model: 'gpt-5.5', last_token_usage: { input_tokens: 40, cached_input_tokens: 5, output_tokens: 7, total_tokens: 47 }, total_token_usage: { input_tokens: 140, cached_input_tokens: 25, output_tokens: 17, total_tokens: 157 } } } },
+    // Turn 1's snapshot re-emitted against turn 2's cumulative: no new tokens.
+    { timestamp: '2026-07-10T08:00:03.000Z', type: 'event_msg', payload: { type: 'token_count', info: { model: 'gpt-5.5', last_token_usage: { input_tokens: 100, cached_input_tokens: 20, output_tokens: 10, total_tokens: 110 }, total_token_usage: { input_tokens: 140, cached_input_tokens: 25, output_tokens: 17, total_tokens: 157 } } } },
+  ])
+
+  const usages = usageEvents(events)
+  assert.equal(usages.length, 2)
+  assert.equal(usages[0].metrics?.tokensTotal, 110)
+  assert.equal(usages[1].metrics?.tokensTotal, 47)
+})
+
+test('parity: ccusage codex counts the first snapshot even when the cumulative is all zeros', async () => {
+  // ccusage tracks previous_totals as an Option, so the first event of a file is
+  // never mistaken for a repeat of a zeroed baseline.
+  const events = await parse([
+    { timestamp: '2026-07-10T08:00:00.000Z', type: 'session_meta', payload: { id: 'session-a', cwd: '/w', model_provider: 'gpt-5.5' } },
+    { timestamp: '2026-07-10T08:00:01.000Z', type: 'event_msg', payload: { type: 'token_count', info: { model: 'gpt-5.5', last_token_usage: { input_tokens: 100, cached_input_tokens: 20, output_tokens: 10, total_tokens: 110 }, total_token_usage: { input_tokens: 0, cached_input_tokens: 0, output_tokens: 0, total_tokens: 0 } } } },
+  ])
+
+  const usages = usageEvents(events)
+  assert.equal(usages.length, 1)
+  assert.equal(usages[0].metrics?.tokensTotal, 110)
+})
+
 // ── headless `codex exec` parity (turn.completed / result / bare data.usage) ──
 
 test('parity: ccusage codex loads_saved_codex_exec_json_usage', async () => {