Fix background task UI and pending Esc handling

Author: LEON-gittech

codex-rs/tui/src/app.rs

@@ -1120,7 +1120,11 @@ See the Codex keymap documentation for supported actions and examples."
                 TuiEvent::Draw | TuiEvent::Resize => {
                     if self.backtrack_render_pending {
                         self.backtrack_render_pending = false;
-                        self.render_transcript_once(tui);
+                        if let Err(err) = self.reflow_transcript_now(tui) {
+                            tracing::warn!(error = %err, "failed to reflow transcript after backtrack");
+                            self.chat_widget
+                                .add_error_message(format!("Failed to redraw transcript: {err}"));
+                        }
                     }
                     self.chat_widget.maybe_post_pending_notification(tui);
                     if self

codex-rs/tui/src/app_backtrack.rs

@@ -255,20 +255,6 @@ impl App {
         }
     }
 
-    /// Re-render the full transcript into the terminal scrollback in one call.
-    /// Useful when switching sessions to ensure prior history remains visible.
-    pub(crate) fn render_transcript_once(&mut self, tui: &mut tui::Tui) {
-        if !self.transcript_cells.is_empty() {
-            let width = tui.terminal.last_known_screen_size.width;
-            for cell in &self.transcript_cells {
-                tui.insert_history_lines_with_wrap_policy(
-                    cell.display_lines_for_mode(width, self.chat_widget.history_render_mode()),
-                    self.history_line_wrap_policy(),
-                );
-            }
-        }
-    }
-
     /// Initialize backtrack state and show composer hint.
     fn prime_backtrack(&mut self) {
         self.backtrack.primed = true;

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

@@ -29,6 +29,9 @@ pub(crate) enum BackgroundTaskKind {
 pub(crate) struct BackgroundTaskItem {
     pub(crate) kind: BackgroundTaskKind,
     pub(crate) title: String,
+    pub(crate) role: Option<String>,
+    pub(crate) task: Option<String>,
+    pub(crate) elapsed: Option<String>,
     pub(crate) detail: Vec<String>,
     pub(crate) status: Option<String>,
     pub(crate) output_lines: Vec<String>,
@@ -210,11 +213,17 @@ impl BackgroundTasksView {
         let mut lines = vec![
             "Shell details".bold().into(),
             status_line(item.status.as_deref().unwrap_or("running")),
-            "".into(),
-            label_value_line("Command", &item.title),
-            "".into(),
-            "Output".bold().into(),
         ];
+        if let Some(elapsed) = item.elapsed.as_deref() {
+            lines.push(label_value_line("Running", elapsed));
+        }
+        lines.push("".into());
+        lines.push(label_value_line("Command", &item.title));
+        if let Some(task) = item.task.as_deref() {
+            lines.push(label_value_line("Task", task));
+        }
+        lines.push("".into());
+        lines.push("Output".bold().into());
 
         if item.output_lines.is_empty() {
             lines.push("  No output yet.".italic().into());
@@ -246,9 +255,19 @@ impl BackgroundTasksView {
             "Agent details".bold().into(),
             label_value_line("Agent", &item.title),
         ];
+        if let Some(role) = item.role.as_deref() {
+            lines.push(label_value_line("Role", role));
+        }
         if let Some(status) = item.status.as_deref() {
             lines.push(status_line(status));
         }
+        if let Some(elapsed) = item.elapsed.as_deref() {
+            lines.push(label_value_line("Running", elapsed));
+        }
+        if let Some(task) = item.task.as_deref() {
+            lines.push("".into());
+            lines.push(label_value_line("Task", task));
+        }
 
         lines.push("".into());
         lines.push("Progress".bold().into());
@@ -364,7 +383,17 @@ fn append_section(
             title.push(": ".dim());
             title.push(status.to_string().dim());
         }
+        if let Some(elapsed) = item.elapsed.as_deref() {
+            title.push(" · ".dim());
+            title.push(elapsed.to_string().dim());
+        }
         lines.push(Line::from(title));
+        if let Some(role) = item.role.as_deref() {
+            lines.push(label_value_line("    Role", role));
+        }
+        if let Some(task) = item.task.as_deref() {
+            lines.push(label_value_line("    Task", task));
+        }
         for detail in item.detail.iter().take(2) {
             lines.push(Line::from(vec!["    ↳ ".dim(), detail.clone().dim()]));
         }

codex-rs/tui/src/chatwidget.rs

@@ -317,6 +317,7 @@ use crate::slash_command::SlashCommand;
 use crate::status::RateLimitSnapshotDisplay;
 use crate::status_indicator_widget::STATUS_DETAILS_DEFAULT_MAX_LINES;
 use crate::status_indicator_widget::StatusDetailsCapitalization;
+use crate::status_indicator_widget::fmt_elapsed_compact;
 use crate::text_formatting::truncate_text;
 use crate::tui::FrameRequester;
 mod background_agents;
@@ -398,6 +399,7 @@ struct UnifiedExecProcessSummary {
     key: String,
     call_id: String,
     command_display: String,
+    started_at: Instant,
     recent_chunks: Vec<String>,
     output_lines: Vec<String>,
 }
@@ -1021,6 +1023,8 @@ pub(crate) struct ChatWidget {
 #[derive(Debug)]
 struct BackgroundActivity {
     cell: Box<dyn HistoryCell>,
+    started_at: Instant,
+    task: Option<String>,
 }
 
 impl BackgroundActivity {
@@ -1047,6 +1051,10 @@ fn split_background_task_status(title: String) -> (String, Option<String>) {
     (title, None)
 }
 
+fn background_elapsed_text(started_at: Instant) -> String {
+    fmt_elapsed_compact(started_at.elapsed().as_secs())
+}
+
 #[cfg_attr(not(test), allow(dead_code))]
 enum CodexOpTarget {
     Direct(UnboundedSender<AppCommand>),
@@ -3950,13 +3958,15 @@ impl ChatWidget {
         {
             existing.call_id = call_id.to_string();
             existing.command_display = command_display;
+            existing.started_at = Instant::now();
             existing.recent_chunks.clear();
             existing.output_lines.clear();
         } else {
             self.unified_exec_processes.push(UnifiedExecProcessSummary {
                 key,
                 call_id: call_id.to_string(),
                 command_display,
+                started_at: Instant::now(),
                 recent_chunks: Vec::new(),
                 output_lines: Vec::new(),
             });
@@ -6983,8 +6993,11 @@ impl ChatWidget {
     fn finalize_active_cell_as_failed(&mut self) {
         if let Some(cell) = self.active_cell.take() {
             if cell.as_any().is::<multi_agents::CollabAgentActivityCell>() {
-                self.background_activities
-                    .push_back(BackgroundActivity { cell });
+                self.background_activities.push_back(BackgroundActivity {
+                    cell,
+                    started_at: Instant::now(),
+                    task: None,
+                });
             } else {
                 self.finalize_boxed_cell_as_failed(cell);
             }
@@ -7092,6 +7105,10 @@ impl ChatWidget {
                 user_message_preview_text(message, self.rejected_steer_history_records.get(idx))
             })
             .collect();
+        if !queued_messages.is_empty() || !pending_steers.is_empty() || !rejected_steers.is_empty()
+        {
+            self.clear_esc_backtrack_hint();
+        }
         self.bottom_pane.set_pending_input_preview(
             queued_messages,
             pending_steers,
@@ -10534,8 +10551,11 @@ impl ChatWidget {
         }
 
         if let Some(cell) = self.active_cell.take() {
-            self.background_activities
-                .push_back(BackgroundActivity { cell });
+            self.background_activities.push_back(BackgroundActivity {
+                cell,
+                started_at: Instant::now(),
+                task: None,
+            });
             self.bump_active_cell_revision();
         }
         self.task_backgrounded = true;
@@ -10580,11 +10600,18 @@ impl ChatWidget {
                 .downcast_ref::<multi_agents::CollabAgentActivityCell>()
             {
                 let (title, status) = split_background_task_status(title);
+                let task = activity
+                    .task
+                    .as_deref()
+                    .map(|task| truncate_text(task, 240));
                 params.subagents.push(BackgroundTaskItem {
                     kind: BackgroundTaskKind::Subagent {
                         thread_id: cell.thread_id(),
                     },
                     title,
+                    role: cell.agent_role().map(str::to_string),
+                    task,
+                    elapsed: Some(background_elapsed_text(activity.started_at)),
                     detail,
                     status,
                     output_lines: Vec::new(),
@@ -10593,6 +10620,9 @@ impl ChatWidget {
                 params.terminals.push(BackgroundTaskItem {
                     kind: BackgroundTaskKind::Terminal,
                     title,
+                    role: None,
+                    task: None,
+                    elapsed: Some(background_elapsed_text(activity.started_at)),
                     detail,
                     status: Some("running".to_string()),
                     output_lines: Vec::new(),
@@ -10606,6 +10636,9 @@ impl ChatWidget {
             params.terminals.push(BackgroundTaskItem {
                 kind: BackgroundTaskKind::Terminal,
                 title: process.command_display.clone(),
+                role: None,
+                task: None,
+                elapsed: Some(background_elapsed_text(process.started_at)),
                 detail,
                 status: Some("running".to_string()),
                 output_lines: process.output_lines.clone(),
@@ -10655,7 +10688,10 @@ impl ChatWidget {
     }
 
     fn should_interrupt_before_submitting_pending_input(&self) -> bool {
-        self.is_cancellable_work_active() || self.user_turn_pending_start
+        self.agent_turn_running
+            || self.mcp_startup_status.is_some()
+            || self.is_review_mode
+            || self.user_turn_pending_start
     }
 
     /// Return the markdown body width available to an active stream.

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

@@ -8,6 +8,7 @@ use codex_app_server_protocol::CollabAgentToolCallStatus;
 use codex_app_server_protocol::ThreadItem;
 use codex_protocol::ThreadId;
 use std::collections::HashSet;
+use std::time::Instant;
 
 pub(super) fn sync_collab_agent_background_activity(chat: &mut ChatWidget, item: &ThreadItem) {
     let ThreadItem::CollabAgentToolCall {
@@ -37,15 +38,16 @@ pub(super) fn sync_collab_agent_background_activity(chat: &mut ChatWidget, item:
             if let Ok(parsed_thread_id) = ThreadId::from_string(thread_id) {
                 seen.insert(parsed_thread_id);
                 if let Some(state) = agents_states.get(thread_id) {
-                    changed |= sync_collab_agent_activity_state(chat, parsed_thread_id, state);
+                    changed |=
+                        sync_collab_agent_activity_state(chat, item, parsed_thread_id, state);
                 }
             }
         }
         for (thread_id, state) in agents_states {
             if let Ok(parsed_thread_id) = ThreadId::from_string(thread_id)
                 && seen.insert(parsed_thread_id)
             {
-                changed |= sync_collab_agent_activity_state(chat, parsed_thread_id, state);
+                changed |= sync_collab_agent_activity_state(chat, item, parsed_thread_id, state);
             }
         }
     }
@@ -58,6 +60,7 @@ pub(super) fn sync_collab_agent_background_activity(chat: &mut ChatWidget, item:
 
 fn sync_collab_agent_activity_state(
     chat: &mut ChatWidget,
+    item: &ThreadItem,
     thread_id: ThreadId,
     state: &CollabAgentState,
 ) -> bool {
@@ -99,6 +102,9 @@ fn sync_collab_agent_activity_state(
                 && cell.thread_id() == thread_id
             {
                 cell.update(state, &metadata);
+                if activity.task.is_none() {
+                    activity.task = prompt_for_thread(item, thread_id);
+                }
                 return true;
             }
         }
@@ -107,13 +113,35 @@ fn sync_collab_agent_activity_state(
             cell: Box::new(multi_agents::CollabAgentActivityCell::new(
                 thread_id, state, &metadata,
             )),
+            started_at: Instant::now(),
+            task: prompt_for_thread(item, thread_id),
         });
         true
     } else {
         remove_collab_agent_background_activity(chat, thread_id)
     }
 }
 
+fn prompt_for_thread(item: &ThreadItem, thread_id: ThreadId) -> Option<String> {
+    let ThreadItem::CollabAgentToolCall {
+        tool,
+        prompt,
+        receiver_thread_ids,
+        ..
+    } = item
+    else {
+        return None;
+    };
+    if !matches!(tool, CollabAgentTool::SpawnAgent) {
+        return None;
+    }
+    let targets_thread = receiver_thread_ids
+        .iter()
+        .filter_map(|id| ThreadId::from_string(id).ok())
+        .any(|id| id == thread_id);
+    if targets_thread { prompt.clone() } else { None }
+}
+
 fn remove_collab_agent_background_activity(chat: &mut ChatWidget, thread_id: ThreadId) -> bool {
     if let Some(index) = chat.background_activities.iter().position(|activity| {
         activity

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

@@ -148,6 +148,7 @@ async fn down_uses_collab_agent_metadata_from_agent_state() {
 
     let rendered = render_bottom_popup(&chat, /*width*/ 96);
     assert!(rendered.contains("Robie [explorer]: Running"));
+    assert!(rendered.contains("Explore the repo"));
     assert!(
         !rendered.contains(&spawned_thread_id.to_string()),
         "background task title should prefer nickname over raw thread id: {rendered:?}"
@@ -223,6 +224,7 @@ async fn down_lists_spawned_agent_activity_without_submitting_core_op() {
         key: "proc-1".to_string(),
         call_id: "call-terminal".to_string(),
         command_display: "sleep 300".to_string(),
+        started_at: std::time::Instant::now(),
         recent_chunks: vec!["still running".to_string()],
         output_lines: vec!["still running".to_string()],
     });
@@ -247,6 +249,7 @@ async fn down_lists_spawned_agent_activity_without_submitting_core_op() {
     assert!(rendered.contains("Background tasks"));
     assert!(rendered.contains("Robie [explorer]"));
     assert!(rendered.contains("Running"));
+    assert!(rendered.contains("Explore the repo"));
     assert!(rendered.contains("Terminals"));
     assert!(rendered.contains("sleep 300"));
     assert!(rendered.contains("still running"));
@@ -308,7 +311,9 @@ async fn down_enter_subagent_opens_agent_detail_without_selecting_thread() {
         "Enter should open subagent detail: {rendered:?}"
     );
     assert!(rendered.contains("Robie [explorer]"));
+    assert!(rendered.contains("Role: explorer"));
     assert!(rendered.contains("Running"));
+    assert!(rendered.contains("Task: Explore the repo"));
     assert!(rendered.contains("Progress"));
     assert!(rendered.contains("Reading files"));
 }

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

@@ -915,6 +915,31 @@ async fn pending_steer_esc_does_not_steal_vim_insert_escape() {
     assert!(chat.submit_pending_steers_after_interrupt);
 }
 
+#[tokio::test]
+async fn pending_steer_esc_interrupts_backgrounded_agent_turn() {
+    let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+    let esc = KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE);
+
+    chat.on_task_started();
+    chat.task_backgrounded = true;
+    chat.update_task_running_state();
+    chat.pending_steers.push_back(pending_steer("queued steer"));
+    chat.refresh_pending_input_preview();
+
+    assert!(chat.agent_turn_running);
+    assert!(chat.task_backgrounded);
+    assert!(!chat.bottom_pane.is_task_running());
+
+    chat.handle_key_event(esc);
+
+    match op_rx.try_recv() {
+        Ok(Op::Interrupt) => {}
+        other => panic!("expected Op::Interrupt, got {other:?}"),
+    }
+    assert!(chat.submit_pending_steers_after_interrupt);
+    assert_eq!(chat.pending_steers.len(), 1);
+}
+
 #[tokio::test]
 async fn restore_thread_input_state_syncs_sleep_inhibitor_state() {
     let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;