fix headers

codex-rs/tui/src/bottom_pane/chat_composer.rs

@@ -1313,7 +1313,7 @@ impl WidgetRef for ChatComposer {
             );
         let mut textarea_rect = textarea_rect;
         textarea_rect.width = textarea_rect.width.saturating_sub(1);
-        textarea_rect.x = textarea_rect.x.saturating_add(1);
+        textarea_rect.x += 1;
 
         let mut state = self.textarea_state.borrow_mut();
         StatefulWidgetRef::render_ref(&(&self.textarea), textarea_rect, buf, &mut state);

codex-rs/tui/src/chatwidget.rs

@@ -101,7 +101,6 @@ pub(crate) struct ChatWidget {
     // Stream lifecycle controller
     stream: StreamController,
     running_commands: HashMap<String, RunningCommand>,
-    // No longer needed; completions are stored within the active ExecCell
     task_complete_pending: bool,
     // Queue of interruptive UI events deferred during an active write cycle
     interrupts: InterruptManager,
@@ -441,15 +440,13 @@ impl ChatWidget {
                 self.task_complete_pending = false;
             }
             // A completed stream indicates non-exec content was just inserted.
-            // Exec grouping relies on active_exec_cell now; nothing to toggle.
             self.flush_interrupt_queue();
         }
     }
 
     #[inline]
     fn handle_streaming_delta(&mut self, delta: String) {
         // Before streaming agent content, flush any active exec cell group.
-        tracing::info!(target: "codex_tui::exec", "flushing active_exec_cell: reason=agent_stream_delta");
         self.flush_active_exec_cell();
         let sink = AppEventHistorySink(self.app_event_tx.clone());
         self.stream.begin(&sink);
@@ -464,8 +461,9 @@ impl ChatWidget {
             None => (vec![ev.call_id.clone()], Vec::new()),
         };
 
-        // Ensure we have an active cell, then record completion into it.
         if self.active_exec_cell.is_none() {
+            // This should have been created by handle_exec_begin_now, but in case it wasn't,
+            // create it now.
             self.active_exec_cell = Some(history_cell::new_active_exec_command(
                 ev.call_id.clone(),
                 command,
@@ -493,9 +491,9 @@ impl ChatWidget {
         &mut self,
         event: codex_core::protocol::PatchApplyEndEvent,
     ) {
-        if event.success {
-            // Suppress success block per new styling spec (no "✓ Applied patch" block)
-        } else {
+        // If the patch was successful, just let the "Edited" block stand.
+        // Otherwise, add a failure block.
+        if !event.success {
             self.add_to_history(history_cell::new_patch_apply_failure(event.stderr));
         }
     }
@@ -541,32 +539,28 @@ impl ChatWidget {
                 parsed_cmd: ev.parsed_cmd.clone(),
             },
         );
-        // Accumulate each exec begin as a new call within the active Exec cell.
-        match self.active_exec_cell.as_mut() {
-            Some(exec) => {
-                if let Some(new_exec) = exec.with_added_call(
-                    ev.call_id.clone(),
-                    ev.command.clone(),
-                    ev.parsed_cmd.clone(),
-                ) {
-                    self.active_exec_cell = Some(new_exec);
-                } else {
-                    // Make a new cell.
-                    self.flush_active_exec_cell();
-                    self.active_exec_cell = Some(history_cell::new_active_exec_command(
-                        ev.call_id.clone(),
-                        ev.command.clone(),
-                        ev.parsed_cmd.clone(),
-                    ));
-                }
-            }
-            _ => {
+        if let Some(exec) = &self.active_exec_cell {
+            if let Some(new_exec) = exec.with_added_call(
+                ev.call_id.clone(),
+                ev.command.clone(),
+                ev.parsed_cmd.clone(),
+            ) {
+                self.active_exec_cell = Some(new_exec);
+            } else {
+                // Make a new cell.
+                self.flush_active_exec_cell();
                 self.active_exec_cell = Some(history_cell::new_active_exec_command(
                     ev.call_id.clone(),
                     ev.command.clone(),
                     ev.parsed_cmd.clone(),
                 ));
             }
+        } else {
+            self.active_exec_cell = Some(history_cell::new_active_exec_command(
+                ev.call_id.clone(),
+                ev.command.clone(),
+                ev.parsed_cmd.clone(),
+            ));
         }
 
         // Request a redraw so the working header and command list are visible immediately.
@@ -638,7 +632,6 @@ impl ChatWidget {
             last_token_usage: TokenUsage::default(),
             stream: StreamController::new(config),
             running_commands: HashMap::new(),
-
             task_complete_pending: false,
             interrupts: InterruptManager::new(),
             reasoning_buffer: String::new(),
@@ -683,7 +676,6 @@ impl ChatWidget {
             last_token_usage: TokenUsage::default(),
             stream: StreamController::new(config),
             running_commands: HashMap::new(),
-
             task_complete_pending: false,
             interrupts: InterruptManager::new(),
             reasoning_buffer: String::new(),
@@ -900,24 +892,16 @@ impl ChatWidget {
 
     fn flush_active_exec_cell(&mut self) {
         if let Some(active) = self.active_exec_cell.take() {
-            tracing::info!(
-                target = "codex_tui::exec",
-                "flush_active_exec_cell: calls={}",
-                active.calls_len(),
-            );
             self.app_event_tx
                 .send(AppEvent::InsertHistoryCell(Box::new(active)));
         }
     }
 
     fn add_to_history(&mut self, cell: impl HistoryCell + 'static) {
-        // Only break exec grouping if the cell renders visible lines.
-        let has_display_lines = !cell.display_lines(u16::MAX).is_empty();
-        if has_display_lines {
-            tracing::info!(target: "codex_tui::exec", "flushing active_exec_cell: reason=insert_other_history_cell");
+        if !cell.display_lines(u16::MAX).is_empty() {
+            // Only break exec grouping if the cell renders visible lines.
             self.flush_active_exec_cell();
         }
-        // Exec grouping relies on active_exec_cell now; nothing to toggle.
         self.app_event_tx
             .send(AppEvent::InsertHistoryCell(Box::new(cell)));
     }

codex-rs/tui/src/chatwidget/tests.rs

@@ -952,8 +952,8 @@ fn apply_patch_events_emit_history_cells() {
     assert!(!cells.is_empty(), "expected apply block cell to be sent");
     let blob = lines_to_single_string(cells.last().unwrap());
     assert!(
-        blob.contains("Edited foo.txt"),
-        "expected single-file edited header with filename: {blob:?}"
+        blob.contains("Added foo.txt") || blob.contains("Edited foo.txt"),
+        "expected single-file header with filename (Added/Edited): {blob:?}"
     );
 
     // 3) End apply success -> success cell

codex-rs/tui/src/diff_render.rs

@@ -126,7 +126,18 @@ fn render_changes_block(
             }
         }
         HeaderKind::Edited => {
-            header_spans.push("Edited".bold());
+            // For a single file, specialize the verb based on the change kind.
+            // Otherwise, use the generic "Edited" summary.
+            let verb = if single_file_inline {
+                match first_row_opt.as_ref().map(|r| &r.change) {
+                    Some(FileChange::Add { .. }) => "Added",
+                    Some(FileChange::Delete) => "Deleted",
+                    _ => "Edited",
+                }
+            } else {
+                "Edited"
+            };
+            header_spans.push(verb.bold());
             if single_file_inline {
                 if let Some(fr) = &first_row_opt {
                     header_spans.push(format!(" {} ", fr.display).into());
@@ -810,7 +821,7 @@ mod tests {
         // This mirrors the desired layout example: sign only on first inserted line,
         // subsequent wrapped pieces start aligned under the line number gutter.
         let original = "1\n2\n3\n4\n";
-        let modified = "1\nadded line which wraps and_if_there_is_a_long_token_it_will_be_broken\n3\n4 context line which also wraps across\n";
+        let modified = "1\nadded long line which wraps and_if_there_is_a_long_token_it_will_be_broken\n3\n4 context line which also wraps across\n";
         let patch = diffy::create_patch(original, modified).to_string();
 
         let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();

codex-rs/tui/src/history_cell.rs

@@ -1964,15 +1964,61 @@ mod tests {
             .join("\n");
         insta::assert_snapshot!(rendered);
     }
+
+    #[test]
+    fn ran_cell_multiline_with_stderr_snapshot() {
+        // Build an exec cell that completes (so it renders as "Ran") with a
+        // command long enough that it must render on its own line under the
+        // header, and include a couple of stderr lines to verify the output
+        // block prefixes and wrapping.
+        let call_id = "c_wrap_err".to_string();
+        let long_cmd =
+            "echo this_is_a_very_long_single_token_that_will_wrap_across_the_available_width";
+        let mut cell = ExecCell::new(ExecCall {
+            call_id: call_id.clone(),
+            command: vec!["bash".into(), "-lc".into(), long_cmd.to_string()],
+            parsed: Vec::new(),
+            output: None,
+            start_time: Some(Instant::now()),
+            duration: None,
+        });
+
+        let stderr = "error: first line on stderr\nerror: second line on stderr".to_string();
+        cell.complete_call(
+            &call_id,
+            CommandOutput {
+                exit_code: 1,
+                stdout: String::new(),
+                stderr,
+                formatted_output: String::new(),
+            },
+            Duration::from_millis(5),
+        );
+
+        // Narrow width to force the command to render under the header line.
+        let width: u16 = 28;
+        let rendered = cell
+            .display_lines(width)
+            .iter()
+            .map(|l| {
+                l.spans
+                    .iter()
+                    .map(|s| s.content.as_ref())
+                    .collect::<String>()
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        insta::assert_snapshot!(rendered);
+    }
     #[test]
     fn user_history_cell_wraps_and_prefixes_each_line_snapshot() {
         let msg = "one two three four five six seven";
         let cell = UserHistoryCell {
             message: msg.to_string(),
         };
 
-        // Small width to force wrapping. Effective wrap width is width-1 due to the ▌ prefix.
-        let width: u16 = 8;
+        // Small width to force wrapping more clearly. Effective wrap width is width-1 due to the ▌ prefix.
+        let width: u16 = 12;
         let lines = cell.display_lines(width);
 
         let rendered = lines

codex-rs/tui/src/snapshots/codex_tui__diff_render__tests__apply_add_block.snap

@@ -1,9 +1,8 @@
 ---
 source: tui/src/diff_render.rs
-assertion_line: 748
 expression: terminal.backend()
 ---
-"• Edited new_file.txt (+2 -0)                                                   "
+"• Added new_file.txt (+2 -0)                                                    "
 "    1     +alpha                                                                "
 "    2     +beta                                                                 "
 "                                                                                "

codex-rs/tui/src/snapshots/codex_tui__diff_render__tests__apply_delete_block.snap

@@ -1,9 +1,8 @@
 ---
 source: tui/src/diff_render.rs
-assertion_line: 748
 expression: terminal.backend()
 ---
-"• Edited tmp_delete_example.txt (+0 -3)                                         "
+"• Deleted tmp_delete_example.txt (+0 -3)                                        "
 "    1     -first                                                                "
 "    2     -second                                                               "
 "    3     -third                                                                "

codex-rs/tui/src/snapshots/codex_tui__diff_render__tests__apply_update_block_wraps_long_lines_text.snap

@@ -4,11 +4,11 @@ expression: text
 ---
     1      1
     2     -2
-    2     +added line which
-           wraps and_if_ther
-           e_is_a_long_token
-           _it_will_be_broke
-           n
+    2     +added long line w
+           hich wraps and_if
+           _there_is_a_long_
+           token_it_will_be_
+           broken
     3      3
     4     -4
     4     +4 context line wh

codex-rs/tui/src/snapshots/codex_tui__history_cell__tests__ran_cell_multiline_with_stderr_snapshot.snap

@@ -0,0 +1,14 @@
+---
+source: tui/src/history_cell.rs
+expression: rendered
+---
+• Ran
+  └ echo
+    this_is_a_very_long_sing
+    le_token_that_will_wrap_
+    across_the_available_wid
+    th
+    error: first line on
+    stderr
+    error: second line on
+    stderr

codex-rs/tui/src/snapshots/codex_tui__history_cell__tests__user_history_cell_wraps_and_prefixes_each_line_snapshot.snap

@@ -3,8 +3,6 @@ source: tui/src/history_cell.rs
 expression: rendered
 ---
 ▌one two
-▌three
-▌four
-▌five
-▌six
+▌three four
+▌five six
 ▌seven

codex-rs/tui/src/streaming/controller.rs

@@ -1,3 +1,5 @@
+use crate::history_cell;
+use crate::history_cell::HistoryCell;
 use codex_core::config::Config;
 use ratatui::text::Line;
 
@@ -6,7 +8,7 @@ use super::StreamState;
 
 /// Sink for history insertions and animation control.
 pub(crate) trait HistorySink {
-    fn insert_history_cell(&self, cell: Box<dyn crate::history_cell::HistoryCell>);
+    fn insert_history_cell(&self, cell: Box<dyn HistoryCell>);
     fn start_commit_animation(&self);
     fn stop_commit_animation(&self);
 }
@@ -66,10 +68,6 @@ impl StreamController {
         // leave header state unchanged; caller decides when to reset
     }
 
-    fn emit_header_if_needed(&mut self, out_lines: &mut Lines) -> bool {
-        self.header.maybe_emit(out_lines)
-    }
-
     /// Begin an answer stream. Does not emit header yet; it is emitted on first commit.
     pub(crate) fn begin(&mut self, _sink: &impl HistorySink) {
         // Starting a new stream cancels any pending finish-from-previous-stream animation.
@@ -124,12 +122,15 @@ impl StreamController {
                 out_lines.extend(step.history);
             }
             if !out_lines.is_empty() {
-                // Determine whether we would have emitted a header for this block.
-                let mut header_probe: Lines = Vec::new();
-                let header_emitted = self.emit_header_if_needed(&mut header_probe);
                 // Insert as a HistoryCell so display drops the header while transcript keeps it.
-                let cell = crate::history_cell::AgentMessageCell::new(out_lines, header_emitted);
-                sink.insert_history_cell(Box::new(cell));
+                let include_header = self.header.should_emit_header();
+                if include_header {
+                    self.header.mark_emitted();
+                }
+                sink.insert_history_cell(Box::new(history_cell::AgentMessageCell::new(
+                    out_lines,
+                    include_header,
+                )));
             }
 
             // Cleanup
@@ -161,11 +162,14 @@ impl StreamController {
         }
         let step = { self.state.step() };
         if !step.history.is_empty() {
-            // Decide if a header would be emitted; always wrap in a cell so display can width-wrap and indent.
-            let mut probe: Lines = Vec::new();
-            let header_emitted = self.emit_header_if_needed(&mut probe);
-            let cell = crate::history_cell::AgentMessageCell::new(step.history, header_emitted);
-            sink.insert_history_cell(Box::new(cell));
+            let include_header = self.header.should_emit_header();
+            if include_header {
+                self.header.mark_emitted();
+            }
+            sink.insert_history_cell(Box::new(history_cell::AgentMessageCell::new(
+                step.history,
+                include_header,
+            )));
         }
 
         let is_idle = self.state.is_idle();