[juliusmarminge]

Problem

When a Codex turn is interrupted after a model request finishes, that request is only written as a top-level token_usage_record line; no token_count follows it. The usage reader ignored those lines, so the next turn's token_count (whose cumulative total includes the interrupted request) failed exact reconciliation and was dropped too. The Usage page under-counts both requests and keeps showing "1 malformed or inconsistent usage record(s) were skipped".

Reproduced on main (ac8dce0) with the reporter's synthetic rollout (below): the parser bills 120 tokens with 1 malformed record instead of 510 with 0. The dev server's Usage page, filtered to Codex, shows 120 processed tokens and the warning. A variant with two unreported requests in the interrupted turn also bills only 120 (expected 565).

Change

• codexUsage.ts reads token_usage_record lines and keeps one pending entry per record since the last cumulative snapshot, with the timestamp, model, turn, speed and tier eligibility in effect when it was read. Every cumulative snapshot clears the list.
• Records never replace the counters, because they are not one-to-one with token_count. They are used only when a snapshot fails exact reconciliation and cumulative - previous equals the pending sum on every field. Then last is taken off the final pending entry and each remaining entry is billed as its own record before last. Otherwise the line stays malformed, as before.
• The reducer can now return several records for one line; parseLine/parseProjected already returned arrays.
• The format's line gate admits "token_usage_record", and the streaming projection keeps payload.usage.
• Fork-copied history: the copy-burst time boundary now applies to token_usage_record lines the same way it applies to token_count. Copied records never become pending, and a fork's first genuine interrupted turn can still be bridged.
• usageScanCache.ts moves to v11. Pre-v11 Codex entries that recorded skipped records are re-parsed. Clean pre-v11 Codex entries are still served while their file is unchanged, but a grown file is re-parsed from the start instead of resuming, because its saved state may already be past an ignored record.

Scope and approval

Fixes #29365

Triaged via the automated issue flow.

Verification

Tests that fail on main and pass here:

• usageTranscriptReader.test.ts, "bills a Codex request whose turn was interrupted before its token_count" (buffered and streaming). It reads the reporter's rollout through the real reader: main gives billedTokens: 120, malformedRecords: 1, requests [120]; here it gives 510, 0, [120, 160, 230]. The streaming case pads lines past the read chunk, so it exercises selectFields + parseProjected.
• codexUsage.test.ts, "bills each interrupted turn's request with the model, tier and time it was read under". Two interrupted turns with a model switch, a tier change and a midnight crossing; each recovered request keeps its own attribution and timestamp.
• codexUsage.test.ts (forked rollouts), "bills the child's first request when its turn is interrupted before any snapshot".
• UsageService.test.ts, "re-parses a clean v10 Codex rollout that grew after an interrupted request": 120/1 before, 510/0 here.
• codexUsage.test.ts, "bills only the reported request when usage records sit between reconciling snapshots" is a control. Several records between two reconciling snapshots still bill exactly last.

vp run check:changed: format, lint, knip, typecheck (3 packages) and 5 test files (115 tests) pass.

Real-data regression check (read-only, local): main's and this branch's parsers were replayed over 751 real Codex rollouts (731 containing token_usage_record, ~17k requests). Billed tokens, record count and malformed count are identical, so normal rollouts are unchanged.

Runtime: the dev server (T3CODE_DEV_SEED=0, CODEX_HOME pointing at a directory holding only the synthetic rollout), Usage page, Tokens, filtered to Codex. The after run started from the v10 scan cache that main had written, so it also exercises the cache upgrade.

Before (main ac8dce0)	After (f3bc74f)
120 processed tokens, "1 malformed or inconsistent usage record(s) were skipped"	510 processed tokens (450 input, 60 output), no warning

The two captures are attached to this PR.

