Lightweight coding agent that runs in your terminal
Rust
Align persisted TUI activity groups and reasoning with live output (#46711)
Eric Trautf43faf132dd2
diff --git a/codex-rs/tui/src/app/history_completion.rs b/codex-rs/tui/src/app/history_completion.rsindex 7a974c7725..6b597bebc9 100644--- a/codex-rs/tui/src/app/history_completion.rs+++ b/codex-rs/tui/src/app/history_completion.rs@@ -1,4 +1,4 @@-//! Group older history items at successful turn boundaries before projecting transcript cells.+//! Separate older history at every turn boundary; only successful turns gain completion metadata.//! A page splitting a turn only adds completion metadata when it contains that turn's last item.use codex_app_server_protocol::ThreadItem;@@ -10,17 +10,17 @@ pub(super) fn group_completed_turn_items(items: Vec<ThreadItem>,turns: &[Turn],) -> Vec<(Vec<ThreadItem>, Option<&Turn>)> {- let completed_boundaries: HashMap<_, _> = turns+ let 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();+ let boundary = boundaries.get(item.id()).copied();pending.push(item);- if completed_turn.is_some() {+ if let Some(turn) = boundary {+ let completed_turn = (turn.status == TurnStatus::Completed).then_some(turn);groups.push((std::mem::take(&mut pending), completed_turn));}}diff --git a/codex-rs/tui/src/app/history_completion_tests.rs b/codex-rs/tui/src/app/history_completion_tests.rsindex aac7bc01a7..273b9fa776 100644--- a/codex-rs/tui/src/app/history_completion_tests.rs+++ b/codex-rs/tui/src/app/history_completion_tests.rs@@ -58,7 +58,7 @@ fn multiple_turns_keep_item_groups_and_completion_order() {}#[test]-fn unsuccessful_and_running_turns_do_not_create_completion_boundaries() {+fn unsuccessful_and_running_turns_separate_groups_without_completion_metadata() {let turns = vec![turn("failed", TurnStatus::Failed, &["a"]),turn("interrupted", TurnStatus::Interrupted, &["b"]),@@ -69,7 +69,10 @@ fn unsuccessful_and_running_turns_do_not_create_completion_boundaries() {.flat_map(|turn| turn.items.clone()).collect::<Vec<_>>();assert_eq!(- group_completed_turn_items(items.clone(), &turns),- vec![(items, None)],+ group_completed_turn_items(items, &turns),+ turns+ .iter()+ .map(|turn| (turn.items.clone(), None))+ .collect::<Vec<_>>(),);}diff --git a/codex-rs/tui/src/app/history_pagination.rs b/codex-rs/tui/src/app/history_pagination.rsindex 60e1296607..f1eb0f7cfc 100644--- a/codex-rs/tui/src/app/history_pagination.rs+++ b/codex-rs/tui/src/app/history_pagination.rs@@ -88,7 +88,7 @@ impl App {store.turns.clone(),)};- let mut items = app_server+ let items = app_server.apply_older_history_page(thread_id, cursor, page, &mut turns).await?;let mut hidden_item_ids = HashSet::new();@@ -185,9 +185,9 @@ 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) {+ for (mut items, completed_turn) in completion::group_completed_turn_items(items, &turns) {+ items.retain(|item| !hidden_item_ids.contains(item.id()));cells.extend(thread_items_to_transcript_cells(Some(thread_id),&cwd,diff --git a/codex-rs/tui/src/app/snapshots/codex_tui__app__transcript_export__tests__persisted_web_and_image_activity_preserves_full_details.snap b/codex-rs/tui/src/app/snapshots/codex_tui__app__transcript_export__tests__persisted_web_and_image_activity_preserves_full_details.snapindex b50b91c2db..e57701e750 100644--- a/codex-rs/tui/src/app/snapshots/codex_tui__app__transcript_export__tests__persisted_web_and_image_activity_preserves_full_details.snap+++ b/codex-rs/tui/src/app/snapshots/codex_tui__app__transcript_export__tests__persisted_web_and_image_activity_preserves_full_details.snap@@ -1,9 +1,14 @@---source: tui/src/app/transcript_export_tests.rs+assertion_line: 227expression: "render_markdown_transcript(&cells).expect(\"exported transcript\")"---# Codex conversation+## Reasoning++Inspect **the saved result**.+## ActivityOpened https://example.com/long/path?query=full#detailsdiff --git a/codex-rs/tui/src/app/transcript_export.rs b/codex-rs/tui/src/app/transcript_export.rsindex 06528e2036..74d8a5416e 100644--- a/codex-rs/tui/src/app/transcript_export.rs+++ b/codex-rs/tui/src/app/transcript_export.rs@@ -237,6 +237,8 @@ fn render_markdown_transcript(cells: &[Arc<dyn HistoryCell>]) -> Result<String,}lines.extend(image_labels.into_iter().map(Into::into));lines+ } else if let Some(reasoning) = cell.as_any().downcast_ref::<ReasoningSummaryCell>() {+ raw_lines_from_source(reasoning.markdown_source().trim())} else {cell.raw_lines()};diff --git a/codex-rs/tui/src/app/transcript_export_tests.rs b/codex-rs/tui/src/app/transcript_export_tests.rsindex a637f6bc39..34a6c82b18 100644--- a/codex-rs/tui/src/app/transcript_export_tests.rs+++ b/codex-rs/tui/src/app/transcript_export_tests.rs@@ -201,6 +201,10 @@ fn transcript_file_resolves_relative_paths_and_refuses_to_overwrite() {#[test]fn persisted_web_and_image_activity_preserves_full_details() {let items = [+ serde_json::json!({+ "type": "reasoning", "id": "reasoning",+ "summary": ["Inspect **the saved result**."], "content": ["Raw details stay hidden."]+ }),serde_json::json!({"type": "webSearch", "id": "open", "query": "","action": {"type": "openPage", "url": "https://example.com/long/path?query=full#details"}diff --git a/codex-rs/tui/src/chatwidget/streaming.rs b/codex-rs/tui/src/chatwidget/streaming.rsindex d8056539b3..1efb23a044 100644--- a/codex-rs/tui/src/chatwidget/streaming.rs+++ b/codex-rs/tui/src/chatwidget/streaming.rs@@ -349,7 +349,8 @@ impl ChatWidget {.or(self.reasoning_header.take());if !self.reasoning_summary_parts.is_empty() {let reasoning_parts = std::mem::take(&mut self.reasoning_summary_parts);- let cell = history_cell::new_reasoning_summary_block(reasoning_parts, &self.config.cwd);+ let cell: Box<dyn HistoryCell> =+ history_cell::new_reasoning_summary_block(reasoning_parts, &self.config.cwd);let result = match self.transcript.active_cell.as_mut() {Some(active) => active.append_reasoning(cell),None => Err(cell),diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rsindex 57d01ccca2..a121c267b8 100644--- a/codex-rs/tui/src/chatwidget/tests.rs+++ b/codex-rs/tui/src/chatwidget/tests.rs@@ -252,6 +252,8 @@ mod copy_export_picker_tests;mod exec_flow;mod goal_menu;mod goal_validation;+#[path = "tests/group_projection_tests.rs"]+mod group_projection_tests;mod guardian;pub(crate) mod helpers;mod history_replay;diff --git a/codex-rs/tui/src/chatwidget/tests/group_projection_tests.rs b/codex-rs/tui/src/chatwidget/tests/group_projection_tests.rsnew file mode 100644index 0000000000..8565c0fc6d--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/group_projection_tests.rs@@ -0,0 +1,79 @@+//! Persisted reasoning matches live replay in compact and detailed presentations.++use super::*;+use crate::thread_transcript::RawReasoningVisibility;+use crate::thread_transcript::thread_items_to_transcript_cells;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn snapshot_formatter_reasoning_matches_legacy_and_detailed_replay() {+ let mut snapshots = Vec::new();+ for visibility in [+ RawReasoningVisibility::Hidden,+ RawReasoningVisibility::Visible,+ ] {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ drain_insert_history(&mut rx);+ chat.config.show_raw_agent_reasoning = visibility == RawReasoningVisibility::Visible;+ let item = AppServerThreadItem::Reasoning {+ id: "reasoning".to_string(),+ summary: vec.".to_string(),+ "**Checking tests**\n\n<!-- -->".to_string(),+ ],+ content: vec!["Raw detail.".to_string()],+ };+ let projected = thread_items_to_transcript_cells(+ chat.thread_id,+ &chat.config.cwd,+ [item.clone()],+ visibility,+ Some(&chat.config),+ );+ chat.replay_thread_item(item, "turn".to_string(), ReplayKind::ThreadSnapshot);+ let replayed: Vec<Box<dyn HistoryCell>> = std::iter::from_fn(|| rx.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => Some(cell),+ _ => None,+ })+ .collect();+ assert_eq!((projected.len(), replayed.len()), (1, 1));+ assert!(+ projected[0]+ .display_hyperlink_lines(/*width*/ 80)+ .is_empty()+ );+ assert!(replayed[0].display_hyperlink_lines(/*width*/ 80).is_empty());+ for width in [28, 80] {+ assert_eq!(+ projected[0].transcript_hyperlink_lines(width),+ replayed[0].transcript_hyperlink_lines(width)+ );+ }+ snapshots.push(format!(+ "{visibility:?}\nlegacy: {:?}\ndetailed:\n{}",+ projected[0].display_lines(/*width*/ 80),+ lines_to_single_string(&projected[0].transcript_lines(/*width*/ 80)),+ ));+ }+ insta::assert_snapshot!(snapshots.join("\n"));+}++#[test]+fn raw_reasoning_keeps_its_own_heading() {+ let projected = thread_items_to_transcript_cells(+ /*thread_id*/ None,+ &codex_utils_absolute_path::AbsolutePathBuf::current_dir().unwrap(),+ [AppServerThreadItem::Reasoning {+ id: "raw".into(),+ summary: Vec::new(),+ content: vec!["**Raw investigation**\nKeep this heading and its details.".into()],+ }],+ RawReasoningVisibility::Visible,+ /*config*/ None,+ );+ insta::assert_snapshot!(lines_to_single_string(&projected[0].transcript_lines(/*width*/ 80)), @"+ • Raw investigation+ Keep this heading and its details.+ ");+}diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__group_projection_tests__snapshot_formatter_reasoning_matches_legacy_and_detailed_replay.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__group_projection_tests__snapshot_formatter_reasoning_matches_legacy_and_detailed_replay.snapnew file mode 100644index 0000000000..88ae31cbb3--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__group_projection_tests__snapshot_formatter_reasoning_matches_legacy_and_detailed_replay.snap@@ -0,0 +1,15 @@+---+source: tui/src/chatwidget/tests/group_projection_tests.rs+expression: "snapshots.join(\"\\n\")"+---+Hidden+legacy: []+detailed:+• Read src/main.rs (src/main.rs:3).++Visible+legacy: []+detailed:+• Read src/main.rs (src/main.rs:3).++ Raw detail.diff --git a/codex-rs/tui/src/exec_cell/model.rs b/codex-rs/tui/src/exec_cell/model.rsindex 5bc34c8c5b..7707a78a11 100644--- a/codex-rs/tui/src/exec_cell/model.rs+++ b/codex-rs/tui/src/exec_cell/model.rs@@ -115,6 +115,20 @@ impl ExecCell {}}+ /// Historical grouping uses the same compatibility and failure boundary as live calls.+ pub(crate) fn append_completed(&mut self, mut newer: Self) -> Result<(), Self> {+ if !self.is_exploring_cell() || self.should_flush() || !newer.is_exploring_cell() {+ return Err(newer);+ }+ newer.group.details.prepend(+ std::mem::take(&mut self.group.details),+ self.group.calls.len(),+ );+ self.group.details = newer.group.details;+ self.group.calls.append(&mut newer.group.calls);+ Ok(())+ }+/// Preserve live clocks and pending output when a validated older page extends exploration.#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]pub(crate) fn prepend(&mut self, older: Self) {diff --git a/codex-rs/tui/src/exec_cell/snapshots/codex_tui__exec_cell__transcript__tests__raw_grouped_history_retains_terminal_input_and_omits_reasoning.snap b/codex-rs/tui/src/exec_cell/snapshots/codex_tui__exec_cell__transcript__tests__raw_grouped_history_retains_terminal_input_and_omits_reasoning.snapnew file mode 100644index 0000000000..fcee08c3db--- /dev/null+++ b/codex-rs/tui/src/exec_cell/snapshots/codex_tui__exec_cell__transcript__tests__raw_grouped_history_retains_terminal_input_and_omits_reasoning.snap@@ -0,0 +1,29 @@+---+source: tui/src/exec_cell/transcript_tests.rs+assertion_line: 73+expression: "format!(\"Rich\\n{rich}\\n\\nRaw\\n{}\", raw.join(\"\\n\"))"+---+Rich+$ cat first.txt+first output+✓ • 5ms++• Inspecting the next file++↳ Interacted with background terminal · cat first.txt+ └ continue++$ cat second.txt+second output+✓ • 5ms++Raw+$ cat first.txt+first output+✓ • 5ms+Interacted with background terminal: cat first.txt+continue++$ cat second.txt+second output+✓ • 5msdiff --git a/codex-rs/tui/src/exec_cell/transcript.rs b/codex-rs/tui/src/exec_cell/transcript.rsindex d8ee0d0ae6..43ed4ce55b 100644--- a/codex-rs/tui/src/exec_cell/transcript.rs+++ b/codex-rs/tui/src/exec_cell/transcript.rs@@ -69,3 +69,7 @@ impl ExecCell {lines}}++#[cfg(test)]+#[path = "transcript_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/exec_cell/transcript_tests.rs b/codex-rs/tui/src/exec_cell/transcript_tests.rsnew file mode 100644index 0000000000..41a8c4f156--- /dev/null+++ b/codex-rs/tui/src/exec_cell/transcript_tests.rs@@ -0,0 +1,90 @@+//! Grouped command details retain terminal input in raw output without exposing hidden reasoning.++use super::*;+use crate::exec_cell::CommandOutput;+use crate::exec_cell::model::ExecCall;+use crate::history_cell::HistoryCell;+use crate::history_cell::new_reasoning_summary_block;+use crate::history_cell::new_unified_exec_interaction;+use codex_app_server_protocol::CommandExecutionSource;+use pretty_assertions::assert_eq;+use std::path::Path;+use std::sync::Arc;+use std::time::Duration;++fn completed_read(name: &str, output: &str) -> ExecCell {+ let command = vec!["cat".to_owned(), name.to_owned()];+ let parsed = codex_shell_command::parse_command::parse_command(&command);+ ExecCell::new(+ ExecCall {+ call_id: name.to_owned(),+ command,+ parsed,+ output: Some(CommandOutput::new(/*exit_code*/ 0, output.to_owned())),+ source: CommandExecutionSource::UnifiedExecStartup,+ start_time: None,+ duration: Some(Duration::from_millis(/*millis*/ 5)),+ interaction_input: None,+ },+ /*animations_enabled*/ false,+ )+}++#[test]+fn raw_grouped_history_retains_terminal_input_and_omits_reasoning() {+ let mut group = completed_read("first.txt", "first output");+ group+ .group+ .push_detail(Arc::from(new_reasoning_summary_block(+ vec!["Inspecting the next file".to_owned()],+ Path::new("."),+ ) as Box<dyn HistoryCell>));+ group+ .group+ .push_detail(Arc::new(new_unified_exec_interaction(+ Some("cat first.txt".to_owned()),+ "continue\n".to_owned(),+ )));+ group+ .append_completed(completed_read("second.txt", "second output"))+ .expect("adjacent reads stay grouped");++ let raw = group+ .raw_lines()+ .iter()+ .map(Line::to_string)+ .collect::<Vec<_>>();+ let rich = group+ .transcript_lines(/*width*/ 80)+ .iter()+ .map(Line::to_string)+ .collect::<Vec<_>>()+ .join("\n");+ insta::assert_snapshot!(format!("Rich\n{rich}\n\nRaw\n{}", raw.join("\n")));++ let mut earlier = completed_read("earlier.txt", "earlier output");+ earlier+ .group+ .push_detail(Arc::from(new_reasoning_summary_block(+ vec!["Inspect the first file".to_owned()],+ Path::new("."),+ ) as Box<dyn HistoryCell>));+ earlier+ .group+ .push_detail(Arc::new(new_unified_exec_interaction(+ Some("cat earlier.txt".to_owned()),+ "next\n".to_owned(),+ )));+ let mut expected_raw = earlier.raw_lines();+ expected_raw.push(Line::from(""));+ expected_raw.extend(group.raw_lines());+ let mut expected_rich = earlier.transcript_hyperlink_lines(/*width*/ 80);+ expected_rich.push(HyperlinkLine::from(""));+ expected_rich.extend(group.transcript_hyperlink_lines(/*width*/ 80));+ group.prepend(earlier);+ assert_eq!(group.raw_lines(), expected_raw);+ assert_eq!(+ group.transcript_hyperlink_lines(/*width*/ 80),+ expected_rich+ );+}diff --git a/codex-rs/tui/src/history_cell/mcp.rs b/codex-rs/tui/src/history_cell/mcp.rsindex 62d912452f..9f80e5e5d7 100644--- a/codex-rs/tui/src/history_cell/mcp.rs+++ b/codex-rs/tui/src/history_cell/mcp.rs@@ -270,10 +270,10 @@ impl McpToolCallCell {continue;};for segment in text.lines() {- let line = Line::from(segment.to_owned().dim());if mode == McpToolCallRenderMode::Display {- preview.push_line(line);+ preview.push_line(Line::from(segment.dim()));} else {+ let line = Line::from(segment.to_owned().dim());lines.extend(adaptive_wrap_hyperlink_lines(&[HyperlinkLine::new(line)],options.clone(),@@ -285,10 +285,10 @@ impl McpToolCallCell {Some(Err(error)) => {let text = format!("Error: {error}");for segment in text.lines() {- let line = Line::from(segment.to_owned().dim());if mode == McpToolCallRenderMode::Display {- preview.push_line(line);+ preview.push_line(Line::from(segment.dim()));} else {+ let line = Line::from(segment.to_owned().dim());lines.extend(adaptive_wrap_hyperlink_lines(&[HyperlinkLine::new(line)],options.clone(),diff --git a/codex-rs/tui/src/history_cell/messages.rs b/codex-rs/tui/src/history_cell/messages.rsindex fad6be07eb..fb4385f26f 100644--- a/codex-rs/tui/src/history_cell/messages.rs+++ b/codex-rs/tui/src/history_cell/messages.rs@@ -318,9 +318,30 @@ pub(crate) struct ReasoningSummaryCell {/// Session cwd used to render local file links inside the reasoning body.cwd: PathBuf,transcript_only: bool,+ /// Persisted identity verifies page folds without comparing rendered reasoning text.+ #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+ source_item_id: Option<String>,}impl ReasoningSummaryCell {+ pub(crate) fn markdown_source(&self) -> &str {+ &self.content+ }++ pub(crate) fn set_source_item_id(&mut self, id: String) {+ self.source_item_id = Some(id);+ }++ #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+ pub(crate) fn source_item_id(&self) -> Option<&str> {+ self.source_item_id.as_deref()+ }++ #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+ pub(crate) fn is_transcript_only(&self) -> bool {+ self.transcript_only+ }+/// Create a reasoning summary cell that will render local file links relative to the session/// cwd active when the summary was recorded.pub(crate) fn new(header: String, content: String, cwd: &Path, transcript_only: bool) -> Self {@@ -329,31 +350,34 @@ impl ReasoningSummaryCell {content,cwd: cwd.to_path_buf(),transcript_only,+ source_item_id: None,}}- fn lines(&self, width: u16) -> Vec<Line<'static>> {- let mut lines: Vec<Line<'static>> = Vec::new();- append_markdown(+ fn lines(&self, width: u16) -> Vec<HyperlinkLine> {+ let lines = crate::markdown_render::render_markdown_lines_with_width_and_cwd(&self.content,crate::width::usable_content_width_u16(width, /*reserved_cols*/ 2),Some(self.cwd.as_path()),- &mut lines,);let summary_style = Style::default().dim().italic();let summary_lines = lines.into_iter().map(|mut line| {- line.spans = line+ line.line.spans = line+ .line.spans.into_iter().map(|span| span.patch_style(summary_style)).collect();+ if let Some(source) = &mut line.source {+ source.span_style = source.span_style.patch(summary_style);+ }line}).collect::<Vec<_>>();- adaptive_wrap_lines(+ crate::terminal_hyperlinks::adaptive_wrap_hyperlink_lines(&summary_lines,RtOptions::new(width as usize).initial_indent("• ".dim().into())@@ -364,6 +388,10 @@ impl ReasoningSummaryCell {impl HistoryCell for ReasoningSummaryCell {fn display_lines(&self, width: u16) -> Vec<Line<'static>> {+ visible_lines(self.display_hyperlink_lines(width))+ }++ fn display_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {if self.transcript_only {Vec::new()} else {@@ -372,6 +400,10 @@ impl HistoryCell for ReasoningSummaryCell {}fn transcript_lines(&self, width: u16) -> Vec<Line<'static>> {+ visible_lines(self.transcript_hyperlink_lines(width))+ }++ fn transcript_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {self.lines(width)}@@ -379,7 +411,7 @@ impl HistoryCell for ReasoningSummaryCell {if self.transcript_only {Vec::new()} else {- raw_lines_from_source(self.content.trim())+ raw_lines_from_source(self.markdown_source().trim())}}}@@ -686,7 +718,7 @@ pub(crate) fn new_spoken_user_prompt(message: String) -> UserHistoryCell {pub(crate) fn new_reasoning_summary_block(reasoning_parts: Vec<String>,cwd: &Path,-) -> Box<dyn HistoryCell> {+) -> Box<ReasoningSummaryCell> {let (header, content) = split_reasoning_summary_parts(&reasoning_parts);Box::new(ReasoningSummaryCell::new(header, content, cwd, /*transcript_only*/ true,diff --git a/codex-rs/tui/src/resume_picker.rs b/codex-rs/tui/src/resume_picker.rsindex 3e37641be1..03779c731c 100644--- a/codex-rs/tui/src/resume_picker.rs+++ b/codex-rs/tui/src/resume_picker.rs@@ -6756,7 +6756,7 @@ session_picker_view = "dense"}#[test]- fn thread_to_transcript_cells_shows_raw_reasoning_over_summary_when_enabled() {+ fn thread_to_transcript_cells_retains_summary_and_raw_reasoning_when_enabled() {use crate::thread_transcript::thread_to_transcript_cells;let thread_id = ThreadId::new();@@ -6819,8 +6819,7 @@ session_picker_view = "dense".collect::<Vec<_>>().join("\n");- assert!(rendered.contains("raw reasoning content"));- assert!(!rendered.contains("public summary"));+ assert_eq!(rendered, "• public summary\n \n raw reasoning content");}#[tokio::test]diff --git a/codex-rs/tui/src/thread_transcript.rs b/codex-rs/tui/src/thread_transcript.rsindex e10deb3286..0d77c0e31a 100644--- a/codex-rs/tui/src/thread_transcript.rs+++ b/codex-rs/tui/src/thread_transcript.rs@@ -1,4 +1,6 @@-//! Project individual persisted items into rich history cells without changing live state.+//! Project persisted items into the same rich cells as completed live output.+//! Tool grouping spans hidden reasoning but stops at visible content and turn boundaries.+//! Only one computer or exploration group can be pending at a time.use std::sync::Arc;@@ -22,11 +24,61 @@ use codex_protocol::items::UserMessageItem;use codex_utils_absolute_path::AbsolutePathBuf;use ratatui::style::Stylize as _;+mod activity_pages;+mod computer_groups;+mod exploration_groups;mod other_items;pub(crate) mod tools;+#[allow(+ unused_imports,+ reason = "Used by later layers of the TUI refresh stack."+)]+pub(crate) use activity_pages::fold_trailing_activity_details;+#[allow(+ unused_imports,+ reason = "Used by later layers of the TUI refresh stack."+)]+pub(crate) use activity_pages::is_hidden_activity_detail;+#[allow(+ unused_imports,+ reason = "Used by later layers of the TUI refresh stack."+)]+pub(crate) use computer_groups::join_computer_groups;+#[allow(+ unused_imports,+ reason = "Used by later layers of the TUI refresh stack."+)]+pub(crate) use computer_groups::older_computer_group;+#[allow(+ unused_imports,+ reason = "Used by later layers of the TUI refresh stack."+)]+pub(crate) use exploration_groups::join_exploration_groups;+#[allow(+ unused_imports,+ reason = "Used by later layers of the TUI refresh stack."+)]+pub(crate) use exploration_groups::older_exploration_group;+pub(crate) type TranscriptCells = Vec<Arc<dyn HistoryCell>>;+enum PendingActivity {+ Computer(crate::history_cell::ComputerActivityCell),+ Exploration(crate::exec_cell::ExecCell),+}++impl PendingActivity {+ fn flush(pending: &mut Option<Self>, cells: &mut TranscriptCells) {+ let cell: Arc<dyn HistoryCell> = match pending.take() {+ Some(Self::Computer(group)) => Arc::new(group),+ Some(Self::Exploration(group)) => Arc::new(group),+ None => return,+ };+ cells.push(cell);+ }+}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub(crate) enum RawReasoningVisibility {Hidden,@@ -68,13 +120,19 @@ pub(crate) fn thread_to_transcript_cells() -> TranscriptCells {let cwd = thread.cwd;let thread_id = ThreadId::from_string(&thread.id).ok();- let mut cells = thread_items_to_transcript_cells(- thread_id,- &cwd,- thread.turns.into_iter().flat_map(|turn| turn.items),- raw_reasoning_visibility,- config,- );+ let mut cells = thread+ .turns+ .into_iter()+ .flat_map(|turn| {+ thread_items_to_transcript_cells(+ thread_id,+ &cwd,+ turn.items,+ raw_reasoning_visibility,+ config,+ )+ })+ .collect::<TranscriptCells>();if cells.is_empty() {cells.push(Arc::new(PlainHistoryCell::new(vec!["No transcript content available".italic().dim().into(),@@ -94,18 +152,89 @@ pub(crate) fn thread_items_to_transcript_cells(thread_id.and_then(|thread_id| InlineVisualizationContext::from_config(config, thread_id))});let mut cells: TranscriptCells = Vec::new();+ let mut pending = None;for item in items {- if let Some(cell) = tools::historical_tool_fallback(&item) {- cells.push(Arc::new(cell));- } else {- cells.extend(item_to_cells(+ if matches!(item, ThreadItem::Reasoning { .. })+ && let Some(group) = &mut pending+ {+ for cell in item_to_cells(item,cwd,raw_reasoning_visibility,inline_visualization_context.clone(),- ));+ ) {+ match group {+ PendingActivity::Computer(group) => group.group.push_detail(cell),+ PendingActivity::Exploration(group) => group.group.push_detail(cell),+ }+ }+ continue;+ }+ if let Some(cell) = tools::historical_tool_fallback(&item) {+ PendingActivity::flush(&mut pending, &mut cells);+ cells.push(Arc::new(cell));+ continue;+ }+ match item {+ item @ ThreadItem::McpToolCall { .. } => {+ let Some(call) = tools::McpHistory::from_item(item) else {+ PendingActivity::flush(&mut pending, &mut cells);+ continue;+ };+ if call.invocation.is_computer_activity() {+ match &mut pending {+ Some(PendingActivity::Computer(group)) => {+ computer_groups::append(group, call);+ }+ Some(PendingActivity::Exploration(_)) | None => {+ PendingActivity::flush(&mut pending, &mut cells);+ let mut group = crate::history_cell::ComputerActivityCell::default();+ computer_groups::append(&mut group, call);+ pending = Some(PendingActivity::Computer(group));+ }+ }+ } else {+ PendingActivity::flush(&mut pending, &mut cells);+ let cell = call.into_cell();+ cells.push(Arc::new(cell));+ }+ }+ item @ ThreadItem::CommandExecution { .. } => {+ if matches!(pending, Some(PendingActivity::Computer(_))) {+ PendingActivity::flush(&mut pending, &mut cells);+ }+ if let Some(command) = tools::CommandHistory::from_item(item) {+ let newer = command.into_cell();+ if let Some(PendingActivity::Exploration(group)) = &mut pending {+ if let Err(newer) = group.append_completed(newer) {+ PendingActivity::flush(&mut pending, &mut cells);+ pending = Some(PendingActivity::Exploration(newer));+ }+ } else {+ pending = Some(PendingActivity::Exploration(newer));+ }+ if let Some(PendingActivity::Exploration(group)) = &pending+ && group.should_flush()+ {+ PendingActivity::flush(&mut pending, &mut cells);+ }+ }+ }+ item => {+ let projected = item_to_cells(+ item,+ cwd,+ raw_reasoning_visibility,+ inline_visualization_context.clone(),+ );+ if !projected.is_empty() {+ PendingActivity::flush(&mut pending, &mut cells);+ cells.extend(projected);+ }+ }}}+ PendingActivity::flush(&mut pending, &mut cells);cells}@@ -196,23 +325,28 @@ fn item_to_cells(}}ThreadItem::Reasoning {- summary, content, ..+ id,+ summary,+ content,} => {- let (header, text) =- if matches!(raw_reasoning_visibility, RawReasoningVisibility::Visible)- && !content.is_empty()- {- ("Reasoning".to_string(), content.join("\n\n"))- } else {- split_reasoning_summary_parts(&summary)- };+ let (header, mut text) = split_reasoning_summary_parts(&summary);+ if matches!(raw_reasoning_visibility, RawReasoningVisibility::Visible)+ && !content.is_empty()+ {+ if !text.is_empty() {+ text.push_str("\n\n");+ }+ text.push_str(&content.join("\n\n"));+ }if !text.trim().is_empty() {- cells.push(Arc::new(ReasoningSummaryCell::new(+ let mut cell = ReasoningSummaryCell::new(header,text,cwd.as_path(),- /*transcript_only*/ false,- )));+ /*transcript_only*/ true,+ );+ cell.set_source_item_id(id);+ cells.push(Arc::new(cell));}}item @ ThreadItem::CommandExecution { .. } => {@@ -220,11 +354,6 @@ fn item_to_cells(cells.push(Arc::new(command.into_cell()));}}- item @ ThreadItem::McpToolCall { .. } => {- if let Some(call) = tools::McpHistory::from_item(item) {- cells.push(Arc::new(call.into_cell()));- }- }other => cells.extend(other_items::cells(other, cwd)),}cellsdiff --git a/codex-rs/tui/src/thread_transcript/activity_pages.rs b/codex-rs/tui/src/thread_transcript/activity_pages.rsnew file mode 100644index 0000000000..2f44848c6b--- /dev/null+++ b/codex-rs/tui/src/thread_transcript/activity_pages.rs@@ -0,0 +1,65 @@+//! Attach transparent page-boundary details to a freshly rebuilt activity group.++use crate::exec_cell::ExecCell;+use crate::history_cell::ComputerActivityCell;+use crate::history_cell::HistoryCell;+use crate::history_cell::ReasoningSummaryCell;+use std::sync::Arc;++#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(crate) fn is_hidden_activity_detail(cell: &Arc<dyn HistoryCell>) -> bool {+ cell.as_any()+ .downcast_ref::<ReasoningSummaryCell>()+ .is_some_and(ReasoningSummaryCell::is_transcript_only)+}++/// Fold standalone reasoning using exact persisted identities from one turn.+///+/// An older page can arrive after the final reasoning page even with no newer group or live tail.+/// Rebuild only known completed calls and share their immutable details; never infer adjacency+/// from identical reasoning text or attach a detail from the next turn.+#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(crate) fn fold_trailing_activity_details(+ older: &Arc<dyn HistoryCell>,+ details: &[Arc<dyn HistoryCell>],+ turns: &[codex_app_server_protocol::Turn],+) -> Option<Arc<dyn HistoryCell>> {+ let (mut ids, retained) =+ if let Some(group) = older.as_any().downcast_ref::<ComputerActivityCell>() {+ (group.call_ids().collect::<Vec<_>>(), &group.group.details)+ } else {+ let group = older.as_any().downcast_ref::<ExecCell>()?;+ if !group.is_exploring_cell() || group.should_flush() {+ return None;+ }+ (+ group+ .iter_calls()+ .map(|call| call.call_id.as_str())+ .collect::<Vec<_>>(),+ &group.group.details,+ )+ };+ let count = ids.len();+ for detail in details {+ let detail = detail.as_any().downcast_ref::<ReasoningSummaryCell>()?;+ if !detail.is_transcript_only() {+ return None;+ }+ ids.push(detail.source_item_id()?);+ }+ let items = super::computer_groups::adjacent_activity_items(&ids, turns)?;+ let mut retained = retained.clone();+ for detail in details {+ retained.push(count, Arc::clone(detail));+ }+ if older.as_any().is::<ComputerActivityCell>() {+ let mut group = super::computer_groups::completed_group(items)?;+ group.group.details = retained;+ Some(Arc::new(group))+ } else {+ let mut group = super::exploration_groups::completed_group(items)?;+ group.group.details = retained;+ Some(Arc::new(group))+ }+}diff --git a/codex-rs/tui/src/thread_transcript/computer_groups.rs b/codex-rs/tui/src/thread_transcript/computer_groups.rsnew file mode 100644index 0000000000..d77dcc2f4f--- /dev/null+++ b/codex-rs/tui/src/thread_transcript/computer_groups.rs@@ -0,0 +1,111 @@+//! Assemble computer activity across hidden reasoning and repair history-page group boundaries.++use super::tools::McpHistory;+use crate::history_cell::ComputerActivityCell;+use crate::history_cell::HistoryCell;+use crate::history_cell::McpToolCallCell;+use codex_app_server_protocol::ThreadItem;+use codex_app_server_protocol::Turn;+use std::sync::Arc;++pub(super) fn append(group: &mut ComputerActivityCell, call: McpHistory) {+ let cell = McpToolCallCell::new(call.id, call.invocation, /*animations_enabled*/ false);+ group.complete(cell, call.duration, call.result);+}++/// Rebuild only an adjacent computer group, using its persisted IDs to verify the turn boundary.+#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(crate) fn join_computer_groups(+ older: &Arc<dyn HistoryCell>,+ newer: &Arc<dyn HistoryCell>,+ turns: &[Turn],+) -> Option<Arc<dyn HistoryCell>> {+ let older = older.as_any().downcast_ref::<ComputerActivityCell>()?;+ let newer = newer.as_any().downcast_ref::<ComputerActivityCell>()?;+ let mut group = completed_group(adjacent_items(older, newer, turns)?)?;+ group.group.details = newer.group.details.clone();+ group+ .group+ .details+ .prepend(older.group.details.clone(), older.call_ids().count());+ Some(Arc::new(group))+}++/// Restore only the older half; the caller retains the live half and its pending calls/timers.+#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(crate) fn older_computer_group(+ older: &dyn HistoryCell,+ newer: &ComputerActivityCell,+ turns: &[Turn],+) -> Option<ComputerActivityCell> {+ let older = older.as_any().downcast_ref::<ComputerActivityCell>()?;+ let items = adjacent_items(older, newer, turns)?;+ let older_items = items+ .iter()+ .filter(|item| !matches!(item, ThreadItem::Reasoning { .. }))+ .take(older.call_ids().count())+ .cloned()+ .collect::<Vec<_>>();+ let mut group = completed_group(&older_items)?;+ group.group.details = older.group.details.clone();+ Some(group)+}++#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+fn adjacent_items<'a>(+ older: &ComputerActivityCell,+ newer: &ComputerActivityCell,+ turns: &'a [Turn],+) -> Option<&'a [ThreadItem]> {+ let ids = older.call_ids().chain(newer.call_ids()).collect::<Vec<_>>();+ adjacent_activity_items(&ids, turns)+}++/// Validate source adjacency without mistaking invisible reasoning for an activity boundary.+#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(super) fn adjacent_activity_items<'a>(+ ids: &[&str],+ turns: &'a [Turn],+) -> Option<&'a [ThreadItem]> {+ let first = *ids.first()?;+ let (turn, start) = turns.iter().find_map(|turn| {+ turn.items+ .iter()+ .position(|item| item.id() == first)+ .map(|start| (turn, start))+ })?;+ let mut matched = 0;+ for (offset, item) in turn.items[start..].iter().enumerate() {+ if item.id() != ids[matched] {+ if matches!(item, ThreadItem::Reasoning { .. }) {+ continue;+ }+ return None;+ }+ matched += 1;+ if matched == ids.len() {+ return Some(&turn.items[start..=start + offset]);+ }+ }+ None+}++#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(super) fn completed_group(items: &[ThreadItem]) -> Option<ComputerActivityCell> {+ let mut group = None;+ for item in items {+ if matches!(item, ThreadItem::Reasoning { .. }) {+ continue;+ }+ let call = McpHistory::from_item(item.clone())?;+ if !call.invocation.is_computer_activity() {+ return None;+ }+ append(group.get_or_insert_default(), call);+ }+ group+}++#[cfg(test)]+#[path = "computer_groups_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/thread_transcript/computer_groups_tests.rs b/codex-rs/tui/src/thread_transcript/computer_groups_tests.rsnew file mode 100644index 0000000000..7bb259621e--- /dev/null+++ b/codex-rs/tui/src/thread_transcript/computer_groups_tests.rs@@ -0,0 +1,173 @@+//! Page boundaries must not change the compact or expanded rendering of computer activity.++use super::*;+use crate::thread_transcript::RawReasoningVisibility;+use crate::thread_transcript::TranscriptCells;+use crate::thread_transcript::thread_items_to_transcript_cells;+use codex_app_server_protocol::ThreadItem;+use codex_app_server_protocol::TurnItemsView;+use codex_app_server_protocol::TurnStatus;+use codex_utils_absolute_path::AbsolutePathBuf;+use pretty_assertions::assert_eq;++fn computer(id: &str) -> ThreadItem {+ serde_json::from_value(serde_json::json!({+ "type": "mcpToolCall", "id": id, "server": "cua_repl", "tool": "js",+ "status": "completed", "arguments": {"title": format!("Inspect {id}"), "code": "await cua.getState()"},+ "appContext": null, "pluginId": null, "readOnlyHint": null,+ "result": {"content": [{"type": "text", "text": format!("Result {id}")}], "structuredContent": null},+ "error": null, "durationMs": 10+ })).unwrap()+}++fn turn(id: &str, items: Vec<ThreadItem>) -> Turn {+ Turn {+ id: id.to_string(),+ items,+ items_view: TurnItemsView::Full,+ status: TurnStatus::Completed,+ error: None,+ started_at: None,+ completed_at: None,+ duration_ms: None,+ }+}++fn project(items: &[ThreadItem]) -> TranscriptCells {+ thread_items_to_transcript_cells(+ /*thread_id*/ None,+ &AbsolutePathBuf::current_dir().unwrap(),+ items.to_vec(),+ RawReasoningVisibility::Hidden,+ /*config*/ None,+ )+}++#[test]+fn every_page_split_retains_the_same_rich_computer_group() {+ let turns = vec![turn(+ "turn",+ vec![+ computer("first"),+ ThreadItem::Reasoning {+ id: "reasoning-first".to_owned(),+ summary: vec!["Inspect the second screen".to_owned()],+ content: Vec::new(),+ },+ computer("second"),+ computer("third"),+ ThreadItem::Reasoning {+ id: "reasoning-second".to_owned(),+ summary: vec!["Confirm the final screen".to_owned()],+ content: Vec::new(),+ },+ computer("last"),+ ],+ )];+ let items = &turns[0].items;+ let expected = project(items);+ for split in 1..items.len() {+ let older = project(&items[..split]);+ let newer = project(&items[split..]);+ let detail_count = newer+ .iter()+ .take_while(|cell| {+ crate::thread_transcript::activity_pages::is_hidden_activity_detail(cell)+ })+ .count();+ let older_group = if detail_count > 0 {+ crate::thread_transcript::activity_pages::fold_trailing_activity_details(+ &older[0],+ &newer[..detail_count],+ &turns,+ )+ .unwrap()+ } else {+ Arc::clone(&older[0])+ };+ let joined = join_computer_groups(&older_group, &newer[detail_count], &turns).unwrap();+ assert_eq!(+ joined.display_hyperlink_lines(/*width*/ 30),+ expected[0].display_hyperlink_lines(/*width*/ 30)+ );+ assert_eq!(+ joined.transcript_hyperlink_lines(/*width*/ 30),+ expected[0].transcript_hyperlink_lines(/*width*/ 30)+ );+ assert_eq!(joined.raw_lines(), expected[0].raw_lines());+ }+}++#[test]+fn successive_single_item_pages_reunite_without_duplicating_calls() {+ let turns = vec![turn(+ "turn",+ (0..6).map(|i| computer(&i.to_string())).collect(),+ )];+ let items = &turns[0].items;+ let mut joined = project(&items[5..]).remove(/*index*/ 0);+ for item in items[..5].iter().rev() {+ let older = project(std::slice::from_ref(item));+ joined = join_computer_groups(&older[0], &joined, &turns).unwrap();+ }+ let expected = project(items);+ assert_eq!(+ joined.transcript_lines(/*width*/ 80),+ expected[0].transcript_lines(/*width*/ 80)+ );+}++#[test]+fn joins_respect_actual_turns_and_intervening_items() {+ let first = computer("first");+ let last = computer("last");+ let older = project(std::slice::from_ref(&first));+ let newer = project(std::slice::from_ref(&last));+ let turns = vec![+ turn("first-turn", vec![first.clone()]),+ turn("last-turn", vec![last.clone()]),+ ];+ assert!(join_computer_groups(&older[0], &newer[0], &turns).is_none());+ let grouped = project(&[+ first.clone(),+ ThreadItem::Sleep(codex_app_server_protocol::SleepItem {+ id: "sleep".into(),+ duration_ms: 10,+ }),+ last.clone(),+ ]);+ let adjacent = project(&[first.clone(), last.clone()]);+ assert_eq!(grouped.len(), 1);+ assert_eq!(+ grouped[0].transcript_lines(/*width*/ 80),+ adjacent[0].transcript_lines(/*width*/ 80)+ );+ let mut turns = vec![turn(+ "turn",+ vec![+ first,+ ThreadItem::Reasoning {+ id: "reasoning".to_string(),+ summary: Vec::new(),+ content: Vec::new(),+ },+ last,+ ],+ )];+ let joined = join_computer_groups(&older[0], &newer[0], &turns)+ .expect("hidden reasoning retains the adjacent computer group");+ let expected = project(&turns[0].items);+ assert_eq!(+ joined.transcript_lines(/*width*/ 80),+ expected[0].transcript_lines(/*width*/ 80),+ );+ turns[0].items[1] = ThreadItem::AgentMessage {+ id: "message".to_string(),+ text: "Visible boundary".to_string(),+ phase: None,+ memory_citation: None,+ delivery: None,+ questions: None,+ };+ assert!(join_computer_groups(&older[0], &newer[0], &turns).is_none());+}diff --git a/codex-rs/tui/src/thread_transcript/exploration_groups.rs b/codex-rs/tui/src/thread_transcript/exploration_groups.rsnew file mode 100644index 0000000000..a7d9569040--- /dev/null+++ b/codex-rs/tui/src/thread_transcript/exploration_groups.rs@@ -0,0 +1,82 @@+//! Apply live exploration compatibility to replay and repair groups split by history pages.++use super::tools::CommandHistory;+use crate::exec_cell::ExecCell;+use crate::history_cell::HistoryCell;+use codex_app_server_protocol::ThreadItem;+use codex_app_server_protocol::Turn;+use std::sync::Arc;++#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(crate) fn join_exploration_groups(+ older: &Arc<dyn HistoryCell>,+ newer: &Arc<dyn HistoryCell>,+ turns: &[Turn],+) -> Option<Arc<dyn HistoryCell>> {+ let older = older.as_any().downcast_ref::<ExecCell>()?;+ let newer = newer.as_any().downcast_ref::<ExecCell>()?;+ let items = adjacent_items(older, newer, turns)?;+ let mut group = completed_group(items)?;+ group.group.details = newer.group.details.clone();+ group+ .group+ .details+ .prepend(older.group.details.clone(), older.group.calls.len());+ Some(Arc::new(group))+}++#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(crate) fn older_exploration_group(+ older: &dyn HistoryCell,+ newer: &ExecCell,+ turns: &[Turn],+) -> Option<ExecCell> {+ let older = older.as_any().downcast_ref::<ExecCell>()?;+ let items = adjacent_items(older, newer, turns)?;+ let older_items = items+ .iter()+ .filter(|item| !matches!(item, ThreadItem::Reasoning { .. }))+ .take(older.group.calls.len())+ .cloned()+ .collect::<Vec<_>>();+ let mut group = completed_group(&older_items)?;+ group.group.details = older.group.details.clone();+ Some(group)+}++#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+fn adjacent_items<'a>(+ older: &ExecCell,+ newer: &ExecCell,+ turns: &'a [Turn],+) -> Option<&'a [ThreadItem]> {+ if !older.is_exploring_cell() || older.should_flush() || !newer.is_exploring_cell() {+ return None;+ }+ let ids = older+ .iter_calls()+ .chain(newer.iter_calls())+ .map(|call| call.call_id.as_str())+ .collect::<Vec<_>>();+ super::computer_groups::adjacent_activity_items(&ids, turns)+}++#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]+pub(super) fn completed_group(items: &[ThreadItem]) -> Option<ExecCell> {+ let mut group: Option<ExecCell> = None;+ for item in items {+ if matches!(item, ThreadItem::Reasoning { .. }) {+ continue;+ }+ let call = CommandHistory::from_item(item.clone())?.into_cell();+ if !call.is_exploring_cell() {+ return None;+ }+ if let Some(group) = &mut group {+ group.append_completed(call).ok()?;+ } else {+ group = Some(call);+ }+ }+ group+}