Lightweight coding agent that runs in your terminal
Rust
Add thread usage to TUI status surfaces (#38282)
Felipe Coury1e71e35df61f
diff --git a/codex-rs/cli/src/doctor/title.rs b/codex-rs/cli/src/doctor/title.rsindex b5413ff979..9894263dd9 100644--- a/codex-rs/cli/src/doctor/title.rs+++ b/codex-rs/cli/src/doctor/title.rs@@ -134,6 +134,8 @@ fn terminal_title_item_id(item: &str) -> Option<&'static str> {"context-used" | "context-usage" => Some("context-used"),"five-hour-limit" => Some("five-hour-limit"),"weekly-limit" => Some("weekly-limit"),+ "thread-credits" => Some("thread-credits"),+ "estimated-thread-cost" => Some("estimated-thread-cost"),"codex-version" => Some("codex-version"),"used-tokens" => Some("used-tokens"),"total-input-tokens" => Some("total-input-tokens"),@@ -306,6 +308,27 @@ mod tests {);}+ #[test]+ fn terminal_title_accepts_thread_usage_items() {+ let check = terminal_title_check_from_inputs(TerminalTitleInputs {+ configured_items: Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]),+ cwd: PathBuf::from("/workspace/project"),+ project_root: None,+ });++ assert_eq!(check.status, CheckStatus::Ok);+ assert_eq!(check.summary, "terminal title configured");+ assert!(+ check.details.contains(+ &"terminal title items: thread-credits, estimated-thread-cost".to_string()+ )+ );+ assert!(check.issues.is_empty());+ }+#[test]fn terminal_title_omits_project_when_project_item_is_not_selected() {let check = terminal_title_check_from_inputs(TerminalTitleInputs {diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__status_line_setup__tests__setup_view_snapshot_includes_thread_usage_items.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__status_line_setup__tests__setup_view_snapshot_includes_thread_usage_items.snapnew file mode 100644index 0000000000..813828171f--- /dev/null+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__status_line_setup__tests__setup_view_snapshot_includes_thread_usage_items.snap@@ -0,0 +1,21 @@+---+source: tui/src/bottom_pane/status_line_setup.rs+expression: "render_lines(&view, 100)"+---++ Configure Status Line+ Select which items to display in the status line.++ Type to search+ >+› [x] Use theme colors Apply colors from the active /theme+ ───────────────────────+ [x] thread-credits Estimated current-thread credits (Enterprise workspaces only; omitte…+ [x] estimated-thread-cost Estimated current-thread cost in USD (Enterprise workspaces only; om…+ [ ] model Current model name+ [ ] model-with-reasoning Current model name with reasoning level+ [ ] reasoning Current reasoning level+ [ ] current-dir Current working directory++ 5.2 credits · ~$1.82+ Press space to toggle; ←/→ to move; enter to confirm and close; esc to closediff --git a/codex-rs/tui/src/bottom_pane/status_line_setup.rs b/codex-rs/tui/src/bottom_pane/status_line_setup.rsindex 32d6daa279..0092d170bd 100644--- a/codex-rs/tui/src/bottom_pane/status_line_setup.rs+++ b/codex-rs/tui/src/bottom_pane/status_line_setup.rs@@ -124,6 +124,12 @@ pub(crate) enum StatusLineItem {/// Total output tokens generated.TotalOutputTokens,+ /// Estimated credits attributed directly to the current enterprise thread.+ ThreadCredits,++ /// Estimated dollar cost attributed directly to the current enterprise thread.+ EstimatedThreadCost,+/// Full thread UUID.#[strum(to_string = "thread-id", serialize = "session-id")]SessionId,@@ -182,6 +188,12 @@ impl StatusLineItem {StatusLineItem::UsedTokens => "Total tokens used in session (omitted when zero)",StatusLineItem::TotalInputTokens => "Total input tokens used in session",StatusLineItem::TotalOutputTokens => "Total output tokens used in session",+ StatusLineItem::ThreadCredits => {+ "Estimated current-thread credits (Enterprise workspaces only; omitted when unavailable)"+ }+ StatusLineItem::EstimatedThreadCost => {+ "Estimated current-thread cost in USD (Enterprise workspaces only; omitted when unavailable)"+ }StatusLineItem::SessionId => "Current thread identifier (omitted until thread starts)",StatusLineItem::FastMode => "Whether Fast mode is currently active",StatusLineItem::RawOutput => "Whether raw scrollback mode is active",@@ -219,6 +231,8 @@ impl StatusLineItem {StatusLineItem::UsedTokens => StatusSurfacePreviewItem::UsedTokens,StatusLineItem::TotalInputTokens => StatusSurfacePreviewItem::TotalInputTokens,StatusLineItem::TotalOutputTokens => StatusSurfacePreviewItem::TotalOutputTokens,+ StatusLineItem::ThreadCredits => StatusSurfacePreviewItem::ThreadCredits,+ StatusLineItem::EstimatedThreadCost => StatusSurfacePreviewItem::EstimatedThreadCost,StatusLineItem::SessionId => StatusSurfacePreviewItem::SessionId,StatusLineItem::FastMode => StatusSurfacePreviewItem::FastMode,StatusLineItem::RawOutput => StatusSurfacePreviewItem::RawOutput,@@ -436,6 +450,19 @@ mod tests {"context-remaining");}++ #[test]+ fn thread_usage_items_are_independently_selectable() {+ assert_eq!(+ "thread-credits".parse::<StatusLineItem>(),+ Ok(StatusLineItem::ThreadCredits)+ );+ assert_eq!(+ "estimated-thread-cost".parse::<StatusLineItem>(),+ Ok(StatusLineItem::EstimatedThreadCost)+ );+ }+#[test]fn project_name_is_canonical_and_accepts_legacy_ids() {assert_eq!(StatusLineItem::ProjectRoot.to_string(), "project-name");@@ -673,6 +700,32 @@ mod tests {assert_snapshot!(render_lines(&view, /*width*/ 72));}+ #[test]+ fn setup_view_snapshot_includes_thread_usage_items() {+ let (tx_raw, _rx) = unbounded_channel::<AppEvent>();+ let view = StatusLineSetupView::new(+ Some(&[+ StatusLineItem::ThreadCredits.to_string(),+ StatusLineItem::EstimatedThreadCost.to_string(),+ ]),+ /*use_theme_colors*/ true,+ StatusSurfacePreviewData::from_iter([+ (+ StatusLineItem::ThreadCredits.preview_item(),+ "5.2 credits".to_string(),+ ),+ (+ StatusLineItem::EstimatedThreadCost.preview_item(),+ "~$1.82".to_string(),+ ),+ ]),+ AppEventSender::new(tx_raw),+ crate::keymap::RuntimeKeymap::defaults().list,+ );++ assert_snapshot!(render_lines(&view, /*width*/ 100));+ }+fn render_lines(view: &StatusLineSetupView, width: u16) -> String {let height = view.desired_height(width);let area = Rect::new(0, 0, width, height);diff --git a/codex-rs/tui/src/bottom_pane/status_line_style.rs b/codex-rs/tui/src/bottom_pane/status_line_style.rsindex 4198943a4f..29e82b8e21 100644--- a/codex-rs/tui/src/bottom_pane/status_line_style.rs+++ b/codex-rs/tui/src/bottom_pane/status_line_style.rs@@ -43,7 +43,9 @@ impl StatusLineAccent {| StatusLineItem::ContextWindowSize| StatusLineItem::UsedTokens| StatusLineItem::TotalInputTokens- | StatusLineItem::TotalOutputTokens => Self::Usage,+ | StatusLineItem::TotalOutputTokens+ | StatusLineItem::ThreadCredits+ | StatusLineItem::EstimatedThreadCost => Self::Usage,StatusLineItem::FiveHourLimit | StatusLineItem::WeeklyLimit => Self::Limit,StatusLineItem::CodexVersion | StatusLineItem::SessionId => Self::Metadata,StatusLineItem::FastMode | StatusLineItem::RawOutput => Self::Mode,@@ -233,6 +235,23 @@ mod tests {assert!(!line.spans[2].style.add_modifier.contains(Modifier::DIM));}+ #[test]+ fn thread_usage_items_share_an_accent_and_dim_separator() {+ let line = status_line_from_segments_with_resolver(+ [+ (StatusLineItem::ThreadCredits, "5.2 credits".to_string()),+ (StatusLineItem::EstimatedThreadCost, "~$0.21".to_string()),+ ],+ /*use_theme_colors*/ true,+ |_| None,+ )+ .expect("thread usage status line");++ assert_eq!(line_text(&line), "5.2 credits · ~$0.21");+ assert_eq!(line.spans[0].style, line.spans[2].style);+ assert!(line.spans[1].style.add_modifier.contains(Modifier::DIM));+ }+#[test]#[allow(clippy::disallowed_methods)]fn status_line_segments_soften_rgb_theme_styles_without_dimming_text() {diff --git a/codex-rs/tui/src/bottom_pane/status_surface_preview.rs b/codex-rs/tui/src/bottom_pane/status_surface_preview.rsindex b8b7a6fbd4..ffa9ae9269 100644--- a/codex-rs/tui/src/bottom_pane/status_surface_preview.rs+++ b/codex-rs/tui/src/bottom_pane/status_surface_preview.rs@@ -27,6 +27,8 @@ pub(crate) enum StatusSurfacePreviewItem {UsedTokens,TotalInputTokens,TotalOutputTokens,+ ThreadCredits,+ EstimatedThreadCost,SessionId,FastMode,RawOutput,@@ -60,6 +62,8 @@ impl StatusSurfacePreviewItem {StatusSurfacePreviewItem::UsedTokens => "0 used",StatusSurfacePreviewItem::TotalInputTokens => "0 in",StatusSurfacePreviewItem::TotalOutputTokens => "0 out",+ StatusSurfacePreviewItem::ThreadCredits => "5.2 credits",+ StatusSurfacePreviewItem::EstimatedThreadCost => "~$1.82",StatusSurfacePreviewItem::SessionId => "550e8400-e29b-41d4",StatusSurfacePreviewItem::FastMode => "Fast on",StatusSurfacePreviewItem::RawOutput => "raw output",@@ -93,6 +97,8 @@ impl StatusSurfacePreviewItem {Self::UsedTokens,Self::TotalInputTokens,Self::TotalOutputTokens,+ Self::ThreadCredits,+ Self::EstimatedThreadCost,Self::SessionId,Self::FastMode,Self::RawOutput,diff --git a/codex-rs/tui/src/bottom_pane/title_setup.rs b/codex-rs/tui/src/bottom_pane/title_setup.rsindex bf4919c94e..146d684791 100644--- a/codex-rs/tui/src/bottom_pane/title_setup.rs+++ b/codex-rs/tui/src/bottom_pane/title_setup.rs@@ -72,6 +72,10 @@ pub(crate) enum TerminalTitleItem {TotalInputTokens,/// Total output tokens generated.TotalOutputTokens,+ /// Estimated credits attributed directly to the current enterprise thread.+ ThreadCredits,+ /// Estimated dollar cost attributed directly to the current enterprise thread.+ EstimatedThreadCost,/// Full thread UUID.#[strum(to_string = "thread-id", serialize = "session-id")]SessionId,@@ -118,6 +122,12 @@ impl TerminalTitleItem {TerminalTitleItem::UsedTokens => "Total tokens used in session (omitted when zero)",TerminalTitleItem::TotalInputTokens => "Total input tokens used in session",TerminalTitleItem::TotalOutputTokens => "Total output tokens used in session",+ TerminalTitleItem::ThreadCredits => {+ "Estimated current-thread credits (Enterprise workspaces only; omitted when unavailable)"+ }+ TerminalTitleItem::EstimatedThreadCost => {+ "Estimated current-thread cost (Enterprise workspaces only; omitted when unavailable)"+ }TerminalTitleItem::SessionId => {"Current thread identifier (omitted until thread starts)"}@@ -150,6 +160,10 @@ impl TerminalTitleItem {TerminalTitleItem::TotalOutputTokens => {Some(StatusSurfacePreviewItem::TotalOutputTokens)}+ TerminalTitleItem::ThreadCredits => Some(StatusSurfacePreviewItem::ThreadCredits),+ TerminalTitleItem::EstimatedThreadCost => {+ Some(StatusSurfacePreviewItem::EstimatedThreadCost)+ }TerminalTitleItem::SessionId => Some(StatusSurfacePreviewItem::SessionId),TerminalTitleItem::FastMode => Some(StatusSurfacePreviewItem::FastMode),TerminalTitleItem::Model => Some(StatusSurfacePreviewItem::Model),@@ -533,6 +547,17 @@ mod tests {);}+ #[test]+ fn thread_usage_items_are_independently_selectable() {+ assert_eq!(+ parse_terminal_title_items(["thread-credits", "estimated-thread-cost"].into_iter()),+ Some(vec![+ TerminalTitleItem::ThreadCredits,+ TerminalTitleItem::EstimatedThreadCost,+ ])+ );+ }+#[test]fn parse_terminal_title_items_accepts_kebab_case_variants() {let items = parse_terminal_title_items(@@ -553,6 +578,8 @@ mod tests {"used-tokens","total-input-tokens","total-output-tokens",+ "thread-credits",+ "estimated-thread-cost","session-id","fast-mode",]@@ -577,6 +604,8 @@ mod tests {TerminalTitleItem::UsedTokens,TerminalTitleItem::TotalInputTokens,TerminalTitleItem::TotalOutputTokens,+ TerminalTitleItem::ThreadCredits,+ TerminalTitleItem::EstimatedThreadCost,TerminalTitleItem::SessionId,TerminalTitleItem::FastMode,])diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 577fee6093..3242bc6b42 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -1220,6 +1220,7 @@ impl ChatWidget {self.refresh_terminal_title();}self.refresh_status_line_if_workspace_headline_due();+ self.refresh_thread_usage_if_settlement_due();}fn flush_active_cell(&mut self) {diff --git a/codex-rs/tui/src/chatwidget/protocol.rs b/codex-rs/tui/src/chatwidget/protocol.rsindex 79e2c3fe6e..a1a8a8cc3f 100644--- a/codex-rs/tui/src/chatwidget/protocol.rs+++ b/codex-rs/tui/src/chatwidget/protocol.rs@@ -15,6 +15,8 @@ impl ChatWidget {return;}+ let was_replaying_turn_completion = self.thread_usage.replaying_turn_completion;+ self.thread_usage.replaying_turn_completion = replay_kind.is_some();let from_replay = replay_kind.is_some();let is_resume_initial_replay =matches!(replay_kind, Some(ReplayKind::ResumeInitialMessages));@@ -230,6 +232,7 @@ impl ChatWidget {| ServerNotification::AccountLoginCompleted(_) => {}ServerNotification::ContextCompacted(_) => {}}+ self.thread_usage.replaying_turn_completion = was_replaying_turn_completion;}pub(super) fn handle_turn_completed_notification(@@ -241,6 +244,8 @@ impl ChatWidget {// this TUI already rendered locally. Once that turn ends, another// client can submit the same text and it still needs its own user cell.self.last_rendered_user_message_display = None;+ let was_replaying_turn_completion = self.thread_usage.replaying_turn_completion;+ self.thread_usage.replaying_turn_completion = replay_kind.is_some();match notification.turn.status {TurnStatus::Completed => {let last_agent_message =@@ -311,6 +316,7 @@ impl ChatWidget {}TurnStatus::InProgress => {}}+ self.thread_usage.replaying_turn_completion = was_replaying_turn_completion;}fn handle_item_started_notification(diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_estimated_thread_cost_footer.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_estimated_thread_cost_footer.snapnew file mode 100644index 0000000000..d6e5058aec--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_estimated_thread_cost_footer.snap@@ -0,0 +1,9 @@+---+source: tui/src/chatwidget/tests/status_and_layout.rs+expression: normalized_backend_snapshot(terminal.backend())+---+" "+" "+"› Ask Codex to do anything "+" "+" gpt-5.6-sol default · 5.2 credits · ~$0.21 "diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_thread_usage.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_thread_usage.snapnew file mode 100644index 0000000000..86ef121b71--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_thread_usage.snap@@ -0,0 +1,6 @@+---+source: tui/src/chatwidget/tests/status_surface_previews.rs+expression: snapshot+---+status line: 5.2 credits · ~$0.21+terminal title: 5.2 credits | ~$0.21diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_thread_usage.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_thread_usage.snapnew file mode 100644index 0000000000..fe2b4d94c3--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_thread_usage.snap@@ -0,0 +1,20 @@+---+source: tui/src/chatwidget/tests/status_surface_previews.rs+expression: terminal_title_popup_snapshot(&mut chat)+---+ Configure Terminal Title+ Select which items to display in the terminal title.++ Type to search+ >+› [x] thread-credits Estimated current-thread credits (Enterprise workspaces only; omitte…+ [x] estimated-thread-cost Estimated current-thread cost (Enterprise workspaces only; omitted w…+ [ ] app-name Codex app name+ [ ] project-name Project name (falls back to current directory name)+ [ ] current-dir Current working directory+ [ ] activity Spinner while working, action-required message while blocked.+ [ ] run-state Compact session run-state text (Ready, Working, Thinking)+ [ ] thread-title Current thread title, or thread identifier when unnamed++ 5.2 credits | ~$1.82+ Press space to toggle; ←/→ to move; enter to confirm and close; esc to closediff --git a/codex-rs/tui/src/chatwidget/status_controls.rs b/codex-rs/tui/src/chatwidget/status_controls.rsindex d715be1ab5..8ebdf0fab8 100644--- a/codex-rs/tui/src/chatwidget/status_controls.rs+++ b/codex-rs/tui/src/chatwidget/status_controls.rs@@ -340,6 +340,13 @@ impl ChatWidget {}}+ if self+ .estimated_thread_usage()+ .is_some_and(|usage| usage.estimated_usage_usd_micros.is_none())+ {+ preview_data.suppress_placeholder(StatusSurfacePreviewItem::EstimatedThreadCost);+ }+preview_data}diff --git a/codex-rs/tui/src/chatwidget/status_surfaces.rs b/codex-rs/tui/src/chatwidget/status_surfaces.rsindex 5c9343c697..04b876aa29 100644--- a/codex-rs/tui/src/chatwidget/status_surfaces.rs+++ b/codex-rs/tui/src/chatwidget/status_surfaces.rs@@ -9,6 +9,8 @@ use crate::branch_summary;use crate::chatwidget::limit_label_for_window;use crate::chatwidget::rate_limits::get_limits_duration;use crate::legacy_core::config::Config;+use crate::status::format_credit_micros;+use crate::status::format_estimated_usd_micros;use crate::status::format_tokens_compact;use codex_app_server_protocol::AskForApproval;use codex_config::ConfigLayerSource;@@ -71,6 +73,20 @@ impl StatusSurfaceSelections {self.status_line_items.contains(&StatusLineItem::WorkspaceHeadline)}++ fn uses_thread_usage(&self) -> bool {+ self.status_line_items.iter().any(|item| {+ matches!(+ item,+ StatusLineItem::ThreadCredits | StatusLineItem::EstimatedThreadCost+ )+ }) || self.terminal_title_items.iter().any(|item| {+ matches!(+ item,+ TerminalTitleItem::ThreadCredits | TerminalTitleItem::EstimatedThreadCost+ )+ })+ }}/// Cached project-root display name keyed by the cwd used for the last lookup.@@ -172,6 +188,12 @@ impl ChatWidget {} else {self.request_status_line_workspace_headline_if_due(Instant::now());}++ if selections.uses_thread_usage() {+ self.ensure_thread_usage_requested();+ } else {+ self.cancel_thread_usage_polling();+ }}fn refresh_status_line_from_selections(&mut self, selections: &StatusSurfaceSelections) {@@ -727,6 +749,14 @@ impl ChatWidget {format_tokens_compact(self.status_line_total_usage().output_tokens))}),+ StatusLineItem::ThreadCredits => self+ .estimated_thread_usage()+ .map(|usage| usage.estimated_usage_credits_micros)+ .map(|credits| format!("{} credits", format_credit_micros(credits))),+ StatusLineItem::EstimatedThreadCost => self+ .estimated_thread_usage()+ .and_then(|usage| usage.estimated_usage_usd_micros)+ .and_then(format_estimated_usd_micros),StatusLineItem::SessionId => self.thread_id.map(|id| id.to_string()),StatusLineItem::FastMode => Some(if self.current_service_tier() == Some(ServiceTier::Fast.request_value()) {@@ -785,6 +815,8 @@ impl ChatWidget {StatusSurfacePreviewItem::UsedTokens => StatusLineItem::UsedTokens,StatusSurfacePreviewItem::TotalInputTokens => StatusLineItem::TotalInputTokens,StatusSurfacePreviewItem::TotalOutputTokens => StatusLineItem::TotalOutputTokens,+ StatusSurfacePreviewItem::ThreadCredits => StatusLineItem::ThreadCredits,+ StatusSurfacePreviewItem::EstimatedThreadCost => StatusLineItem::EstimatedThreadCost,StatusSurfacePreviewItem::SessionId => StatusLineItem::SessionId,StatusSurfacePreviewItem::FastMode => StatusLineItem::FastMode,StatusSurfacePreviewItem::RawOutput => StatusLineItem::RawOutput,@@ -843,6 +875,12 @@ impl ChatWidget {TerminalTitleItem::TotalOutputTokens => self.status_line_value_for_item(StatusLineItem::TotalOutputTokens).map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),+ TerminalTitleItem::ThreadCredits => self+ .status_line_value_for_item(StatusLineItem::ThreadCredits)+ .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),+ TerminalTitleItem::EstimatedThreadCost => self+ .status_line_value_for_item(StatusLineItem::EstimatedThreadCost)+ .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),TerminalTitleItem::SessionId => self.status_line_value_for_item(StatusLineItem::SessionId).map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),diff --git a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rsindex 70cbb4a0dc..b28bc6a63e 100644--- a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs+++ b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs@@ -1,8 +1,10 @@use super::*;use crate::bottom_pane::goal_status_indicator_line;+use crate::chatwidget::ThreadUsageOutcome;use crate::chatwidget::rate_limits::NUDGE_MODEL_SLUG;use crate::chatwidget::rate_limits::get_limits_duration;use codex_app_server_protocol::SpendControlLimitSnapshot;+use codex_app_server_protocol::ThreadUsage;use pretty_assertions::assert_eq;use ratatui::backend::TestBackend;use serial_test::serial;@@ -2851,6 +2853,632 @@ async fn status_line_legacy_context_usage_renders_context_used_percent() {);}+#[tokio::test]+async fn status_line_estimated_thread_cost_fetches_and_renders_backend_estimate() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);++ chat.refresh_status_line();+ assert_eq!(status_line_text(&chat), None);+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage {+ thread_id: requested_thread_id,+ request_id,+ }) => {+ assert_eq!(requested_thread_id, thread_id);+ request_id+ }+ event => panic!("expected estimated thread usage refresh, got {event:?}"),+ };++ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));+ assert_eq!(status_line_text(&chat), Some("~$1.82".to_string()));+ assert!(rx.try_recv().is_err(), "idle refresh must not poll");+}++#[tokio::test]+async fn status_line_thread_credits_fetches_and_renders_fractional_credits() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["thread-credits".to_string()]);++ chat.refresh_status_line();+ assert_eq!(status_line_text(&chat), None);+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage {+ thread_id: requested_thread_id,+ request_id,+ }) => {+ assert_eq!(requested_thread_id, thread_id);+ request_id+ }+ event => panic!("expected thread credits refresh, got {event:?}"),+ };++ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_240_000,+ estimated_usage_usd_micros: Some(210_000),+ groups: Vec::new(),+ })),+ ));+ assert_eq!(status_line_text(&chat), Some("5.2 credits".to_string()));+ assert!(rx.try_recv().is_err(), "idle refresh must not poll");+}++#[tokio::test]+async fn status_line_thread_credits_and_cost_share_one_backend_request() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);++ chat.refresh_status_line();+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected a shared thread usage refresh, got {event:?}"),+ };+ assert!(rx.try_recv().is_err(), "both items must share one request");++ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: Some(210_000),+ groups: Vec::new(),+ })),+ ));+ assert_eq!(+ status_line_text(&chat),+ Some("5.2 credits · ~$0.21".to_string())+ );+ assert!(rx.try_recv().is_err(), "idle refresh must not poll");+}++#[tokio::test]+async fn status_line_thread_credits_remain_visible_when_usd_is_unavailable() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);++ chat.refresh_status_line();+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected a shared thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: None,+ groups: Vec::new(),+ })),+ ));++ assert_eq!(status_line_text(&chat), Some("5.2 credits".to_string()));+ assert!(+ rx.try_recv().is_err(),+ "credits-only estimates must not trigger retries"+ );+}++#[tokio::test]+async fn terminal_title_thread_usage_fetches_and_renders_without_status_line() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(Vec::new());+ chat.config.tui_terminal_title = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);++ chat.refresh_terminal_title();+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage {+ thread_id: requested_thread_id,+ request_id,+ }) => {+ assert_eq!(requested_thread_id, thread_id);+ request_id+ }+ event => panic!("expected title-only thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: Some(210_000),+ groups: Vec::new(),+ })),+ ));++ assert_eq!(+ chat.last_terminal_title,+ Some("5.2 credits | ~$0.21".to_string())+ );+ assert_eq!(status_line_text(&chat), None);+ assert!(rx.try_recv().is_err(), "title-only refresh must not poll");+}++#[tokio::test]+async fn terminal_title_thread_credits_remain_visible_when_usd_is_unavailable() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(Vec::new());+ chat.config.tui_terminal_title = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);++ chat.refresh_terminal_title();+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected title-only thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: None,+ groups: Vec::new(),+ })),+ ));++ assert_eq!(chat.last_terminal_title, Some("5.2 credits".to_string()));+ assert!(+ rx.try_recv().is_err(),+ "credits-only title estimates must not trigger retries"+ );+}++#[tokio::test]+async fn terminal_title_and_status_line_share_one_thread_usage_request() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.config.tui_terminal_title = Some(vec!["thread-credits".to_string()]);++ chat.refresh_status_surfaces();+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected a shared title/footer thread usage request, got {event:?}"),+ };+ assert!(+ rx.try_recv().is_err(),+ "title and footer must share one request"+ );+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: Some(210_000),+ groups: Vec::new(),+ })),+ ));++ assert_eq!(chat.last_terminal_title, Some("5.2 credits".to_string()));+ assert_eq!(status_line_text(&chat), Some("~$0.21".to_string()));+}++#[tokio::test]+async fn status_line_estimated_thread_cost_avoids_unsupported_plan_requests() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Pro);+ chat.config.tui_status_line = Some(vec![+ "estimated-thread-cost".to_string(),+ "run-state".to_string(),+ ]);++ chat.refresh_status_line();++ assert_eq!(status_line_text(&chat), Some("Ready".to_string()));+ assert!(+ rx.try_recv().is_err(),+ "unsupported plans must not query usage"+ );+}++#[tokio::test]+async fn status_line_estimated_thread_cost_stops_after_backend_disables_feature() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::EnterpriseCbpAutomation);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected estimated thread usage refresh, got {event:?}"),+ };++ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Disabled),+ ));+ chat.refresh_thread_usage_after_turn();++ assert_eq!(status_line_text(&chat), None);+ assert!(rx.try_recv().is_err(), "disabled feature must not retry");+}++#[tokio::test]+async fn status_line_estimated_thread_cost_preserves_cached_amount_during_settlement() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();+ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));++ chat.refresh_thread_usage_after_turn();+ let settlement_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected post-turn thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ settlement_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 0,+ estimated_usage_usd_micros: Some(0),+ groups: Vec::new(),+ })),+ ));++ assert_eq!(status_line_text(&chat), Some("~$1.82".to_string()));+ assert!(+ rx.try_recv().is_err(),+ "settlement must not poll continuously"+ );+}++#[tokio::test]+async fn completed_turn_refreshes_estimated_thread_cost() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));++ chat.on_task_complete(+ /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ );++ let request_id = std::iter::from_fn(|| rx.try_recv().ok())+ .find_map(|event| match event {+ AppEvent::RefreshThreadUsage {+ thread_id: requested_thread_id,+ request_id,+ } if requested_thread_id == thread_id => Some(request_id),+ _ => None,+ })+ .expect("completed turns should refresh estimated thread usage");+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 50_000_000,+ estimated_usage_usd_micros: Some(2_100_000),+ groups: Vec::new(),+ })),+ ));+ assert_eq!(status_line_text(&chat), Some("~$2.10".to_string()));+}++#[tokio::test]+async fn completed_turn_refreshes_credits_only_terminal_title() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(Vec::new());+ chat.config.tui_terminal_title = Some(vec!["thread-credits".to_string()]);+ chat.refresh_terminal_title();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected title-only thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: None,+ groups: Vec::new(),+ })),+ ));++ chat.on_task_complete(+ /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ );++ let request_id = std::iter::from_fn(|| rx.try_recv().ok())+ .find_map(|event| match event {+ AppEvent::RefreshThreadUsage {+ thread_id: requested_thread_id,+ request_id,+ } if requested_thread_id == thread_id => Some(request_id),+ _ => None,+ })+ .expect("completed turns should refresh title-only thread usage");+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 6_200_000,+ estimated_usage_usd_micros: None,+ groups: Vec::new(),+ })),+ ));+ assert_eq!(chat.last_terminal_title, Some("6.2 credits".to_string()));+}++#[tokio::test]+async fn interrupted_turn_refreshes_estimated_thread_usage() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));++ chat.on_interrupted_turn(TurnAbortReason::Interrupted);++ assert!(+ std::iter::from_fn(|| rx.try_recv().ok()).any(|event| {+ matches!(+ event,+ AppEvent::RefreshThreadUsage {+ thread_id: requested_thread_id,+ ..+ } if requested_thread_id == thread_id+ )+ }),+ "interrupted turns must refresh estimated thread usage"+ );+}++#[tokio::test]+async fn failed_turn_refreshes_estimated_thread_usage() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));++ chat.handle_non_retry_error(+ "turn failed after generating tokens".to_string(),+ /*codex_error_info*/ None,+ );++ assert!(+ std::iter::from_fn(|| rx.try_recv().ok()).any(|event| {+ matches!(+ event,+ AppEvent::RefreshThreadUsage {+ thread_id: requested_thread_id,+ ..+ } if requested_thread_id == thread_id+ )+ }),+ "failed turns must refresh estimated thread usage"+ );+}++#[tokio::test]+async fn status_line_estimated_thread_cost_rejects_stale_thread_completions() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let previous_thread_id = ThreadId::new();+ let active_thread_id = ThreadId::new();+ chat.thread_id = Some(previous_thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();+ let previous_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected previous-thread usage refresh, got {event:?}"),+ };++ chat.thread_id = Some(active_thread_id);+ chat.refresh_status_line();+ let active_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected active-thread usage refresh, got {event:?}"),+ };+ assert!(!chat.finish_thread_usage_refresh(+ previous_thread_id,+ previous_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: previous_thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));+ assert_eq!(status_line_text(&chat), None);++ assert!(chat.finish_thread_usage_refresh(+ active_thread_id,+ active_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: active_thread_id.to_string(),+ estimated_usage_credits_micros: 1_000_000,+ estimated_usage_usd_micros: Some(400),+ groups: Vec::new(),+ })),+ ));+ assert_eq!(status_line_text(&chat), Some("~$0.0004".to_string()));+}++#[tokio::test]+async fn status_line_estimated_thread_cost_footer_snapshot() {+ use ratatui::Terminal;+ use ratatui::backend::TestBackend;++ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.show_welcome_banner = false;+ chat.config.tui_status_line = Some(vec![+ "model-with-reasoning".to_string(),+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);+ chat.refresh_status_line();+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected estimated thread usage refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: Some(210_000),+ groups: Vec::new(),+ })),+ ));++ let width = 80;+ let height = chat.desired_height(width);+ let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("create terminal");+ terminal+ .draw(|frame| chat.render(frame.area(), frame.buffer_mut()))+ .expect("draw estimated-thread-cost footer");+ assert_chatwidget_snapshot!(+ "status_line_estimated_thread_cost_footer",+ normalized_backend_snapshot(terminal.backend())+ );+}+#[tokio::test]async fn status_line_workspace_headline_renders_cached_value() {let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/chatwidget/tests/status_surface_previews.rs b/codex-rs/tui/src/chatwidget/tests/status_surface_previews.rsindex 9e38065a8c..5891301f55 100644--- a/codex-rs/tui/src/chatwidget/tests/status_surface_previews.rs+++ b/codex-rs/tui/src/chatwidget/tests/status_surface_previews.rs@@ -1,5 +1,7 @@use super::*;use crate::bottom_pane::preview_line_for_title_items;+use crate::chatwidget::ThreadUsageOutcome;+use codex_app_server_protocol::ThreadUsage;use pretty_assertions::assert_eq;use ratatui::text::Line;@@ -233,6 +235,107 @@ async fn status_surface_preview_lines_rate_limits_snapshot() {assert_chatwidget_snapshot!("status_surface_previews_rate_limits", snapshot);}+#[tokio::test]+async fn status_surface_preview_lines_thread_usage_snapshot() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);+ chat.config.tui_terminal_title = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);+ chat.refresh_status_surfaces();++ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected shared thread usage preview request, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: Some(210_000),+ groups: Vec::new(),+ })),+ ));++ let snapshot = combined_preview_snapshot(+ &mut chat,+ &[+ StatusLineItem::ThreadCredits,+ StatusLineItem::EstimatedThreadCost,+ ],+ &[+ TerminalTitleItem::ThreadCredits,+ TerminalTitleItem::EstimatedThreadCost,+ ],+ );++ assert_chatwidget_snapshot!("status_surface_previews_thread_usage", snapshot);+}++#[tokio::test]+async fn status_surface_thread_usage_previews_omit_unavailable_usd_estimates() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);+ chat.config.tui_terminal_title = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);+ chat.refresh_status_surfaces();++ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected shared thread usage preview request, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 5_200_000,+ estimated_usage_usd_micros: None,+ groups: Vec::new(),+ })),+ ));++ assert_eq!(+ status_preview_line(+ &mut chat,+ &[+ StatusLineItem::ThreadCredits,+ StatusLineItem::EstimatedThreadCost,+ ],+ ),+ "5.2 credits"+ );+ assert_eq!(+ title_preview_line(+ &mut chat,+ &[+ TerminalTitleItem::ThreadCredits,+ TerminalTitleItem::EstimatedThreadCost,+ ],+ ),+ "5.2 credits"+ );+}+#[tokio::test]async fn status_surface_preview_omits_unavailable_rate_limit_items() {let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;@@ -374,6 +477,20 @@ async fn terminal_title_setup_popup_rate_limits_snapshot() {);}+#[tokio::test]+async fn terminal_title_setup_popup_thread_usage_snapshot() {+ let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.config.tui_terminal_title = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);++ assert_chatwidget_snapshot!(+ "terminal_title_setup_popup_thread_usage",+ terminal_title_popup_snapshot(&mut chat)+ );+}+#[tokio::test]async fn missing_project_root_uses_different_status_and_title_preview_sources() {let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/chatwidget/thread_usage.rs b/codex-rs/tui/src/chatwidget/thread_usage.rsindex c4ba3c4a8b..9907aa1c69 100644--- a/codex-rs/tui/src/chatwidget/thread_usage.rs+++ b/codex-rs/tui/src/chatwidget/thread_usage.rs@@ -2,7 +2,11 @@use super::AppEvent;use super::ChatWidget;+use super::Duration;+use super::Instant;use super::PlanType;+use super::StatusLineItem;+use super::TerminalTitleItem;use super::ThreadId;use crate::status::StatusHistoryHandle;use codex_app_server_protocol::ThreadUsage;@@ -13,14 +17,41 @@ pub(crate) enum ThreadUsageOutcome {Disabled,}+const THREAD_USAGE_SETTLEMENT_DELAYS: [Duration; 3] = [+ Duration::from_secs(/*secs*/ 15),+ Duration::from_secs(/*secs*/ 60),+ Duration::from_secs(/*secs*/ 120),+];+const THREAD_USAGE_RETRY_DELAYS: [Duration; 3] = [+ Duration::from_secs(/*secs*/ 5),+ Duration::from_secs(/*secs*/ 15),+ Duration::from_secs(/*secs*/ 60),+];++#[derive(Debug, Default)]+struct SelectedThreadUsage {+ credits: bool,+ estimated_cost: bool,+}+#[derive(Debug, Default)]pub(super) struct ThreadUsageState {thread_id: Option<ThreadId>,estimate: Option<ThreadUsage>,pending_request_id: Option<u64>,next_request_id: u64,+ requested: bool,feature_disabled: bool,status_history_handles: Vec<StatusHistoryHandle>,+ status_requested: bool,+ retry_attempts: usize,+ retry_due_at: Option<Instant>,+ settlement_attempts: usize,+ settlement_baseline_credits_micros: Option<i64>,+ settlement_baseline_usd_micros: Option<i64>,+ settlement_request_id: Option<u64>,+ settlement_refresh_due_at: Option<Instant>,+ pub(super) replaying_turn_completion: bool,}impl ChatWidget {@@ -32,6 +63,85 @@ impl ChatWidget {};}+ pub(super) fn ensure_thread_usage_requested(&mut self) {+ let Some(thread_id) = self.thread_id else {+ return;+ };+ if self.thread_usage.thread_id != Some(thread_id) {+ self.clear_thread_usage_state();+ self.thread_usage.thread_id = Some(thread_id);+ }+ if self.thread_usage.requested {+ return;+ }+ self.request_thread_usage();+ }++ pub(super) fn refresh_thread_usage_after_turn(&mut self) {+ if self.thread_usage.replaying_turn_completion+ || !self.thread_usage_is_selected()+ || !self.thread_usage_is_available()+ {+ return;+ }++ self.thread_usage.settlement_attempts = 0;+ self.thread_usage.settlement_request_id = None;+ self.thread_usage.settlement_baseline_credits_micros = Some(+ self.thread_usage+ .estimate+ .as_ref()+ .map(|estimate| estimate.estimated_usage_credits_micros)+ .unwrap_or_default(),+ );+ self.thread_usage.settlement_baseline_usd_micros = self+ .thread_usage+ .estimate+ .as_ref()+ .and_then(|estimate| estimate.estimated_usage_usd_micros);+ self.schedule_next_thread_usage_settlement();+ self.request_thread_usage();+ }++ pub(super) fn refresh_thread_usage_if_settlement_due(&mut self) {+ let now = Instant::now();+ let settlement_due = self+ .thread_usage+ .settlement_refresh_due_at+ .is_some_and(|due_at| now >= due_at);+ let retry_due = self+ .thread_usage+ .retry_due_at+ .is_some_and(|due_at| now >= due_at);+ if !settlement_due && !retry_due {+ if let Some(next_due_at) = [+ self.thread_usage.settlement_refresh_due_at,+ self.thread_usage.retry_due_at,+ ]+ .into_iter()+ .flatten()+ .min()+ {+ self.frame_requester+ .schedule_frame_in(next_due_at.saturating_duration_since(now));+ }+ return;+ }++ if !self.thread_usage_is_selected() {+ self.cancel_thread_usage_polling();+ return;+ }++ if settlement_due {+ self.thread_usage.settlement_refresh_due_at = None;+ }+ if retry_due {+ self.thread_usage.retry_due_at = None;+ }+ self.request_thread_usage();+ }+pub(super) fn request_thread_usage_for_status(&mut self, handle: StatusHistoryHandle) {if !self.thread_usage_is_available() {return;@@ -46,9 +156,27 @@ impl ChatWidget {}self.thread_usage.status_history_handles.push(handle);+ self.thread_usage.status_requested = true;+ self.thread_usage.retry_attempts = 0;self.request_thread_usage();}+ pub(super) fn cancel_thread_usage_polling(&mut self) {+ if self.thread_usage.status_requested {+ return;+ }++ self.thread_usage.pending_request_id = None;+ self.thread_usage.requested = false;+ self.thread_usage.retry_attempts = 0;+ self.thread_usage.retry_due_at = None;+ self.thread_usage.settlement_attempts = 0;+ self.thread_usage.settlement_baseline_credits_micros = None;+ self.thread_usage.settlement_baseline_usd_micros = None;+ self.thread_usage.settlement_request_id = None;+ self.thread_usage.settlement_refresh_due_at = None;+ }+pub(crate) fn finish_thread_usage_refresh(&mut self,thread_id: ThreadId,@@ -64,11 +192,18 @@ impl ChatWidget {self.thread_usage.pending_request_id = None;let mut usage_updated = false;+ self.thread_usage.status_requested = false;+ let post_turn_request = self.thread_usage.settlement_request_id == Some(request_id);match result {Ok(ThreadUsageOutcome::Disabled) => {self.thread_usage.feature_disabled = true;self.thread_usage.estimate = None;usage_updated = true;+ self.thread_usage.retry_due_at = None;+ self.thread_usage.settlement_refresh_due_at = None;+ self.thread_usage.settlement_baseline_credits_micros = None;+ self.thread_usage.settlement_baseline_usd_micros = None;+ self.thread_usage.settlement_request_id = None;}Ok(ThreadUsageOutcome::Available(usage))if usage.thread_id != thread_id.to_string() =>@@ -78,20 +213,112 @@ impl ChatWidget {returned_thread_id = %usage.thread_id,"thread usage response referred to another thread");+ self.schedule_thread_usage_retry();}- Ok(ThreadUsageOutcome::Available(usage)) => {- self.thread_usage.estimate = Some(usage);+ Ok(ThreadUsageOutcome::Available(mut usage)) => {usage_updated = true;+ self.thread_usage.retry_attempts = 0;+ self.thread_usage.retry_due_at = None;+ let previous_positive_credits_micros = self+ .thread_usage+ .estimate+ .as_ref()+ .map(|estimate| estimate.estimated_usage_credits_micros)+ .filter(|micros| *micros > 0);+ let transient_zero_credits = usage.estimated_usage_credits_micros == 0+ && previous_positive_credits_micros.is_some();+ if let Some(previous_positive_credits_micros) = previous_positive_credits_micros+ && transient_zero_credits+ {+ usage.estimated_usage_credits_micros = previous_positive_credits_micros;+ }+ let previous_positive_usd_micros = self+ .thread_usage+ .estimate+ .as_ref()+ .and_then(|estimate| estimate.estimated_usage_usd_micros)+ .filter(|micros| *micros > 0);+ let transient_zero_cost = usage.estimated_usage_usd_micros == Some(0)+ && previous_positive_usd_micros.is_some();+ if let Some(previous_positive_usd_micros) = previous_positive_usd_micros+ && transient_zero_cost+ {+ usage.estimated_usage_usd_micros = Some(previous_positive_usd_micros);+ }+ if (transient_zero_credits || transient_zero_cost)+ && usage.groups.is_empty()+ && let Some(previous_usage) = self.thread_usage.estimate.as_ref()+ {+ usage.groups.clone_from(&previous_usage.groups);+ }+ let estimated_credits_micros = usage.estimated_usage_credits_micros;+ let estimated_usd_micros = usage.estimated_usage_usd_micros;+ self.thread_usage.estimate = Some(usage);+ if let Some(baseline) = self.thread_usage.settlement_baseline_credits_micros {+ if !post_turn_request {+ self.thread_usage.settlement_baseline_credits_micros =+ Some(baseline.max(estimated_credits_micros));+ self.thread_usage.settlement_baseline_usd_micros = match (+ self.thread_usage.settlement_baseline_usd_micros,+ estimated_usd_micros,+ ) {+ (Some(previous), Some(current)) => Some(previous.max(current)),+ (previous, current) => previous.or(current),+ };+ } else {+ let mut selected = self.selected_thread_usage();+ if !self.thread_usage.status_history_handles.is_empty() {+ selected.credits = true;+ selected.estimated_cost |=+ self.thread_usage.settlement_baseline_usd_micros.is_some()+ || estimated_usd_micros.is_some();+ }+ let credits_settled =+ !selected.credits || estimated_credits_micros > baseline;+ let cost_settled = !selected.estimated_cost+ || estimated_usd_micros.is_some_and(|current| {+ self.thread_usage+ .settlement_baseline_usd_micros+ .map_or(current > 0, |previous| current > previous)+ });+ if credits_settled && cost_settled {+ self.thread_usage.settlement_baseline_credits_micros = None;+ self.thread_usage.settlement_baseline_usd_micros = None;+ self.thread_usage.settlement_request_id = None;+ self.thread_usage.settlement_refresh_due_at = None;+ } else if self.thread_usage.settlement_refresh_due_at.is_none() {+ self.schedule_next_thread_usage_settlement();+ }+ }+ }}Err(err) => {tracing::debug!(error = %err, "failed to fetch estimated thread usage");+ self.schedule_thread_usage_retry();}}if usage_updated && !self.thread_usage.status_history_handles.is_empty() {- for handle in self.thread_usage.status_history_handles.drain(..) {+ for handle in &self.thread_usage.status_history_handles {handle.set_thread_usage(self.thread_usage.estimate.clone());}+ if self+ .thread_usage+ .settlement_baseline_credits_micros+ .is_none()+ {+ self.thread_usage.status_history_handles.clear();+ }}+ if self+ .thread_usage+ .settlement_baseline_credits_micros+ .is_some()+ && self.thread_usage.settlement_request_id.is_none()+ && self.thread_usage_is_selected()+ {+ self.request_thread_usage();+ }+ self.refresh_status_line();self.request_redraw();true}@@ -112,7 +339,15 @@ impl ChatWidget {self.thread_usage.next_request_id =self.thread_usage.next_request_id.wrapping_add(/*rhs*/ 1);self.thread_usage.pending_request_id = Some(request_id);+ self.thread_usage.requested = true;self.thread_usage.thread_id = Some(thread_id);+ if self+ .thread_usage+ .settlement_baseline_credits_micros+ .is_some()+ {+ self.thread_usage.settlement_request_id = Some(request_id);+ }self.app_event_tx.send(AppEvent::RefreshThreadUsage {thread_id,request_id,@@ -132,4 +367,63 @@ impl ChatWidget {))}++ fn thread_usage_is_selected(&self) -> bool {+ let selected = self.selected_thread_usage();+ selected.credits || selected.estimated_cost+ }++ fn selected_thread_usage(&self) -> SelectedThreadUsage {+ let mut selected = SelectedThreadUsage::default();+ for item in self.configured_status_line_items() {+ match item.parse::<StatusLineItem>() {+ Ok(StatusLineItem::ThreadCredits) => selected.credits = true,+ Ok(StatusLineItem::EstimatedThreadCost) => selected.estimated_cost = true,+ Ok(_) | Err(_) => {}+ }+ }+ for item in self.configured_terminal_title_items() {+ match item.parse::<TerminalTitleItem>() {+ Ok(TerminalTitleItem::ThreadCredits) => selected.credits = true,+ Ok(TerminalTitleItem::EstimatedThreadCost) => selected.estimated_cost = true,+ Ok(_) | Err(_) => {}+ }+ }+ selected+ }++ fn schedule_next_thread_usage_settlement(&mut self) {+ let Some(delay) = THREAD_USAGE_SETTLEMENT_DELAYS+ .get(self.thread_usage.settlement_attempts)+ .copied()+ else {+ self.thread_usage.settlement_baseline_credits_micros = None;+ self.thread_usage.settlement_baseline_usd_micros = None;+ self.thread_usage.settlement_request_id = None;+ return;+ };+ self.thread_usage.settlement_attempts += 1;+ self.thread_usage.settlement_refresh_due_at = Some(Instant::now() + delay);+ self.frame_requester.schedule_frame_in(delay);+ }++ fn schedule_thread_usage_retry(&mut self) {+ if !self.thread_usage_is_selected() {+ return;+ }++ let Some(delay) = THREAD_USAGE_RETRY_DELAYS+ .get(self.thread_usage.retry_attempts)+ .copied()+ else {+ return;+ };+ self.thread_usage.retry_attempts += 1;+ self.thread_usage.retry_due_at = Some(Instant::now() + delay);+ self.frame_requester.schedule_frame_in(delay);+ }}++#[cfg(test)]+#[path = "thread_usage_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/chatwidget/thread_usage_tests.rs b/codex-rs/tui/src/chatwidget/thread_usage_tests.rsnew file mode 100644index 0000000000..d166325ffb--- /dev/null+++ b/codex-rs/tui/src/chatwidget/thread_usage_tests.rs@@ -0,0 +1,997 @@+use super::THREAD_USAGE_RETRY_DELAYS;+use super::THREAD_USAGE_SETTLEMENT_DELAYS;+use super::ThreadUsageOutcome;+use crate::app_event::AppEvent;+use crate::chatwidget::ReplayKind;+use crate::chatwidget::tests::make_chatwidget_manual_with_sender;+use crate::status::format_estimated_usd_micros;+use crate::tui::FrameRequester;+use codex_app_server_protocol::CodexErrorInfo;+use codex_app_server_protocol::ErrorNotification;+use codex_app_server_protocol::ServerNotification;+use codex_app_server_protocol::ThreadUsage;+use codex_app_server_protocol::ThreadUsageBreakdownGroup;+use codex_app_server_protocol::Turn;+use codex_app_server_protocol::TurnError;+use codex_app_server_protocol::TurnItemsView;+use codex_app_server_protocol::TurnStatus;+use codex_protocol::ThreadId;+use codex_protocol::account::PlanType;+use pretty_assertions::assert_eq;+use std::time::Duration;+use std::time::Instant;+use tokio::sync::mpsc::UnboundedReceiver;++fn thread_usage_request_id(events: &mut UnboundedReceiver<AppEvent>) -> u64 {+ match events.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected a thread usage request, got {event:?}"),+ }+}++fn thread_usage(+ thread_id: ThreadId,+ estimated_usage_credits_micros: i64,+ estimated_usage_usd_micros: Option<i64>,+) -> ThreadUsage {+ ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros,+ estimated_usage_usd_micros,+ groups: Vec::new(),+ }+}++#[test]+fn estimated_cost_formats_dollars_and_sub_cent_values() {+ assert_eq!(+ format_estimated_usd_micros(/*micros*/ 0),+ Some("~$0.00".to_string())+ );+ assert_eq!(+ format_estimated_usd_micros(/*micros*/ 1),+ Some("~$0.000001".to_string())+ );+ assert_eq!(+ format_estimated_usd_micros(/*micros*/ 400),+ Some("~$0.0004".to_string())+ );+ assert_eq!(+ format_estimated_usd_micros(/*micros*/ 1_820_000),+ Some("~$1.82".to_string())+ );+ assert_eq!(+ format_estimated_usd_micros(/*micros*/ 995_000),+ Some("~$1.00".to_string())+ );+ assert_eq!(format_estimated_usd_micros(/*micros*/ -1), None);+}++#[tokio::test]+async fn temporary_thread_usage_failures_have_bounded_retries() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ for attempt in 0..=THREAD_USAGE_RETRY_DELAYS.len() {+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected retry attempt {attempt}, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Err("thread usage temporarily unavailable".to_string()),+ ));++ if attempt < THREAD_USAGE_RETRY_DELAYS.len() {+ assert!(chat.thread_usage.retry_due_at.is_some());+ chat.thread_usage.retry_due_at = Some(Instant::now());+ chat.refresh_thread_usage_if_settlement_due();+ }+ }++ assert!(chat.thread_usage.retry_due_at.is_none());+ assert!(rx.try_recv().is_err(), "retries must stop after the bound");+}++#[tokio::test]+async fn status_history_survives_exhausted_billing_retries() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();+ let mut request_id = thread_usage_request_id(&mut rx);++ chat.add_status_output(+ /*refreshing_rate_limits*/ false, /*request_id*/ None,+ );+ let first_status_cell = match rx.try_recv() {+ Ok(AppEvent::InsertHistoryCell(cell)) => cell,+ event => panic!("expected the first /status card, got {event:?}"),+ };++ for attempt in 0..=THREAD_USAGE_RETRY_DELAYS.len() {+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Err("thread usage temporarily unavailable".to_string()),+ ));+ assert_eq!(chat.thread_usage.status_history_handles.len(), 1);++ if attempt < THREAD_USAGE_RETRY_DELAYS.len() {+ chat.thread_usage.retry_due_at = Some(Instant::now());+ chat.refresh_thread_usage_if_settlement_due();+ request_id = thread_usage_request_id(&mut rx);+ }+ }++ assert_eq!(chat.thread_usage.retry_due_at, None);+ chat.add_status_output(+ /*refreshing_rate_limits*/ false, /*request_id*/ None,+ );+ let retry_status_cell = match rx.try_recv() {+ Ok(AppEvent::InsertHistoryCell(cell)) => cell,+ event => panic!("expected a fresh /status card, got {event:?}"),+ };+ request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 50_000_000,+ Some(2_100_000),+ ))),+ ));++ for status_cell in [&first_status_cell, &retry_status_cell] {+ let rendered = status_cell+ .display_lines(/*width*/ 90)+ .into_iter()+ .flat_map(|line| line.spans)+ .map(|span| span.content.into_owned())+ .collect::<String>();+ assert!(rendered.contains("50 credits · ~$2.10"));+ }+ assert!(chat.thread_usage.status_history_handles.is_empty());+}++#[tokio::test]+async fn status_history_updates_again_after_billing_settles() {+ for (selected_item, stale_credits_micros, stale_usd_micros) in [+ ("estimated-thread-cost", 40_000_000, 1_820_000),+ ("thread-credits", 50_000_000, 1_820_000),+ ("estimated-thread-cost", 40_000_000, 2_100_000),+ ] {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec![selected_item.to_string()]);+ chat.refresh_status_line();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 40_000_000,+ Some(1_820_000),+ ))),+ ));++ chat.refresh_thread_usage_after_turn();+ let request_id = thread_usage_request_id(&mut rx);+ chat.add_status_output(+ /*refreshing_rate_limits*/ false, /*request_id*/ None,+ );+ let status_cell = match rx.try_recv() {+ Ok(AppEvent::InsertHistoryCell(cell)) => cell,+ event => panic!("expected an immediate /status card, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ stale_credits_micros,+ Some(stale_usd_micros),+ ))),+ ));+ assert_eq!(chat.thread_usage.status_history_handles.len(), 1);++ chat.thread_usage.settlement_refresh_due_at = Some(Instant::now());+ chat.refresh_thread_usage_if_settlement_due();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 50_000_000,+ Some(2_100_000),+ ))),+ ));++ let rendered = status_cell+ .display_lines(/*width*/ 90)+ .into_iter()+ .flat_map(|line| line.spans)+ .map(|span| span.content.into_owned())+ .collect::<String>();+ assert!(rendered.contains("50 credits · ~$2.10"));+ assert!(chat.thread_usage.status_history_handles.is_empty());+ }+}++#[tokio::test]+async fn replayed_turn_completions_do_not_start_live_billing_refreshes() {+ for replay_kind in [+ ReplayKind::ResumeInitialMessages,+ ReplayKind::ThreadSnapshot,+ ] {+ for (status, error) in [+ (TurnStatus::Completed, None),+ (TurnStatus::Interrupted, None),+ (TurnStatus::Failed, None),+ (+ TurnStatus::Failed,+ Some(TurnError {+ message: "the replayed turn failed".to_string(),+ codex_error_info: Some(CodexErrorInfo::ServerOverloaded),+ additional_details: None,+ }),+ ),+ ] {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 46_000_000,+ Some(1_820_000),+ ))),+ ));++ chat.replay_thread_turns(+ vec![Turn {+ id: "replayed-turn".to_string(),+ items: Vec::new(),+ items_view: TurnItemsView::NotLoaded,+ status: status.clone(),+ error,+ started_at: None,+ completed_at: None,+ duration_ms: None,+ }],+ replay_kind,+ );++ assert!(+ !std::iter::from_fn(|| rx.try_recv().ok())+ .any(|event| matches!(event, AppEvent::RefreshThreadUsage { .. })),+ "{replay_kind:?} replay of {status:?} must not start live billing settlement"+ );+ assert_eq!(chat.thread_usage.settlement_baseline_credits_micros, None);+ assert_eq!(chat.thread_usage.settlement_baseline_usd_micros, None);+ assert_eq!(chat.thread_usage.settlement_refresh_due_at, None);+ assert!(!chat.thread_usage.replaying_turn_completion);+ }+ }+}++#[tokio::test]+async fn replayed_errors_do_not_start_live_billing_refreshes() {+ for replay_kind in [+ ReplayKind::ResumeInitialMessages,+ ReplayKind::ThreadSnapshot,+ ] {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 46_000_000,+ Some(1_820_000),+ ))),+ ));++ let notification = ServerNotification::Error(ErrorNotification {+ error: TurnError {+ message: "the replayed turn failed".to_string(),+ codex_error_info: Some(CodexErrorInfo::ServerOverloaded),+ additional_details: None,+ },+ will_retry: false,+ thread_id: thread_id.to_string(),+ turn_id: "replayed-turn".to_string(),+ });+ chat.handle_server_notification(notification.clone(), Some(replay_kind));+ assert!(+ !std::iter::from_fn(|| rx.try_recv().ok())+ .any(|event| matches!(event, AppEvent::RefreshThreadUsage { .. })),+ "{replay_kind:?} error replay must not start live billing settlement"+ );+ assert!(!chat.thread_usage.replaying_turn_completion);++ chat.handle_server_notification(notification, /*replay_kind*/ None);+ assert!(+ std::iter::from_fn(|| rx.try_recv().ok())+ .any(|event| matches!(event, AppEvent::RefreshThreadUsage { .. })),+ "a later live error must still refresh billing"+ );+ }+}++#[tokio::test]+async fn transient_zero_cost_preserves_fresh_credits_and_breakdowns() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);+ chat.config.tui_terminal_title = chat.config.tui_status_line.clone();+ chat.refresh_status_surfaces();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 46_000_000,+ Some(1_820_000),+ ))),+ ));++ chat.refresh_thread_usage_after_turn();+ let request_id = thread_usage_request_id(&mut rx);+ let fresh_usage = ThreadUsage {+ groups: vec![ThreadUsageBreakdownGroup {+ model: Some("gpt-5.4".to_string()),+ reasoning_effort: Some("high".to_string()),+ speed: Some("fast".to_string()),+ estimated_usage_credits_micros: 50_000_000,+ net_new_input_tokens: Some(80),+ cached_input_tokens: Some(20),+ input_tokens: Some(100),+ output_tokens: Some(40),+ total_tokens: Some(140),+ }],+ ..thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 50_000_000,+ Some(0),+ )+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(fresh_usage.clone())),+ ));++ assert_eq!(+ chat.estimated_thread_usage(),+ Some(&ThreadUsage {+ estimated_usage_usd_micros: Some(1_820_000),+ ..fresh_usage+ })+ );+ assert_eq!(+ chat.status_line_text(),+ Some("50 credits · ~$1.82".to_string())+ );+ assert_eq!(+ chat.last_terminal_title,+ Some("50 credits | ~$1.82".to_string())+ );+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());+}++#[tokio::test]+async fn transient_zero_credits_preserves_credits_only_estimates() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["thread-credits".to_string()]);+ chat.config.tui_terminal_title = chat.config.tui_status_line.clone();+ chat.refresh_status_surfaces();+ let request_id = thread_usage_request_id(&mut rx);+ let previous_usage = ThreadUsage {+ groups: vec![ThreadUsageBreakdownGroup {+ model: Some("gpt-5.4".to_string()),+ reasoning_effort: Some("high".to_string()),+ speed: Some("fast".to_string()),+ estimated_usage_credits_micros: 46_000_000,+ net_new_input_tokens: Some(80),+ cached_input_tokens: Some(20),+ input_tokens: Some(100),+ output_tokens: Some(40),+ total_tokens: Some(140),+ }],+ ..thread_usage(+ thread_id, /*estimated_usage_credits_micros*/ 46_000_000,+ /*estimated_usage_usd_micros*/ None,+ )+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(previous_usage.clone())),+ ));++ chat.refresh_thread_usage_after_turn();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id, /*estimated_usage_credits_micros*/ 0,+ /*estimated_usage_usd_micros*/ None,+ ))),+ ));++ assert_eq!(chat.estimated_thread_usage(), Some(&previous_usage));+ assert_eq!(chat.status_line_text(), Some("46 credits".to_string()));+ assert_eq!(chat.last_terminal_title, Some("46 credits".to_string()));+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());+}++#[tokio::test]+async fn cost_settlement_waits_for_new_or_missing_usd_estimates() {+ for (previous_usd_micros, stale_usd_micros) in [+ (Some(1_820_000), Some(1_820_000)),+ (None, None),+ (None, Some(0)),+ ] {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 40_000_000,+ previous_usd_micros,+ ))),+ ));++ chat.refresh_thread_usage_after_turn();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 50_000_000,+ stale_usd_micros,+ ))),+ ));+ assert_eq!(+ chat.thread_usage.settlement_baseline_credits_micros,+ Some(40_000_000)+ );+ assert_eq!(+ chat.thread_usage.settlement_baseline_usd_micros,+ previous_usd_micros+ );+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());++ chat.thread_usage.settlement_refresh_due_at = Some(Instant::now());+ chat.refresh_thread_usage_if_settlement_due();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 50_000_000,+ Some(2_100_000),+ ))),+ ));++ assert_eq!(chat.status_line_text(), Some("~$2.10".to_string()));+ assert_eq!(chat.thread_usage.settlement_baseline_credits_micros, None);+ assert_eq!(chat.thread_usage.settlement_baseline_usd_micros, None);+ assert_eq!(chat.thread_usage.settlement_refresh_due_at, None);+ }+}++#[tokio::test]+async fn credits_only_settlement_completes_without_usd_estimates() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_terminal_title = Some(vec!["thread-credits".to_string()]);+ chat.refresh_terminal_title();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id, /*estimated_usage_credits_micros*/ 40_000_000,+ /*estimated_usage_usd_micros*/ None,+ ))),+ ));++ chat.refresh_thread_usage_after_turn();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id, /*estimated_usage_credits_micros*/ 50_000_000,+ /*estimated_usage_usd_micros*/ None,+ ))),+ ));++ assert_eq!(chat.last_terminal_title, Some("50 credits".to_string()));+ assert_eq!(chat.thread_usage.settlement_baseline_credits_micros, None);+ assert_eq!(chat.thread_usage.settlement_baseline_usd_micros, None);+ assert_eq!(chat.thread_usage.settlement_refresh_due_at, None);+}++#[tokio::test]+async fn combined_billing_surfaces_wait_for_credits_and_cost() {+ for (status_line_item, title_item) in [+ ("thread-credits", "estimated-thread-cost"),+ ("estimated-thread-cost", "thread-credits"),+ ] {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec![status_line_item.to_string()]);+ chat.config.tui_terminal_title = Some(vec![title_item.to_string()]);+ chat.refresh_status_surfaces();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 40_000_000,+ Some(1_820_000),+ ))),+ ));++ chat.refresh_thread_usage_after_turn();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 50_000_000,+ Some(1_820_000),+ ))),+ ));+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());++ chat.thread_usage.settlement_refresh_due_at = Some(Instant::now());+ chat.refresh_thread_usage_if_settlement_due();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 50_000_000,+ Some(2_100_000),+ ))),+ ));++ assert_eq!(chat.thread_usage.settlement_baseline_credits_micros, None);+ assert_eq!(chat.thread_usage.settlement_baseline_usd_micros, None);+ assert_eq!(chat.thread_usage.settlement_refresh_due_at, None);+ }+}++#[tokio::test]+async fn billing_surfaces_render_for_every_supported_enterprise_plan() {+ for plan_type in [+ PlanType::Business,+ PlanType::EnterpriseCbpUsageBased,+ PlanType::EnterpriseCbpAutomation,+ ] {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(plan_type);+ chat.config.tui_status_line = Some(vec![+ "thread-credits".to_string(),+ "estimated-thread-cost".to_string(),+ ]);+ chat.config.tui_terminal_title = chat.config.tui_status_line.clone();+ chat.refresh_status_surfaces();+ let request_id = thread_usage_request_id(&mut rx);+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(thread_usage(+ thread_id,+ /*estimated_usage_credits_micros*/ 5_200_000,+ Some(210_000),+ ))),+ ));++ assert_eq!(+ chat.status_line_text(),+ Some("5.2 credits · ~$0.21".to_string())+ );+ assert_eq!(+ chat.last_terminal_title,+ Some("5.2 credits | ~$0.21".to_string())+ );+ assert!(rx.try_recv().is_err(), "billing surfaces share a request");+ }+}++#[tokio::test]+async fn early_draw_rearms_thread_usage_retry_after_immediate_redraw() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage request, got {event:?}"),+ };+ let (frame_requester, mut frame_rx) = FrameRequester::test_channel();+ chat.frame_requester = frame_requester;++ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Err("thread usage temporarily unavailable".to_string()),+ ));+ let retry_due_at = chat+ .thread_usage+ .retry_due_at+ .expect("temporary failures schedule a retry");+ let scheduled = std::iter::from_fn(|| frame_rx.try_recv().ok()).collect::<Vec<_>>();+ assert!(scheduled.iter().any(|deadline| *deadline >= retry_due_at));+ assert!(scheduled.iter().any(|deadline| *deadline < retry_due_at));++ chat.pre_draw_tick();++ let rearmed = std::iter::from_fn(|| frame_rx.try_recv().ok())+ .find(|deadline| *deadline >= retry_due_at)+ .expect("the immediate redraw must re-arm the pending billing retry");+ assert!(rearmed.duration_since(retry_due_at) < Duration::from_secs(/*secs*/ 1));+}++#[tokio::test]+async fn unchanged_thread_usage_has_bounded_settlement_refreshes() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage request, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));++ chat.refresh_thread_usage_after_turn();+ for attempt in 0..=THREAD_USAGE_SETTLEMENT_DELAYS.len() {+ let request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected settlement attempt {attempt}, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));++ if attempt < THREAD_USAGE_SETTLEMENT_DELAYS.len() {+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());+ chat.thread_usage.settlement_refresh_due_at = Some(Instant::now());+ chat.refresh_thread_usage_if_settlement_due();+ }+ }++ assert!(chat.thread_usage.settlement_refresh_due_at.is_none());+ assert!(+ chat.thread_usage+ .settlement_baseline_credits_micros+ .is_none()+ );+ assert!(rx.try_recv().is_err(), "settlement polling must stop");+}++#[tokio::test]+async fn early_draw_rearms_thread_usage_settlement_after_immediate_redraw() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage request, got {event:?}"),+ };+ let usage = ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(usage.clone())),+ ));++ let (frame_requester, mut frame_rx) = FrameRequester::test_channel();+ chat.frame_requester = frame_requester;+ chat.refresh_thread_usage_after_turn();+ let settlement_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected immediate post-turn thread usage request, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ settlement_request_id,+ Ok(ThreadUsageOutcome::Available(usage)),+ ));+ let settlement_due_at = chat+ .thread_usage+ .settlement_refresh_due_at+ .expect("unchanged post-turn billing schedules a settlement refresh");+ let scheduled = std::iter::from_fn(|| frame_rx.try_recv().ok()).collect::<Vec<_>>();+ assert!(+ scheduled+ .iter()+ .any(|deadline| *deadline >= settlement_due_at)+ );+ assert!(+ scheduled+ .iter()+ .any(|deadline| *deadline < settlement_due_at)+ );++ chat.pre_draw_tick();++ let rearmed = std::iter::from_fn(|| frame_rx.try_recv().ok())+ .find(|deadline| *deadline >= settlement_due_at)+ .expect("the immediate redraw must re-arm the pending billing settlement");+ assert!(rearmed.duration_since(settlement_due_at) < Duration::from_secs(/*secs*/ 1));+}++#[tokio::test]+async fn thread_usage_settlement_requires_request_started_after_turn_completion() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.refresh_status_line();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage request, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 40_000_000,+ estimated_usage_usd_micros: Some(1_600_000),+ groups: Vec::new(),+ })),+ ));++ chat.thread_usage.status_requested = true;+ chat.request_thread_usage();+ let pre_turn_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected pre-turn thread usage request, got {event:?}"),+ };+ chat.refresh_thread_usage_after_turn();+ assert_eq!(chat.thread_usage.settlement_request_id, None);+ assert_eq!(+ chat.thread_usage.settlement_baseline_credits_micros,+ Some(40_000_000)+ );++ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ pre_turn_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));+ let post_turn_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected a request started after turn completion, got {event:?}"),+ };+ assert_eq!(+ chat.thread_usage.settlement_baseline_credits_micros,+ Some(46_000_000)+ );+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());++ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ post_turn_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());++ chat.thread_usage.settlement_refresh_due_at = Some(Instant::now());+ chat.refresh_thread_usage_if_settlement_due();+ let settlement_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected another post-turn settlement request, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ settlement_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 50_000_000,+ estimated_usage_usd_micros: Some(2_100_000),+ groups: Vec::new(),+ })),+ ));+ assert_eq!(chat.thread_usage.settlement_baseline_credits_micros, None);+ assert_eq!(chat.thread_usage.settlement_refresh_due_at, None);+}++#[tokio::test]+async fn deselecting_billing_surfaces_cancels_polling_and_preserves_status_cache() {+ let (mut chat, _sender, mut rx, _op_rx) = make_chatwidget_manual_with_sender().await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.has_codex_backend_auth = true;+ chat.plan_type = Some(PlanType::Business);+ chat.config.tui_status_line = Some(vec!["estimated-thread-cost".to_string()]);+ chat.config.tui_terminal_title = Some(vec!["thread-credits".to_string()]);+ chat.refresh_status_surfaces();++ let initial_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected initial thread usage request, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ initial_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })),+ ));++ chat.thread_usage.status_requested = true;+ chat.request_thread_usage();+ assert!(chat.thread_usage.status_requested);+ let status_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected explicit /status refresh, got {event:?}"),+ };+ assert!(chat.finish_thread_usage_refresh(+ thread_id,+ status_request_id,+ Err("thread usage temporarily unavailable".to_string()),+ ));+ assert!(!chat.thread_usage.status_requested);+ assert!(chat.thread_usage.retry_due_at.is_some());++ chat.refresh_thread_usage_after_turn();+ let settlement_request_id = match rx.try_recv() {+ Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,+ event => panic!("expected post-turn thread usage refresh, got {event:?}"),+ };+ assert!(chat.thread_usage.settlement_refresh_due_at.is_some());++ chat.config.tui_status_line = Some(Vec::new());+ chat.config.tui_terminal_title = Some(Vec::new());+ chat.refresh_status_surfaces();++ assert!(!chat.thread_usage.status_requested);+ assert!(!chat.thread_usage.requested);+ assert_eq!(chat.thread_usage.pending_request_id, None);+ assert_eq!(chat.thread_usage.retry_due_at, None);+ assert_eq!(chat.thread_usage.settlement_refresh_due_at, None);+ assert_eq!(chat.thread_usage.settlement_baseline_credits_micros, None);+ assert_eq!(+ chat.estimated_thread_usage(),+ Some(&ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 46_000_000,+ estimated_usage_usd_micros: Some(1_820_000),+ groups: Vec::new(),+ })+ );+ assert!(!chat.finish_thread_usage_refresh(+ thread_id,+ settlement_request_id,+ Ok(ThreadUsageOutcome::Available(ThreadUsage {+ thread_id: thread_id.to_string(),+ estimated_usage_credits_micros: 50_000_000,+ estimated_usage_usd_micros: Some(2_100_000),+ groups: Vec::new(),+ })),+ ));+ chat.refresh_thread_usage_if_settlement_due();+ assert!(rx.try_recv().is_err(), "deselected billing must not poll");+}diff --git a/codex-rs/tui/src/chatwidget/turn_runtime.rs b/codex-rs/tui/src/chatwidget/turn_runtime.rsindex e8e7304526..88ff71a287 100644--- a/codex-rs/tui/src/chatwidget/turn_runtime.rs+++ b/codex-rs/tui/src/chatwidget/turn_runtime.rs@@ -173,6 +173,7 @@ impl ChatWidget {self.transcript.had_work_activity = false;self.request_status_line_branch_refresh();self.request_status_line_git_summary_refresh();+ self.refresh_thread_usage_after_turn();}// Mark task stopped and request redraw now that all content is in history.self.status_state.pending_status_indicator_restore = false;@@ -339,6 +340,7 @@ impl ChatWidget {self.safety_buffering_prompt = None;self.request_status_line_branch_refresh();self.request_status_line_git_summary_refresh();+ self.refresh_thread_usage_after_turn();self.maybe_show_pending_rate_limit_prompt();}diff --git a/codex-rs/tui/src/status/mod.rs b/codex-rs/tui/src/status/mod.rsindex cdf89ffcaf..8dfced4d75 100644--- a/codex-rs/tui/src/status/mod.rs+++ b/codex-rs/tui/src/status/mod.rs@@ -30,6 +30,8 @@ pub(crate) use rate_limits::RateLimitWindowDisplay;#[cfg(test)]pub(crate) use rate_limits::rate_limit_snapshot_display;pub(crate) use rate_limits::rate_limit_snapshot_display_for_limit;+pub(crate) use thread_usage::format_credit_micros;+pub(crate) use thread_usage::format_estimated_usd_micros;#[cfg(test)]mod tests;