feat(review): live token counts for claude and codex reviewers

[peyton-alt]

https://entire.io/gh/entireio/cli/trails/788

Salvages the live-token slices from closed #1370 (per its disposition comment: "live-token tailing … wanted separately"), rebuilt against current main's parsers rather than cherry-picked — #1370 was based on the old redesign stack.

What

Reviewer token totals previously appeared only at run completion. This PR makes them move during the run:

• Claude: assistant stream-json envelopes carry a usage snapshot taken at the start of each turn — input/cache counts are real, but output_tokens is a 1–8 token "initial decision" stub that never updates as text streams. The parser now emits input-only Tokens{In, Out: 0} per usage-carrying assistant envelope (context growth is honest to show; the misleading output stub is not), with the terminal result envelope still delivering the final {In, Out} aggregate.
• Codex: exec --json stdout only carries usage on turn.completed, and a review is usually a single turn — so a new rollout-transcript tailer (review_tokens.go) locates the session's rollout file by thread.started's thread_id (the same source codex's interactive UI reads for its live counter) and emits cumulative Tokens per token_count event, deduped on movement. The parser stops the tailer and waits for it before closing the event channel, so a tailer send can never race the close. turn.completed now also emits per-turn (multi-turn runs update at each boundary), keeping the old post-loop emission as a defensive backstop.

All consumers already treat Tokens as cumulative-overwrite ("overwrite, don't sum"), which is exactly the contract both sources emit.

Verification

• TDD throughout — every behavior change had a failing test first; -race clean on the codex package.
• New wiring test (TestParseCodexOutput_StartsRolloutTailerOnThreadStarted) pins that the parser launches the tailer, receives its Tokens through the real event channel, and shuts it down cleanly on stdout EOF.
• End-to-end shim smoke: fake claude/codex binaries drove entire review — claude streaming usage-carrying envelopes, codex writing real rollout token_count lines picked up by the tailer — both to clean completion (codex wall time == shim sleep budget, i.e. no shutdown hang).
• mise run fmt + lint clean, full unit suite green (7625 tests).

File adjacency (benign)

Touches claudecode/reviewer.go and codex/reviewer.go, which open PRs #1647 (child context + fan-out) and #1669 (codex skills — absorbed #1655) also modify — but different functions (they touch buildCmd/prompt composition; this touches the parse*Output paths and adds a new file). Merges are expected to be clean in any order; all three were verified together in the live integration runs.

🤖 Generated with Claude Code

---

Note

^{Cursor Bugbot is generating a summary for commit 5860d3a. Configure here.}

[cursor]

Cursor Bugbot has reviewed your changes and found 2 potential issues.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

Comment @cursor review or bugbot run to trigger another review on this PR

^{Reviewed by Cursor Bugbot for commit 5860d3a. Configure here.}

[Copilot]

Pull request overview

This PR improves entire review live token reporting by emitting incremental token updates during reviewer runs for both Claude Code and Codex, instead of only reporting totals at completion.

Changes:

• Claude Code: emit input-only Tokens{In, Out:0} snapshots from assistant stream-json envelopes, plus final {In, Out} from the terminal result.
• Codex: start a rollout-transcript tailer keyed by thread_id to emit live cumulative Tokens between turn boundaries; additionally emit Tokens on every turn.completed.
• Add targeted unit tests and fixtures to lock these live-token semantics.

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
cmd/entire/cli/agent/codex/reviewer.go	Starts/stops a rollout token tailer and emits Tokens per turn.completed.
cmd/entire/cli/agent/codex/reviewer_test.go	Adds coverage asserting per-turn token emissions.
cmd/entire/cli/agent/codex/review_tokens.go	New rollout JSONL tailer that emits cumulative Tokens on token_count events.
cmd/entire/cli/agent/codex/review_tokens_test.go	Adds tests for tailing behavior and parser↔tailer wiring.
cmd/entire/cli/agent/claudecode/testdata/stream_with_deltas.jsonl	Adds a realistic Claude stream-json fixture with per-assistant usage snapshots and a final result.
cmd/entire/cli/agent/claudecode/reviewer.go	Emits input-only Tokens for assistant envelopes; final aggregate Tokens from result.
cmd/entire/cli/agent/claudecode/reviewer_test.go	Updates existing expectations and adds a new test for input-only during-run token behavior.

Comments suppressed due to low confidence (1)

cmd/entire/cli/agent/codex/reviewer.go:236

• Finished should be the last event on the channel. With the rollout tailer running concurrently, emit Finished only after stopping and waiting for the tailer; otherwise, a final token_count write could arrive after Finished and reorder the stream.

			// Success is hard-coded true here because codex's `turn.completed`
			// envelope has no turn-level error field in 0.130.0. If a future
			// codex version adds one (e.g., an `error` or `is_error` field on
			// the envelope), capture it into a local during the switch case and
			// thread it through here as `!turnErr` — mirroring claude's
			// `!resultErr` pattern.
			out <- reviewtypes.Finished{Success: true}
			return