Lightweight coding agent that runs in your terminal
Rust
Make the agents overview an interactive task dashboard (#39112)
Eric Traut319b2f72b1d4
diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rsindex d5a4bc77d3..94c139d2f9 100644--- a/codex-rs/tui/src/app/agents_overview.rs+++ b/codex-rs/tui/src/app/agents_overview.rs@@ -4,6 +4,7 @@ use super::agents_overview_view::AgentsOverviewGroup;use super::agents_overview_view::AgentsOverviewRow;use super::agents_overview_view::AgentsOverviewView;use super::*;+use crate::chatwidget::ThreadInputStateRestoreMode;use codex_app_server_protocol::RequestId;use codex_app_server_protocol::SessionSource;use codex_app_server_protocol::Thread;@@ -15,6 +16,9 @@ use codex_app_server_protocol::ThreadReadResponse;use codex_app_server_protocol::ThreadStatus;use codex_app_server_protocol::ThreadTurnsListParams;use codex_app_server_protocol::ThreadTurnsListResponse;+use codex_app_server_protocol::TurnStartParams;+use codex_app_server_protocol::TurnStartResponse;+use codex_app_server_protocol::UserInput;use codex_protocol::protocol::SubAgentSource;pub(crate) const AGENTS_OVERVIEW_VIEW_ID: &str = "agents-overview";@@ -27,6 +31,8 @@ pub(super) struct AgentsOverviewState {pub(super) visible_thread_ids: Vec<ThreadId>,pub(super) view_state:Arc<std::sync::Mutex<super::agents_overview_view::AgentsOverviewViewState>>,+ pub(super) input_states: HashMap<ThreadId, ThreadInputState>,+ pub(super) dispatched_requests: HashMap<ThreadId, Vec<ServerRequest>>,}impl App {@@ -190,6 +196,14 @@ impl App {};let view = self.agents_overview_view(threads, selected_thread_id);self.agents_overview.visible_thread_ids = view.thread_ids();+ if selected_thread_id+ .is_some_and(|thread_id| !self.agents_overview.visible_thread_ids.contains(&thread_id))+ && let Ok(mut state) = self.agents_overview.view_state.lock()+ && state.renaming+ {+ state.renaming = false;+ state.input.clear();+ }self.chat_widget.replace_bottom_pane_view_if_present(AGENTS_OVERVIEW_VIEW_ID, Box::new(view));if std::mem::take(&mut self.agents_overview.refresh_pending) {@@ -253,6 +267,386 @@ impl App {Arc::clone(&self.agents_overview.view_state),)}++ pub(super) async fn select_agents_overview_thread(+ &mut self,+ tui: &mut tui::Tui,+ app_server: &mut AppServerSession,+ root_thread_id: ThreadId,+ ) -> color_eyre::Result<AppRunControl> {+ if self.current_displayed_thread_id() == Some(root_thread_id) {+ return Ok(AppRunControl::Continue);+ }++ if self.primary_thread_id != Some(root_thread_id) {+ let previous_displayed_thread_id = self.current_displayed_thread_id();+ let mut previous_thread_ids =+ Vec::from_iter(self.thread_event_channels.keys().copied());+ previous_thread_ids.extend(+ self.agent_navigation+ .tracked_thread_ids()+ .into_iter()+ .filter(|thread_id| !self.thread_event_channels.contains_key(thread_id)),+ );+ let mut previous_running_thread_ids = Vec::new();+ let mut previous_pending_requests = Vec::new();+ for thread_id in &previous_thread_ids {+ if self.side_threads.contains_key(thread_id) {+ continue;+ }+ if let Some(channel) = self.thread_event_channels.get(thread_id) {+ let store = channel.store.lock().await;+ if store.active_turn_id().is_some() {+ previous_running_thread_ids.push(*thread_id);+ }+ if let Some(input_state) = store.input_state.clone() {+ self.agents_overview+ .input_states+ .insert(*thread_id, input_state);+ }+ let requests = store.pending_replay_requests();+ if !requests.is_empty() {+ previous_pending_requests.push((*thread_id, requests));+ }+ } else if self+ .agent_navigation+ .get(thread_id)+ .is_some_and(|entry| entry.is_running)+ {+ previous_running_thread_ids.push(*thread_id);+ }+ }+ if let Some(active_thread_id) = self.current_displayed_thread_id()+ && let Some(input_state) = self.chat_widget.capture_thread_input_state()+ {+ self.agents_overview+ .input_states+ .insert(active_thread_id, input_state);+ }++ let target_thread = match app_server+ .thread_read(root_thread_id, /*include_turns*/ false)+ .await+ {+ Ok(thread) => thread,+ Err(error) => {+ self.chat_widget.add_error_message(format!(+ "Agent session {root_thread_id} is unavailable: {error}"+ ));+ return Ok(AppRunControl::Continue);+ }+ };+ let config_cwd = if self.app_server_target.uses_remote_workspace() {+ self.config.cwd.to_path_buf()+ } else {+ target_thread.cwd.to_path_buf()+ };+ let current_cwd = self.config.cwd.to_path_buf();+ let resume_config = match self+ .rebuild_config_for_resume_or_fallback(¤t_cwd, config_cwd)+ .await+ {+ Ok(config) => config,+ Err(error) => {+ self.chat_widget+ .add_error_message(format!("Failed to load task settings: {error}"));+ return Ok(AppRunControl::Continue);+ }+ };+ let baseline_approval = resume_config.permissions.approval_policy.value();+ let baseline_permissions =+ RuntimePermissionProfileOverride::from_config(&resume_config);+ let resumed = match app_server+ .resume_thread(+ resume_config.clone(),+ root_thread_id,+ crate::app_server_session::ResumeModelSettings::PreserveExistingThread,+ )+ .await+ {+ Ok(resumed) => resumed,+ Err(error) => {+ self.chat_widget+ .add_error_message(format!("Failed to attach to task: {error}"));+ return Ok(AppRunControl::Continue);+ }+ };+ if !previous_running_thread_ids.is_empty() {+ for side_thread_id in Vec::from_iter(self.side_threads.keys().copied()) {+ if !self.discard_side_thread(app_server, side_thread_id).await {+ let _ = app_server.thread_unsubscribe(root_thread_id).await;+ return Ok(AppRunControl::Continue);+ }+ }+ }+ for (thread_id, requests) in previous_pending_requests {+ self.agents_overview+ .dispatched_requests+ .entry(thread_id)+ .or_default()+ .extend(requests);+ }+ if !previous_running_thread_ids.is_empty() {+ for thread_id in &previous_thread_ids {+ if !self.side_threads.contains_key(thread_id) {+ self.agents_overview+ .dispatched_requests+ .entry(*thread_id)+ .or_default();+ }+ }+ }+ if previous_running_thread_ids.is_empty() {+ self.shutdown_current_thread(app_server).await;+ }+ self.runtime_approval_policy_override = None;+ self.runtime_permission_profile_override = None;+ self.config = resume_config;+ tui.set_notification_settings(+ self.config.tui_notifications.method,+ self.config.tui_notifications.condition,+ );+ self.file_search+ .update_search_dir(self.config.cwd.to_path_buf());+ if let Err(error) = self+ .replace_chat_widget_with_app_server_thread(+ tui,+ resumed,+ super::session_lifecycle::ThreadAttachPresentation::SessionLineage,+ /*initial_user_message*/ None,+ )+ .await+ {+ self.chat_widget+ .add_error_message(format!("Failed to attach to task: {error}"));+ return Ok(AppRunControl::Continue);+ }+ let mut destination_config = self.chat_widget.config_ref().clone();+ if self.app_server_target.uses_remote_workspace() {+ destination_config.cwd.clone_from(&self.config.cwd);+ destination_config+ .workspace_roots+ .clone_from(&self.config.workspace_roots);+ destination_config+ .permissions+ .set_workspace_roots(self.config.permissions.workspace_roots().to_vec());+ }+ self.config = destination_config;+ if self.config.permissions.approval_policy.value() != baseline_approval {+ self.runtime_approval_policy_override =+ Some(self.config.permissions.approval_policy.value().into());+ }+ let destination_permissions =+ RuntimePermissionProfileOverride::from_config(&self.config);+ if destination_permissions != baseline_permissions {+ self.runtime_permission_profile_override = Some(destination_permissions);+ }+ if !self+ .backfill_loaded_subagent_threads(app_server)+ .await+ .completed+ {+ self.backfill_loaded_subagent_threads(app_server).await;+ }+ for thread_id in previous_thread_ids {+ if previous_running_thread_ids.is_empty()+ && thread_id != root_thread_id+ && Some(thread_id) != previous_displayed_thread_id+ && let Err(error) = app_server.thread_unsubscribe(thread_id).await+ {+ tracing::warn!(%thread_id, %error, "failed to unsubscribe previous agent thread");+ }+ }+ }++ if self.current_displayed_thread_id() != Some(root_thread_id) {+ self.select_agent_thread_and_discard_side(tui, app_server, root_thread_id)+ .await?;+ }+ self.replay_agents_overview_requests(app_server, root_thread_id)+ .await;+ if self.current_displayed_thread_id() == Some(root_thread_id)+ && let Some(input_state) = self.agents_overview.input_states.remove(&root_thread_id)+ {+ let preserve_in_flight_turn = self+ .active_turn_id_for_thread(root_thread_id)+ .await+ .is_some();+ self.chat_widget.restore_thread_input_state(+ Some(input_state),+ ThreadInputStateRestoreMode {+ preserve_in_flight_turn,+ },+ );+ if !preserve_in_flight_turn {+ self.chat_widget.maybe_send_next_queued_input();+ }+ }+ self.maybe_prompt_resume_paused_goal_after_resume(app_server, root_thread_id)+ .await;++ Ok(AppRunControl::Continue)+ }++ pub(super) async fn replay_agents_overview_requests(+ &mut self,+ app_server: &AppServerSession,+ root_thread_id: ThreadId,+ ) {+ let requests = self+ .agents_overview+ .dispatched_requests+ .extract_if(|id, _| *id == root_thread_id || self.agent_navigation.get(id).is_some())+ .flat_map(|(_, requests)| requests)+ .collect::<Vec<_>>();+ for request in requests {+ self.handle_app_server_event(+ app_server,+ codex_app_server_client::AppServerEvent::ServerRequest(Box::new(request)),+ )+ .await;+ }+ }++ pub(super) async fn dispatch_agents_overview_task(+ &mut self,+ app_server: &mut AppServerSession,+ prompt: String,+ cwd: Option<AbsolutePathBuf>,+ ) {+ self.refresh_in_memory_config_from_disk_best_effort("starting a background task")+ .await;+ let remote_cwd = cwd+ .as_ref()+ .filter(|_| app_server.uses_remote_workspace())+ .map(AbsolutePathBuf::to_path_buf);+ let mut config = match cwd {+ Some(cwd) if app_server.uses_remote_workspace() => {+ let mut config = self.fresh_session_config();+ config.cwd = cwd;+ config+ }+ Some(cwd) => match self.rebuild_config_for_cwd(cwd.to_path_buf()).await {+ Ok(config) => config,+ Err(error) => {+ if let Ok(mut state) = self.agents_overview.view_state.lock() {+ state.input = prompt;+ }+ return self+ .chat_widget+ .add_error_message(format!("Failed to load project settings: {error}"));+ }+ },+ None => self.fresh_session_config(),+ };+ if let Some(profile) = self.runtime_permission_profile_override.as_ref()+ && profile.active_permission_profile.is_some()+ && (RuntimePermissionProfileOverride::from_config(&config) != *profile+ || config.permissions.profile_workspace_roots()+ != self.config.permissions.profile_workspace_roots())+ {+ if let Ok(mut state) = self.agents_overview.view_state.lock() {+ state.input = prompt;+ }+ return self+ .chat_widget+ .add_error_message("Permission profile has different settings.".to_string());+ }+ self.apply_runtime_policy_overrides(&mut config);+ apply_managed_new_thread_defaults(+ &mut config,+ app_server.managed_new_thread_defaults(),+ &self.cli_kv_overrides,+ &self.harness_overrides,+ );+ match app_server+ .start_thread_with_session_start_source(+ &config,+ /*session_start_source*/ None,+ remote_cwd.as_deref(),+ )+ .await+ {+ Ok(started) => {+ let thread_id = started.session.thread_id;+ self.agents_overview+ .dispatched_requests+ .insert(thread_id, Vec::new());+ self.submit_agents_overview_prompt(app_server, thread_id, prompt)+ .await;+ }+ Err(error) => {+ if let Ok(mut state) = self.agents_overview.view_state.lock() {+ state.input = prompt;+ }+ self.chat_widget+ .add_error_message(format!("Failed to start background task: {error}"));+ }+ }+ }++ pub(super) async fn submit_agents_overview_prompt(+ &mut self,+ app_server: &AppServerSession,+ thread_id: ThreadId,+ prompt: String,+ ) {+ let result = app_server+ .request_handle()+ .request_typed::<TurnStartResponse>(ClientRequest::TurnStart {+ request_id: RequestId::String(Uuid::new_v4().to_string()),+ params: TurnStartParams {+ thread_id: thread_id.to_string(),+ input: vec![UserInput::Text {+ text: prompt.clone(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ },+ })+ .await;+ if let Err(error) = result {+ if let Ok(mut state) = self.agents_overview.view_state.lock() {+ state.input = prompt;+ }+ self.chat_widget+ .add_error_message(format!("Failed to send task message: {error}"));+ }+ }++ pub(super) async fn stop_agents_overview_thread(+ &mut self,+ app_server: &mut AppServerSession,+ thread_id: ThreadId,+ ) {+ let active_turn_id = match self.active_turn_id_for_thread(thread_id).await {+ Some(turn_id) => Some(turn_id),+ None => match app_server+ .thread_read(thread_id, /*include_turns*/ true)+ .await+ {+ Ok(thread) => thread+ .turns+ .into_iter()+ .find(|turn| turn.status == TurnStatus::InProgress)+ .map(|turn| turn.id),+ Err(error) => {+ self.chat_widget+ .add_error_message(format!("Failed to stop background task: {error}"));+ self.refresh_agents_overview_threads(app_server);+ return;+ }+ },+ };+ let Some(turn_id) = active_turn_id else {+ return;+ };+ if let Err(error) = app_server.turn_interrupt(thread_id, turn_id).await {+ self.chat_widget+ .add_error_message(format!("Failed to stop background task: {error}"));+ self.refresh_agents_overview_threads(app_server);+ }+ }}#[cfg(test)]diff --git a/codex-rs/tui/src/app/agents_overview_tests.rs b/codex-rs/tui/src/app/agents_overview_tests.rsindex 37e54132f7..9eb42048f9 100644--- a/codex-rs/tui/src/app/agents_overview_tests.rs+++ b/codex-rs/tui/src/app/agents_overview_tests.rs@@ -1,68 +1,220 @@-use crate::app::agents_overview_view::AgentsOverviewGroup;+use super::*;use crate::app::test_support::make_test_app;use crate::bottom_pane::BottomPaneView;use crate::chatwidget::tests::helpers::render_bottom_popup;+use crate::render::renderable::Renderable;use crate::test_support::PathBufExt;use crate::test_support::test_path_buf;use crate::test_support::test_path_display;+use codex_app_server_client::AppServerEvent;+use codex_app_server_protocol::CurrentTimeReadParams;+use codex_app_server_protocol::ServerRequest;+use codex_app_server_protocol::SessionSource;use codex_app_server_protocol::ThreadActiveFlag;-use codex_app_server_protocol::ThreadStatus;-use codex_protocol::ThreadId;-use crossterm::event::KeyCode;-use crossterm::event::KeyEvent;-use crossterm::event::KeyModifiers;+use codex_app_server_protocol::ThreadUnsubscribeParams;+use codex_app_server_protocol::ThreadUnsubscribeResponse;+use codex_app_server_protocol::ThreadUnsubscribeStatus;+use codex_protocol::protocol::SubAgentSource;++static OVERVIEW_TIMESTAMP: std::sync::LazyLock<i64> =+ std::sync::LazyLock::new(|| chrono::Utc::now().timestamp() - 120);++fn overview_thread(+ thread_id: ThreadId,+ parent_thread_id: Option<ThreadId>,+ name: &str,+ status: ThreadStatus,+) -> Thread {+ Thread {+ id: thread_id.to_string(),+ extra: None,+ project_id: None,+ session_id: parent_thread_id.unwrap_or(thread_id).to_string(),+ forked_from_id: None,+ parent_thread_id: None,+ preview: name.to_string(),+ ephemeral: false,+ section: None,+ section_entered_at: None,+ history_mode: Default::default(),+ model_provider: "openai".to_string(),+ created_at: *OVERVIEW_TIMESTAMP,+ updated_at: *OVERVIEW_TIMESTAMP,+ recency_at: Some(*OVERVIEW_TIMESTAMP),+ status,+ path: None,+ cwd: test_path_buf("/tmp/project").abs(),+ cli_version: "0.0.0".to_string(),+ source: parent_thread_id.map_or(SessionSource::Cli, |parent_thread_id| {+ SessionSource::SubAgent(SubAgentSource::ThreadSpawn {+ parent_thread_id,+ depth: 1,+ agent_path: None,+ agent_nickname: None,+ agent_role: None,+ })+ }),+ can_accept_direct_input: Some(parent_thread_id.is_none()),+ thread_source: None,+ agent_nickname: None,+ agent_role: None,+ git_info: None,+ name: Some(name.to_string()),+ turns: Vec::new(),+ }+}#[tokio::test]-async fn shared_agents_dashboard_is_rendered() {+async fn shared_overview_shows_only_root_sessions() {assert_eq!(AgentsOverviewGroup::for_status(&ThreadStatus::SystemError),AgentsOverviewGroup::NeedsYou);let mut app = make_test_app().await;- let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref())- .await- .expect("embedded app server");- let started = app_server- .start_thread(&app.config)- .await- .expect("start example thread");- let mut thread = app_server- .thread_read(started.session.thread_id, /*include_turns*/ false)- .await- .expect("read example thread");- thread.name = Some("Example task".to_string());- thread.preview = "Inspect the current project".to_string();- thread.cwd = test_path_buf("/tmp/project").abs();- thread.status = ThreadStatus::Active {- active_flags: vec![ThreadActiveFlag::WaitingOnApproval],- };- app.primary_thread_id = Some(started.session.thread_id);- let mut view = app.agents_overview_view(vec![thread.clone()], /*selected_thread_id*/ None);+ let first_root = ThreadId::from_string("00000000-0000-0000-0000-000000000101").unwrap();+ let [child, second_root, side_thread] = std::array::from_fn(|_| ThreadId::new());+ app.primary_thread_id = Some(first_root);++ let mut threads = vec![+ overview_thread(+ first_root,+ /*parent_thread_id*/ None,+ "Build the dashboard",+ ThreadStatus::Idle,+ ),+ overview_thread(+ child,+ Some(first_root),+ "Inspect keyboard shortcuts",+ ThreadStatus::Active {+ active_flags: vec![ThreadActiveFlag::WaitingOnApproval],+ },+ ),+ overview_thread(+ second_root,+ /*parent_thread_id*/ None,+ "Repair authentication",+ ThreadStatus::Active {+ active_flags: Vec::new(),+ },+ ),+ ];+ let mut side = overview_thread(+ side_thread,+ /*parent_thread_id*/ None,+ "Ephemeral side",+ ThreadStatus::Idle,+ );+ side.ephemeral = true;+ threads.push(side);+ let view = app.agents_overview_view(threads, /*selected_thread_id*/ None);++ let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();+ let mut action_view = AgentsOverviewView::new(+ view.rows.clone(),+ Some(first_root),+ /*exit_on_cancel*/ false,+ crate::app_event_sender::AppEventSender::new(event_tx),+ app.keymap.clone(),+ Arc::clone(&app.agents_overview.view_state),+ );let state = &app.agents_overview.view_state;assert!(!state.lock().unwrap().status_grouping);- view.handle_key_event(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL));assert!(state.lock().unwrap().status_grouping);app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);assert!(state.lock().unwrap().status_grouping);- view.handle_key_event(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL));+ assert!(+ action_view.handle_paste("Use \u{1b}[31mthe\u{1b}[0m current project\u{7}".to_string())+ );+ action_view.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ assert!(matches!(+ event_rx.try_recv(),+ Ok(AppEvent::DispatchAgentsOverviewTask { prompt, cwd: None })+ if prompt == "Use the current project"+ ));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL));+ assert!(action_view.handle_paste("Fix the flaky tests after all retries complete".to_string()));+ let area = ratatui::layout::Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 12,+ );+ let mut buffer = ratatui::buffer::Buffer::empty(area);+ action_view.render(area, &mut buffer);+ let prompt = buffer+ .content()+ .iter()+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>();+ assert!(prompt.contains("complete"));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ assert!(matches!(+ event_rx.try_recv(),+ Ok(AppEvent::DispatchAgentsOverviewTask { prompt, cwd: Some(cwd) })+ if prompt == "Fix the flaky tests after all retries complete"+ && cwd == test_path_buf("/tmp/project").abs()+ ));+ assert!(action_view.handle_paste(" ".to_string()));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::CONTROL));+ assert!(action_view.handle_paste("Repair authentication".to_string()));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ assert!(matches!(+ event_rx.try_recv(),+ Ok(AppEvent::SelectAgentsOverviewThread { thread_id }) if thread_id == second_root+ ));+ assert!(action_view.handle_paste("Continue working".to_string()));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ assert!(matches!(+ event_rx.try_recv(),+ Ok(AppEvent::DispatchAgentsOverviewTask { prompt, .. })+ if prompt.trim() == "Continue working"+ ));+ action_view.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL));+ crate::chatwidget::tests::helpers::set_active_cell(+ &mut app.chat_widget,+ Box::new(crate::history_cell::PlainHistoryCell::new(vec![+ Line::from("Previous session status"),+ ])),+ );app.chat_widget.show_bottom_pane_view(Box::new(view));-+ let project = test_path_display("/tmp/project");+ let normalized_project_group = format!(+ "/tmp/project 2{}",+ " ".repeat(project.len().saturating_sub("/tmp/project".len()))+ );insta::with_settings!({snapshot_path => "../snapshots"}, {insta::assert_snapshot!("agents_overview",render_bottom_popup(&app.chat_widget, /*width*/ 96)- .replace(&test_path_display("/tmp/project"), "/tmp/project")+ .replace(&format!("{project} 2"), &normalized_project_group)+ .replace(&project, "/tmp/project"));});let threads = (0..20).map(|index| {- let mut candidate = thread.clone();- if index != 0 {- candidate.id = ThreadId::new().to_string();- candidate.status = ThreadStatus::Idle;+ let thread_id = if index == 0 {+ first_root+ } else {+ ThreadId::new()+ };+ let status = if index == 0 {+ ThreadStatus::Active {+ active_flags: vec![ThreadActiveFlag::WaitingOnApproval],+ }+ } else {+ ThreadStatus::Idle+ };+ let mut candidate = overview_thread(+ thread_id,+ /*parent_thread_id*/ None,+ &format!("Task {index}"),+ status,+ );+ if index == 0 {+ candidate.name = None;+ candidate.preview = "Inspect unnamed task".to_string();}- candidate.name = (index != 0).then(|| format!("Task {index}"));candidate.updated_at = index;candidate.cwd = if index == 0 {test_path_buf("/tmp/project-selected").abs()@@ -77,10 +229,12 @@ async fn shared_agents_dashboard_is_rendered() {let view = app.agents_overview_view(threads, /*selected_thread_id*/ None);app.chat_widget.show_bottom_pane_view(Box::new(view));let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);- assert!(rendered.lines().any(- |line| line.contains("› ● Inspect the current project current")- && line.contains("Needs input")- ));+ assert!(+ rendered+ .lines()+ .any(|line| line.contains("› ● Inspect unnamed task current")+ && line.contains("Needs input"))+ );app.transcript_cells.push(std::sync::Arc::new(crate::history_cell::PlainHistoryCell::new(vec![ratatui::text::Line::from(@@ -98,6 +252,95 @@ async fn shared_agents_dashboard_is_rendered() {.expect("restore conversation after closing dashboard");assert!(tui.terminal.viewport_area.height < screen_size.height);assert!(app.last_rendered_history_tail.is_some());+}++#[tokio::test]+async fn failed_root_switch_keeps_background_requests_on_the_active_session() -> Result<()> {+ let mut app = make_test_app().await;+ let mut app_server =+ crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;+ app.primary_thread_id = Some(ThreadId::new());+ app.ensure_thread_channel(ThreadId::new())+ .store+ .lock()+ .await+ .active_turn_id = Some("running-turn".to_string());+ let mut tui = crate::tui::test_support::make_test_tui()?;- app_server.shutdown().await.expect("shutdown app server");+ app.select_agents_overview_thread(&mut tui, &mut app_server, ThreadId::new())+ .await?;++ assert!(app.agents_overview.dispatched_requests.is_empty());+ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn root_switch_preserves_idle_root_with_running_subagent() -> Result<()> {+ let mut app = make_test_app().await;+ let mut app_server =+ crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;+ let previous = app_server.start_thread(&app.config).await?;+ let previous_root_id = previous.session.thread_id;+ app.enqueue_primary_thread_session(previous.session, previous.turns)+ .await?;+ let target_thread_id = ThreadId::from_string(+ &app_test_support::create_fake_rollout(+ app.config.codex_home.as_path(),+ "2025-01-05T12-00-00",+ "2025-01-05T12:00:00Z",+ "Target task",+ Some(&app.config.model_provider_id),+ /*git_info*/ None,+ )+ .expect("materialize target rollout"),+ )?;+ let target = app_server+ .resume_thread(+ app.config.clone(),+ target_thread_id,+ crate::app_server_session::ResumeModelSettings::PreserveExistingThread,+ )+ .await?;+ let child_id = ThreadId::new();+ let idle_child_id = ThreadId::new();+ app.ensure_thread_channel(idle_child_id);+ app.upsert_agent_picker_thread(+ child_id, /*agent_nickname*/ None, /*agent_role*/ None, /*is_closed*/ false,+ );+ app.agent_navigation.mark_running(child_id);+ app.active_thread_id = Some(child_id);+ let mut tui = crate::tui::test_support::make_test_tui()?;++ app.select_agents_overview_thread(&mut tui, &mut app_server, target.session.thread_id)+ .await?;++ assert!(+ app.agents_overview+ .dispatched_requests+ .contains_key(&idle_child_id)+ );+ app.handle_app_server_event(+ &app_server,+ AppServerEvent::ServerRequest(Box::new(ServerRequest::CurrentTimeRead {+ request_id: RequestId::Integer(99),+ params: CurrentTimeReadParams {+ thread_id: idle_child_id.to_string(),+ },+ })),+ )+ .await;+ assert!(app.agents_overview.dispatched_requests[&idle_child_id].is_empty());+ let response: ThreadUnsubscribeResponse = app_server+ .request_handle()+ .request_typed(ClientRequest::ThreadUnsubscribe {+ request_id: RequestId::String("verify-root-subscription".to_string()),+ params: ThreadUnsubscribeParams {+ thread_id: previous_root_id.to_string(),+ },+ })+ .await?;+ assert_eq!(response.status, ThreadUnsubscribeStatus::Unsubscribed);+ app_server.shutdown().await?;+ Ok(())}diff --git a/codex-rs/tui/src/app/agents_overview_view.rs b/codex-rs/tui/src/app/agents_overview_view.rsindex 6354c02871..e6334037d9 100644--- a/codex-rs/tui/src/app/agents_overview_view.rs+++ b/codex-rs/tui/src/app/agents_overview_view.rs@@ -1,10 +1,11 @@-//! Read-only dashboard of the daemon's active tasks.+//! Dashboard for inspecting and managing the daemon's active tasks.use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;use crate::app_event::AppEvent;use crate::app_event_sender::AppEventSender;use crate::bottom_pane::BottomPaneView;use crate::bottom_pane::ViewCompletion;+use crate::key_hint::is_plain_text_key_event;use crate::keymap::KeymapContext;use crate::keymap::KeymapContextSet;use crate::keymap::ListAction;@@ -23,14 +24,19 @@ use ratatui::layout::Constraint;use ratatui::layout::Layout;use ratatui::layout::Margin;use ratatui::layout::Rect;+use ratatui::style::Style;use ratatui::style::Stylize;use ratatui::text::Line;use ratatui::text::Span;use ratatui::widgets::Clear;+use ratatui::widgets::Paragraph;use ratatui::widgets::Widget;use std::sync::Arc;use std::sync::Mutex;+use std::sync::MutexGuard;use std::sync::PoisonError;+use unicode_width::UnicodeWidthChar;+use unicode_width::UnicodeWidthStr;#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]pub(super) enum AgentsOverviewGroup {@@ -76,10 +82,12 @@ pub(super) struct AgentsOverviewRow {#[derive(Clone, Default)]pub(super) struct AgentsOverviewViewState {+ pub(super) input: String,search: String,searching: bool,pub(super) status_grouping: bool,pub(super) refresh_task: Option<tokio::task::AbortHandle>,+ pub(super) renaming: bool,}pub(super) struct AgentsOverviewView {@@ -139,6 +147,16 @@ impl AgentsOverviewView {self.rows.iter().map(|row| row.thread_id).collect()}+ fn state(&self) -> MutexGuard<'_, AgentsOverviewViewState> {+ self.state.lock().unwrap_or_else(PoisonError::into_inner)+ }++ fn selected_row(&self) -> Option<&AgentsOverviewRow> {+ self.rows+ .get(self.selected)+ .filter(|_| self.visible_indices().contains(&self.selected))+ }+fn visible_indices(&self) -> Vec<usize> {let state = self.state.lock().unwrap_or_else(PoisonError::into_inner);let search = state.search.to_lowercase();@@ -169,6 +187,9 @@ impl AgentsOverviewView {}fn move_selection(&mut self, forward: bool) {+ if self.state().renaming {+ return;+ }let visible = self.visible_indices();if visible.is_empty() {return;@@ -184,8 +205,67 @@ impl AgentsOverviewView {};}+ fn activate(&mut self) {+ let state = self.state().clone();+ let input = state.input.clone();+ if !state.searching && !input.is_empty() && input.trim().is_empty() {+ return;+ }+ if !state.searching && !input.trim().is_empty() {+ if state.renaming {+ if let Some(row) = self.selected_row() {+ self.app_event_tx+ .send(AppEvent::RenameAgentsOverviewThread {+ thread_id: row.thread_id,+ name: input.trim().to_string(),+ });+ }+ self.state().renaming = false;+ } else {+ self.app_event_tx+ .send(AppEvent::DispatchAgentsOverviewTask {+ prompt: input,+ cwd: (!state.status_grouping)+ .then(|| self.selected_row().map(|row| row.thread.cwd.clone()))+ .flatten(),+ });+ }+ self.state().input.clear();+ } else if let Some(row) = self.selected_row().filter(|_| !state.renaming) {+ self.app_event_tx+ .send(AppEvent::SelectAgentsOverviewThread {+ thread_id: row.thread_id,+ });+ if state.searching {+ let mut state = self.state();+ state.search.clear();+ state.searching = false;+ }+ self.completion = Some(ViewCompletion::Accepted);+ }+ }++ fn edit_input(&mut self, edit: impl FnOnce(&mut String)) -> bool {+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);+ let searching = state.searching;+ edit(if searching {+ &mut state.search+ } else {+ &mut state.input+ });+ drop(state);+ if searching {+ self.selected = self+ .visible_indices()+ .first()+ .copied()+ .unwrap_or(usize::MAX);+ }+ true+ }+fn status(row: &AgentsOverviewRow) -> (&'static str, Span<'static>) {- match AgentsOverviewGroup::for_status(&row.thread.status) {+ match row.group {AgentsOverviewGroup::NeedsYou => ("Needs input", "●".red()),AgentsOverviewGroup::Working => ("Working", "●".green()),AgentsOverviewGroup::Ready => ("Ready", "○".cyan()),@@ -284,6 +364,49 @@ impl AgentsOverviewView {offset += 1;}}++ fn render_details(&self, area: Rect, buf: &mut Buffer) {+ let Some(row) = self.selected_row() else {+ return;+ };+ let (status, dot) = Self::status(row);+ let mut lines = vec![+ Line::from("Task details".bold()),+ Line::default(),+ Line::from(row.thread.name.as_deref().unwrap_or("Untitled task").bold()),+ Line::from(vec![dot, " ".into(), status.into()]),+ Line::default(),+ Line::from("Project".dim()),+ Line::from(row.thread.cwd.display().to_string()),+ ];+ if let Some(branch) = row+ .thread+ .git_info+ .as_ref()+ .and_then(|git| git.branch.as_ref())+ {+ lines.push(Line::default());+ lines.push("Branch".dim().into());+ lines.push(branch.clone().into());+ }+ let preview = crate::text_formatting::truncate_text(+ &row.thread.preview,+ usize::from(area.width) * usize::from(area.height),+ );+ lines.extend([+ Line::default(),+ Line::from("Latest activity".dim()),+ Line::from(match preview.as_str() {+ "" => "No activity yet.",+ preview => preview,+ }),+ ]);+ Paragraph::new(crate::wrapping::word_wrap_lines(+ lines,+ usize::from(area.width),+ ))+ .render(area, buf);+ }}impl BottomPaneView for AgentsOverviewView {@@ -311,22 +434,70 @@ impl BottomPaneView for AgentsOverviewView {true}+ fn handle_paste(&mut self, pasted: String) -> bool {+ self.edit_input(|input| {+ input.push_str(&crate::history_cell::sanitize_user_text(pasted.into()))+ })+ }+fn handle_key_event(&mut self, key: KeyEvent) {- if key.code == KeyCode::Char('s') && key.modifiers == KeyModifiers::CONTROL {- let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);- state.status_grouping = !state.status_grouping;- return;- }- if key.code == KeyCode::Char('f') && key.modifiers == KeyModifiers::CONTROL {- let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);- state.searching = !state.searching;+ if key.modifiers == KeyModifiers::CONTROL+ && matches!(key.code, KeyCode::Char('f' | 'n' | 'r' | 's' | 'x'))+ {+ match key.code {+ KeyCode::Char('s') => {+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);+ state.status_grouping = !state.status_grouping;+ }+ KeyCode::Char('f') => {+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);+ if !state.renaming {+ state.searching = !state.searching;+ if !state.searching {+ state.search.clear();+ }+ }+ }+ KeyCode::Char('n') => {+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);+ state.search.clear();+ state.searching = false;+ state.renaming = false;+ state.input.clear();+ }+ KeyCode::Char('r') => {+ if let Some(row) = self.selected_row() {+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);+ if state.input.is_empty() {+ state.input = row.thread.name.clone().unwrap_or_default();+ state.search.clear();+ state.searching = false;+ state.renaming = true;+ }+ }+ }+ KeyCode::Char('x') => {+ if let Some(row) = self.selected_row()+ && matches!(row.thread.status, ThreadStatus::Active { .. })+ {+ self.app_event_tx.send(AppEvent::StopAgentsOverviewThread {+ thread_id: row.thread_id,+ });+ }+ }+ _ => {}+ }return;}- if let Some(action) = self.keymap.action_for(key)- && (!matches!(key.code, KeyCode::Char(_))- || self.state.lock().is_ok_and(|state| !state.searching))+ if !is_plain_text_key_event(key)+ && let Some(action) = self.keymap.action_for(key){+ if self.state().renaming+ && matches!(action, ListAction::JumpTop | ListAction::JumpBottom)+ {+ return;+ }match action {ListAction::MoveUp => self.move_selection(/*forward*/ false),ListAction::MoveDown => self.move_selection(/*forward*/ true),@@ -336,12 +507,16 @@ impl BottomPaneView for AgentsOverviewView {ListAction::JumpBottom => {self.selected = self.visible_indices().last().copied().unwrap_or(0);}+ ListAction::Accept => self.activate(),ListAction::Cancel => {let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);if state.searching {state.search.clear();state.searching = false;self.selected = 0;+ } else if !state.input.is_empty() || state.renaming {+ state.input.clear();+ state.renaming = false;} else {if self.exit_on_cancel {self.app_event_tx@@ -355,32 +530,24 @@ impl BottomPaneView for AgentsOverviewView {self.move_selection(action == ListAction::PageDown);}}- ListAction::Accept | ListAction::MoveLeft | ListAction::MoveRight => {}+ ListAction::MoveLeft | ListAction::MoveRight => {}}return;}- let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);- if !state.searching {- return;- }match key.code {KeyCode::Backspace => {- state.search.pop();+ self.edit_input(|input| {+ input.pop();+ });}KeyCode::Char(character)if key.modifiers.is_empty() || key.modifiers == KeyModifiers::SHIFT =>{- state.search.push(character);+ self.edit_input(|input| input.push(character));}- _ => return,+ _ => {}}- drop(state);- self.selected = self- .visible_indices()- .first()- .copied()- .unwrap_or(usize::MAX);}}@@ -389,17 +556,34 @@ impl Renderable for AgentsOverviewView {24}+ fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {+ let state = self.state().clone();+ let (label, input) = if state.searching {+ (" Search › ", &state.search)+ } else if state.renaming {+ (" Rename › ", &state.input)+ } else {+ (" New task › ", &state.input)+ };+ let x = area+ .x+ .saturating_add((label.width() + input.width()) as u16)+ .min(area.right().saturating_sub(3));+ Some((x, area.bottom().saturating_sub(2)))+ }+fn render(&self, area: Rect, buf: &mut Buffer) {if area.width < 12 || area.height < 8 {return;}Clear.render(area, buf);- let [header, summary, divider, body, footer] = Layout::vertical([+ let [header, summary, divider, body, prompt, footer] = Layout::vertical([Constraint::Length(1),Constraint::Length(1),Constraint::Length(1),Constraint::Min(3),Constraint::Length(1),+ Constraint::Length(1),]).areas(area);let inset =@@ -419,22 +603,77 @@ impl Renderable for AgentsOverviewView {.render(inset(summary), buf);Line::from("─".repeat(usize::from(area.width.saturating_sub(4))).dim()).render(inset(divider), buf);- self.render_rows(inset(body), buf);- let state = self.state.lock().unwrap_or_else(PoisonError::into_inner);- let footer_line = if state.searching {- Line::from(vec!["Search › ".cyan().bold(), state.search.clone().into()])- } else {- Line::from(vec![- "↑↓".bold(),- " navigate ".dim(),- "ctrl+f".bold(),- " search ".dim(),- "ctrl+s".bold(),- " group ".dim(),- "esc".bold(),- " back".dim(),+ let body = inset(body);+ if body.width >= 90 {+ let [list, gap, details] = Layout::horizontal([+ Constraint::Min(46),+ Constraint::Length(3),+ Constraint::Length(38),])+ .areas(body);+ for y in gap.y..gap.bottom() {+ buf[(gap.x + 1, y)]+ .set_symbol("│")+ .set_style(Style::new().dim());+ }+ self.render_rows(list, buf);+ self.render_details(details, buf);+ } else {+ self.render_rows(body, buf);+ }+ let state = self.state().clone();+ let (label, input) = if state.searching {+ ("Search › ", &state.search)+ } else if state.renaming {+ ("Rename › ", &state.input)+ } else {+ ("New task › ", &state.input)};- footer_line.render(inset(footer), buf);+ let placeholder = if input.is_empty() && !state.searching && !state.renaming {+ "Describe a task and press enter to dispatch it"+ } else {+ ""+ };+ let available_width = usize::from(inset(prompt).width)+ .saturating_sub(label.width())+ .saturating_sub(1);+ let mut visible_start = input.len();+ let mut visible_width = 0;+ for (index, character) in input.char_indices().rev() {+ let width = character.width().unwrap_or(0);+ if visible_width + width > available_width {+ break;+ }+ visible_width += width;+ visible_start = index;+ }+ let input = &input[visible_start..];+ Line::from(vec![label.cyan().bold(), input.into(), placeholder.dim()])+ .render(inset(prompt), buf);+ let stop_hint = if self+ .selected_row()+ .is_some_and(|row| matches!(row.thread.status, ThreadStatus::Active { .. }))+ {+ "ctrl+x".bold()+ } else {+ "ctrl+x".dim()+ };+ Line::from(vec![+ "↑↓".bold(),+ " navigate ".dim(),+ "enter".bold(),+ " open ".dim(),+ "ctrl+f".bold(),+ " search ".dim(),+ "ctrl+s".bold(),+ " group ".dim(),+ "ctrl+r".bold(),+ " rename ".dim(),+ stop_hint,+ " stop ".dim(),+ "esc".bold(),+ " back".dim(),+ ])+ .render(inset(footer), buf);}}diff --git a/codex-rs/tui/src/app/app_server_events.rs b/codex-rs/tui/src/app/app_server_events.rsindex 7ebcf4ab9c..6b13bc0313 100644--- a/codex-rs/tui/src/app/app_server_events.rs+++ b/codex-rs/tui/src/app/app_server_events.rs@@ -87,6 +87,21 @@ impl App {app_server_client: &AppServerSession,notification: ServerNotification,) {+ if let ServerNotification::ThreadStarted(started) = ¬ification+ && let SessionSource::SubAgent(SubAgentSource::ThreadSpawn {+ parent_thread_id, ..+ }) = &started.thread.source+ && self+ .agents_overview+ .dispatched_requests+ .contains_key(parent_thread_id)+ && let Ok(thread_id) = codex_protocol::ThreadId::from_string(&started.thread.id)+ {+ self.agents_overview+ .dispatched_requests+ .entry(thread_id)+ .or_default();+ }if matches!(¬ification,ServerNotification::ThreadStarted(_)@@ -105,6 +120,9 @@ impl App {!matches!(event, ThreadBufferedEvent::Request(request)if request.id() == ¬ification.request_id)});+ for requests in self.agents_overview.dispatched_requests.values_mut() {+ requests.retain(|request| request.id() != ¬ification.request_id);+ }if let Some(request) = self.pending_app_server_requests.resolve_notification(¬ification.request_id)@@ -289,9 +307,32 @@ impl App {.push_back(ThreadBufferedEvent::Request(Box::new(request)));return;}+ let unsupported_request = matches!(+ &request,+ ServerRequest::DynamicToolCall { .. }+ | ServerRequest::AttestationGenerate { .. }+ | ServerRequest::CurrentTimeRead { .. }+ | ServerRequest::ApplyPatchApproval { .. }+ | ServerRequest::ExecCommandApproval { .. }+ );+ if self+ .pending_app_server_requests+ .contains_server_request(&request)+ {+ return;+ }+ if let Some(thread_id) = thread_id+ && self.primary_thread_id != Some(thread_id)+ && !unsupported_request+ && let Some(requests) = self.agents_overview.dispatched_requests.get_mut(&thread_id)+ {+ requests.push(request);+ return;+ }if thread_id.is_some()&& self.primary_thread_id.is_none()&& !self.pending_startup_thread_start+ && !unsupported_request{return;}@@ -301,6 +342,7 @@ impl App {&& !self.thread_event_channels.contains_key(&thread_id)&& self.agent_navigation.get(&thread_id).is_none()&& !self.side_threads.contains_key(&thread_id)+ && !unsupported_request{let thread = app_server_client.request_handle()@@ -312,18 +354,30 @@ impl App {},}).await;- if !matches!(- thread,- Ok(ThreadReadResponse { thread })- if matches!(thread.source,- SessionSource::SubAgent(SubAgentSource::ThreadSpawn {- parent_thread_id,- ..- }) if self.primary_thread_id == Some(parent_thread_id)- || self.thread_event_channels.contains_key(&parent_thread_id)- || self.agent_navigation.get(&parent_thread_id).is_some()- )- ) {+ let Ok(ThreadReadResponse { thread }) = thread else {+ return;+ };+ let SessionSource::SubAgent(SubAgentSource::ThreadSpawn {+ parent_thread_id, ..+ }) = thread.source+ else {+ return;+ };+ if self.primary_thread_id != Some(parent_thread_id)+ && !self.thread_event_channels.contains_key(&parent_thread_id)+ && self.agent_navigation.get(&parent_thread_id).is_none()+ {+ if self+ .agents_overview+ .dispatched_requests+ .contains_key(&parent_thread_id)+ {+ self.agents_overview+ .dispatched_requests+ .entry(thread_id)+ .or_default()+ .push(request);+ }return;}}diff --git a/codex-rs/tui/src/app/app_server_requests.rs b/codex-rs/tui/src/app/app_server_requests.rsindex b36f1d4a38..99d907e2f2 100644--- a/codex-rs/tui/src/app/app_server_requests.rs+++ b/codex-rs/tui/src/app/app_server_requests.rs@@ -355,12 +355,12 @@ impl PendingAppServerRequests {.mcp_requests.values().any(|pending_request_id| pending_request_id == request_id),+ ServerRequest::ChatgptAuthTokensRefresh { .. } => true,ServerRequest::DynamicToolCall { .. }- | ServerRequest::ChatgptAuthTokensRefresh { .. }| ServerRequest::AttestationGenerate { .. }| ServerRequest::CurrentTimeRead { .. }| ServerRequest::ApplyPatchApproval { .. }- | ServerRequest::ExecCommandApproval { .. } => true,+ | ServerRequest::ExecCommandApproval { .. } => false,}}@@ -721,18 +721,20 @@ mod tests {#[test]fn rejects_dynamic_tool_calls_as_unsupported() {let mut pending = PendingAppServerRequests::default();+ let request = ServerRequest::DynamicToolCall {+ request_id: AppServerRequestId::Integer(99),+ params: codex_app_server_protocol::DynamicToolCallParams {+ thread_id: "thread-1".to_string(),+ turn_id: "turn-1".to_string(),+ call_id: "tool-1".to_string(),+ namespace: None,+ tool: "tool".to_string(),+ arguments: json!({}),+ },+ };+ assert!(!pending.contains_server_request(&request));let unsupported = pending- .note_server_request(&ServerRequest::DynamicToolCall {- request_id: AppServerRequestId::Integer(99),- params: codex_app_server_protocol::DynamicToolCallParams {- thread_id: "thread-1".to_string(),- turn_id: "turn-1".to_string(),- call_id: "tool-1".to_string(),- namespace: None,- tool: "tool".to_string(),- arguments: json!({}),- },- })+ .note_server_request(&request).expect("dynamic tool calls should be rejected");assert_eq!(unsupported.request_id, AppServerRequestId::Integer(99));diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex 1266071d10..be21f4280a 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -445,6 +445,7 @@ impl App {app_server.start_thread_with_session_start_source(&config, /*session_start_source*/ None,+ /*remote_cwd_override*/ None,).await}@@ -2320,6 +2321,33 @@ impl App {AppEvent::AgentsOverviewThreadsLoaded { request_id, result } => {self.apply_agents_overview_thread_refresh(app_server, request_id, result);}+ AppEvent::SelectAgentsOverviewThread { thread_id } => {+ match self+ .select_agents_overview_thread(tui, app_server, thread_id)+ .await?+ {+ AppRunControl::Continue => {}+ AppRunControl::Exit(reason) => return Ok(AppRunControl::Exit(reason)),+ }+ }+ AppEvent::DispatchAgentsOverviewTask { prompt, cwd } => {+ self.dispatch_agents_overview_task(app_server, prompt, cwd)+ .await;+ }+ AppEvent::RenameAgentsOverviewThread { thread_id, name } => {+ if let Err(error) = app_server.thread_set_name(thread_id, name.clone()).await {+ if let Ok(mut state) = self.agents_overview.view_state.lock() {+ state.input = name;+ state.renaming = true;+ }+ self.chat_widget+ .add_error_message(format!("Failed to rename task: {error}"));+ }+ }+ AppEvent::StopAgentsOverviewThread { thread_id } => {+ self.stop_agents_overview_thread(app_server, thread_id)+ .await;+ }AppEvent::OpenAgentPicker => {self.open_agent_picker(app_server).await;}diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rsindex 696fbfe5c7..60e6c54004 100644--- a/codex-rs/tui/src/app/session_lifecycle.rs+++ b/codex-rs/tui/src/app/session_lifecycle.rs@@ -529,6 +529,9 @@ impl App {&mut snapshot,).await;+ if snapshot.input_state.is_none() {+ snapshot.input_state = self.agents_overview.input_states.remove(&thread_id);+ }let blocks_direct_input = self.agent_navigation.is_parent_owned(thread_id);self.active_thread_id = Some(thread_id);@@ -728,7 +731,11 @@ impl App {}self.config = config.clone();match app_server- .start_thread_with_session_start_source(&config, session_start_source)+ .start_thread_with_session_start_source(+ &config,+ session_start_source,+ /*remote_cwd_override*/ None,+ ).await{Ok(mut started) => {@@ -1091,6 +1098,8 @@ impl App {{Ok(()) => {self.backfill_loaded_subagent_threads(app_server).await;+ self.replay_agents_overview_requests(app_server, resumed_thread_id)+ .await;if let Some(summary) = summary {let mut lines: Vec<Line<'static>> = Vec::new();if let Some(usage_line) = summary.usage_line {diff --git a/codex-rs/tui/src/app/working_directory.rs b/codex-rs/tui/src/app/working_directory.rsindex 7f4dad99b8..3212f9085a 100644--- a/codex-rs/tui/src/app/working_directory.rs+++ b/codex-rs/tui/src/app/working_directory.rs@@ -128,7 +128,9 @@ impl App {.await} else {app_server- .start_thread_with_session_start_source(&config, /*session_start_source*/ None)+ .start_thread_with_session_start_source(+ &config, /*session_start_source*/ None, /*remote_cwd_override*/ None,+ ).await};let transitioned = match transitioned {diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex 64a4643506..506778538a 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -195,13 +195,31 @@ pub(crate) enum TranscriptExportDestination {#[allow(clippy::large_enum_variant)]#[derive(Debug)]pub(crate) enum AppEvent {- /// Open the daemon-wide overview of loaded root sessions and their subagents.+ /// Open the daemon-wide overview of loaded root sessions.OpenAgentsOverview,/// Update the daemon-wide overview after a background thread listing finishes.AgentsOverviewThreadsLoaded {request_id: Uuid,result: Result<Vec<Thread>, String>,},+ /// Switch to a root session selected from the shared dashboard.+ SelectAgentsOverviewThread {+ thread_id: ThreadId,+ },+ /// Start a background task directly from the shared dashboard.+ DispatchAgentsOverviewTask {+ prompt: String,+ cwd: Option<AbsolutePathBuf>,+ },+ /// Rename a task directly from the shared dashboard.+ RenameAgentsOverviewThread {+ thread_id: ThreadId,+ name: String,+ },+ /// Interrupt a task directly from the shared dashboard.+ StopAgentsOverviewThread {+ thread_id: ThreadId,+ },/// Open the agent picker for switching active threads.OpenAgentPicker,/// Merge a completed root-scoped agent-picker refresh without blocking terminal input.diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex 491c35ce52..420c1fdabf 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -602,21 +602,24 @@ impl AppServerSession {#[cfg(test)]pub(crate) async fn start_thread(&mut self, config: &Config) -> Result<AppServerStartedThread> {- self.start_thread_with_session_start_source(config, /*session_start_source*/ None)- .await+ self.start_thread_with_session_start_source(+ config, /*session_start_source*/ None, /*remote_cwd_override*/ None,+ )+ .await}pub(crate) async fn start_thread_with_session_start_source(&mut self,config: &Config,session_start_source: Option<ThreadStartSource>,+ remote_cwd_override: Option<&std::path::Path>,) -> Result<AppServerStartedThread> {let request_id = self.next_request_id();let session_config = self.session_config_with_effective_service_tier(config);let mut params = thread_start_params_from_config(&session_config,self.thread_params_mode(),- self.remote_cwd_override.as_deref(),+ remote_cwd_override.or(self.remote_cwd_override.as_deref()),session_start_source,);if self.history_support == ThreadHistorySupport::LegacyOnly {diff --git a/codex-rs/tui/src/snapshots/codex_tui__app__agents_overview__tests__agents_overview.snap b/codex-rs/tui/src/snapshots/codex_tui__app__agents_overview__tests__agents_overview.snapindex 3434395801..19c033e869 100644--- a/codex-rs/tui/src/snapshots/codex_tui__app__agents_overview__tests__agents_overview.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__app__agents_overview__tests__agents_overview.snap@@ -1,29 +1,28 @@---source: tui/src/app/agents_overview_tests.rs-assertion_line: 49-expression: "render_bottom_popup(&app.chat_widget, 96)"+expression: "render_bottom_popup(&app.chat_widget,\n96).replace(&test_path_display(\"/tmp/project\"), \"/tmp/project\")"---Agent command center- 1 need input 0 working 0 ready+ 1 need input 1 working 0 ready────────────────────────────────────────────────────────────────────────────────────────────- /tmp/project 1- › ● Example task current Needs input------------------- ↑↓ navigate ctrl+f search ctrl+s group esc back+ /tmp/project 2 │ Task details+ › ● Build the dashboard current Needs input │+ ● Repair authentication Working │ Build the dashboard+ │ ● Needs input+ │+ │ Project+ │ /tmp/project+ │+ │ Latest activity+ │ Build the dashboard+ │+ │+ │+ │+ │+ │+ │+ │+ │+ New task › Describe a task and press enter to dispatch it+ ↑↓ navigate enter open ctrl+f search ctrl+s group ctrl+r rename ctrl+x stop esc back