Lightweight coding agent that runs in your terminal
Rust
Keep TUI exploration grouped across reasoning and nonzero exits (#46487)
Eric Traut71406edbd58e
diff --git a/codex-rs/tui/src/chatwidget/command_lifecycle.rs b/codex-rs/tui/src/chatwidget/command_lifecycle.rsindex 00e1ea2a6d..ddfeef26a2 100644--- a/codex-rs/tui/src/chatwidget/command_lifecycle.rs+++ b/codex-rs/tui/src/chatwidget/command_lifecycle.rs@@ -431,7 +431,6 @@ impl ChatWidget {self.request_redraw();}ExecEndTarget::NewCell => {- self.flush_active_cell();let mut cell = new_active_exec_command(id.clone(),command,@@ -442,12 +441,28 @@ impl ChatWidget {);let completed = cell.complete_call(&id, output, duration);debug_assert!(completed, "new exec cell should contain {id}");- if cell.should_flush() {- self.add_to_history(cell);- } else {- self.transcript.active_cell = Some(Box::new(cell));+ if let Some(active) = self+ .transcript+ .active_cell+ .as_mut()+ .and_then(|cell| cell.as_any_mut().downcast_mut::<ExecCell>())+ && !active.is_active()+ && active.is_exploring_cell()+ && cell.is_exploring_cell()+ {+ // Replayed commands have completion events without matching starts.+ active.calls.extend(cell.calls);self.bump_active_cell_revision();self.request_redraw();+ } else {+ self.flush_active_cell();+ if cell.should_flush() {+ self.add_to_history(cell);+ } else {+ self.transcript.active_cell = Some(Box::new(cell));+ self.bump_active_cell_revision();+ self.request_redraw();+ }}}}diff --git a/codex-rs/tui/src/chatwidget/streaming.rs b/codex-rs/tui/src/chatwidget/streaming.rsindex 5c1cc08f56..f1deccd655 100644--- a/codex-rs/tui/src/chatwidget/streaming.rs+++ b/codex-rs/tui/src/chatwidget/streaming.rs@@ -350,7 +350,20 @@ impl ChatWidget {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);- self.add_boxed_history(cell);+ if let Some(exec) = self+ .transcript+ .active_cell+ .as_mut()+ .and_then(|cell| cell.as_any_mut().downcast_mut::<ExecCell>())+ && exec.is_exploring_cell()+ && !exec.is_active()+ {+ // Keep adjacent exploration grouped while retaining reasoning in transcript order.+ exec.reasoning.push((exec.calls.len(), cell));+ self.bump_active_cell_revision();+ } else {+ self.add_boxed_history(cell);+ }}self.reasoning_buffer.clear();// Keep the last useful summary through tools and later empty items.diff --git a/codex-rs/tui/src/chatwidget/tests/exec_flow.rs b/codex-rs/tui/src/chatwidget/tests/exec_flow.rsindex 8df2eae2c4..5c23db1702 100644--- a/codex-rs/tui/src/chatwidget/tests/exec_flow.rs+++ b/codex-rs/tui/src/chatwidget/tests/exec_flow.rs@@ -141,12 +141,10 @@ async fn failed_exploration_keeps_overlapping_commands_active_until_all_finish()assert!(drain_insert_history(&mut rx).is_empty());end_exec(&mut chat, followup, "followup\n", "", /*exit_code*/ 0);- let cells = drain_insert_history(&mut rx);- assert_eq!(cells.len(), 1);- let history = lines_to_single_string(&cells[0]);- insta::assert_snapshot!(history, @r"+ assert!(drain_insert_history(&mut rx).is_empty());+ insta::assert_snapshot!(active_blob(&chat), @r"• Explored- └ List missing+ └ List missing (exit 1)Read foo.txt, bar.txt");@@ -154,10 +152,153 @@ async fn failed_exploration_keeps_overlapping_commands_active_until_all_finish()end_exec(&mut chat, later, "later\n", "", /*exit_code*/ 0);insta::assert_snapshot!(active_blob(&chat), @r"• Explored- └ Read later.txt+ └ List missing (exit 1)+ Read foo.txt, bar.txt, later.txt");}+#[tokio::test]+async fn exploration_nonzero_exits_remain_visible_beside_successful_reads() {+ let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ for (id, command, exit_code) in [+ ("read", "cat first.txt", 0),+ ("missing", "cat missing.txt", 1),+ ("later", "cat later.txt", 0),+ ("search", "rg absent .", 1),+ ("error", "rg text missing.txt", 2),+ ("compound", "cat existing.txt && rg absent .", 1),+ ] {+ let item = begin_exec(&mut chat, id, command);+ end_exec(&mut chat, item, "", "", exit_code);+ }+ insta::assert_snapshot!(active_blob(&chat));+ let statuses = chat+ .transcript+ .active_cell+ .as_ref()+ .unwrap()+ .display_lines(/*width*/ 80)+ .into_iter()+ .flat_map(|line| line.spans)+ .filter(|span| {+ span.content.starts_with(" (exit") || span.content.starts_with(" (command exit")+ })+ .map(|span| (span.content.into_owned(), span.style.fg))+ .collect::<Vec<_>>();+ assert_eq!(+ statuses,+ vec![+ (" (exit 1)".to_string(), Some(ratatui::style::Color::Red)),+ (" (exit 1)".to_string(), None),+ (" (exit 2)".to_string(), Some(ratatui::style::Color::Red)),+ (" (command exit 1)".to_string(), None),+ ]+ );+}++#[tokio::test]+async fn adjacent_exploration_groups_across_reasoning_live_and_replayed() {+ let mut renders = Vec::new();+ for replay in [false, true] {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.on_task_started();+ for (id, script, exit_code) in [+ ("list", "ls missing", 1),+ ("read", "cat index.html", 0),+ ("run", "echo boundary", 0),+ ("later", "cat later.txt", 0),+ ("after-message", "cat final.txt", 0),+ ] {+ let command = vec!["bash".to_string(), "-lc".to_string(), script.to_string()];+ let mut item = AppServerThreadItem::CommandExecution {+ model_context: None,+ id: id.to_string(),+ command: codex_shell_command::parse_command::shlex_join(&command),+ cwd: chat.config.cwd.clone().into(),+ process_id: None,+ plugin_id: None,+ script_path: None,+ source: ExecCommandSource::UnifiedExecStartup,+ status: AppServerCommandExecutionStatus::InProgress,+ command_actions: codex_shell_command::parse_command::parse_command(&command)+ .into_iter()+ .map(|parsed| {+ AppServerCommandAction::from_core_with_cwd(parsed, &chat.config.cwd)+ })+ .collect(),+ aggregated_output: Some(format!("{id} output\n")),+ exit_code: Some(exit_code),+ duration_ms: Some(5),+ };+ if !replay {+ handle_exec_begin(&mut chat, item.clone());+ }+ if let AppServerThreadItem::CommandExecution { status, .. } = &mut item {+ *status = if exit_code == 0 {+ AppServerCommandExecutionStatus::Completed+ } else {+ AppServerCommandExecutionStatus::Failed+ };+ }+ if replay {+ chat.replay_thread_item(item, "turn-1".to_string(), ReplayKind::ThreadSnapshot);+ } else {+ handle_exec_end(&mut chat, item);+ }+ if id == "list" {+ for summary in ["Inspecting the page", "Checking its contents"] {+ if replay {+ chat.replay_thread_item(+ AppServerThreadItem::Reasoning {+ id: summary.to_string(),+ summary: vec![summary.to_string()],+ content: Vec::new(),+ },+ "turn-1".to_string(),+ ReplayKind::ThreadSnapshot,+ );+ } else {+ chat.on_agent_reasoning_delta(summary.to_string());+ chat.on_agent_reasoning_final();+ }+ }+ }+ if id == "later" {+ complete_assistant_message(+ &mut chat,+ "message",+ "Checking one more file.",+ Some(MessagePhase::Commentary),+ );+ }+ }+ chat.flush_active_cell();+ let cells = std::iter::from_fn(|| rx.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => Some(cell),+ _ => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(cells.len(), 5);+ let mut render = String::new();+ for mode in ["Compact", "Expanded", "Raw"] {+ render.push_str(&format!("{mode}:\n"));+ for cell in &cells {+ let lines = match mode {+ "Compact" => cell.display_lines(/*width*/ 80),+ "Expanded" => cell.transcript_lines(/*width*/ 80),+ _ => cell.raw_lines(),+ };+ render.push_str(&lines_to_single_string(&lines));+ render.push('\n');+ }+ }+ renders.push(render);+ }+ assert_eq!(renders[0], renders[1]);+ insta::assert_snapshot!(renders[0]);+}+#[tokio::test]async fn replayed_commands_preserve_individual_output_and_failure_status() {let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__exec_flow__adjacent_exploration_groups_across_reasoning_live_and_replayed.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__exec_flow__adjacent_exploration_groups_across_reasoning_live_and_replayed.snapnew file mode 100644index 0000000000..d4e4fe5997--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__exec_flow__adjacent_exploration_groups_across_reasoning_live_and_replayed.snap@@ -0,0 +1,69 @@+---+source: tui/src/chatwidget/tests/exec_flow.rs+expression: "renders[0]"+---+Compact:+• Explored+ └ List missing (exit 1)+ Read index.html++• Ran echo boundary+ └ run output++• Explored+ └ Read later.txt++• Checking one more file.++• Explored+ └ Read final.txt++Expanded:+$ ls missing+list output+✗ (1) • 5ms++• Inspecting the page++• Checking its contents++$ cat index.html+read output+✓ • 5ms++$ echo boundary+run output+✓ • 5ms++$ cat later.txt+later output+✓ • 5ms++• Checking one more file.++$ cat final.txt+after-message output+✓ • 5ms++Raw:+$ ls missing+list output+✗ (1) • 5ms++$ cat index.html+read output+✓ • 5ms++$ echo boundary+run output+✓ • 5ms++$ cat later.txt+later output+✓ • 5ms++Checking one more file.++$ cat final.txt+after-message output+✓ • 5msdiff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__exec_flow__exploration_nonzero_exits_remain_visible_beside_successful_reads.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__exec_flow__exploration_nonzero_exits_remain_visible_beside_successful_reads.snapnew file mode 100644index 0000000000..9779d552ec--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__exec_flow__exploration_nonzero_exits_remain_visible_beside_successful_reads.snap@@ -0,0 +1,12 @@+---+source: tui/src/chatwidget/tests/exec_flow.rs+expression: active_blob(&chat)+---+• Explored+ └ Read first.txt+ Read missing.txt (exit 1)+ Read later.txt+ Search absent in . (exit 1)+ Search text in missing.txt (exit 2)+ Read existing.txt+ Search absent in . (command exit 1)diff --git a/codex-rs/tui/src/exec_cell/mod.rs b/codex-rs/tui/src/exec_cell/mod.rsindex 40bef5d6b3..033a949a80 100644--- a/codex-rs/tui/src/exec_cell/mod.rs+++ b/codex-rs/tui/src/exec_cell/mod.rs@@ -1,6 +1,7 @@mod live_output;mod model;mod render;+mod transcript;pub(crate) use model::CommandOutput;#[cfg(test)]diff --git a/codex-rs/tui/src/exec_cell/model.rs b/codex-rs/tui/src/exec_cell/model.rsindex e5fc309e33..3eb2a2431e 100644--- a/codex-rs/tui/src/exec_cell/model.rs+++ b/codex-rs/tui/src/exec_cell/model.rs@@ -4,12 +4,15 @@//! list/search commands. The chat widget relies on stable `call_id` matching to route progress and//! end events into the right cell, and it treats "call id not found" as a real signal (for//! example, an orphan end that should render as a separate history entry).+//! Transcript-only reasoning stays inside completed exploration groups so it does not split their+//! compact display, while the expanded transcript retains its position between commands.use std::borrow::Cow;use std::time::Duration;use std::time::Instant;use super::live_output::LiveCommandOutput;+use crate::history_cell::HistoryCell;use codex_app_server_protocol::CommandExecutionSource as ExecCommandSource;use codex_protocol::parse_command::ParsedCommand;use itertools::Either;@@ -75,6 +78,8 @@ pub(crate) struct ExecCall {#[derive(Debug)]pub(crate) struct ExecCell {pub(crate) calls: Vec<ExecCall>,+ /// Transcript-only reasoning, paired with the number of calls preceding it.+ pub(crate) reasoning: Vec<(usize, Box<dyn HistoryCell>)>,animations_enabled: bool,}@@ -82,6 +87,7 @@ impl ExecCell {pub(crate) fn new(call: ExecCall, animations_enabled: bool) -> Self {Self {calls: vec![call],+ reasoning: Vec::new(),animations_enabled,}}@@ -133,14 +139,7 @@ impl ExecCell {}pub(crate) fn should_flush(&self) -> bool {- if self.calls.iter().any(|call| {- call.output- .as_ref()- .is_some_and(|output| output.exit_code != 0)- }) {- return !self.is_active();- }-+ // Exploration stays open for adjacent calls, including after a failed read/list/search.!self.is_exploring_cell() && self.calls.iter().all(|c| c.duration.is_some())}diff --git a/codex-rs/tui/src/exec_cell/render.rs b/codex-rs/tui/src/exec_cell/render.rsindex ed091515d3..13574fe7fa 100644--- a/codex-rs/tui/src/exec_cell/render.rs+++ b/codex-rs/tui/src/exec_cell/render.rs@@ -5,6 +5,7 @@ use super::model::ExecCall;use super::model::ExecCell;use crate::exec_command::strip_bash_lc_and_escape;use crate::history_cell::HistoryCell;+use crate::history_cell::HistoryRenderMode;use crate::history_cell::plain_lines;use crate::motion::MotionMode;use crate::motion::ReducedMotionIndicator;@@ -15,12 +16,10 @@ use crate::render::line_utils::push_owned_lines;use crate::ui_consts::TRANSCRIPT_HINT;use crate::wrapping::RtOptions;use crate::wrapping::adaptive_wrap_line;-use crate::wrapping::adaptive_wrap_lines;use codex_ansi_escape::ansi_escape_line;use codex_app_server_protocol::CommandExecutionSource as ExecCommandSource;use codex_protocol::parse_command::ParsedCommand;use codex_shell_command::bash::extract_bash_command;-use codex_utils_elapsed::format_duration;use itertools::Itertools;use ratatui::prelude::*;use ratatui::style::Modifier;@@ -193,53 +192,11 @@ impl HistoryCell for ExecCell {}fn transcript_lines(&self, width: u16) -> Vec<Line<'static>> {- let mut lines: Vec<Line<'static>> = vec![];- for (i, call) in self.iter_calls().enumerate() {- if i > 0 {- lines.push("".into());- }- let script = strip_bash_lc_and_escape(&call.command);- let highlighted_script = highlight_bash_to_lines(&script);- let cmd_display = adaptive_wrap_lines(- &highlighted_script,- RtOptions::new(width as usize)- .initial_indent("$ ".magenta().into())- .subsequent_indent(" ".into()),- );- lines.extend(cmd_display);-- if let Some(output) = call.output.as_ref() {- if !call.is_unified_exec_interaction() {- let wrap_width = width.max(1) as usize;- let wrap_opts = RtOptions::new(wrap_width);- for unwrapped in output- .transcript_lines()- .map(|line| ansi_escape_line(line.as_ref()))- {- let wrapped = adaptive_wrap_line(&unwrapped, wrap_opts.clone());- push_owned_lines(&wrapped, &mut lines);- }- }- if let Some(duration) = call.duration {- let duration = format_duration(duration);- let mut result: Line = if output.exit_code == 0 {- Line::from("✓".green().bold())- } else {- Line::from(vec![- "✗".red().bold(),- format!(" ({})", output.exit_code).into(),- ])- };- result.push_span(format!(" • {duration}").dim());- lines.push(result);- }- }- }- lines+ self.detailed_lines(width, HistoryRenderMode::Rich)}fn raw_lines(&self) -> Vec<Line<'static>> {- plain_lines(self.transcript_lines(u16::MAX))+ plain_lines(self.detailed_lines(u16::MAX, HistoryRenderMode::Raw))}}@@ -270,18 +227,27 @@ impl ExecCell {let mut calls = self.calls.as_slice();let mut out_indented = Vec::new();+ let nonzero_exit = |call: &ExecCall| {+ call.duration+ .and(call.output.as_ref())+ .map(|output| output.exit_code)+ .filter(|code| *code != 0)+ };while let Some((call, remaining)) = calls.split_first() {+ let exit_code = nonzero_exit(call);let reads_only = call.parsed.iter().all(|parsed| matches!(parsed, ParsedCommand::Read { .. }));- let group_len = if reads_only {+ let group_len = if reads_only && exit_code.is_none() {1 + remaining.iter().take_while(|next| {- next.parsed- .iter()- .all(|parsed| matches!(parsed, ParsedCommand::Read { .. }))+ nonzero_exit(next).is_none()+ && next+ .parsed+ .iter()+ .all(|parsed| matches!(parsed, ParsedCommand::Read { .. }))}).count()} else {@@ -331,7 +297,31 @@ impl ExecCell {lines};- for (title, line) in call_lines {+ let line_count = call_lines.len();+ for (index, (title, mut line)) in call_lines.into_iter().enumerate() {+ if let Some(code) = exit_code+ && index + 1 == line_count+ {+ // A compound command has one exit code, not an outcome for each parsed action.+ let status = if call.parsed.len() > 1 {+ format!(" (command exit {code})")+ } else {+ format!(" (exit {code})")+ };+ // Search exit 1 can mean no matches; report the code without calling it a failure.+ line.push(+ if code == 1+ && call+ .parsed+ .iter()+ .any(|p| matches!(p, ParsedCommand::Search { .. }))+ {+ status.dim()+ } else {+ status.red()+ },+ );+ }let line = Line::from(line);let initial_indent = Line::from(vec![title.cyan(), " ".into()]);let subsequent_indent = " ".repeat(initial_indent.width()).into();diff --git a/codex-rs/tui/src/exec_cell/transcript.rs b/codex-rs/tui/src/exec_cell/transcript.rsnew file mode 100644index 0000000000..f25e766904--- /dev/null+++ b/codex-rs/tui/src/exec_cell/transcript.rs@@ -0,0 +1,76 @@+//! Expanded command history, preserving reasoning between grouped exploration calls.+//!+//! Compact history groups adjacent exploration; expanded history retains chronological details,+//! and raw history continues to omit transcript-only reasoning.++use super::model::ExecCell;+use crate::exec_command::strip_bash_lc_and_escape;+use crate::history_cell::HistoryRenderMode;+use crate::render::highlight::highlight_bash_to_lines;+use crate::render::line_utils::push_owned_lines;+use crate::wrapping::RtOptions;+use crate::wrapping::adaptive_wrap_line;+use crate::wrapping::adaptive_wrap_lines;+use codex_ansi_escape::ansi_escape_line;+use codex_utils_elapsed::format_duration;+use ratatui::prelude::*;++impl ExecCell {+ pub(super) fn detailed_lines(&self, width: u16, mode: HistoryRenderMode) -> Vec<Line<'static>> {+ let mut lines: Vec<Line<'static>> = vec![];+ let mut reasoning = self.reasoning.iter().peekable();+ for (i, call) in self.iter_calls().enumerate() {+ if i > 0 {+ lines.push("".into());+ }+ let script = strip_bash_lc_and_escape(&call.command);+ let highlighted_script = highlight_bash_to_lines(&script);+ let cmd_display = adaptive_wrap_lines(+ &highlighted_script,+ RtOptions::new(width as usize)+ .initial_indent("$ ".magenta().into())+ .subsequent_indent(" ".into()),+ );+ lines.extend(cmd_display);++ if let Some(output) = call.output.as_ref() {+ if !call.is_unified_exec_interaction() {+ let wrap_width = width.max(1) as usize;+ let wrap_opts = RtOptions::new(wrap_width);+ for unwrapped in output+ .transcript_lines()+ .map(|line| ansi_escape_line(line.as_ref()))+ {+ let wrapped = adaptive_wrap_line(&unwrapped, wrap_opts.clone());+ push_owned_lines(&wrapped, &mut lines);+ }+ }+ if let Some(duration) = call.duration {+ let duration = format_duration(duration);+ let mut result: Line = if output.exit_code == 0 {+ Line::from("✓".green().bold())+ } else {+ Line::from(vec![+ "✗".red().bold(),+ format!(" ({})", output.exit_code).into(),+ ])+ };+ result.push_span(format!(" • {duration}").dim());+ lines.push(result);+ }+ }+ if mode == HistoryRenderMode::Rich {+ while let Some((_, cell)) =+ reasoning.next_if(|(after_calls, _)| *after_calls == i + 1)+ {+ let reasoning_lines = cell.transcript_lines(width);+ if !reasoning_lines.is_empty() {+ lines.push("".into());+ lines.extend(reasoning_lines);+ }+ }+ }+ }+ lines+ }+}