Lightweight coding agent that runs in your terminal
Rust
Show completion timestamps after successful TUI turns (#43558)
Felipe Coury333c41eef6b9
diff --git a/codex-rs/tui/src/app/history_completion.rs b/codex-rs/tui/src/app/history_completion.rsnew file mode 100644index 0000000000..7a974c7725--- /dev/null+++ b/codex-rs/tui/src/app/history_completion.rs@@ -0,0 +1,35 @@+//! Group older history items at successful turn boundaries before projecting transcript cells.+//! A page splitting a turn only adds completion metadata when it contains that turn's last item.++use codex_app_server_protocol::ThreadItem;+use codex_app_server_protocol::Turn;+use codex_app_server_protocol::TurnStatus;+use std::collections::HashMap;++pub(super) fn group_completed_turn_items(+ items: Vec<ThreadItem>,+ turns: &[Turn],+) -> Vec<(Vec<ThreadItem>, Option<&Turn>)> {+ let completed_boundaries: HashMap<_, _> = turns+ .iter()+ .filter(|turn| turn.status == TurnStatus::Completed)+ .filter_map(|turn| turn.items.last().map(|item| (item.id(), turn)))+ .collect();+ let mut groups = Vec::new();+ let mut pending = Vec::new();+ for item in items {+ let completed_turn = completed_boundaries.get(item.id()).copied();+ pending.push(item);+ if completed_turn.is_some() {+ groups.push((std::mem::take(&mut pending), completed_turn));+ }+ }+ if !pending.is_empty() {+ groups.push((pending, None));+ }+ groups+}++#[cfg(test)]+#[path = "history_completion_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app/history_completion_tests.rs b/codex-rs/tui/src/app/history_completion_tests.rsnew file mode 100644index 0000000000..aac7bc01a7--- /dev/null+++ b/codex-rs/tui/src/app/history_completion_tests.rs@@ -0,0 +1,75 @@+//! Pagination boundaries preserve grouped item rendering and attach completion metadata once.++use super::*;+use codex_app_server_protocol::TurnItemsView;+use pretty_assertions::assert_eq;++fn turn(id: &str, status: TurnStatus, item_ids: &[&str]) -> Turn {+ Turn {+ id: id.to_string(),+ items: item_ids+ .iter()+ .map(|id| ThreadItem::UserMessage {+ id: id.to_string(),+ client_id: None,+ content: Vec::new(),+ })+ .collect(),+ items_view: TurnItemsView::Summary,+ status,+ error: None,+ started_at: None,+ completed_at: Some(1_700_000_000),+ duration_ms: Some(125_000),+ }+}++#[test]+fn split_turn_only_completes_on_the_page_with_its_last_item() {+ let turns = vec![turn(+ "turn",+ TurnStatus::Completed,+ &["first", "second", "last"],+ )];+ assert_eq!(+ group_completed_turn_items(turns[0].items[1..].to_vec(), &turns),+ vec![(turns[0].items[1..].to_vec(), Some(&turns[0]))],+ );+ assert_eq!(+ group_completed_turn_items(turns[0].items[..1].to_vec(), &turns),+ vec![(turns[0].items[..1].to_vec(), None)],+ );+}++#[test]+fn multiple_turns_keep_item_groups_and_completion_order() {+ let turns = vec![+ turn("first", TurnStatus::Completed, &["a", "b"]),+ turn("second", TurnStatus::Completed, &["c", "d"]),+ ];+ let items = turns.iter().flat_map(|turn| turn.items.clone()).collect();+ assert_eq!(+ group_completed_turn_items(items, &turns),+ vec![+ (turns[0].items.clone(), Some(&turns[0])),+ (turns[1].items.clone(), Some(&turns[1])),+ ],+ );+}++#[test]+fn unsuccessful_and_running_turns_do_not_create_completion_boundaries() {+ let turns = vec![+ turn("failed", TurnStatus::Failed, &["a"]),+ turn("interrupted", TurnStatus::Interrupted, &["b"]),+ turn("running", TurnStatus::InProgress, &["c"]),+ ];+ let items = turns+ .iter()+ .flat_map(|turn| turn.items.clone())+ .collect::<Vec<_>>();+ assert_eq!(+ group_completed_turn_items(items.clone(), &turns),+ vec![(items, None)],+ );+}diff --git a/codex-rs/tui/src/app/history_pagination.rs b/codex-rs/tui/src/app/history_pagination.rsindex 725f8d74e6..60e1296607 100644--- a/codex-rs/tui/src/app/history_pagination.rs+++ b/codex-rs/tui/src/app/history_pagination.rs@@ -13,6 +13,9 @@ use crate::thread_transcript::thread_items_to_transcript_cells;use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::ThreadItemsListResponse;+#[path = "history_completion.rs"]+mod completion;+impl App {/// Start one bounded page request shared by scrollback refill and the transcript overlay.pub(crate) fn request_older_history_page(@@ -183,6 +186,23 @@ impl App {}}items.retain(|item| !hidden_item_ids.contains(item.id()));+ let mut cells = Vec::new();+ for (items, completed_turn) in completion::group_completed_turn_items(items, &turns) {+ cells.extend(thread_items_to_transcript_cells(+ Some(thread_id),+ &cwd,+ items,+ visibility,+ Some(&self.config),+ ));+ if let Some(turn) = completed_turn+ && let Some(completion) = self+ .chat_widget+ .completion_cell(turn, Some(ReplayKind::ResumeInitialMessages))+ {+ cells.push(Arc::new(completion));+ }+ }{let mut store = store.lock().await;turns.retain_mut(|turn| {@@ -199,13 +219,6 @@ impl App {});store.turns.splice(0..0, turns);}- let cells = thread_items_to_transcript_cells(- Some(thread_id),- &cwd,- items,- visibility,- Some(&self.config),- );if self.backtrack.overlay_preview_active {self.backtrack.nth_user_message = self.backtrack.nth_user_message.saturating_add(cellsdiff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex 64c8bda18d..bd98ce8a6c 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -34,6 +34,8 @@ mod misalignment_policy;mod model_catalog;#[path = "tests/model_defaults_tests.rs"]mod model_defaults;+#[path = "tests/pagination_completion_tests.rs"]+mod pagination_completion_tests;#[path = "tests/patch_approval_tests.rs"]mod patch_approval_tests;#[path = "tests/permission_shortcuts_tests.rs"]diff --git a/codex-rs/tui/src/app/tests/pagination_completion_tests.rs b/codex-rs/tui/src/app/tests/pagination_completion_tests.rsnew file mode 100644index 0000000000..b0418b8324--- /dev/null+++ b/codex-rs/tui/src/app/tests/pagination_completion_tests.rs@@ -0,0 +1,169 @@+//! Completed older pages keep each footer after its answer, including overlapping pages.++use super::session_lifecycle_requests::start_recording_app_server;+use super::*;+use app_test_support::create_fake_paginated_rollout;+use app_test_support::rollout_path;+use chrono::TimeZone;+use codex_app_server_protocol::ThreadItemsListResponse;+use codex_protocol::items::AgentMessageContent;+use codex_protocol::items::AgentMessageItem;+use codex_protocol::items::TurnItem;+use codex_protocol::items::UserMessageItem;+use codex_protocol::protocol::ItemCompletedEvent;+use codex_protocol::protocol::TurnCompleteEvent;+use codex_protocol::user_input::UserInput as CoreUserInput;+use codex_state::SqliteConfig;++#[tokio::test]+async fn older_pagination_completion_footers_follow_answers_without_overlap_duplicates()+-> Result<()> {+ let mut app = make_test_app().await;+ let codex_home = tempdir()?;+ app.config.codex_home = codex_home.path().to_path_buf().abs();+ app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());+ app.local_settings.tui.terminal_resize_reflow_max_rows = Some(2);+ let completed_at = chrono::Local+ .with_ymd_and_hms(+ /*year*/ 2000, /*month*/ 9, /*day*/ 6, /*hour*/ 14,+ /*min*/ 32, /*sec*/ 0,+ )+ .single()+ .expect("unambiguous local completion time");+ let timestamp = completed_at.to_rfc3339();+ let filename_timestamp = "2000-09-06T14-32-00";+ let thread_id = create_fake_paginated_rollout(+ codex_home.path(),+ filename_timestamp,+ ×tamp,+ "completed pagination",+ Some(app.config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .map_err(|error| color_eyre::eyre::eyre!(error))?;+ let path = rollout_path(codex_home.path(), filename_timestamp, &thread_id);+ let thread_id = ThreadId::from_string(&thread_id)?;+ let mut records = std::fs::read_to_string(&path)?+ .lines()+ .take(/*n*/ 1)+ .map(serde_json::from_str::<serde_json::Value>)+ .collect::<Result<Vec<_>, _>>()?;+ for (index, name) in ["Oldest", "Middle", "Newest"].into_iter().enumerate() {+ let turn_id = format!("turn-{index}");+ let finished = completed_at.timestamp() + index as i64 * 60;+ let mut events = vec![EventMsg::TurnStarted(TurnStartedEvent {+ turn_id: turn_id.clone(),+ trace_id: None,+ started_at: Some(finished - 125),+ model_context_window: None,+ collaboration_mode_kind: Default::default(),+ })];+ let items = [+ TurnItem::UserMessage(UserMessageItem {+ id: format!("prompt-{index}"),+ client_id: None,+ content: vec![CoreUserInput::Text {+ text: format!("{name} prompt"),+ text_elements: Vec::new(),+ }],+ }),+ TurnItem::AgentMessage(AgentMessageItem {+ id: format!("answer-{index}"),+ content: vec![AgentMessageContent::Text {+ text: format!("{name} answer"),+ }],+ phase: None,+ memory_citation: None,+ delivery: None,+ questions: None,+ }),+ ];+ events.extend(items.into_iter().map(|item| {+ EventMsg::ItemCompleted(ItemCompletedEvent {+ thread_id,+ turn_id: turn_id.clone(),+ item,+ started_at_ms: None,+ completed_at_ms: finished * 1_000,+ })+ }));+ events.push(EventMsg::TurnComplete(TurnCompleteEvent {+ turn_id,+ last_agent_message: Some(format!("{name} answer")),+ error: None,+ started_at: Some(finished - 125),+ completed_at: Some(finished),+ duration_ms: Some(125_000),+ time_to_first_token_ms: None,+ }));+ for event in events {+ records.push(serde_json::json!({+ "timestamp": timestamp,+ "ordinal": records.len(),+ "type": "event_msg",+ "payload": event,+ }));+ }+ }+ let records = records+ .iter()+ .map(ToString::to_string)+ .collect::<Vec<_>>()+ .join("\n");+ std::fs::write(path, format!("{records}\n"))?;+ let (mut app_server, _requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ let started = app_server+ .resume_thread(+ &app.local_settings,+ app.config.clone(),+ thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ app.enqueue_primary_thread_session(started.session, started.turns)+ .await?;+ // Snapshot only the prepended pages; the newest turn is already hydrated in the store.+ app.local_settings.tui.terminal_resize_reflow_max_rows = None;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.open_transcript_overlay(&mut tui);+ let mut overlapping_answer = None;+ let mut snapshots = Vec::new();+ for limit in [1, 100] {+ let cursor = app_server+ .begin_older_history_page(thread_id)+ .expect("older page");+ let mut page: ThreadItemsListResponse = app_server+ .thread_items_page(+ thread_id,+ /*turn_id*/ None,+ Some(cursor.clone()),+ limit,+ )+ .await?;+ if let Some(answer) = overlapping_answer.take() {+ // The later response repeats the preceding page's completed answer.+ page.data.insert(/*index*/ 0, answer);+ } else {+ overlapping_answer = page.data.first().cloned();+ }+ app.handle_older_history_page(&mut tui, &mut app_server, thread_id, &cursor, Ok(page))+ .await?;+ snapshots.push(+ app.render_transcript_lines_for_reflow(/*width*/ 80)+ .lines+ .iter()+ .map(rendered_line_text)+ .collect::<Vec<_>>()+ .join("\n"),+ );+ }+ insta::assert_snapshot!(snapshots.join("\n\n--- next overlapping page ---\n\n"));+ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}diff --git a/codex-rs/tui/src/app/tests/safety_buffering.rs b/codex-rs/tui/src/app/tests/safety_buffering.rsindex f32476b924..d22d12f87a 100644--- a/codex-rs/tui/src/app/tests/safety_buffering.rs+++ b/codex-rs/tui/src/app/tests/safety_buffering.rs@@ -2,6 +2,7 @@ use super::*;use crate::app::safety_buffering::SafetyBufferedRetry;use crate::app::session_lifecycle::ThreadAttachPresentation;use crate::chatwidget::UserMessage;+use crate::chatwidget::tests::helpers::normalize_completion_timestamps;use codex_app_server_client::AppServerEvent;use codex_app_server_protocol::ModelSafetyBufferingUpdatedNotification;use codex_model_provider_info::ModelProviderInfo;@@ -894,9 +895,15 @@ goals = truelet mut replayed_history = String::new();while let Ok(event) = app_event_rx.try_recv() {if let AppEvent::InsertHistoryCell(cell) = event {- replayed_history.push_str(&lines_to_single_string(- &cell.transcript_lines(/*width*/ 80),- ));+ let rendered = lines_to_single_string(&cell.transcript_lines(/*width*/ 80));+ if cell+ .as_any()+ .is::<crate::history_cell::FinalMessageSeparator>()+ {+ replayed_history.push_str(&normalize_completion_timestamps(rendered));+ } else {+ replayed_history.push_str(&rendered);+ }}}assert_eq!(diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__pagination_completion_tests__older_pagination_completion_footers_follow_answers_without_overlap_duplicates.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__pagination_completion_tests__older_pagination_completion_footers_follow_answers_without_overlap_duplicates.snapnew file mode 100644index 0000000000..7263cb06b5--- /dev/null+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__pagination_completion_tests__older_pagination_completion_footers_follow_answers_without_overlap_duplicates.snap@@ -0,0 +1,26 @@+---+source: tui/src/app/tests/pagination_completion_tests.rs+expression: "snapshots.join(\"\\n\\n--- next overlapping page ---\\n\\n\")"+---+Earlier messages are available — press ctrl + t to view the full transcript+• Middle answer++ Worked for 2m 5s · done Sep 6, 2000 at 2:33 PM++--- next overlapping page ---+++› Oldest prompt+++• Oldest answer++ Worked for 2m 5s · done Sep 6, 2000 at 2:32 PM+++› Middle prompt+++• Middle answer++ Worked for 2m 5s · done Sep 6, 2000 at 2:33 PMdiff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__safety_buffering__safety_retry_committed_steer_history.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__safety_buffering__safety_retry_committed_steer_history.snapindex 3480bc55d1..0adc4a3857 100644--- a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__safety_buffering__safety_retry_committed_steer_history.snap+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__safety_buffering__safety_retry_committed_steer_history.snap@@ -4,4 +4,4 @@ expression: rendered_retry---› Handle the safety-buffered requestKeep the accepted steer-⚠ Full-history hydration is deprecated for paginated threads; omit `includeTurns` or set it to `false`, then page with `thread/turns/list` and `thread/items/list`.• done+⚠ Full-history hydration is deprecated for paginated threads; omit `includeTurns` or set it to `false`, then page with `thread/turns/list` and `thread/items/list`.• done done [completion time]diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 16d4a6e593..e7a96037d7 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -405,6 +405,7 @@ use self::rate_limits::is_app_server_cyber_policy_error;mod recap;mod reset_credits;pub(crate) use self::rate_limits::limit_label_for_window;+mod completion;mod reasoning_shortcuts;mod rendering;mod replay;@@ -1196,7 +1197,6 @@ impl ChatWidget {fn flush_active_cell(&mut self) {if let Some(active) = self.transcript.take_active_cell() {- self.transcript.needs_final_message_separator = true;self.app_event_tx.send(AppEvent::InsertHistoryCell(active));self.request_pending_usage_output_insertion();}@@ -1242,7 +1242,6 @@ impl ChatWidget {if !self.has_active_stream_tail() {self.flush_active_cell();}- self.transcript.needs_final_message_separator = true;} else if !keep_placeholder_header_active&& self.transcript@@ -1351,9 +1350,6 @@ impl ChatWidget {display.remote_image_urls,));}-- // User messages reset separator state so the next agent response doesn't add a stray break.- self.transcript.needs_final_message_separator = false;}/// Exit the UI immediately without waiting for shutdown.diff --git a/codex-rs/tui/src/chatwidget/command_lifecycle.rs b/codex-rs/tui/src/chatwidget/command_lifecycle.rsindex 5959669a99..5b3ffda9fe 100644--- a/codex-rs/tui/src/chatwidget/command_lifecycle.rs+++ b/codex-rs/tui/src/chatwidget/command_lifecycle.rs@@ -10,7 +10,6 @@ impl ChatWidget {let Some(wait) = self.unified_exec_wait_streak.take() else {return;};- self.transcript.needs_final_message_separator = true;let cell = history_cell::new_unified_exec_interaction(wait.command_display, String::new());self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(cell)));@@ -422,7 +421,6 @@ impl ChatWidget {);let completed = orphan.complete_call(&id, output, duration);debug_assert!(completed, "new orphan exec cell should contain {id}");- self.transcript.needs_final_message_separator = true;self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(orphan)));self.request_redraw();@@ -448,8 +446,6 @@ impl ChatWidget {}}}- // Mark that actual work was done (command executed)- self.transcript.had_work_activity = true;if is_user_shell {self.maybe_send_next_queued_input();}diff --git a/codex-rs/tui/src/chatwidget/completion.rs b/codex-rs/tui/src/chatwidget/completion.rsnew file mode 100644index 0000000000..d538a18628--- /dev/null+++ b/codex-rs/tui/src/chatwidget/completion.rs@@ -0,0 +1,53 @@+//! Completion metadata for live and restored turns. Saved timestamps are authoritative;+//! only a live completion may fall back to the local clock. Labels are deduplicated per thread.++use super::*;++impl ChatWidget {+ pub(crate) fn completion_cell(+ &mut self,+ turn: &Turn,+ replay_kind: Option<ReplayKind>,+ ) -> Option<history_cell::FinalMessageSeparator> {+ if self+ .turn_lifecycle+ .rendered_completion_turn_ids+ .contains(&turn.id)+ {+ return None;+ }+ let elapsed_seconds = turn+ .duration_ms+ .and_then(|duration| u64::try_from(duration).ok())+ .map(|duration| duration / 1_000)+ .or_else(|| {+ if replay_kind.is_none() {+ self.bottom_pane+ .status_elapsed()+ .map(|elapsed| elapsed.as_secs())+ } else {+ None+ }+ })+ .filter(|seconds| *seconds > 60);+ let completed_at = turn+ .completed_at+ .and_then(|timestamp| chrono::DateTime::from_timestamp(timestamp, /*nsecs*/ 0))+ .map(|timestamp| timestamp.with_timezone(&Local))+ .or_else(|| replay_kind.is_none().then(Local::now));+ if completed_at.is_none() && elapsed_seconds.is_none() {+ return None;+ }+ self.turn_lifecycle+ .rendered_completion_turn_ids+ .insert(turn.id.clone());+ let cell = history_cell::FinalMessageSeparator::new(+ elapsed_seconds,+ /*runtime_metrics*/ None,+ );+ Some(match completed_at {+ Some(completed_at) => cell.with_completed_at(completed_at),+ None => cell,+ })+ }+}diff --git a/codex-rs/tui/src/chatwidget/hook_lifecycle.rs b/codex-rs/tui/src/chatwidget/hook_lifecycle.rsindex e85cb7aa5a..de46ff34b8 100644--- a/codex-rs/tui/src/chatwidget/hook_lifecycle.rs+++ b/codex-rs/tui/src/chatwidget/hook_lifecycle.rs@@ -81,7 +81,6 @@ impl ChatWidget {}self.flush_completed_command_activity();self.bump_active_cell_revision();- self.transcript.needs_final_message_separator = true;self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(completed_cell)));self.request_pending_usage_output_insertion();@@ -101,7 +100,6 @@ impl ChatWidget {&& let Some(cell) = self.active_hook_cell.take(){self.bump_active_cell_revision();- self.transcript.needs_final_message_separator = true;self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(cell)));self.request_pending_usage_output_insertion();diff --git a/codex-rs/tui/src/chatwidget/input_submission.rs b/codex-rs/tui/src/chatwidget/input_submission.rsindex 6e408aab3c..2abcb5655d 100644--- a/codex-rs/tui/src/chatwidget/input_submission.rs+++ b/codex-rs/tui/src/chatwidget/input_submission.rs@@ -463,7 +463,6 @@ impl ChatWidget {}}- self.transcript.needs_final_message_separator = false;(true, Some(op))}diff --git a/codex-rs/tui/src/chatwidget/protocol.rs b/codex-rs/tui/src/chatwidget/protocol.rsindex 6f7efeef2c..c2fc8039ef 100644--- a/codex-rs/tui/src/chatwidget/protocol.rs+++ b/codex-rs/tui/src/chatwidget/protocol.rs@@ -330,9 +330,10 @@ impl ChatWidget {);}self.last_non_retry_error = None;+ let completion = self.completion_cell(¬ification.turn, replay_kind);self.on_task_complete(last_agent_message.map(|(_, _, text)| text),- notification.turn.duration_ms,+ completion,replay_kind.is_some(),);}diff --git a/codex-rs/tui/src/chatwidget/replay.rs b/codex-rs/tui/src/chatwidget/replay.rsindex 52b31fcbd6..18ad2d01f3 100644--- a/codex-rs/tui/src/chatwidget/replay.rs+++ b/codex-rs/tui/src/chatwidget/replay.rs@@ -6,22 +6,10 @@use super::*;impl ChatWidget {- /// Flush prior activity and preserve its separator before live or replayed assistant text.+ /// Flush prior activity before live or replayed assistant text.pub(super) fn prepare_assistant_message(&mut self) {- // Before starting an agent stream, flush any active exec cell group.self.flush_unified_exec_wait_streak();self.flush_active_cell();- // If the previous turn inserted non-stream history (exec output, patch status, MCP- // calls), render a separator before starting the next streamed assistant message.- if self.transcript.needs_final_message_separator && self.transcript.had_work_activity {- self.add_to_history(history_cell::FinalMessageSeparator::new(- /*elapsed_seconds*/ None, /*runtime_metrics*/ None,- ));- self.transcript.needs_final_message_separator = false;- } else if self.transcript.needs_final_message_separator {- // Reset the flag even if we don't show separator (no work was done)- self.transcript.needs_final_message_separator = false;- }}/// Replay a subset of initial events into the UI to seed the transcript when@@ -40,6 +28,14 @@ impl ChatWidget {})).collect::<Vec<_>>();for (turn, hidden_nested_review_turn) in turns.into_iter().zip(hidden_nested_review_turns) {+ // Defer completed metadata-only turns until their page loads. Active+ // turns must restore their lifecycle even before any items are available.+ if turn.status == TurnStatus::Completed+ && turn.items_view == codex_app_server_protocol::TurnItemsView::NotLoaded+ && turn.items.is_empty()+ {+ continue;+ }let Turn {id: turn_id,items_view: _,@@ -76,6 +72,11 @@ impl ChatWidget {{error = None;}+ if hidden_nested_review_turn {+ self.turn_lifecycle+ .rendered_completion_turn_ids+ .insert(turn_id.clone());+ }if matches!(status,TurnStatus::Completed | TurnStatus::Interrupted | TurnStatus::Faileddiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chatwidget_markdown_code_blocks_vt100_snapshot.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chatwidget_markdown_code_blocks_vt100_snapshot.snapindex 8017384f55..b7bc04285f 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chatwidget_markdown_code_blocks_vt100_snapshot.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chatwidget_markdown_code_blocks_vt100_snapshot.snap@@ -1,6 +1,6 @@----source: tui/src/chatwidget/tests.rs-expression: term.backend().vt100().screen().contents()+source: tui/src/chatwidget/tests/status_and_layout.rs+expression: "normalize_completion_timestamps(&\n(normalize_snapshot_paths(term.backend().vt100().screen().contents())))"---@@ -34,7 +34,6 @@ expression: term.backend().vt100().screen().contents()-• -- Indented code block (4 spaces)@@ -51,3 +50,4 @@ expression: term.backend().vt100().screen().contents()"path": "C:\\Program Files\\App","regex": "^foo.*(bar)?$"}+ done [completion time]diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_after_plain_answer.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_after_plain_answer.snapnew file mode 100644index 0000000000..0df5a3f92f--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_after_plain_answer.snap@@ -0,0 +1,7 @@+---+source: tui/src/chatwidget/tests/completion_styling_tests.rs+expression: normalize_completion_timestamps(& (text))+---+• The change is ready.++ Worked for [duration] · done [completion time]diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_after_streamed_tool_answer.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_after_streamed_tool_answer.snapnew file mode 100644index 0000000000..197fe805ec--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_after_streamed_tool_answer.snap@@ -0,0 +1,10 @@+---+source: tui/src/chatwidget/tests/completion_styling_tests.rs+expression: normalize_completion_timestamps(& (text))+---+• Ran echo ready+ └ ready++• The change is ready.++ Worked for [duration] · done [completion time]diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_like_transcript_text.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_like_transcript_text.snapnew file mode 100644index 0000000000..edbc853489--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__completion_like_transcript_text.snap@@ -0,0 +1,13 @@+---+source: tui/src/chatwidget/tests/completion_styling_tests.rs+expression: "&transcript"+---+› done Sep 6, 2000 at 2:32 PM+• done Sep 6, 2000 at 2:32 PM+ └ done Sep 6, 2000 at 2:32 PM+ The job was done Sep 6, 2000 at 2:32 PM+ done Sep 6, 2000 at 2:32 PM is the expected text+ Worked for 2m 5s · done Sep 6, 2000 at 2:32 PM is quoted++ done 3:24 PM+ Worked for 1h 2m 3s · done Sep 6, 2000 at 2:32 PMdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__final_worked_for_uses_cumulative_turn_duration.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__final_worked_for_uses_cumulative_turn_duration.snapindex b0d5db920b..4d4c170c71 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__final_worked_for_uses_cumulative_turn_duration.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__final_worked_for_uses_cumulative_turn_duration.snap@@ -1,12 +1,10 @@---source: tui/src/chatwidget/tests/exec_flow.rs-expression: combined+expression: normalize_completion_timestamps(& (combined))---• Ran echo preparing└ preparing-────────────────────────────────────────────────────────────────────────────────-• Final response.-─ Worked for 2m 05s ────────────────────────────────────────────────────────────+ Worked for [duration] · done [completion time]diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__replayed_in_progress_turn.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__replayed_in_progress_turn.snapnew file mode 100644index 0000000000..4ce4e7eff3--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__replayed_in_progress_turn.snap@@ -0,0 +1,10 @@+---+source: tui/src/chatwidget/tests/history_replay.rs+expression: "normalize_completion_timestamps(& (render_bottom_popup(&chat, 80)))"+---+• Working (0s • esc to interrupt)+++› Ask Codex to do anything++ gpt-5.6-sol default · /tmp/projectdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__slash_export_completion_message.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__slash_export_completion_message.snapindex 48d4adb50e..1cb3a9b91f 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__slash_export_completion_message.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__slash_export_completion_message.snap@@ -1,7 +1,8 @@---source: tui/src/chatwidget/tests/slash_commands.rs-expression: "cells.iter().map(|cell|\nlines_to_single_string(cell).trim().to_string()).collect::<Vec<_>>().join(\"\\n\")"+expression: "normalize_completion_timestamps(&\n(cells.iter().map(|cell|\nlines_to_single_string(cell).trim().to_string()).collect::<Vec<_>>().join(\"\\n\")))"---+done [completion time]• Saved conversation to conversation.md• Copied conversation to clipboard■ Copy failed: clipboard unavailablediff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_non_empty_then_empty_after.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_non_empty_then_empty_after.snapindex 952205e732..5fc634ac57 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_non_empty_then_empty_after.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_non_empty_then_empty_after.snap@@ -1,8 +1,10 @@----source: tui/src/chatwidget/tests.rs-expression: combined+source: tui/src/chatwidget/tests/exec_flow.rs+expression: normalize_completion_timestamps(& (combined))---↳ Interacted with background terminal · just fix└ pwd• Waited for background terminal · just fix++ done [completion time]diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_after_final_agent_message.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_after_final_agent_message.snapindex fdbdffc5dd..82e8ca4712 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_after_final_agent_message.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_after_final_agent_message.snap@@ -1,7 +1,9 @@----source: tui/src/chatwidget/tests.rs-expression: combined+source: tui/src/chatwidget/tests/exec_flow.rs+expression: normalize_completion_timestamps(& (combined))---• Waited for background terminal · cargo test -p codex-core• Final response.++ done [completion time]diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_before_streamed_agent_message.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_before_streamed_agent_message.snapindex f91637e2db..d1aebded50 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_before_streamed_agent_message.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_wait_before_streamed_agent_message.snap@@ -1,7 +1,9 @@----source: tui/src/chatwidget/tests.rs-expression: combined+source: tui/src/chatwidget/tests/exec_flow.rs+expression: normalize_completion_timestamps(& (combined))---• Waited for background terminal · cargo test -p codex-core• Streaming response.++ done [completion time]diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_waiting_multiple_empty_after.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_waiting_multiple_empty_after.snapindex 99bf8e2bdc..c6c442d506 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_waiting_multiple_empty_after.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__unified_exec_waiting_multiple_empty_after.snap@@ -1,5 +1,7 @@----source: tui/src/chatwidget/tests.rs-expression: combined+source: tui/src/chatwidget/tests/exec_flow.rs+expression: normalize_completion_timestamps(& (combined))---• Waited for background terminal · just fix++ done [completion time]diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rsindex 6fe9ad42d0..3b4270379a 100644--- a/codex-rs/tui/src/chatwidget/tests.rs+++ b/codex-rs/tui/src/chatwidget/tests.rs@@ -207,7 +207,7 @@ macro_rules! assert_chatwidget_snapshot {settings.bind(|| {insta::assert_snapshot!(format!("codex_tui__chatwidget__tests__{}", $name),- &($value),+ $value,@$snapshot);});@@ -240,6 +240,8 @@ mod bedrock_catalog_tests;mod collaboration_catalog_tests;#[path = "tests/compaction_tests.rs"]mod compaction_tests;+#[path = "tests/completion_styling_tests.rs"]+mod completion_styling;mod composer_submission;#[path = "tests/config_errors_tests.rs"]mod config_errors;diff --git a/codex-rs/tui/src/chatwidget/tests/app_server.rs b/codex-rs/tui/src/chatwidget/tests/app_server.rsindex 8222ef5bfc..566d84b546 100644--- a/codex-rs/tui/src/chatwidget/tests/app_server.rs+++ b/codex-rs/tui/src/chatwidget/tests/app_server.rs@@ -824,7 +824,11 @@ async fn live_app_server_turn_completed_clears_working_status_after_answer_item(/*replay_kind*/ None,);- assert!(drain_insert_history(&mut rx).is_empty());+ let completion_cells = drain_insert_history(&mut rx)+ .iter()+ .map(|lines| normalize_completion_timestamps(lines_to_single_string(lines).trim()))+ .collect::<Vec<_>>();+ assert_eq!(completion_cells, vec!["done [completion time]"]);assert!(!chat.bottom_pane.is_task_running());assert!(chat.bottom_pane.status_widget().is_none());assert_eq!(diff --git a/codex-rs/tui/src/chatwidget/tests/completion_styling_tests.rs b/codex-rs/tui/src/chatwidget/tests/completion_styling_tests.rsnew file mode 100644index 0000000000..afbe3f645a--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/completion_styling_tests.rs@@ -0,0 +1,241 @@+//! Exercises completion metadata through live notifications and restored turn history.++use super::*;+use chrono::Local;+use chrono::TimeZone;+use pretty_assertions::assert_eq;++const COMPLETED_AT: i64 = 1_700_000_000;++fn completed_turn(duration_ms: Option<i64>, completed_at: Option<i64>) -> AppServerTurn {+ AppServerTurn {+ completed_at,+ items: vec![AppServerThreadItem::AgentMessage {+ id: "answer-1".to_string(),+ text: "The change is ready.".to_string(),+ phase: Some(MessagePhase::FinalAnswer),+ memory_citation: None,+ delivery: None,+ questions: None,+ }],+ ..app_server_turn(+ "turn-1",+ AppServerTurnStatus::Completed,+ duration_ms,+ /*error*/ None,+ )+ }+}++fn complete_turn(chat: &mut ChatWidget, turn: AppServerTurn) {+ chat.handle_server_notification(+ ServerNotification::TurnCompleted(TurnCompletedNotification {+ thread_id: chat.thread_id.map(|id| id.to_string()).unwrap_or_default(),+ turn,+ }),+ /*replay_kind*/ None,+ );+}++fn completion_labels(rx: &mut tokio::sync::mpsc::UnboundedReceiver<AppEvent>) -> String {+ std::iter::from_fn(|| rx.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::InsertHistoryCell(cell)+ if cell.as_any().is::<history_cell::FinalMessageSeparator>() =>+ {+ let label = lines_to_single_string(&cell.raw_lines()).trim().to_string();+ (!label.is_empty()).then_some(label)+ }+ _ => None,+ })+ .collect::<Vec<_>>()+ .join("\n")+}++fn saved_completion_label() -> String {+ Local+ .timestamp_opt(COMPLETED_AT, /*nsecs*/ 0)+ .unwrap()+ .format("done %b %-d, %Y at %-I:%M %p")+ .to_string()+}++#[tokio::test]+async fn completion_follows_plain_and_streamed_tool_answers() {+ for streamed in [false, true] {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ handle_turn_started(&mut chat, "turn-1");+ if streamed {+ let command = begin_exec(&mut chat, "command-1", "echo ready");+ end_exec(&mut chat, command, "ready", "", /*exit_code*/ 0);+ handle_agent_message_delta(&mut chat, "The change is ready.\n");+ chat.run_commit_tick();+ }+ complete_turn(&mut chat, completed_turn(Some(125_000), Some(COMPLETED_AT)));++ let text = drain_insert_history(&mut rx)+ .iter()+ .map(|lines| lines_to_single_string(lines))+ .collect::<String>();+ assert_chatwidget_snapshot!(+ if streamed {+ "completion_after_streamed_tool_answer"+ } else {+ "completion_after_plain_answer"+ },+ normalize_completion_timestamps(text),+ );+ }+}++#[tokio::test]+async fn completion_live_applies_duration_threshold_and_preserves_timestamp_fallback() {+ for (duration_ms, completed_at, prefix) in [+ (598, Some(COMPLETED_AT), ""),+ (1_000, Some(COMPLETED_AT), ""),+ (60_000, Some(COMPLETED_AT), ""),+ (60_999, Some(COMPLETED_AT), ""),+ (61_000, Some(COMPLETED_AT), "Worked for 1m 1s · "),+ (125_000, Some(COMPLETED_AT), "Worked for 2m 5s · "),+ (1_000, None, ""),+ ] {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ handle_turn_started(&mut chat, "turn-1");+ let turn = completed_turn(Some(duration_ms), completed_at);+ let before = Local::now();+ complete_turn(&mut chat, turn.clone());+ let after = Local::now();+ let possible = [before, after].map(|time| {+ let time = if completed_at.is_some() {+ saved_completion_label()+ } else {+ time.format("done %-I:%M %p").to_string()+ };+ format!("{prefix}{time}")+ });+ let label = completion_labels(&mut rx);+ assert!(possible.contains(&label), "{label:?}");+ complete_turn(&mut chat, turn);+ assert_eq!(completion_labels(&mut rx), "");+ }+}++#[tokio::test]+async fn completion_replay_preserves_metadata_and_input_without_live_side_effects() {+ let done = saved_completion_label();+ for (duration_ms, completed_at, expected) in [+ (+ Some(125_000),+ Some(COMPLETED_AT),+ format!("Worked for 2m 5s · {done}"),+ ),+ (None, None, String::new()),+ (Some(598), Some(COMPLETED_AT), done.clone()),+ (Some(60_000), Some(COMPLETED_AT), done.clone()),+ (+ Some(61_000),+ Some(COMPLETED_AT),+ format!("Worked for 1m 1s · {done}"),+ ),+ (Some(60_000), None, String::new()),+ (Some(125_000), None, "Worked for 2m 5s".to_string()),+ ] {+ for replay_kind in [+ ReplayKind::ResumeInitialMessages,+ ReplayKind::ThreadSnapshot,+ ] {+ let (mut chat, mut rx, mut op_rx) =+ make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ handle_turn_started(&mut chat, "turn-1");+ if matches!(replay_kind, ReplayKind::ThreadSnapshot) {+ chat.queue_user_message("Continue".into());+ }+ let queued_input = chat.input_queue.queued_user_messages.clone();+ while op_rx.try_recv().is_ok() {}+ let mut turn = completed_turn(duration_ms, completed_at);+ chat.replay_thread_turns(vec![turn.clone()], replay_kind);+ assert_eq!(completion_labels(&mut rx), expected);+ assert_matches!(chat.pending_notification, None);+ assert_eq!(chat.input_queue.queued_user_messages, queued_input);+ assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty));++ // An empty replay label must not suppress later authoritative live metadata.+ chat.input_queue.queued_user_messages.clear();+ turn.completed_at = Some(COMPLETED_AT);+ complete_turn(&mut chat, turn.clone());+ assert_eq!(+ completion_labels(&mut rx),+ if expected.is_empty() { &done } else { "" }+ );+ complete_turn(&mut chat, turn);+ assert_eq!(completion_labels(&mut rx), "");+ }+ }+}++#[tokio::test]+async fn completion_replay_waits_for_older_turn_items_to_load() {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ let older_completed_at = COMPLETED_AT - 86_400;+ let mut older = completed_turn(Some(125_000), Some(older_completed_at));+ older.id = "older-turn".to_string();+ let mut unloaded = older.clone();+ unloaded.items_view = codex_app_server_protocol::TurnItemsView::NotLoaded;+ unloaded.items.clear();+ let newer = completed_turn(Some(1_000), Some(COMPLETED_AT));++ chat.replay_thread_turns(vec![unloaded, newer], ReplayKind::ResumeInitialMessages);+ assert_eq!(completion_labels(&mut rx), saved_completion_label());++ chat.replay_thread_turns(vec![older], ReplayKind::ThreadSnapshot);+ let older_time = Local+ .timestamp_opt(older_completed_at, /*nsecs*/ 0)+ .unwrap()+ .format("done %b %-d, %Y at %-I:%M %p");+ assert_eq!(+ completion_labels(&mut rx),+ format!("Worked for 2m 5s · {older_time}"),+ );+}++#[tokio::test]+async fn completion_failed_and_interrupted_turns_do_not_report_success() {+ for status in [+ AppServerTurnStatus::Failed,+ AppServerTurnStatus::Interrupted,+ ] {+ for replay_kind in [None, Some(ReplayKind::ResumeInitialMessages)] {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ let mut turn = completed_turn(Some(125_000), Some(COMPLETED_AT));+ turn.status = status.clone();+ turn.error = (status == AppServerTurnStatus::Failed).then(|| AppServerTurnError {+ misalignment: None,+ message: "The task failed.".to_string(),+ codex_error_info: None,+ additional_details: None,+ });+ if let Some(replay_kind) = replay_kind {+ chat.replay_thread_turns(vec![turn], replay_kind);+ } else {+ handle_turn_started(&mut chat, "turn-1");+ complete_turn(&mut chat, turn);+ }+ assert_eq!(completion_labels(&mut rx), "");+ assert!(!chat.bottom_pane.is_task_running());+ }+ }+}++#[test]+fn completion_snapshot_normalization_is_explicit_and_line_scoped() {+ let timestamp = "Sep 6, 2000 at 2:32 PM";+ let transcript = format!(+ "› done {timestamp}\n• done {timestamp}\n └ done {timestamp}\n The job was done {timestamp}\n done {timestamp} is the expected text\n Worked for 2m 5s · done {timestamp} is quoted\n\n done 3:24 PM\n Worked for 1h 2m 3s · done {timestamp}\n"+ );+ assert_chatwidget_snapshot!("completion_like_transcript_text", &transcript);+ assert_eq!(+ normalize_completion_timestamps(&transcript),+ "› done Sep 6, 2000 at 2:32 PM\n• done Sep 6, 2000 at 2:32 PM\n └ done Sep 6, 2000 at 2:32 PM\n The job was done Sep 6, 2000 at 2:32 PM\n done Sep 6, 2000 at 2:32 PM is the expected text\n Worked for 2m 5s · done Sep 6, 2000 at 2:32 PM is quoted\n\n done [completion time]\n Worked for [duration] · done [completion time]\n"+ );+}diff --git a/codex-rs/tui/src/chatwidget/tests/exec_flow.rs b/codex-rs/tui/src/chatwidget/tests/exec_flow.rsindex 012b4c8ebd..45906e8c99 100644--- a/codex-rs/tui/src/chatwidget/tests/exec_flow.rs+++ b/codex-rs/tui/src/chatwidget/tests/exec_flow.rs@@ -847,7 +847,7 @@ async fn unified_exec_end_after_task_complete_is_suppressed() {drain_insert_history(&mut rx);chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);end_exec(&mut chat, begin, "", "", /*exit_code*/ 0);@@ -863,7 +863,7 @@ async fn unified_exec_interaction_after_task_complete_is_suppressed() {let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;chat.on_task_started();chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);terminal_interaction(&mut chat, "call-1", "proc-1", "ls\n");@@ -891,7 +891,10 @@ async fn unified_exec_wait_after_final_agent_message_snapshot() {.iter().map(|lines| lines_to_single_string(lines)).collect::<String>();- assert_chatwidget_snapshot!("unified_exec_wait_after_final_agent_message", combined);+ assert_chatwidget_snapshot!(+ "unified_exec_wait_after_final_agent_message",+ normalize_completion_timestamps(combined)+ );}#[tokio::test]@@ -915,7 +918,10 @@ async fn unified_exec_wait_before_streamed_agent_message_snapshot() {.iter().map(|lines| lines_to_single_string(lines)).collect::<String>();- assert_chatwidget_snapshot!("unified_exec_wait_before_streamed_agent_message", combined);+ assert_chatwidget_snapshot!(+ "unified_exec_wait_before_streamed_agent_message",+ normalize_completion_timestamps(combined)+ );}#[tokio::test]@@ -952,10 +958,13 @@ async fn final_worked_for_uses_cumulative_turn_duration_snapshot() {.map(|lines| lines_to_single_string(lines)).collect::<String>();assert!(- combined.contains("Worked for 2m 05s"),+ combined.contains("Worked for 2m 5s"),"expected final separator to use cumulative turn duration, got:\n{combined}");- assert_chatwidget_snapshot!("final_worked_for_uses_cumulative_turn_duration", combined);+ assert_chatwidget_snapshot!(+ "final_worked_for_uses_cumulative_turn_duration",+ normalize_completion_timestamps(combined)+ );}}@@ -1027,7 +1036,10 @@ async fn unified_exec_waiting_multiple_empty_snapshots() {.iter().map(|lines| lines_to_single_string(lines)).collect::<String>();- assert_chatwidget_snapshot!("unified_exec_waiting_multiple_empty_after", combined);+ assert_chatwidget_snapshot!(+ "unified_exec_waiting_multiple_empty_after",+ normalize_completion_timestamps(combined)+ );}#[tokio::test]@@ -1107,7 +1119,10 @@ async fn unified_exec_non_empty_then_empty_snapshots() {combined.push('\n');}combined.push_str(&post);- assert_chatwidget_snapshot!("unified_exec_non_empty_then_empty_after", combined);+ assert_chatwidget_snapshot!(+ "unified_exec_non_empty_then_empty_after",+ normalize_completion_timestamps(combined)+ );}#[tokio::test]diff --git a/codex-rs/tui/src/chatwidget/tests/helpers.rs b/codex-rs/tui/src/chatwidget/tests/helpers.rsindex dcf517ad38..e4cb315e71 100644--- a/codex-rs/tui/src/chatwidget/tests/helpers.rs+++ b/codex-rs/tui/src/chatwidget/tests/helpers.rs@@ -1724,3 +1724,25 @@ pub(super) async fn assert_hook_events_snapshot(.collect::<String>();assert_chatwidget_snapshot!(snapshot_name, combined);}++/// Normalize complete footer lines only, in snapshots that opt into clock normalization.+pub(crate) fn normalize_completion_timestamps(value: impl std::fmt::Display) -> String {+ static COMPLETION_FOOTER: std::sync::LazyLock<regex_lite::Regex> = std::sync::LazyLock::new(+ || {+ regex_lite::Regex::new(r"(?m)^(?P<indent>[ \t]*)(?P<duration>Worked for (?:[0-9]+h )?(?:[0-9]+m )?[0-9]+s · )?done (?:[A-Z][a-z]{2} [0-9]{1,2}(?:, [0-9]{4})? at )?[0-9]{1,2}:[0-9]{2} (?:AM|PM)(?P<padding>[ \t]*)$")+ .expect("valid completion footer pattern")+ },+ );+ COMPLETION_FOOTER+ .replace_all(&value.to_string(), |captures: ®ex_lite::Captures<'_>| {+ let indent = &captures["indent"];+ let padding = &captures["padding"];+ let duration = if captures.name("duration").is_some() {+ "Worked for [duration] · "+ } else {+ ""+ };+ format!("{indent}{duration}done [completion time]{padding}")+ })+ .into_owned()+}diff --git a/codex-rs/tui/src/chatwidget/tests/history_replay.rs b/codex-rs/tui/src/chatwidget/tests/history_replay.rsindex 31af6ad260..3165fe86d4 100644--- a/codex-rs/tui/src/chatwidget/tests/history_replay.rs+++ b/codex-rs/tui/src/chatwidget/tests/history_replay.rs@@ -1508,29 +1508,51 @@ async fn thread_snapshot_replayed_turn_started_marks_task_running() {#[tokio::test]async fn replayed_in_progress_turn_marks_task_running() {- let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;-- chat.replay_thread_turns(- vec![AppServerTurn {- id: "turn-1".to_string(),- items_view: codex_app_server_protocol::TurnItemsView::Full,- items: Vec::new(),- status: AppServerTurnStatus::InProgress,- error: None,- started_at: None,- completed_at: None,- duration_ms: None,- }],+ for replay_kind in [ReplayKind::ResumeInitialMessages,- );-- assert!(drain_insert_history(&mut rx).is_empty());- assert!(chat.bottom_pane.is_task_running());- let status = chat- .bottom_pane- .status_widget()- .expect("status indicator should be visible");- assert_eq!(status.header(), "Working");+ ReplayKind::ThreadSnapshot,+ ] {+ for items_view in [+ codex_app_server_protocol::TurnItemsView::Full,+ codex_app_server_protocol::TurnItemsView::NotLoaded,+ ] {+ let (mut chat, mut rx, mut op_rx) =+ make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.replay_thread_turns(+ vec![AppServerTurn {+ items_view,+ ..app_server_turn(+ "turn-1",+ AppServerTurnStatus::InProgress,+ /*duration_ms*/ None,+ /*error*/ None,+ )+ }],+ replay_kind,+ );++ assert!(drain_insert_history(&mut rx).is_empty());+ assert_eq!(+ (+ chat.bottom_pane.is_task_running(),+ chat.turn_lifecycle.last_turn_id.as_deref(),+ ),+ (true, Some("turn-1")),+ );+ assert_chatwidget_snapshot!(+ "replayed_in_progress_turn",+ normalize_snapshot_paths(render_bottom_popup(&chat, /*width*/ 80)),+ );++ chat.handle_key_event(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL));+ assert_matches!(op_rx.try_recv(), Ok(Op::Interrupt));+ assert!(+ std::iter::from_fn(|| rx.try_recv().ok())+ .all(|event| !matches!(event, AppEvent::Exit(_)))+ );+ }+ }}#[tokio::test]diff --git a/codex-rs/tui/src/chatwidget/tests/plan_mode.rs b/codex-rs/tui/src/chatwidget/tests/plan_mode.rsindex 8244b851a1..bcec1cf9a6 100644--- a/codex-rs/tui/src/chatwidget/tests/plan_mode.rs+++ b/codex-rs/tui/src/chatwidget/tests/plan_mode.rs@@ -935,7 +935,7 @@ async fn plan_implementation_popup_skips_when_messages_queued() {chat.on_task_complete(Some("Plan details".to_string()),- /*duration_ms*/ None,+ /*completion*/ None,/*from_replay*/ false,);@@ -963,7 +963,7 @@ async fn plan_implementation_popup_skips_without_proposed_plan() {}],});chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let popup = render_bottom_popup(&chat, /*width*/ 80);@@ -985,7 +985,7 @@ async fn plan_implementation_popup_shows_after_proposed_plan_output() {chat.on_plan_delta("- Step 1\n- Step 2\n".to_string());chat.on_plan_item_completed("- Step 1\n- Step 2\n".to_string());chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let popup = render_bottom_popup(&chat, /*width*/ 80);@@ -1028,7 +1028,7 @@ async fn plan_implementation_popup_skips_when_steer_follows_proposed_plan() {complete_user_message(&mut chat, "user-1", "Please continue.");chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let popup = render_bottom_popup(&chat, /*width*/ 80);@@ -1075,7 +1075,7 @@ async fn plan_implementation_popup_shows_after_new_plan_follows_steer() {.to_string(),);chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let popup = render_bottom_popup(&chat, /*width*/ 80);@@ -1104,7 +1104,7 @@ async fn plan_implementation_popup_skips_when_rate_limit_prompt_pending() {});chat.on_rate_limit_snapshot(Some(snapshot(/*percent*/ 92.0)));chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let popup = render_bottom_popup(&chat, /*width*/ 80);diff --git a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs b/codex-rs/tui/src/chatwidget/tests/slash_commands.rsindex e84f8fb136..95f78826c5 100644--- a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs+++ b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs@@ -2437,11 +2437,13 @@ async fn slash_export_opens_destination_picker() {let cells = drain_insert_history(&mut rx);assert_chatwidget_snapshot!("slash_export_completion_message",- cells- .iter()- .map(|cell| lines_to_single_string(cell).trim().to_string())- .collect::<Vec<_>>()- .join("\n"),+ normalize_completion_timestamps(+ cells+ .iter()+ .map(|cell| lines_to_single_string(cell).trim().to_string())+ .collect::<Vec<_>>()+ .join("\n")+ ),);}diff --git a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rsindex 6e68f7795e..4ae4c253f3 100644--- a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs+++ b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs@@ -2532,7 +2532,6 @@ async fn added_history_uses_pet_adjusted_terminal_width() {chat.add_to_history(WidthCell(std::sync::Arc::clone(&width)));assert_eq!(width.load(std::sync::atomic::Ordering::Relaxed), 69);- assert!(chat.transcript.needs_final_message_separator);let backend = VT100Backend::new(/*width*/ 80, /*height*/ 4);let mut terminal = crate::custom_terminal::Terminal::with_options(backend).expect("terminal");terminal.set_viewport_area(Rect::new(@@ -3332,7 +3331,7 @@ async fn completed_turn_refreshes_estimated_thread_cost() {));chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let request_id = std::iter::from_fn(|| rx.try_recv().ok())@@ -3384,7 +3383,7 @@ async fn completed_turn_refreshes_credits_only_terminal_title() {));chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let request_id = std::iter::from_fn(|| rx.try_recv().ok())@@ -4518,7 +4517,7 @@ async fn runtime_metrics_websocket_timing_logs_and_final_separator_sums_totals()assert!(second_log.contains("TTFT: 80ms (iapi)"));chat.on_task_complete(- /*last_agent_message*/ None, /*duration_ms*/ None, /*from_replay*/ false,+ /*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,);let mut final_separator = None;while let Ok(event) = rx.try_recv() {@@ -5729,7 +5728,9 @@ printf 'fenced within fenced\n'assert_chatwidget_snapshot!("chatwidget_markdown_code_blocks_vt100_snapshot",- normalize_snapshot_paths(term.backend().vt100().screen().contents())+ normalize_completion_timestamps(normalize_snapshot_paths(+ term.backend().vt100().screen().contents()+ )));}diff --git a/codex-rs/tui/src/chatwidget/tool_lifecycle.rs b/codex-rs/tui/src/chatwidget/tool_lifecycle.rsindex acc0e97523..d0c3c14d5d 100644--- a/codex-rs/tui/src/chatwidget/tool_lifecycle.rs+++ b/codex-rs/tui/src/chatwidget/tool_lifecycle.rs@@ -105,7 +105,6 @@ impl ChatWidget {if !handled {self.add_to_history(history_cell::new_web_search_call(call_id, query, action));}- self.transcript.had_work_activity = true;}pub(super) fn on_collab_event(&mut self, cell: PlainHistoryCell) {@@ -160,8 +159,6 @@ impl ChatWidget {if matches!(status, codex_app_server_protocol::PatchApplyStatus::Failed) {self.add_to_history(history_cell::new_patch_apply_failure(String::new()));}- // Mark that actual work was done (patch applied)- self.transcript.had_work_activity = true;}pub(crate) fn handle_mcp_tool_call_started_now(&mut self, item: ThreadItem) {@@ -251,8 +248,6 @@ impl ChatWidget {if let Some(extra) = extra_cell {self.add_boxed_history(extra);}- // Mark that actual work was done (MCP tool call)- self.transcript.had_work_activity = true;}pub(crate) fn handle_queued_item_started_now(&mut self, item: ThreadItem) {diff --git a/codex-rs/tui/src/chatwidget/transcript.rs b/codex-rs/tui/src/chatwidget/transcript.rsindex 67b506ac28..8b2c3e520e 100644--- a/codex-rs/tui/src/chatwidget/transcript.rs+++ b/codex-rs/tui/src/chatwidget/transcript.rs@@ -49,10 +49,6 @@ pub(super) struct TranscriptState {pub(super) latest_proposed_plan_markdown: Option<String>,/// Whether this turn already produced a copyable response.pub(super) saw_copy_source_this_turn: bool,- /// Whether the next streamed assistant content should be preceded by a final message separator.- pub(super) needs_final_message_separator: bool,- /// Whether the current turn performed "work" (exec commands, MCP tool calls, patch applications).- pub(super) had_work_activity: bool,/// Whether the current turn emitted a plan update.pub(super) saw_plan_update_this_turn: bool,/// Whether the current turn emitted a proposed plan item that has not been superseded by a@@ -109,7 +105,6 @@ impl TranscriptState {self.last_completed_agent_message = None;self.saw_plan_update_this_turn = false;self.saw_plan_item_this_turn = false;- self.had_work_activity = false;self.latest_proposed_plan_markdown = None;self.plan_delta_buffer.clear();self.plan_item_active = false;diff --git a/codex-rs/tui/src/chatwidget/turn_lifecycle.rs b/codex-rs/tui/src/chatwidget/turn_lifecycle.rsindex 6ecc29e02f..67ced849ad 100644--- a/codex-rs/tui/src/chatwidget/turn_lifecycle.rs+++ b/codex-rs/tui/src/chatwidget/turn_lifecycle.rs@@ -12,6 +12,8 @@ pub(super) struct TurnLifecycleState {pub(super) agent_turn_running: bool,pub(super) last_turn_id: Option<String>,pub(super) budget_limited_turn_ids: HashSet<String>,+ /// Completion labels already inserted into this thread's visible history.+ pub(super) rendered_completion_turn_ids: HashSet<String>,pub(super) goal_status_active_turn_started_at: Option<Instant>,}@@ -22,6 +24,7 @@ impl TurnLifecycleState {agent_turn_running: false,last_turn_id: None,budget_limited_turn_ids: HashSet::new(),+ rendered_completion_turn_ids: HashSet::new(),goal_status_active_turn_started_at: None,}}@@ -49,6 +52,7 @@ impl TurnLifecycleState {self.finish();self.last_turn_id = None;self.budget_limited_turn_ids.clear();+ self.rendered_completion_turn_ids.clear();}pub(super) fn set_prevent_idle_sleep(&mut self, enabled: bool) {diff --git a/codex-rs/tui/src/chatwidget/turn_runtime.rs b/codex-rs/tui/src/chatwidget/turn_runtime.rsindex 0d5303686e..18f51fff29 100644--- a/codex-rs/tui/src/chatwidget/turn_runtime.rs+++ b/codex-rs/tui/src/chatwidget/turn_runtime.rs@@ -1,7 +1,7 @@//! Agent turn lifecycle and runtime bookkeeping for `ChatWidget`.//!//! This module owns task start/completion state, runtime metrics, plan updates,-//! and final-message separator handling.+//! and completion metadata rendering.use super::*;@@ -113,7 +113,7 @@ impl ChatWidget {pub(super) fn on_task_complete(&mut self,last_agent_message: Option<String>,- duration_ms: Option<i64>,+ completion: Option<history_cell::FinalMessageSeparator>,from_replay: bool,) {self.input_queue.submit_pending_steers_after_interrupt = false;@@ -154,31 +154,19 @@ impl ChatWidget {self.flush_unified_exec_wait_streak();if !from_replay {self.collect_runtime_metrics_delta();- let runtime_metrics =- (!self.turn_runtime_metrics.is_empty()).then_some(self.turn_runtime_metrics);- let show_work_separator = self.transcript.had_work_activity- && (self.transcript.needs_final_message_separator || runtime_metrics.is_some());- if show_work_separator || runtime_metrics.is_some() {- let elapsed_seconds = if show_work_separator {- duration_ms- .and_then(|duration_ms| u64::try_from(duration_ms).ok())- .map(|duration_ms| duration_ms / 1_000)- .or_else(|| {- self.bottom_pane- .status_elapsed()- .map(|elapsed| elapsed.as_secs())- })- } else {- None- };- self.add_to_history(history_cell::FinalMessageSeparator::new(- elapsed_seconds,- runtime_metrics,- ));- }- self.turn_runtime_metrics = RuntimeMetricsSummary::default();- self.transcript.needs_final_message_separator = false;- self.transcript.had_work_activity = false;+ }+ let runtime_metrics = (!from_replay && !self.turn_runtime_metrics.is_empty())+ .then_some(self.turn_runtime_metrics);+ if let Some(completion) = completion {+ self.add_to_history(completion.with_runtime_metrics(runtime_metrics));+ } else if let Some(runtime_metrics) = runtime_metrics {+ self.add_to_history(history_cell::FinalMessageSeparator::new(+ /*elapsed_seconds*/ None,+ Some(runtime_metrics),+ ));+ }+ self.turn_runtime_metrics = RuntimeMetricsSummary::default();+ if !from_replay {self.request_status_line_branch_refresh();self.request_status_line_git_summary_refresh();self.refresh_thread_usage_after_turn();@@ -213,23 +201,20 @@ impl ChatWidget {if !from_replay {self.transcript.saw_plan_item_this_turn = false;}- // If there is a queued user message, send exactly one now to begin the next turn.- let follow_up_started = self.maybe_send_next_queued_input();- let active_goal_continuing = self- .current_goal_status- .as_ref()- .is_some_and(GoalStatusState::is_active);- // Emit a notification when the agent is truly waiting for the user.- // Queued follow-up input and active goal continuation both start the- // next turn immediately, so notifying at that boundary would feel like- // a false "needs attention".- if !follow_up_started && !active_goal_continuing {- self.notify(Notification::AgentTurnComplete {- response: notification_response,- });+ if !from_replay {+ // Emit a notification only when the live agent is waiting for the user.+ let follow_up_started = self.maybe_send_next_queued_input();+ let active_goal_continuing = self+ .current_goal_status+ .as_ref()+ .is_some_and(GoalStatusState::is_active);+ if !follow_up_started && !active_goal_continuing {+ self.notify(Notification::AgentTurnComplete {+ response: notification_response,+ });+ }+ self.maybe_show_pending_rate_limit_prompt();}-- self.maybe_show_pending_rate_limit_prompt();}pub(super) fn maybe_prompt_plan_implementation(&mut self) {diff --git a/codex-rs/tui/src/history_cell/separators.rs b/codex-rs/tui/src/history_cell/separators.rsindex 1eced782ce..2ac840301d 100644--- a/codex-rs/tui/src/history_cell/separators.rs+++ b/codex-rs/tui/src/history_cell/separators.rs@@ -1,19 +1,28 @@-//! Turn separators and runtime-metrics labels for transcript history.+//! Subtle completion timestamps, elapsed durations, and runtime metrics for transcript history.use super::*;+use chrono::DateTime;+use chrono::Datelike;+use chrono::Local;+use chrono::NaiveDate;-#[derive(Debug)]-/// A visual divider between turns, optionally showing how long the assistant "worked for".+/// Completion metadata shown after the assistant's final response.///-/// This separator is only emitted for turns that performed concrete work (e.g., running commands,-/// applying patches, making MCP tool calls), so purely conversational turns do not show an empty-/// divider.+/// The timestamp records when the turn actually finished, including when restored from history.+/// Times use a twelve-hour clock; other local days include the date and other years include the year.+/// Durations are shown only above sixty seconds; shorter turns still show their timestamp.+/// Absent metadata occupies no transcript rows.+/// The display date is fixed at construction so crossing midnight cannot invalidate cached heights;+/// restoring the conversation constructs new cells and refreshes whether the timestamp needs a date.+#[derive(Debug)]pub struct FinalMessageSeparator {elapsed_seconds: Option<u64>,runtime_metrics: Option<RuntimeMetricsSummary>,+ completed_at: Option<DateTime<Local>>,+ display_date: NaiveDate,}impl FinalMessageSeparator {- /// Creates a separator; completed turns should pass protocol turn duration when available.+ /// Creates completion metadata using the protocol turn duration when available.pub(crate) fn new(elapsed_seconds: Option<u64>,runtime_metrics: Option<RuntimeMetricsSummary>,@@ -21,58 +30,85 @@ impl FinalMessageSeparator {Self {elapsed_seconds,runtime_metrics,+ completed_at: None,+ display_date: Local::now().date_naive(),}}-}-impl HistoryCell for FinalMessageSeparator {- fn display_lines(&self, width: u16) -> Vec<Line<'static>> {- let mut label_parts = Vec::new();- if let Some(elapsed_seconds) = self- .elapsed_seconds- .filter(|seconds| *seconds > 60)- .map(crate::status_indicator_widget::fmt_elapsed_compact)- {- label_parts.push(format!("Worked for {elapsed_seconds}"));- }- if let Some(metrics_label) = self.runtime_metrics.and_then(runtime_metrics_label) {- label_parts.push(metrics_label);- }- if label_parts.is_empty() {- return vec![Line::from_iter(["─".repeat(width as usize).dim()])];- }+ pub(crate) fn with_completed_at(mut self, completed_at: DateTime<Local>) -> Self {+ self.completed_at = Some(completed_at);+ self+ }- let label = format!("─ {} ─", label_parts.join(" • "));- let (label, _suffix, label_width) = take_prefix_by_width(&label, width as usize);- vec![- Line::from_iter([- label,- "─".repeat((width as usize).saturating_sub(label_width)),- ])- .dim(),- ]+ pub(crate) fn with_runtime_metrics(+ mut self,+ runtime_metrics: Option<RuntimeMetricsSummary>,+ ) -> Self {+ self.runtime_metrics = runtime_metrics;+ self}- fn raw_lines(&self) -> Vec<Line<'static>> {+ fn label(&self, today: NaiveDate) -> Option<String> {let mut label_parts = Vec::new();- if let Some(elapsed_seconds) = self- .elapsed_seconds- .filter(|seconds| *seconds > 60)- .map(crate::status_indicator_widget::fmt_elapsed_compact)- {- label_parts.push(format!("Worked for {elapsed_seconds}"));+ if let Some(elapsed_seconds) = self.elapsed_seconds.filter(|seconds| *seconds > 60) {+ let hours = elapsed_seconds / 3_600;+ let minutes = (elapsed_seconds % 3_600) / 60;+ let seconds = elapsed_seconds % 60;+ let elapsed = if hours > 0 {+ format!("{hours}h {minutes}m {seconds}s")+ } else if minutes > 0 {+ format!("{minutes}m {seconds}s")+ } else {+ format!("{seconds}s")+ };+ label_parts.push(format!("Worked for {elapsed}"));+ }+ if let Some(completed_at) = self.completed_at {+ let format = if completed_at.date_naive() == today {+ "done %-I:%M %p"+ } else if completed_at.year() == today.year() {+ "done %b %-d at %-I:%M %p"+ } else {+ "done %b %-d, %Y at %-I:%M %p"+ };+ label_parts.push(completed_at.format(format).to_string());}if let Some(metrics_label) = self.runtime_metrics.and_then(runtime_metrics_label) {label_parts.push(metrics_label);}- if label_parts.is_empty() {- Vec::new()- } else {- vec![Line::from(label_parts.join(" • "))]+ (!label_parts.is_empty()).then(|| label_parts.join(" · "))+ }+}+impl HistoryCell for FinalMessageSeparator {+ fn display_lines(&self, width: u16) -> Vec<Line<'static>> {+ if width == 0 {+ return Vec::new();}+ self.label(self.display_date)+ .map(|label| {+ let indent = if width > 2 { " " } else { "" };+ let options = textwrap::Options::new(usize::from(width))+ .initial_indent(indent)+ .subsequent_indent(indent);+ textwrap::wrap(&label, options)+ .into_iter()+ .map(|line| Line::from(line.into_owned()).dim())+ .collect()+ })+ .unwrap_or_default()+ }++ fn raw_lines(&self) -> Vec<Line<'static>> {+ self.label(self.display_date)+ .map(|label| vec![Line::from(label)])+ .unwrap_or_default()}}+#[cfg(test)]+#[path = "separators_tests.rs"]+mod tests;+pub(crate) fn runtime_metrics_label(summary: RuntimeMetricsSummary) -> Option<String> {let mut parts = Vec::new();if summary.tool_calls.count > 0 {diff --git a/codex-rs/tui/src/history_cell/separators_tests.rs b/codex-rs/tui/src/history_cell/separators_tests.rsnew file mode 100644index 0000000000..4ea0e7de79--- /dev/null+++ b/codex-rs/tui/src/history_cell/separators_tests.rs@@ -0,0 +1,168 @@+//! Completion metadata rendering, date selection, and muted styling coverage.++use super::*;+use chrono::NaiveDateTime;+use chrono::TimeZone;+use chrono::Timelike;+use codex_otel::RuntimeMetricTotals;+use pretty_assertions::assert_eq;+use ratatui::buffer::Buffer;+use ratatui::layout::Rect;++fn completed_at() -> DateTime<Local> {+ let datetime = NaiveDateTime::parse_from_str("2000-09-06 14:32:00", "%Y-%m-%d %H:%M:%S")+ .expect("valid completion time");+ Local+ .from_local_datetime(&datetime)+ .single()+ .expect("unambiguous completion time")+}++#[test]+fn completion_label_shows_duration_only_above_sixty_seconds() {+ let completed_at = completed_at();+ let labels = [+ None,+ Some(0),+ Some(12),+ Some(60),+ Some(61),+ Some(125),+ Some(3_605),+ ]+ .into_iter()+ .map(|elapsed_seconds| {+ FinalMessageSeparator::new(elapsed_seconds, /*runtime_metrics*/ None)+ .with_completed_at(completed_at)+ .label(completed_at.date_naive())+ .expect("completion label")+ })+ .collect::<Vec<_>>();++ insta::assert_snapshot!(labels.join("\n"), @"+ done 2:32 PM+ done 2:32 PM+ done 2:32 PM+ done 2:32 PM+ Worked for 1m 1s · done 2:32 PM+ Worked for 2m 5s · done 2:32 PM+ Worked for 1h 0m 5s · done 2:32 PM+ ");+}++#[test]+fn completion_label_includes_date_when_viewed_on_another_day() {+ let completed_at = completed_at();+ let cell = FinalMessageSeparator::new(+ /*elapsed_seconds*/ Some(125),+ /*runtime_metrics*/ None,+ )+ .with_completed_at(completed_at);+ let tomorrow = completed_at.date_naive().succ_opt().expect("next day");++ insta::assert_snapshot!(cell.label(tomorrow).expect("completion label"), @"Worked for 2m 5s · done Sep 6 at 2:32 PM");+ let next_year = tomorrow.with_year(/*year*/ 2001).expect("valid next year");+ insta::assert_snapshot!(cell.label(next_year).expect("completion label"), @"Worked for 2m 5s · done Sep 6, 2000 at 2:32 PM");+}++#[test]+fn completion_uses_twelve_hour_time_at_midnight_noon_and_afternoon() {+ let labels = [0, 12, 15].map(|hour| {+ let completed_at = completed_at().with_hour(hour).expect("valid hour");+ FinalMessageSeparator::new(/*elapsed_seconds*/ None, /*runtime_metrics*/ None)+ .with_completed_at(completed_at)+ .label(completed_at.date_naive())+ .expect("completion label")+ });+ insta::assert_snapshot!(labels.join("\n"), @"+ done 12:32 AM+ done 12:32 PM+ done 3:32 PM+ ");+}++#[test]+fn completion_without_metadata_has_no_visible_or_raw_lines() {+ let cell =+ FinalMessageSeparator::new(/*elapsed_seconds*/ None, /*runtime_metrics*/ None);+ assert_eq!(cell.display_lines(/*width*/ 80), Vec::<Line>::new());+ assert_eq!(cell.raw_lines(), Vec::<Line>::new());+}++#[test]+fn completion_without_timestamp_retains_known_elapsed_duration() {+ let cell = FinalMessageSeparator::new(+ /*elapsed_seconds*/ Some(125),+ /*runtime_metrics*/ None,+ );+ insta::assert_snapshot!(cell.raw_lines()[0].to_string(), @"Worked for 2m 5s");+}++#[test]+fn completion_wraps_metadata_and_preserves_unwrapped_raw_text() {+ let cell = FinalMessageSeparator::new(+ /*elapsed_seconds*/ Some(125),+ /*runtime_metrics*/ None,+ )+ .with_completed_at(completed_at())+ .with_runtime_metrics(Some(RuntimeMetricsSummary {+ tool_calls: RuntimeMetricTotals {+ count: 3,+ duration_ms: 2_450,+ },+ ..RuntimeMetricsSummary::default()+ }));+ let lines = cell.display_lines(/*width*/ 24);+ let rendered = lines.iter().map(ToString::to_string).collect::<Vec<_>>();++ insta::assert_snapshot!(rendered.join("\n"), @"+ Worked for 2m 5s ·+ done Sep 6, 2000 at+ 2:32 PM · Local tools:+ 3 calls (2.5s)+ ");+ insta::assert_snapshot!(cell.raw_lines()[0].to_string(), @"Worked for 2m 5s · done Sep 6, 2000 at 2:32 PM · Local tools: 3 calls (2.5s)");+ for width in [0, 1, 5, 24] {+ assert!(+ cell.display_lines(width)+ .iter()+ .all(|line| line.width() <= usize::from(width))+ );+ }+}++#[test]+fn completion_renders_with_dim_default_colors() {+ let cell: Box<dyn HistoryCell> = Box::new(+ FinalMessageSeparator::new(/*elapsed_seconds*/ None, /*runtime_metrics*/ None)+ .with_completed_at(completed_at()),+ );+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 1,+ );+ let mut buffer = Buffer::empty(area);+ cell.render(area, &mut buffer);+ let text_width = cell.display_lines(area.width)[0].width();+ let styles = (0..text_width)+ .map(|x| {+ let rendered = &buffer[(x as u16, 0)];+ (rendered.fg, rendered.bg, rendered.modifier)+ })+ .collect::<Vec<_>>();+ assert_eq!(+ styles,+ vec![(Color::Reset, Color::Reset, Modifier::DIM); text_width]+ );+}++#[test]+fn completion_rendering_uses_the_captured_display_date() {+ let completed_at = completed_at();+ let mut cell =+ FinalMessageSeparator::new(/*elapsed_seconds*/ None, /*runtime_metrics*/ None)+ .with_completed_at(completed_at);+ cell.display_date = completed_at.date_naive();++ insta::assert_snapshot!(cell.display_lines(/*width*/ 80)[0].to_string(), @" done 2:32 PM");+ assert_eq!(cell.raw_lines(), vec![Line::from("done 2:32 PM")]);+}diff --git a/codex-rs/tui/src/history_cell/tests.rs b/codex-rs/tui/src/history_cell/tests.rsindex 785ff02744..c2a6cc4f41 100644--- a/codex-rs/tui/src/history_cell/tests.rs+++ b/codex-rs/tui/src/history_cell/tests.rs@@ -598,7 +598,7 @@ fn unified_exec_interaction_cell_renders_wait() {}#[test]-fn final_message_separator_hides_short_worked_label_and_includes_runtime_metrics() {+fn final_message_separator_preserves_runtime_metrics_for_short_turns() {let summary = RuntimeMetricsSummary {tool_calls: RuntimeMetricTotals {count: 3,@@ -633,7 +633,7 @@ fn final_message_separator_hides_short_worked_label_and_includes_runtime_metricslet rendered = render_lines(&cell.display_lines(/*width*/ 600));assert_eq!(rendered.len(), 1);- assert!(!rendered[0].contains("Worked for"));+ assert!(rendered[0].starts_with(" Local tools:"));assert!(rendered[0].contains("Local tools: 3 calls (2.5s)"));assert!(rendered[0].contains("Inference: 2 calls (1.2s)"));assert!(rendered[0].contains("WebSocket: 1 events send (700ms)"));