Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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(
cells
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 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.rs
new file mode 100644
index 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,
+ &timestamp,
+ "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.rs
index 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 = true
let 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.snap
new file mode 100644
index 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 PM
diff --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.snap
index 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 request
Keep 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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(&notification.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.rs
index 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::Failed
diff --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.snap
index 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.snap
new file mode 100644
index 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.snap
new file mode 100644
index 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.snap
new file mode 100644
index 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 PM
diff --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.snap
index 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.snap
new file mode 100644
index 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/project
diff --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.snap
index 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 unavailable
diff --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.snap
index 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.snap
index 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.snap
index 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.snap
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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: &regex_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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_metrics
let 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)"));