Fix Codex request-level turn accounting (#504)

CHANGELOG.md

@@ -4,6 +4,7 @@ Cross-package release notes for relayburn. Package changelogs contain package-le
 
 ## [Unreleased]
 
+- Codex turns and inference rows now reflect each model API request represented by an advancing usage snapshot, so summary, sessions, and compare per-turn metrics no longer collapse long agent loops into one turn. Run `burn state rebuild` to correct previously ingested Codex sessions.
 - `burn mcp-server` now exposes summary, hotspots, overhead attribution,
  overhead trimming, and model comparison through validated read-only tools.
 - `burn --json` commands and stdout `burn stamps export` streams now exit quietly when a downstream pipe closes early instead of reporting the pipe closure as a generic error.

crates/relayburn-cli/src/commands/mcp_server.rs

@@ -885,6 +885,7 @@ mod tests {
  fn fixture_turn(index: u64, session: &str, model: &str, project: &str) -> TurnRecord {
  TurnRecord {
  v: 1,
+ request_count: 1,
  source: SourceKind::ClaudeCode,
  session_id: session.to_string(),
  session_path: None,

crates/relayburn-cli/tests/json_broken_pipe.rs

@@ -33,6 +33,7 @@ fn turn(index: usize) -> TurnRecord {
  cache_create_1h: 0,
  },
  tool_calls: Vec::new(),
+ request_count: 1,
  files_touched: None,
  subagent: None,
  stop_reason: None,

crates/relayburn-sdk/src/analyze/claude_md.rs

@@ -518,6 +518,7 @@ mod tests {
  session_path: None,
  message_id: message_id.into(),
  turn_index,
+ request_count: 1,
  ts: "2026-04-23T00:00:00.000Z".into(),
  model: "claude-sonnet-4-6".into(),
  project: None,

crates/relayburn-sdk/src/analyze/compare.rs

@@ -40,13 +40,15 @@ pub struct CompareCell {
  pub one_shot_rate: Option<f64>,
  pub cache_hit_rate: Option<f64>,
  pub median_retries: Option<f64>,
- /// True when the cell has zero turns. Distinct from `insufficient_sample`
- /// so JSON consumers can tell "we never saw this combination" apart
- /// from "we have data but the sample is small." Only one of `no_data` /
- /// `insufficient_sample` is ever true at a time.
+ /// True when the cell has zero matching logical turn records. Distinct
+ /// from `insufficient_sample` so JSON consumers can tell "we never saw
+ /// this combination" apart from "we have data but the sample is small."
+ /// Only one of `no_data` / `insufficient_sample` is ever true at a time.
  pub no_data: bool,
- /// True when `0 < turns < min_sample`. A cell with `no_data == true`
- /// always has `insufficient_sample == false`.
+ /// True when `0 < logical turn records < min_sample`. This sample gate is
+ /// independent of `turns`, which reports model requests and may be zero
+ /// for an observed Codex record. A cell with `no_data == true` always has
+ /// `insufficient_sample == false`.
  pub insufficient_sample: bool,
 }
 
@@ -89,6 +91,7 @@ impl<'a> CompareOptions<'a> {
 #[derive(Debug, Default)]
 struct Accum {
  turns: u64,
+ logical_turns: u64,
  edit_turns: u64,
  one_shot_turns: u64,
  priced_turns: u64,
@@ -151,11 +154,13 @@ pub fn build_compare_table(turns: &[EnrichedTurn], opts: &CompareOptions<'_>) ->
  .expect("model just inserted");
  let acc = by_cat.entry(cat).or_default();
 
- acc.turns += 1;
+ let request_count = t.effective_request_count();
+ acc.turns += request_count;
+ acc.logical_turns += 1;
  let mt = model_totals.get_mut(model).expect("model just inserted");
- mt.turns += 1;
+ mt.turns += request_count;
  if let Some(c) = cost_for_turn(t, opts.pricing) {
- acc.priced_turns += 1;
+ acc.priced_turns += request_count;
  acc.total_cost += c.total;
  mt.total_cost += c.total;
  }
@@ -239,7 +244,7 @@ fn to_cell(acc: Option<&Accum>, min_sample: u64) -> CompareCell {
  let Some(acc) = acc else {
  return empty_cell();
  };
- if acc.turns == 0 {
+ if acc.logical_turns == 0 {
  return empty_cell();
  }
  CompareCell {
@@ -272,7 +277,7 @@ fn to_cell(acc: Option<&Accum>, min_sample: u64) -> CompareCell {
  None
  },
  no_data: false,
- insufficient_sample: acc.turns < min_sample,
+ insufficient_sample: acc.logical_turns < min_sample,
  }
 }
 
@@ -340,6 +345,7 @@ mod tests {
  session_path: None,
  message_id: id,
  turn_index: 0,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".into(),
  model: model.into(),
  project: None,
@@ -638,6 +644,51 @@ mod tests {
  assert!((cpt - cell.total_cost / 2.0).abs() < 1e-9);
  }
 
+ #[test]
+ fn uses_request_count_as_codex_cost_per_turn_denominator() {
+ let pricing = load_builtin_pricing();
+ let mut turns = vec![turn(
+ "claude-sonnet-4-6",
+ Some(ActivityCategory::Coding),
+ default_usage(),
+ Some(false),
+ None,
+ )];
+ turns[0].turn.source = SourceKind::Codex;
+ turns[0].turn.request_count = 7;
+
+ let t = build_compare_table(&turns, &CompareOptions::new(&pricing));
+ let cell = &t.cells["claude-sonnet-4-6"]["coding"];
+ assert_eq!(cell.turns, 7);
+ assert_eq!(cell.priced_turns, 7);
+ assert_eq!(cell.cost_per_turn, Some(cell.total_cost / 7.0));
+ assert!(
+ cell.insufficient_sample,
+ "request cardinality must not satisfy the logical sample-size gate"
+ );
+ }
+
+ #[test]
+ fn zero_request_logical_turn_is_insufficient_not_no_data() {
+ let pricing = load_builtin_pricing();
+ let mut turns = vec![turn(
+ "claude-sonnet-4-6",
+ Some(ActivityCategory::Coding),
+ Usage::default(),
+ Some(false),
+ None,
+ )];
+ turns[0].turn.source = SourceKind::Codex;
+ turns[0].turn.request_count = 0;
+
+ let table = build_compare_table(&turns, &CompareOptions::new(&pricing));
+ let cell = &table.cells["claude-sonnet-4-6"]["coding"];
+ assert_eq!(cell.turns, 0);
+ assert!(!cell.no_data);
+ assert!(cell.insufficient_sample);
+ assert_eq!(cell.cost_per_turn, None);
+ }
+
  #[test]
  fn groups_unclassified_turns_under_unclassified() {
  let pricing = load_builtin_pricing();

crates/relayburn-sdk/src/analyze/cost.rs

@@ -258,6 +258,7 @@ mod tests {
  session_path: None,
  message_id: "m".into(),
  turn_index: 0,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".into(),
  model: model.into(),
  project: None,

crates/relayburn-sdk/src/analyze/findings.rs

@@ -1112,6 +1112,7 @@ mod tests {
  fn detector_finding_in_unpriced_session_drops_false_usd_estimate() {
  let turn = TurnRecord {
  v: 1,
+ request_count: 1,
  source: SourceKind::ClaudeCode,
  session_id: "unknown-session".to_string(),
  session_path: None,
@@ -1168,6 +1169,7 @@ mod tests {
  fn unpriced_codex_volume_does_not_double_count_reasoning_inside_output() {
  let turn = TurnRecord {
  v: 1,
+ request_count: 1,
  source: SourceKind::Codex,
  session_id: "codex-unknown".to_string(),
  session_path: None,

crates/relayburn-sdk/src/analyze/ghost_surface_inputs.rs

@@ -136,6 +136,7 @@ mod tests {
  session_path: None,
  message_id: format!("msg-{session_id}"),
  turn_index: 0,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".to_string(),
  model: model.to_string(),
  project: None,

crates/relayburn-sdk/src/analyze/hotspots_tests.rs

@@ -37,6 +37,7 @@ fn turn(
  session_path: None,
  message_id: message_id.into(),
  turn_index,
+ request_count: 1,
  ts: ts.into(),
  model: model.into(),
  project: None,

crates/relayburn-sdk/src/analyze/overhead.rs

@@ -200,6 +200,7 @@ mod tests {
  session_path: None,
  message_id: format!("m-{}", idx),
  turn_index: idx,
+ request_count: 1,
  ts: "2026-04-23T00:00:00.000Z".to_string(),
  model: "claude-sonnet-4-6".to_string(),
  project: None,

crates/relayburn-sdk/src/analyze/patterns_tests.rs

@@ -87,6 +87,7 @@ fn turn(session_id: &str, message_id: &str, turn_index: u64) -> TurnRecord {
  session_path: None,
  message_id: message_id.into(),
  turn_index,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".into(),
  model: "claude-sonnet-4-6".into(),
  project: None,

crates/relayburn-sdk/src/analyze/provider.rs

@@ -258,7 +258,7 @@ pub(crate) fn aggregate_by_provider(
  let row = by_provider
  .entry(provider.clone())
  .or_insert_with(|| empty_provider_row(&provider));
- row.turns += 1;
+ row.turns += t.effective_request_count();
  row.usage.input += t.usage.input;
  row.usage.output += t.usage.output;
  row.usage.reasoning += t.usage.reasoning;
@@ -385,6 +385,7 @@ mod tests {
  session_path: None,
  message_id: "m-provider".into(),
  turn_index: 0,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".into(),
  model: model.into(),
  project: None,
@@ -498,17 +499,13 @@ mod tests {
  #[test]
  fn aggregate_falls_through_to_collector_for_non_synthetic_turns() {
  let pricing = pricing_fixture();
- let rows = aggregate_by_provider(
- &[turn(
- "gpt-5",
- SourceKind::Codex,
- one_million_in_one_million_out(),
- )],
- AggregateByProviderOptions::new(&pricing),
- );
+ let mut codex = turn("gpt-5", SourceKind::Codex, one_million_in_one_million_out());
+ codex.request_count = 7;
+ let rows = aggregate_by_provider(&[codex], AggregateByProviderOptions::new(&pricing));
 
  assert_eq!(rows.len(), 1);
  assert_eq!(rows[0].provider, "openai");
+ assert_eq!(rows[0].turns, 7);
  assert_eq!(rows[0].cost.total, 9.0);
  }
 
@@ -614,6 +611,7 @@ mod cost_lookup_via_reattribution_tests {
  session_path: None,
  message_id: "m".into(),
  turn_index: 0,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".into(),
  model: model.into(),
  project: None,

crates/relayburn-sdk/src/analyze/quality.rs

@@ -537,6 +537,7 @@ mod tests {
  session_path: None,
  message_id: o.message_id,
  turn_index: o.turn_index,
+ request_count: 1,
  ts: o
  .ts
  .unwrap_or_else(|| "2026-04-20T00:00:00.000Z".to_string()),

crates/relayburn-sdk/src/analyze/replacement_savings.rs

@@ -187,6 +187,7 @@ mod tests {
  session_path: None,
  message_id: "m".to_string(),
  turn_index: 0,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".to_string(),
  model: "claude-sonnet-4-6".to_string(),
  project: None,

crates/relayburn-sdk/src/analyze/subagent_tree_tests.rs

@@ -22,6 +22,7 @@ fn make_turn(
  session_path: None,
  message_id: message_id.into(),
  turn_index,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".into(),
  model: model.into(),
  project: None,

crates/relayburn-sdk/src/analyze/tool_call_patterns.rs

@@ -530,6 +530,7 @@ mod tests {
  session_path: None,
  message_id: message_id.to_string(),
  turn_index,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".to_string(),
  model: "claude-sonnet-4-6".to_string(),
  project: None,

crates/relayburn-sdk/src/analyze/tool_output_bloat_tests.rs

@@ -133,6 +133,7 @@ fn turn_with(
  session_path: None,
  message_id: message_id.to_string(),
  turn_index,
+ request_count: 1,
  ts: "2026-04-20T00:00:00.000Z".to_string(),
  model: "claude-sonnet-4-6".to_string(),
  project: None,

crates/relayburn-sdk/src/export_verbs.rs

@@ -297,6 +297,7 @@ mod tests {
  session_path: None,
  message_id: "m1".into(),
  turn_index: 0,
+ request_count: 1,
  ts: "2025-01-01T00:00:00Z".into(),
  model: "claude-sonnet-4-6".into(),
  project: None,

crates/relayburn-sdk/src/ingest/gap.rs

@@ -392,6 +392,7 @@ mod tests {
  session_path: None,
  message_id: message.into(),
  turn_index: 0,
+ request_count: 1,
  ts: "2026-04-22T00:00:00.000Z".into(),
  model: "gpt-5".into(),
  project: None,

crates/relayburn-sdk/src/ingest/ingest.rs

@@ -1170,6 +1170,11 @@ trait DerivedRecords {
  /// `apply_parsed_extras` inference materializer uses it to rebuild
  /// the per-API-call rows in lockstep with the persisted turns.
  fn turns(&self) -> &[TurnRecord];
+ /// Harness-native request rows when the source exposes request
+ /// boundaries that cannot be reconstructed from logical turns.
+ fn native_inferences(&self) -> Option<&[crate::reader::Inference]> {
+ None
+ }
 }
 
 /// Shared accessor body for the four parser-result types. The
@@ -1212,9 +1217,32 @@ macro_rules! impl_derived_records_common {
 
 impl_derived_records_common!(ClaudeParseResult);
 impl_derived_records_common!(ClaudeParseIncrementalResult);
-impl_derived_records_common!(ParseCodexIncrementalResult);
 impl_derived_records_common!(ParseOpencodeIncrementalResult);
 
+impl DerivedRecords for ParseCodexIncrementalResult {
+ fn content(&self) -> &[ContentRecord] {
+ &self.content
+ }
+ fn events(&self) -> &[CompactionEvent] {
+ &self.events
+ }
+ fn relationships(&self) -> &[SessionRelationshipRecord] {
+ &self.relationships
+ }
+ fn tool_result_events(&self) -> &[ToolResultEventRecord] {
+ &self.tool_result_events
+ }
+ fn user_turns(&self) -> &[UserTurnRecord] {
+ &self.user_turns
+ }
+ fn turns(&self) -> &[TurnRecord] {
+ &self.turns
+ }
+ fn native_inferences(&self) -> Option<&[crate::reader::Inference]> {
+ Some(&self.inferences)
+ }
+}
+
 /// Per-type adapter for the `request_id_lookup` override (issue #434).
 /// Specialized for Claude's two result types so they borrow the parser's
 /// real lookup; the generic fallback returns an empty owned lookup so
@@ -1233,11 +1261,6 @@ impl ClaudeRequestIdSource for ClaudeParseIncrementalResult {
  std::borrow::Cow::Borrowed(&self.request_id_lookup)
  }
 }
-impl ClaudeRequestIdSource for ParseCodexIncrementalResult {
- fn lookup_cow(&self) -> std::borrow::Cow<'_, crate::reader::RequestIdLookup> {
- std::borrow::Cow::Owned(crate::reader::RequestIdLookup::new())
- }
-}
 impl ClaudeRequestIdSource for ParseOpencodeIncrementalResult {
  fn lookup_cow(&self) -> std::borrow::Cow<'_, crate::reader::RequestIdLookup> {
  std::borrow::Cow::Owned(crate::reader::RequestIdLookup::new())
@@ -1276,7 +1299,11 @@ fn apply_parsed_extras<P: DerivedRecords>(ledger: &mut Ledger, p: &P) -> anyhow:
  // was deduped at append time by the content-fingerprint check, its
  // inference will simply re-replace the prior row via the
  // `INSERT OR REPLACE` writer, which is the correct steady-state.
- if !p.turns().is_empty() {
+ if let Some(inferences) = p.native_inferences() {
+ if !inferences.is_empty() {
+ ledger.append_inferences(inferences)?;
+ }
+ } else if !p.turns().is_empty() {
  let lookup = p.request_id_lookup();
  let inferences = crate::reader::build_inferences(p.turns(), lookup.as_ref());
  if !inferences.is_empty() {