Synthetic rollout used for every check above (the reporter's, from the issue):

{"type":"session_meta","timestamp":"2026-11-02T10:00:00.000Z","payload":{"id":"aborted-turn-repro","model_provider":"openai"}}
{"type":"turn_context","timestamp":"2026-11-02T10:00:00.000Z","payload":{"turn_id":"turn-1","model":"gpt-6-sol"}}
{"type":"token_usage_record","timestamp":"2026-11-02T10:00:01.000Z","payload":{"turn_id":"turn-1","response_id":"resp_1","usage":{"input_tokens":100,"cached_input_tokens":0,"cache_write_input_tokens":0,"output_tokens":20,"reasoning_output_tokens":0,"total_tokens":120}}}
{"type":"event_msg","timestamp":"2026-11-02T10:00:01.001Z","payload":{"type":"token_count","info":{"last_token_usage":{"input_tokens":100,"cached_input_tokens":0,"cache_write_input_tokens":0,"output_tokens":20,"reasoning_output_tokens":0,"total_tokens":120},"total_token_usage":{"input_tokens":100,"cached_input_tokens":0,"cache_write_input_tokens":0,"output_tokens":20,"reasoning_output_tokens":0,"total_tokens":120}}}}
{"type":"token_usage_record","timestamp":"2026-11-02T10:00:02.000Z","payload":{"turn_id":"turn-1","response_id":"resp_2","usage":{"input_tokens":150,"cached_input_tokens":0,"cache_write_input_tokens":0,"output_tokens":10,"reasoning_output_tokens":0,"total_tokens":160}}}
{"type":"event_msg","timestamp":"2026-11-02T10:00:03.000Z","payload":{"type":"turn_aborted","turn_id":"turn-1","reason":"interrupted"}}
{"type":"turn_context","timestamp":"2026-11-02T10:00:04.000Z","payload":{"turn_id":"turn-2","model":"gpt-6-sol"}}
{"type":"token_usage_record","timestamp":"2026-11-02T10:00:05.000Z","payload":{"turn_id":"turn-2","response_id":"resp_3","usage":{"input_tokens":200,"cached_input_tokens":0,"cache_write_input_tokens":0,"output_tokens":30,"reasoning_output_tokens":0,"total_tokens":230}}}
{"type":"event_msg","timestamp":"2026-11-02T10:00:05.001Z","payload":{"type":"token_count","info":{"last_token_usage":{"input_tokens":200,"cached_input_tokens":0,"cache_write_input_tokens":0,"output_tokens":30,"reasoning_output_tokens":0,"total_tokens":230},"total_token_usage":{"input_tokens":450,"cached_input_tokens":0,"cache_write_input_tokens":0,"output_tokens":60,"reasoning_output_tokens":0,"total_tokens":510}}}}

Not checked: a replay of the reporter's own macOS rollout corpus. Rendering code is unchanged.

Model and harness: Claude Opus 5.5 (lead, tests, implementation, reviewer B) and GPT-6.1 Sol (reviewer A) in Claude Code and Codex, orchestrated by T3 Code.

🤖 Generated with Claude Code

[macroscopeapp]

Approvability

Verdict: Approved at f3bc74f

Macroscope's review found this PR approvable — Recovers usage from interrupted Codex turns while preserving request attribution and refreshing affected scan caches. The change is limited to derived usage reporting, with exact counter reconciliation and reported runtime and real-data regression verification.

No code changes detected at cde8d9c. Prior analysis still applies.

^{You can add or adjust custom eligibility rules. Learn more.}

[github-actions]

Thread transfer impact

✅ Thread transfer remains within every enforced ceiling.

Provider	Metric	Main baseline	This PR	Impact	PR ceiling
Codex	Total thread wire	5.0 KiB	5.0 KiB	0 B (0.0%)	6.8 KiB	✅
Codex	Thread snapshot wire	3.8 KiB	3.8 KiB	0 B (0.0%)	4.9 KiB	✅
Codex	Live turn WebSocket wire	1.2 KiB	1.2 KiB	0 B (0.0%)	2.0 KiB	✅
Codex	Live turn WebSocket decoded	21.6 KiB	21.6 KiB	0 B (0.0%)	24.4 KiB	✅
Codex	Live turn messages	2	2	0 (0.0%)	8	✅
Claude	Total thread wire	5.0 KiB	5.1 KiB	+17 B (+0.3%)	6.8 KiB	✅
Claude	Thread snapshot wire	3.8 KiB	3.8 KiB	0 B (0.0%)	4.9 KiB	✅
Claude	Live turn WebSocket wire	1.2 KiB	1.3 KiB	+17 B (+1.3%)	2.0 KiB	✅
Claude	Live turn WebSocket decoded	21.9 KiB	21.9 KiB	0 B (0.0%)	24.4 KiB	✅
Claude	Live turn messages	2	2	0 (0.0%)	8	✅

Baseline: f6503f0 · PR result: cde8d9c · Source CI: success

Scenario and decoded snapshot size

10 historical turns, 5 command tools per turn, 878.9 KiB retained MCP result per historical turn, and a 1.05 MiB retained result in the measured turn.

• Codex decoded thread snapshot: 108.5 KiB
• Claude decoded thread snapshot: 108.8 KiB

Updated in place by a trusted workflow. PR artifacts are strictly validated and never executed.

[coderabbitai]

No actionable comments were generated in the recent review.

Walkthrough

Codex parsing now buffers request-level usage events and reconciles them with later cumulative snapshots. The scan-cache format advances to version 11, and older Codex cache entries restart scanning from the beginning.

Changes: Codex usage reconciliation

Layer / File(s)	Summary
Buffer and reconcile Codex requests apps/server/src/provider/Drivers/codexUsage.ts, apps/server/src/provider/Drivers/codexUsage.test.ts, apps/server/src/usage/usageTranscriptReader.test.ts	The parser buffers token_usage_record events and emits their usage when a later cumulative snapshot exactly reconciles the counter gap. Emitted records use the timestamp, model, service tier, and other attribution captured when each request was read. Tests cover interrupted turns, fork copies, and buffered and streaming parsing.
Migrate Codex scan-cache state apps/server/src/usage/usageScanCache.ts, apps/server/src/usage/usageScanCache.test.ts, apps/server/src/usage/UsageService.test.ts	The cache format advances from version 10 to version 11. Older Codex entries restart scanning from offset zero. Tests cover cache compatibility and an upgrade after an interrupted request.

Estimated code review effort: 4 (Complex) | ~45 minutes

Change: Bug fix · Severity of issue fixed: Low

Sequence Diagram(s)

sequenceDiagram
  participant Transcript as Codex transcript
  participant Parser as parseCodexLine
  participant State as CodexScanState
  participant Output as UsageRecord output
  Transcript->>Parser: token_usage_record event
  Parser->>State: buffer attributed request
  Transcript->>Parser: cumulative token_count snapshot
  Parser->>State: reconcile buffered usage with counter gap
  Parser->>Output: emit reconciled request records

Loading

Possibly related issues

• pingdotgg/t3code#29363 — The changes update Codex cumulative-snapshot reconciliation, but do not establish that they fix the reported baseline rewind.
• pingdotgg/t3code#29365 — The parser buffers token_usage_record entries and uses their exact totals to recover requests across interrupted turns.

Possibly related PRs

• pingdotgg/t3code#29392 — Both PRs reconcile buffered request usage with later cumulative snapshots; this PR also changes attribution, fork handling, and cache behavior.

Suggested reviewers: pixpmusic, fixfon, maria-rcks

Merge Risk: Low · up to cde8d

A fast request after a fork may be omitted from usage totals. This timing-dependent issue should be addressed or accepted before merging.

Pre-merge checks: 4

Check name	Status	Explanation
Title check		The title "fix(server): Codex usage keeps requests from interrupted turns" matches the main change. The diff adds parsing of token_usage_record lines so requests from interrupted turns are billed wh…
Description check		The description covers the template's main parts. Problem: it explains that interrupted-turn requests appear only as token_usage_record lines, that the reader drops them, and that the next `token_co…
Linked Issues check		Issue #29365 requires that Codex usage bill a request recorded only as top-level token_usage_record when its turn is interrupted. It also requires that the next token_count reconcile, and that the…
Out of Scope Changes check		Whole-PR changes map to #29365. codexUsage.ts implements the bridging logic. codexUsage.ts format and projection changes expose token_usage_record payloads. Fork-copy handling applies the same b…

Full details: Title check

Explanation

The title "fix(server): Codex usage keeps requests from interrupted turns" matches the main change. The diff adds parsing of token_usage_record lines so requests from interrupted turns are billed when a later cumulative snapshot reconciles, and it updates the scan cache to v11 to re-parse affected rollouts. The title follows the conventional-commit form the template recommends and names the primary fix without listing files.

Full details: Description check

Explanation

The description covers the template's main parts. Problem: it explains that interrupted-turn requests appear only as token_usage_record lines, that the reader drops them, and that the next token_count then fails reconciliation. It gives reproduction steps, a synthetic rollout, and before/after results (120 vs 510 tokens). Change: it lists the parser, reducer, format-gate, fork-copy, and scan-cache updates and explains why counters are not replaced. Verification: it names the specific failing-then-passing tests, reports a real-data regression replay, and includes the runtime before/after check with screenshots. It also states what was not checked. Scope and approval: it links the issue (#29365) and says it was triaged through the automated issue flow. The template asks for a triaged issue or discussion with explicit maintainer approval, including the approval comment. The description links the issue but does not show a maintainer approval comment or explain why the fix qualifies without one. The model/harness attribution is present. Minor gaps: the template's HTML comments remain in the template, and the description does not explicitly confirm that the reference link is an approved triage. Overall the description is mostly complete.

Full details: Linked Issues check

Explanation

Issue #29365 requires that Codex usage bill a request recorded only as top-level token_usage_record when its turn is interrupted. It also requires that the next token_count reconcile, and that the warning clear. The whole-PR change in codexUsage.ts buffers pending records since the last cumulative snapshot. It uses them only when cumulative - previous equals the pending sum on every field, then bills last after the unreported entries. Records never replace counters. Per-entry model, tier, speed and timestamp are kept. Tests cover the reporter's rollout through the buffered and streaming reader paths (510 tokens, 0 malformed), multiple interrupted turns with attribution changes, fork-copied history, and a control case with several records between reconciling snapshots. The usageScanCache.ts v11 change forces re-parse of affected pre-v11 Codex entries, so existing caches pick up the fix. The incremental diff since the previous reviewed head (f3bc74f) leaves codexUsage.ts unchanged, so the earlier conclusion still holds for the parser. The verification results were not rerun in this review. Assessment is based on source and summary evidence.

Full details: Out of Scope Changes check

Explanation

Whole-PR changes map to #29365. codexUsage.ts implements the bridging logic. codexUsage.ts format and projection changes expose token_usage_record payloads. Fork-copy handling applies the same burst boundary to the new record type, which prevents double billing. usageScanCache.ts moves to v11 and re-parses affected Codex entries; the diff matches this purpose. The UsageService.test.ts, usageScanCache.test.ts and usageTranscriptReader.test.ts changes cover these behaviors. The incremental diff since the previous reviewed head adds Cursor credential and shared-account tests in UsageService.test.ts. These appear to come from the merge of main (merge base f6503f0). The whole-PR summary for that file reports +103/-3 lines and describes only usage-cache tests, which does not include those Cursor additions. Those Cursor changes are therefore not attributed to this PR. This conclusion relies on the summary line counts and merge history, not on a full base-to-head diff of that file.

Finishing Touches

Generate docstrings

• Commit to this branch
• Create a new PR

Generate unit tests (beta)

• Commit to this branch
• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Warning

Some tools did not complete. Review the errors below.

ast-grep (0.51.1)

ast-grep could not parse rule config: /ast-grep-rules/ast-grep-essentials/rules/scala/security/jwt-scala-hardcode-scala.yml

Usage-based review receipt

• Mode: Continue automatically
• Reviewed files: 1
• Charged: $0.25
• View usage details

Note

This review was completed with usage-based billing: files reviewed beyond your plan's included limits are billed at $0.25/file. View usage-based billing.

CodeRabbit Verify

• Run CodeRabbit Verify to test the changes in this pull request.

Recent review info

Run configuration

• Source mode: Auto
• Repository: pingdotgg/t3code
• Branch: fix/issue-29365
• File: .coderabbit.config.ts
• Commit: cde8d9c
• Layers: Repository TS config
• Review profile: CHILL
• Plan: Team
• Run ID: 454c1424-d6ae-4527-baa8-45895c917d4d

Commits

Reviewing files that changed from the base of the PR and between f3bc74f and cde8d9c.

Files selected for processing: 1

• apps/server/src/usage/UsageService.test.ts

Limit details: You’ve used all 10 included reviews currently available.

[coderabbitai]

• Fix comments: Fix CodeRabbit comments on this PR