From b7056f3408522716b6643c8b3e23ce7c9b53b041 Mon Sep 17 00:00:00 2001 From: Benjamin Carlsson Date: Sun, 15 Nov 2026 01:22:18 +0000 Subject: [PATCH] Keep agent overview refresh state scoped to each backend (#61596) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Why Switching backends while an overview refresh is pending can lose queued pagination or let a late page consume another backend's refill budget. ## What changed - Track queued refreshes, “Show more” requests, refill counts, and refresh failures per backend. - Preserve pending work across backend switches and use registered live request handles to refresh the owning backend. - Cancel stale reads for the affected backend after mutations, event lag, or disconnects, and hide “Show more” when its backend is disconnected. ## Testing Add regression coverage for pagination across focus changes, backend-specific refills, pin completion, stale reads after event lag, and connection registration during reconnect. GitOrigin-RevId: 3429b2b3ac93156b4dc4234ad042431d26c84525 --- codex-rs/tui/src/app/agents_overview.rs | 233 +++++++++++++----- .../tui/src/app/agents_overview_actions.rs | 45 ++-- .../src/app/agents_overview_actions_tests.rs | 80 +++++- .../app/agents_overview_discovery_tests.rs | 64 +++-- codex-rs/tui/src/app/agents_overview_tests.rs | 196 ++++++++++++++- .../tui/src/app/agents_overview_threads.rs | 147 ++++++++--- codex-rs/tui/src/app/app_server_events.rs | 34 +-- codex-rs/tui/src/app/backend_events.rs | 7 +- codex-rs/tui/src/app/backend_registry.rs | 18 +- codex-rs/tui/src/app/backend_selection.rs | 11 +- codex-rs/tui/src/app/event_dispatch.rs | 6 +- codex-rs/tui/src/app/reconnect.rs | 58 +++-- codex-rs/tui/src/app/startup.rs | 13 +- .../tui/src/app/tests/backend_event_tests.rs | 19 +- .../app/tests/navigation_reconnect_tests.rs | 37 ++- .../tui/src/app/tests/new_session_tests.rs | 20 +- .../app/tests/session_lifecycle_requests.rs | 14 +- codex-rs/tui/src/app_event.rs | 2 + 18 files changed, 777 insertions(+), 227 deletions(-) diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rs index f1f9e8b90c..6f6896a1af 100644 --- a/codex-rs/tui/src/app/agents_overview.rs +++ b/codex-rs/tui/src/app/agents_overview.rs @@ -1,5 +1,5 @@ -//! Overview of recent and locally retained sessions and their subagents. -//! Tasks owned by another app server open as frozen, read-only history snapshots. +//! Overview of recent and locally retained sessions across registered backends. +//! Selecting a task on another backend prepares its owner before switching the UI. //! Only the immediate attachment of a dashboard-created task is treated as fresh. #[path = "agents_overview_new.rs"] @@ -26,14 +26,13 @@ use super::*; use crate::app_event::AgentsOverviewThreadRefresh; use crate::backend_id::BackendId; use crate::bottom_pane::BottomPaneView; -use crate::bottom_pane::SelectionItem; -use crate::bottom_pane::SelectionViewParams; use crate::chatwidget::ThreadInputStateRestoreMode; use crate::startup_draft::StartupDraftPump; use codex_app_server_protocol::SessionSource; use codex_app_server_protocol::Thread; use codex_app_server_protocol::ThreadHistoryMode; use codex_protocol::protocol::SubAgentSource; +use std::collections::VecDeque; pub(crate) const AGENTS_OVERVIEW_VIEW_ID: &str = "agents-overview"; @@ -57,13 +56,14 @@ pub(super) struct AgentsOverviewState { pub(super) initialized: HashSet, pub(super) discovery: HashMap, - pub(super) show_more_requested: bool, + pub(super) show_more_backends: HashSet, pub(super) refresh_show_more: bool, - /// Vacancies left by lifecycle removals, filled without expanding the visible window. - pub(super) refill_count: usize, + pub(super) refresh_failed_backends: HashSet, + /// Vacancies left by lifecycle removals, tracked by the backend that owned the row. + pub(super) refill_by_backend: HashMap, pub(super) active_refresh: Option<(Uuid, BackendId)>, - pub(super) refresh_pending: bool, - pub(super) refresh_invalidated: bool, + /// Other backends queued while the shared overview refresh slot is occupied. + pub(super) pending_refresh_backends: VecDeque, pub(super) pin_refresh_requested: bool, pub(super) refresh_thread_ids: HashSet, pub(super) active_refresh_thread_ids: HashSet, @@ -89,30 +89,23 @@ pub(super) struct AgentsOverviewState { } impl AgentsOverviewState { - pub(super) fn invalidate_discovery(&mut self, backend: BackendId, displayed: bool) { - self.initialized.remove(&backend); - self.discovery.remove(&backend); - if displayed { - self.reset_visible_pagination(); - self.view_state - .lock() - .unwrap_or_else(std::sync::PoisonError::into_inner) - .has_more = false; - } - self.refresh_invalidated |= self - .active_refresh - .is_some_and(|(_, owner)| owner == backend); + pub(super) fn refill_count(&self, owner: BackendId) -> usize { + self.refill_by_backend + .get(&owner) + .copied() + .unwrap_or_default() } - pub(super) fn reset_visible_pagination(&mut self) { - self.show_more_requested = false; - self.refill_count = 0; - } - - pub(super) fn has_more(&self, backend_id: BackendId) -> bool { - self.discovery - .get(&backend_id) - .is_none_or(super::agents_overview_discovery::AgentsOverviewDiscovery::has_more) + pub(super) fn has_more_for( + &self, + registry: &super::backend_registry::BackendRegistry, + owner: BackendId, + ) -> bool { + registry.request_handle(owner).is_some() + && self + .discovery + .get(&owner) + .is_some_and(super::agents_overview_discovery::AgentsOverviewDiscovery::has_more) } } @@ -150,9 +143,8 @@ impl App { } else { "Reconnecting — agent list is stale" }); - } else { - self.refresh_agents_overview_threads(app_server); } + self.refresh_agents_overview_threads(app_server); } pub(super) fn apply_agents_overview_thread_refresh( @@ -171,10 +163,21 @@ impl App { self.agents_overview.refresh_show_more = false; self.agents_overview.active_refresh_thread_ids.clear(); self.agents_overview.refresh_task = None; - let invalidated = std::mem::take(&mut self.agents_overview.refresh_invalidated); let refill_succeeded = result .as_ref() .is_ok_and(|refresh| refresh.recent_seed_complete); + if !refill_succeeded { + self.agents_overview + .refresh_failed_backends + .insert(refresh_backend_id); + } else if result + .as_ref() + .is_ok_and(|refresh| refresh.discovery.is_some()) + { + self.agents_overview + .refresh_failed_backends + .remove(&refresh_backend_id); + } { let mut state = self .agents_overview @@ -182,10 +185,12 @@ impl App { .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); state.loading = false; - state.refresh_failed = !invalidated && !refill_succeeded; + state.refresh_failed = self + .agents_overview + .refresh_failed_backends + .contains(&app_server.backend_id()); } match result { - _ if invalidated => self.agents_overview.refresh_notifications.clear(), Ok(mut refresh) => { for id in refresh.cleared_unread { self.agents_overview.unread.remove(&id); @@ -204,29 +209,29 @@ impl App { .pins_by_backend .insert(refresh_backend_id, pins); } - let displayed_refresh = refresh_backend_id == app_server.backend_id(); - if refresh.discovery.is_some() - || (displayed_refresh && refresh.recent_seed_complete) - { + if refresh.recent_seed_complete { self.agents_overview.initialized.insert(refresh_backend_id); - } else if displayed_refresh { - self.agents_overview.initialized.remove(&refresh_backend_id); } if let Some(discovery) = refresh.discovery { - if displayed_refresh { - let has_more = discovery.has_more(); - if !has_more { - self.agents_overview.reset_visible_pagination(); - } + if !discovery.has_more() { self.agents_overview - .view_state - .lock() - .unwrap_or_else(std::sync::PoisonError::into_inner) - .has_more = has_more; + .refill_by_backend + .remove(&refresh_backend_id); + self.agents_overview + .show_more_backends + .remove(&refresh_backend_id); } self.agents_overview .discovery .insert(refresh_backend_id, discovery); + let has_more = self + .agents_overview + .has_more_for(&self.backend_registry, app_server.backend_id()); + self.agents_overview + .view_state + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .has_more = has_more; } for (thread_id, thread) in refresh.threads { if self.agents_overview.removed_threads.contains(&thread_id) { @@ -256,13 +261,15 @@ impl App { self.agents_overview.usage.remove(&thread_id); continue; } - if displayed_refresh - && !self.agents_overview.threads.contains_key(&thread_id) + if !self.agents_overview.threads.contains_key(&thread_id) && !self.agents_overview.hidden_threads.contains(&thread_id) && is_overview_root(&thread) + && let Some(refill) = self + .agents_overview + .refill_by_backend + .get_mut(&refresh_backend_id) { - self.agents_overview.refill_count = - self.agents_overview.refill_count.saturating_sub(1); + *refill = refill.saturating_sub(1); } self.agents_overview .activity @@ -300,14 +307,116 @@ impl App { self.track_agents_overview_notification(¬ification); } } - if std::mem::take(&mut self.agents_overview.refresh_pending) - || invalidated - || (refill_succeeded - && (self.agents_overview.refill_count > 0 - || self.agents_overview.show_more_requested) - && self.agents_overview.has_more(app_server.backend_id())) + let overview = &mut self.agents_overview; + if refill_succeeded { + for (&owner, discovery) in &overview.discovery { + if owner == app_server.backend_id() + && discovery.has_more() + && (overview.refill_count(owner) > 0 + || overview.show_more_backends.contains(&owner)) + && !overview.pending_refresh_backends.contains(&owner) + { + overview.pending_refresh_backends.push_back(owner); + } + } + } + self.drain_agents_overview_refresh_queue(); + self.repaint_agents_overview(); + } + + pub(super) fn drain_agents_overview_refresh_queue(&mut self) { + if self.agents_overview.active_refresh.is_some() || self.reconnect.offline { + return; + } + let visible = self + .chat_widget + .selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID) + .is_some(); + if let Some((backend_id, handle)) = self + .agents_overview + .pending_refresh_backends + .iter() + .copied() + .filter(|&backend_id| { + self.app_server_backend_id + .is_none_or(|owner| owner == backend_id) + && (visible || !self.agents_overview.initialized.contains(&backend_id)) + }) + .find_map(|backend_id| { + self.backend_registry + .request_handle(backend_id) + .map(|handle| (backend_id, handle)) + }) { - self.refresh_changed_agents_overview_threads(app_server); + self.start_agents_overview_refresh_for_backend(backend_id, handle); + } + } + + pub(super) fn reset_agents_overview_discovery(&mut self, backend_id: BackendId) { + let overview = &mut self.agents_overview; + overview.initialized.remove(&backend_id); + overview.discovery.remove(&backend_id); + overview + .removed_threads + .retain(|thread_id| self.backend_registry.owner(*thread_id) != Some(backend_id)); + overview + .view_state + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .has_more = self + .app_server_backend_id + .is_some_and(|owner| overview.has_more_for(&self.backend_registry, owner)); + } + + pub(super) fn cancel_agents_overview_refresh(&mut self, backend_id: BackendId) { + let overview = &mut self.agents_overview; + if overview + .active_refresh + .is_some_and(|(_, owner)| owner == backend_id) + { + if let Some(task) = overview.refresh_task.take() { + task.abort(); + } + overview.active_refresh = None; + overview.refresh_notifications.clear(); + if std::mem::take(&mut overview.refresh_show_more) { + overview.show_more_backends.insert(backend_id); + } + let removed_threads = &overview.removed_threads; + overview.refresh_thread_ids.extend( + overview + .active_refresh_thread_ids + .drain() + .filter(|id| !removed_threads.contains(id)), + ); + overview + .view_state + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .loading = false; + } + overview + .pending_refresh_backends + .retain(|id| *id != backend_id); + if self.backend_registry.request_handle(backend_id).is_none() { + overview.refresh_failed_backends.remove(&backend_id); + } + self.drain_agents_overview_refresh_queue(); + { + let mut state = self + .agents_overview + .view_state + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + state.has_more = self.app_server_backend_id.is_some_and(|owner| { + self.agents_overview + .has_more_for(&self.backend_registry, owner) + }); + state.refresh_failed = self.app_server_backend_id.is_some_and(|owner| { + self.agents_overview + .refresh_failed_backends + .contains(&owner) + }); } self.repaint_agents_overview(); } diff --git a/codex-rs/tui/src/app/agents_overview_actions.rs b/codex-rs/tui/src/app/agents_overview_actions.rs index a15cf413f5..d5414302f4 100644 --- a/codex-rs/tui/src/app/agents_overview_actions.rs +++ b/codex-rs/tui/src/app/agents_overview_actions.rs @@ -7,6 +7,7 @@ use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID; use crate::app_event::AgentsOverviewAction; use crate::app_event::AppEvent; use crate::app_server_session::AppServerSession; +use crate::backend_id::BackendId; use crate::bottom_pane::SelectionItem; use crate::bottom_pane::SelectionViewParams; use crate::chatwidget::ChatWidget; @@ -107,6 +108,7 @@ impl App { } let request_id = Uuid::new_v4(); self.agents_overview.pending_pin_change = Some((request_id, app_server.backend_id())); + let backend_id = app_server.backend_id(); let request_handle = app_server.request_handle(); let app_event_tx = self.app_event_tx.clone(); tokio::spawn(async move { @@ -123,6 +125,7 @@ impl App { .map(|_| ()) .map_err(|error| error.to_string()); app_event_tx.send(AppEvent::AgentsOverviewPinToggled { + backend_id, request_id, thread_id, pinned, @@ -134,6 +137,7 @@ impl App { pub(super) fn complete_agents_overview_pin( &mut self, app_server: &AppServerSession, + backend_id: BackendId, request_id: Uuid, thread_id: ThreadId, pinned: bool, @@ -142,7 +146,7 @@ impl App { let Some((_, owner)) = self .agents_overview .pending_pin_change - .filter(|(id, _)| *id == request_id) + .filter(|(id, owner)| *id == request_id && *owner == backend_id) else { return; }; @@ -168,21 +172,11 @@ impl App { )); } } - let restore_show_more = self.agents_overview.refresh_show_more; - if let Some(refresh) = self.agents_overview.refresh_task.take() { - refresh.abort(); + self.cancel_agents_overview_refresh(backend_id); + if backend_id == app_server.backend_id() { + self.refresh_agents_overview_threads(app_server); } - self.agents_overview.active_refresh = None; - self.agents_overview.refresh_show_more = false; - self.agents_overview.refresh_notifications.clear(); - let refresh_thread_ids = - std::mem::take(&mut self.agents_overview.active_refresh_thread_ids); - self.agents_overview - .refresh_thread_ids - .extend(refresh_thread_ids); - self.agents_overview.refresh_pending = false; - self.agents_overview.show_more_requested |= restore_show_more; - self.refresh_agents_overview_threads(app_server); + self.repaint_agents_overview(); } @@ -375,22 +369,7 @@ impl App { .unwrap_or_else(std::sync::PoisonError::into_inner) .removal = None; let (result, detach_primary) = outcome?; - if attempted { - // A read started before the RPC can contain stale task and approval state. - if let Some(refresh) = self.agents_overview.refresh_task.take() { - refresh.abort(); - } - self.agents_overview.active_refresh = None; - self.agents_overview.refresh_show_more = false; - self.agents_overview.active_refresh_thread_ids.clear(); - self.agents_overview - .view_state - .lock() - .unwrap_or_else(std::sync::PoisonError::into_inner) - .loading = false; - self.agents_overview.refresh_pending = false; - self.agents_overview.refresh_notifications.clear(); - } + if result.is_ok() { let mut removed = if removes_subtree { self.known_thread_subtree(thread_id) @@ -413,6 +392,10 @@ impl App { self.agents_overview.dispatched_requests.remove(&removed_id); } } + if attempted { + // Discard reads started before the mutation after recording the removed threads. + self.cancel_agents_overview_refresh(app_server.backend_id()); + } if detach_primary { self.agents_overview.selection_after_removal = self.agents_overview.selection_after_removal.or_else(|| { diff --git a/codex-rs/tui/src/app/agents_overview_actions_tests.rs b/codex-rs/tui/src/app/agents_overview_actions_tests.rs index ee0b1cc0a9..97c762786d 100644 --- a/codex-rs/tui/src/app/agents_overview_actions_tests.rs +++ b/codex-rs/tui/src/app/agents_overview_actions_tests.rs @@ -5,6 +5,7 @@ use crate::app_event::AgentsOverviewAction; use codex_app_server_protocol::ClientRequest; use codex_app_server_protocol::RequestId; use codex_app_server_protocol::ThreadLoadedListParams; +use codex_app_server_protocol::ThreadStatusChangedNotification; use codex_app_server_protocol::TurnStartParams; use codex_app_server_protocol::TurnStartResponse; use codex_model_provider_info::ModelProviderInfo; @@ -21,9 +22,28 @@ async fn pin_action_updates_shared_section_state() -> Result<()> { let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; let started = app_server.start_thread(&app.config).await?; let thread_id = started.session.thread_id; + attach_thread(&mut app, thread_id); let mut tui = crate::tui::test_support::make_test_tui()?; + app.backend_registry.connect(&app_server); + app.open_agents_overview(&app_server); + finish_overview_refresh(&mut app, &app_server, &mut rx).await; + let status_changed = |status| { + ServerNotification::ThreadStatusChanged(ThreadStatusChangedNotification { + thread_id: thread_id.to_string(), + status, + }) + }; for pinned in [true, false] { + app.refresh_agents_overview_threads(&app_server); + app.track_agents_overview_notification(&status_changed(ThreadStatus::Active { + active_flags: Vec::new(), + })); + assert!( + app.agents_overview + .refresh_notifications + .contains_key(&thread_id) + ); Box::pin(app.handle_event( &mut tui, &mut app_server, @@ -34,6 +54,12 @@ async fn pin_action_updates_shared_section_state() -> Result<()> { .agents_overview .pending_pin_change .expect("pin request started"); + app.chat_widget.handle_key_event(KeyCode::Esc.into()); + assert!( + app.chat_widget + .selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID) + .is_none() + ); let completed = tokio::time::timeout(std::time::Duration::from_secs(15), async { loop { let event = rx.recv().await.expect("pin request completes"); @@ -45,12 +71,19 @@ async fn pin_action_updates_shared_section_state() -> Result<()> { } }) .await?; - app.agents_overview - .refresh_notifications - .insert(thread_id, Vec::new()); Box::pin(app.handle_event(&mut tui, &mut app_server, completed)).await?; assert_eq!(app.agents_overview.pending_pin_change, None); - assert!(app.agents_overview.refresh_notifications.is_empty()); + assert_eq!(app.agents_overview.active_refresh, None); + app.track_agents_overview_notification(&status_changed(ThreadStatus::Idle)); + app.open_agents_overview(&app_server); + finish_overview_refresh(&mut app, &app_server, &mut rx).await; + assert_eq!( + app.agents_overview.threads[&thread_id] + .as_ref() + .unwrap() + .status, + ThreadStatus::Idle + ); let threads = list_pinned_threads(&app_server.request_handle()) .await .map_err(color_eyre::eyre::Report::msg)? @@ -181,6 +214,44 @@ async fn cloud_archive_preserves_attached_child_and_other_tasks() -> Result<()> Ok(()) } +#[tokio::test] +async fn pin_completion_cancels_the_originating_backends_stale_refresh() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; + let backend_id = BackendId::new(); + let thread_id = ThreadId::new(); + app.backend_registry.observe(backend_id, thread_id); + app.agents_overview + .pins_by_backend + .insert(backend_id, Some(Vec::new())); + let pin_request = Uuid::new_v4(); + app.agents_overview.pending_pin_change = Some((pin_request, backend_id)); + let stale_refresh = Uuid::new_v4(); + app.agents_overview.active_refresh = Some((stale_refresh, backend_id)); + let mut tui = crate::tui::test_support::make_test_tui()?; + + Box::pin(app.handle_event( + &mut tui, + &mut app_server, + AppEvent::AgentsOverviewPinToggled { + backend_id, + request_id: pin_request, + thread_id, + pinned: true, + result: Ok(()), + }, + )) + .await?; + + assert_eq!(app.agents_overview.active_refresh, None); + assert_eq!( + app.agents_overview.pins_by_backend[&backend_id], + Some(vec![thread_id]) + ); + app_server.shutdown().await?; + Ok(()) +} + #[tokio::test] async fn archive_confirmation_number_keys_act_immediately() { for key in ['1', '2'] { @@ -977,6 +1048,7 @@ async fn lifecycle_removes_background_and_current_tasks_without_losing_the_dashb }; let mut tui = crate::tui::test_support::make_test_tui()?; tui.pause_events(); + app.backend_registry.connect(&app_server); app.open_agents_overview(&app_server); if action == AgentsOverviewAction::Archive { let rollout = app_server diff --git a/codex-rs/tui/src/app/agents_overview_discovery_tests.rs b/codex-rs/tui/src/app/agents_overview_discovery_tests.rs index cd5ee4f7b2..73438391cc 100644 --- a/codex-rs/tui/src/app/agents_overview_discovery_tests.rs +++ b/codex-rs/tui/src/app/agents_overview_discovery_tests.rs @@ -214,6 +214,9 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> { crate::connect_remote_app_server(endpoint).await?, ThreadParamsMode::Remote, ); + let owner = session.backend_id(); + app.app_server_backend_id = Some(owner); + app.backend_registry.connect(&session); let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None); app.chat_widget.show_bottom_pane_view(Box::new(view)); let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); @@ -225,7 +228,10 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> { app.agents_overview.pins_by_backend[&session.backend_id()], Some(vec![ids[1]]) ); - assert!(app.agents_overview.has_more(session.backend_id())); + assert!( + app.agents_overview + .has_more_for(&app.backend_registry, owner) + ); let browse = app.agents_overview.threads.clone(); let browse_rows = || browse.values().flatten().cloned().collect(); let mut view = app.agents_overview_view(browse_rows(), Some(ids[4])); @@ -259,6 +265,11 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> { assert!(rendered.contains("1 of 10"), "{rendered}"); // The pinned task has its own group. view.handle_key_event(KeyCode::Esc.into()); + if mixed_sources { + // Queue Show more behind a metadata refresh before the archive creates a vacancy. + app.refresh_agents_overview_threads(&session); + app.show_more_agents_overview(&session); + } app.track_agents_overview_notification(&ServerNotification::ThreadArchived( ThreadArchivedNotification { thread_id: ids[0].to_string(), @@ -268,7 +279,9 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> { expected.remove(&ids[0]); app.refresh_agents_overview_threads(&session); finish_overview_refresh(&mut app, &session, &mut rx).await; - if !mixed_sources { + if mixed_sources { + finish_overview_refresh(&mut app, &session, &mut rx).await; + } else { assert_eq!(app.agents_overview.threads.len(), 9); assert!( app.agents_overview @@ -283,31 +296,51 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> { assert_eq!(app.agents_overview.threads.len(), 10); assert!(app.agents_overview.threads.contains_key(&ids[10])); let other = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?; + let other_owner = other.backend_id(); if mixed_sources { let archived = ids[22]; - app.backend_registry.observe(session.backend_id(), archived); + app.backend_registry.observe(owner, archived); app.track_agents_overview_notification(&ServerNotification::ThreadArchived( ThreadArchivedNotification { thread_id: archived.to_string(), }, )); expected.remove(&archived); + } else { + app.show_more_agents_overview(&session); } - app.agents_overview.reset_visible_pagination(); + assert!( + app.agents_overview.active_refresh.is_some(), + "Show more should load a page after the vacancy is filled" + ); + assert_eq!( + app.agents_overview.active_refresh.map(|(_, owner)| owner), + Some(owner) + ); + // The page may finish while another backend is displayed, or after returning. + app.app_server_backend_id = Some(other_owner); + app.backend_registry.connect(&other); + assert!(app.backend_registry.request_handle(owner).is_some()); + assert!( + !app.agents_overview + .has_more_for(&app.backend_registry, other_owner) + ); + app.show_more_agents_overview(&other); + assert!(app.agents_overview.pending_refresh_backends.is_empty()); if mixed_sources { app.refresh_agents_overview_threads(&other); - finish_overview_refresh(&mut app, &other, &mut rx).await; } - app.agents_overview.reset_visible_pagination(); - app.show_more_agents_overview(&session); - // The page may finish while another backend is displayed, or after returning. - app.agents_overview.reset_visible_pagination(); + finish_overview_refresh(&mut app, &other, &mut rx).await; if mixed_sources { - finish_overview_refresh(&mut app, &session, &mut rx).await; - } else { finish_overview_refresh(&mut app, &other, &mut rx).await; - app.agents_overview.reset_visible_pagination(); + assert!(app.agents_overview.initialized.contains(&other_owner)); } + app.app_server_backend_id = Some(owner); + assert!( + app.agents_overview + .has_more_for(&app.backend_registry, owner) + ); + app.backend_registry.disconnect(other_owner); other.shutdown().await?; assert_eq!( app.agents_overview @@ -334,7 +367,10 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> { app.refresh_agents_overview_threads(&session); finish_overview_refresh(&mut app, &session, &mut rx).await; assert_eq!(app.agents_overview.threads, expected); - assert!(!app.agents_overview.has_more(session.backend_id())); + assert!( + !app.agents_overview + .has_more_for(&app.backend_registry, owner) + ); let old = app.agents_overview.threads[&ids[23]].as_ref().unwrap(); assert_eq!(old.preview, "Task 23"); assert_eq!( @@ -356,7 +392,7 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> { view.handle_key_event(KeyCode::Esc.into()); app.agents_overview.threads.clear(); app.agents_overview.pins_by_backend = [(session.backend_id(), Some(Vec::new()))].into(); - app.agents_overview.refill_count = 0; + app.agents_overview.refill_by_backend.clear(); app.refresh_agents_overview_threads(&session); finish_overview_refresh(&mut app, &session, &mut rx).await; assert_eq!( diff --git a/codex-rs/tui/src/app/agents_overview_tests.rs b/codex-rs/tui/src/app/agents_overview_tests.rs index 1a7ac065a1..8868c69dd8 100644 --- a/codex-rs/tui/src/app/agents_overview_tests.rs +++ b/codex-rs/tui/src/app/agents_overview_tests.rs @@ -293,6 +293,102 @@ async fn overview_opens_a_search_only_task_on_the_search_backend() -> Result<()> Ok(()) } +#[tokio::test] +async fn late_overview_page_only_refills_its_own_backend() { + let mut app = make_test_app().await; + let displayed = BackendId::new(); + let other = BackendId::new(); + let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1); + let session = AppServerSession::new( + displayed, + AppServerClient::Cloud(client), + ThreadParamsMode::Cloud, + ); + app.app_server_backend_id = Some(displayed); + let id = ThreadId::new(); + assert!(app.backend_registry.observe(displayed, id)); + app.agents_overview.threads.insert( + id, + Some(overview_thread( + id, + /*parent_thread_id*/ None, + "Removed", + ThreadStatus::Idle, + )), + ); + app.remove_agents_overview_thread(id); + + for owner in [other, displayed] { + let request_id = Uuid::new_v4(); + let replacement = ThreadId::new(); + let row = overview_thread( + replacement, + /*parent_thread_id*/ None, + "Replacement", + ThreadStatus::Idle, + ); + app.agents_overview.active_refresh = Some((request_id, owner)); + app.apply_agents_overview_thread_refresh( + &session, + request_id, + Ok(AgentsOverviewThreadRefresh { + cleared_unread: Vec::new(), + threads: HashMap::from([(replacement, Some((row, false, None)))]), + last_messages: HashMap::new(), + recent_seed_complete: true, + discovery: None, + pinned_thread_ids: None, + }), + ); + assert_eq!(app.agents_overview.refill_count(other), 0); + assert_eq!( + app.agents_overview.refill_count(displayed), + usize::from(owner != displayed) + ); + } +} + +#[tokio::test] +async fn queued_overview_page_survives_a_focus_change() { + let mut app = make_test_app().await; + let owner = BackendId::new(); + let other = BackendId::new(); + let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1); + let session = AppServerSession::new( + owner, + AppServerClient::Cloud(client), + ThreadParamsMode::Cloud, + ); + app.backend_registry.connect(&session); + app.app_server_backend_id = Some(owner); + app.agents_overview.initialized.insert(owner); + app.agents_overview + .discovery + .insert(owner, Default::default()); + app.agents_overview.active_refresh = Some((Uuid::new_v4(), other)); + app.open_agents_overview(&session); + app.show_more_agents_overview(&session); + + app.app_server_backend_id = Some(other); + app.agents_overview.active_refresh = None; + app.drain_agents_overview_refresh_queue(); + assert_eq!( + app.agents_overview.pending_refresh_backends.front(), + Some(&owner) + ); + assert!(app.agents_overview.active_refresh.is_none()); + + app.app_server_backend_id = Some(owner); + app.open_agents_overview(&session); + assert_eq!( + app.agents_overview.active_refresh.map(|(_, id)| id), + Some(owner) + ); + assert!(app.agents_overview.pending_refresh_backends.is_empty()); + assert!(app.agents_overview.refresh_show_more); + app.cancel_agents_overview_refresh(owner); +} + #[tokio::test] async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> { let mut app = make_test_app().await; @@ -315,6 +411,7 @@ async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> { let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); app.app_event_tx = AppEventSender::new(tx); app.app_server_backend_id = Some(displayed.backend_id()); + app.backend_registry.connect(&displayed); let local_reads = HashMap::from([(local_id, Some((local, false, None))), (remote_id, None)]); let remote_reads = HashMap::from([ (remote_id, Some((remote.clone(), false, None))), @@ -347,7 +444,7 @@ async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> { threads: reads, last_messages: HashMap::new(), recent_seed_complete: owner == remote_owner, - discovery: (owner != displayed.backend_id()).then(Default::default), + discovery: (owner == remote_owner).then(Default::default), pinned_thread_ids: Some(pins), }), ); @@ -471,6 +568,37 @@ async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> { Ok(()) } +#[tokio::test] +async fn overview_hides_show_more_when_only_paginated_backend_disconnects() { + let mut app = make_test_app().await; + let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1); + let session = AppServerSession::new( + BackendId::new(), + AppServerClient::Cloud(client), + crate::app_server_session::ThreadParamsMode::Cloud, + ); + let owner = session.backend_id(); + app.backend_registry.connect(&session); + app.agents_overview + .discovery + .insert(owner, Default::default()); + app.agents_overview.view_state.lock().unwrap().has_more = true; + + app.backend_registry.disconnect(owner); + app.cancel_agents_overview_refresh(owner); + app.reconnect.offline = true; + app.open_agents_overview(&session); + + assert!(app.backend_registry.request_handle(owner).is_none()); + assert!( + !app.agents_overview + .has_more_for(&app.backend_registry, owner) + ); + assert!(!app.agents_overview.view_state.lock().unwrap().has_more); + app.show_more_agents_overview(&session); + assert!(app.agents_overview.active_refresh.is_none()); +} + #[tokio::test] async fn overview_right_opens_current_or_highlighted_task() { let mut app = make_test_app().await; @@ -605,7 +733,7 @@ pub(in crate::app) fn overview_thread( #[tokio::test] async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Result<()> { - let mut app = make_test_app().await; + let (mut app, mut events, _) = make_test_app_with_channels().await; let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; let mut tui = crate::tui::test_support::make_test_tui()?; let [retained, archived, deleted, created] = std::array::from_fn(|_| ThreadId::new()); @@ -770,6 +898,46 @@ async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Re assert!(app.agents_overview.activity.contains_key(&retained)); assert!(app.agents_overview.active_refresh.is_none()); } + + // Archive a retained task while its metadata refresh is in flight, then lose events. + app.backend_registry.connect(&app_server); + app.refresh_agents_overview_threads(&app_server); + let interrupted_request = app.agents_overview.active_refresh.unwrap().0; + app.handle_app_server_event( + &app_server, + AppServerEvent::ServerNotification(Box::new(ServerNotification::ThreadArchived( + ThreadArchivedNotification { + thread_id: retained.to_string(), + }, + ))), + ) + .await; + assert_eq!( + app.agents_overview.active_refresh.map(|(id, _)| id), + Some(interrupted_request) + ); + assert!(app.agents_overview.removed_threads.contains(&retained)); + assert!( + app.agents_overview + .active_refresh_thread_ids + .contains(&retained) + ); + + app.handle_app_server_event(&app_server, AppServerEvent::Lagged { skipped: 1 }) + .await; + let restarted_request = app + .agents_overview + .active_refresh + .expect("lag starts a replacement refresh") + .0; + assert_ne!(restarted_request, interrupted_request); + // Check the replacement read targets before applying any results. + assert_eq!( + app.agents_overview.active_refresh_thread_ids, + HashSet::from([created]) + ); + finish_overview_refresh(&mut app, &app_server, &mut events).await; + assert!(!app.agents_overview.threads.contains_key(&retained)); app_server.shutdown().await?; Ok(()) } @@ -851,6 +1019,7 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res }; let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel(); app.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx); + app.backend_registry.connect(&app_server); app.refresh_agents_overview_threads(&app_server); finish_overview_refresh(&mut app, &app_server, &mut event_rx).await; let recent_ids: HashSet<_> = ids[2..].iter().copied().collect(); @@ -941,6 +1110,7 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res let app_server = Box::pin(crate::start_embedded_app_server_for_picker(&config)).await?; let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel(); restarted.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx); + restarted.backend_registry.connect(&app_server); restarted.refresh_agents_overview_threads(&app_server); finish_overview_refresh(&mut restarted, &app_server, &mut event_rx).await; let retained: HashSet<_> = restarted.agents_overview.threads.keys().copied().collect(); @@ -953,7 +1123,11 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res "agents_overview_recent_sessions", age.replace_all(&rendered, " [age]") ); - assert!(restarted.agents_overview.has_more(app_server.backend_id())); + assert!( + restarted + .agents_overview + .has_more_for(&restarted.backend_registry, app_server.backend_id()) + ); // Opening starts a metadata refresh; Show more queues behind it. restarted.show_more_agents_overview(&app_server); finish_overview_refresh(&mut restarted, &app_server, &mut event_rx).await; @@ -967,7 +1141,11 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res .collect::>(), ids.into_iter().collect() ); - assert!(!restarted.agents_overview.has_more(app_server.backend_id())); + assert!( + !restarted + .agents_overview + .has_more_for(&restarted.backend_registry, app_server.backend_id()) + ); app_server.shutdown().await?; Ok(()) } @@ -1046,7 +1224,9 @@ async fn check_hidden_thread_does_not_refresh_shared_overview(source: &str) { assert_eq!( ( app.agents_overview.active_refresh.map(|(id, _)| id), - app.agents_overview.refresh_pending, + app.agents_overview + .pending_refresh_backends + .contains(&app_server.backend_id()), ), (Some(request_id), false) ); @@ -1077,7 +1257,9 @@ async fn check_hidden_thread_does_not_refresh_shared_overview(source: &str) { assert_eq!( ( app.agents_overview.active_refresh.map(|(id, _)| id), - app.agents_overview.refresh_pending, + app.agents_overview + .pending_refresh_backends + .contains(&app_server.backend_id()), ), (Some(request_id), true) ); @@ -3370,7 +3552,7 @@ async fn command_center_refresh_failure_is_inline_and_clears_on_success() -> Res threads: HashMap::new(), last_messages: HashMap::new(), recent_seed_complete: true, - discovery: None, + discovery: Some(Default::default()), pinned_thread_ids: None, }), ); diff --git a/codex-rs/tui/src/app/agents_overview_threads.rs b/codex-rs/tui/src/app/agents_overview_threads.rs index 0156409db1..e31b33f87a 100644 --- a/codex-rs/tui/src/app/agents_overview_threads.rs +++ b/codex-rs/tui/src/app/agents_overview_threads.rs @@ -1,10 +1,13 @@ //! Retains overview membership for this TUI, independently of server subscriptions. -//! A bounded recent seed runs at startup, after reconnect, and after event lag. +//! Each backend owns its initialization and discovery cursor. A bounded recent seed runs +//! at startup, after reconnect, and after event lag. Reopening also checks the +//! newest rows on parked backends. //! Discovery merges into retained membership without evicting rows. use super::App; use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID; use super::agents_overview_details::preview_agent_message; +use super::agents_overview_discovery::AgentsOverviewDiscovery; use super::agents_overview_discovery::is_overview_root; use super::agents_overview_discovery::list_pinned_threads; use super::app_server_event_targets::ServerNotificationThreadTarget; @@ -12,7 +15,9 @@ use super::app_server_event_targets::server_notification_thread_target; use crate::app_event::AgentsOverviewThreadRefresh; use crate::app_event::AppEvent; use crate::app_server_session::AppServerSession; +use crate::backend_id::BackendId; use crate::chatwidget::ChatWidget; +use codex_app_server_client::AppServerRequestHandle; use codex_app_server_protocol::ClientRequest; use codex_app_server_protocol::RequestId; use codex_app_server_protocol::ServerNotification; @@ -28,6 +33,7 @@ use codex_app_server_protocol::ThreadTurnsListResponse; use codex_protocol::ThreadId; use futures::StreamExt; use std::collections::HashMap; +use std::collections::HashSet; use uuid::Uuid; const RECENT_DETAIL_LIMIT: usize = 10; @@ -58,21 +64,37 @@ impl App { self.prepare_agents_overview_removal(&std::collections::HashSet::from([thread_id])); self.agents_overview.search_matches.remove(&thread_id); self.agents_overview.removed_threads.insert(thread_id); + self.agents_overview + .refresh_notifications + .remove(&thread_id); self.agents_overview.unread.remove(&thread_id); if let Some(Some(thread)) = self.agents_overview.threads.remove(&thread_id) && is_overview_root(&thread) && !self.agents_overview.hidden_threads.contains(&thread_id) + && let Some(owner) = self.backend_registry.owner(thread_id) { - self.agents_overview.refill_count += 1; + *self + .agents_overview + .refill_by_backend + .entry(owner) + .or_default() += 1; } } pub(super) fn show_more_agents_overview(&mut self, app_server: &AppServerSession) { - if !self.agents_overview.has_more(app_server.backend_id()) { - return; + let owner = app_server.backend_id(); + if self + .agents_overview + .discovery + .get(&owner) + .is_some_and(AgentsOverviewDiscovery::has_more) + && let Some(handle) = self.backend_registry.request_handle(owner) + { + if self.agents_overview.refill_count(owner) == 0 { + self.agents_overview.show_more_backends.insert(owner); + } + self.start_agents_overview_refresh_for_backend(owner, handle); } - self.agents_overview.show_more_requested |= self.agents_overview.refill_count == 0; - self.start_agents_overview_refresh(app_server); } pub(super) fn track_agents_overview_notification(&mut self, notification: &ServerNotification) { @@ -253,13 +275,41 @@ impl App { { return; } + self.agents_overview.pin_refresh_requested = true; self.start_agents_overview_refresh(app_server); } fn start_agents_overview_refresh(&mut self, app_server: &AppServerSession) { let backend_id = app_server.backend_id(); - let initialized = self.agents_overview.initialized.contains(&backend_id); - let source_has_more = self.agents_overview.has_more(backend_id); + if self.reconnect.offline + || self + .app_server_backend_id + .is_some_and(|owner| owner != backend_id) + { + return; + } + self.backend_registry.connect(app_server); + self.start_agents_overview_refresh_for_backend(backend_id, app_server.request_handle()); + } + + pub(super) fn start_agents_overview_refresh_for_backend( + &mut self, + backend_id: BackendId, + request_handle: AppServerRequestHandle, + ) { + if self.reconnect.offline + && self + .app_server_backend_id + .is_none_or(|owner| owner == backend_id) + { + return; + } + let overview = &mut self.agents_overview; + let initialized = overview.initialized.contains(&backend_id); + let source_has_more = overview + .discovery + .get(&backend_id) + .is_none_or(AgentsOverviewDiscovery::has_more); let visible = self .chat_widget .selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID) @@ -267,24 +317,33 @@ impl App { if !visible && initialized { return; } - if self.agents_overview.active_refresh.is_some() { - self.agents_overview.refresh_pending = true; + if overview.active_refresh.is_some() { + if !overview.pending_refresh_backends.contains(&backend_id) { + overview.pending_refresh_backends.push_back(backend_id); + } return; } - if initialized - && self.agents_overview.refresh_thread_ids.is_empty() - && !self.agents_overview.show_more_requested - && !(self.agents_overview.refill_count > 0 && source_has_more) - && !self.agents_overview.pin_refresh_requested - { + let refill = overview.refill_count(backend_id); + let queued = overview.pending_refresh_backends.contains(&backend_id); + if queued { + overview + .pending_refresh_backends + .retain(|id| *id != backend_id); + overview.pin_refresh_requested = true; + } + let should_refresh = !initialized + || overview.refresh_thread_ids.iter().any(|id| { + self.backend_registry + .owner(*id) + .is_none_or(|owner| owner == backend_id) + }) + || overview.show_more_backends.contains(&backend_id) + || (refill > 0 && source_has_more) + || overview.pin_refresh_requested; + if !should_refresh { return; } - let owns_thread = |thread_id| { - self.backend_registry - .owner(thread_id) - .is_none_or(|owner| owner == backend_id) - }; let mut unread_rows = Vec::new(); if std::mem::take(&mut self.agents_overview.pin_refresh_requested) { unread_rows.extend( @@ -292,15 +351,20 @@ impl App { .visible_thread_ids .iter() .copied() - .filter(|id| self.agents_overview.unread.contains(id) && owns_thread(*id)), + .filter(|id| { + self.agents_overview.unread.contains(id) + && self + .backend_registry + .owner(*id) + .is_none_or(|owner| owner == backend_id) + }), ); } let request_id = Uuid::new_v4(); self.agents_overview.active_refresh = Some((request_id, backend_id)); - self.agents_overview.refresh_invalidated = false; - let refill = self.agents_overview.refill_count; - let show_more = - refill == 0 && std::mem::take(&mut self.agents_overview.show_more_requested); + let show_more = refill == 0 + && source_has_more + && self.agents_overview.show_more_backends.remove(&backend_id); self.agents_overview.refresh_show_more = show_more; let discover = !initialized || show_more || (refill > 0 && source_has_more); let limit = if initialized && refill > 0 { @@ -309,23 +373,24 @@ impl App { 10 }; let mut discovery = discover.then(|| { - if initialized { - self.agents_overview - .discovery - .get(&backend_id) - .cloned() - .unwrap_or_default() - } else { - self.agents_overview - .removed_threads - .retain(|id| !owns_thread(*id)); - Default::default() - } + self.agents_overview + .discovery + .get(&backend_id) + .cloned() + .unwrap_or_default() }); - let mut thread_ids = std::mem::take(&mut self.agents_overview.refresh_thread_ids); - thread_ids.retain(|id| owns_thread(*id)); + let (mut thread_ids, foreign_thread_ids) = + std::mem::take(&mut self.agents_overview.refresh_thread_ids) + .into_iter() + .partition::, _>(|thread_id| { + self.backend_registry + .owner(*thread_id) + .is_none_or(|owner| owner == backend_id) + }); + self.agents_overview + .refresh_thread_ids + .extend(foreign_thread_ids); self.agents_overview.active_refresh_thread_ids = thread_ids.clone(); - let request_handle = app_server.request_handle(); let app_event_tx = self.app_event_tx.clone(); self.agents_overview .view_state diff --git a/codex-rs/tui/src/app/app_server_events.rs b/codex-rs/tui/src/app/app_server_events.rs index cccac3bbe6..3f6606caab 100644 --- a/codex-rs/tui/src/app/app_server_events.rs +++ b/codex-rs/tui/src/app/app_server_events.rs @@ -76,19 +76,24 @@ impl App { "app-server event consumer lagged; dropping ignored events" ); self.chat_widget.finish_mcp_startup_after_lag(); - if let Some(task) = self.agents_overview.refresh_task.take() { - task.abort(); - } - self.agents_overview.active_refresh = None; - self.agents_overview.refresh_show_more = false; - self.agents_overview.active_refresh_thread_ids.clear(); - self.agents_overview.refresh_pending = false; + let owner = app_server_client.backend_id(); + self.cancel_agents_overview_refresh(owner); + self.reset_agents_overview_discovery(owner); + let registry = &self.backend_registry; + let belongs_to_other = + |id: &ThreadId| registry.owner(*id).is_some_and(|known| known != owner); self.agents_overview - .invalidate_discovery(app_server_client.backend_id(), /*displayed*/ true); - self.agents_overview.refresh_notifications.clear(); - self.agents_overview.activity.clear(); - self.agents_overview.last_messages.clear(); - self.agents_overview.usage.clear(); + .refresh_notifications + .retain(|id, _| belongs_to_other(id)); + self.agents_overview + .activity + .retain(|id, _| belongs_to_other(id)); + self.agents_overview + .last_messages + .retain(|id, _| belongs_to_other(id)); + self.agents_overview + .usage + .retain(|id, _| belongs_to_other(id)); self.agents_overview.pending_usage = None; self.agents_overview.usage_disabled = false; self.repaint_agents_overview(); @@ -398,8 +403,9 @@ impl App { return; } ServerNotification::AccountUpdated(notification) => { - self.agents_overview - .invalidate_discovery(app_server_client.backend_id(), /*displayed*/ true); + let owner = app_server_client.backend_id(); + self.cancel_agents_overview_refresh(owner); + self.reset_agents_overview_discovery(owner); self.refresh_changed_agents_overview_threads(app_server_client); self.agents_overview.usage.clear(); self.agents_overview.pending_usage = None; diff --git a/codex-rs/tui/src/app/backend_events.rs b/codex-rs/tui/src/app/backend_events.rs index cab6d050fa..82ce650a05 100644 --- a/codex-rs/tui/src/app/backend_events.rs +++ b/codex-rs/tui/src/app/backend_events.rs @@ -37,8 +37,8 @@ impl App { _ => false, }; if invalidates_discovery { - self.agents_overview - .invalidate_discovery(event.backend_id, /*displayed*/ false); + self.cancel_agents_overview_refresh(event.backend_id); + self.reset_agents_overview_discovery(event.backend_id); } if let AppServerEvent::ServerNotification(notification) = &event.event && let ServerNotificationThreadTarget::Thread(thread_id) = @@ -51,10 +51,7 @@ impl App { | ServerNotification::ThreadUnarchived(_) ) && self.backend_registry.owner(thread_id) == Some(event.backend_id) { - // A parked removal must not consume the displayed backend's page budget. - let refill_count = self.agents_overview.refill_count; self.track_agents_overview_notification(notification); - self.agents_overview.refill_count = refill_count; self.repaint_agents_overview(); } if let ServerNotification::ThreadSettingsUpdated(settings) = notification.as_ref() diff --git a/codex-rs/tui/src/app/backend_registry.rs b/codex-rs/tui/src/app/backend_registry.rs index 94631faf93..ac596b87e7 100644 --- a/codex-rs/tui/src/app/backend_registry.rs +++ b/codex-rs/tui/src/app/backend_registry.rs @@ -1,14 +1,17 @@ -//! Tracks conversation ownership across backends. +//! Tracks conversation ownership and the live request handle for each backend. //! A thread ID keeps its first observed owner across connection replacement. +use crate::app_server_session::AppServerSession; use crate::app_server_session::AppServerStartedThread; use crate::backend_id::BackendId; +use codex_app_server_client::AppServerRequestHandle; use codex_protocol::ThreadId; use std::collections::HashMap; #[derive(Default)] pub(super) struct BackendRegistry { owners: HashMap, + connections: HashMap, } impl BackendRegistry { @@ -35,4 +38,17 @@ impl BackendRegistry { } true } + + pub(super) fn connect(&mut self, session: &AppServerSession) { + self.connections + .insert(session.backend_id(), session.request_handle()); + } + + pub(super) fn disconnect(&mut self, owner: BackendId) { + self.connections.remove(&owner); + } + + pub(super) fn request_handle(&self, owner: BackendId) -> Option { + self.connections.get(&owner).cloned() + } } diff --git a/codex-rs/tui/src/app/backend_selection.rs b/codex-rs/tui/src/app/backend_selection.rs index 5d1cb47be0..de7a81160e 100644 --- a/codex-rs/tui/src/app/backend_selection.rs +++ b/codex-rs/tui/src/app/backend_selection.rs @@ -467,16 +467,19 @@ impl App { self.agents_overview.pending_usage = None; self.reset_agents_overview_usage_for_backend_switch(); self.agents_overview.usage_disabled = false; - self.agents_overview.reset_visible_pagination(); self.app_event_tx = AppEventSender::new(self.app_event_tx.app_event_tx.clone()); self.app_server_backend_id = Some(destination.backend_id()); self.app_server_target = target; self.reconnect = Default::default(); if let Ok(mut state) = self.agents_overview.view_state.lock() { state.connection_notice = None; - let destination_id = destination.backend_id(); - state.has_more = self.agents_overview.initialized.contains(&destination_id) - && self.agents_overview.has_more(destination_id); + state.has_more = self + .agents_overview + .has_more_for(&self.backend_registry, destination.backend_id()); + state.refresh_failed = self + .agents_overview + .refresh_failed_backends + .contains(&destination.backend_id()); state.restart_history_search(); } self.rate_limit_hard_stop_generation = self.rate_limit_hard_stop_generation.wrapping_add(1); diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index 61de38b6f4..019903c319 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -104,6 +104,9 @@ impl App { | AppEvent::ManagedWorktreeCreated(_) | AppEvent::AgentsOverviewWorktreeCreated(_) | AppEvent::AgentsOverviewPinToggled { .. } + | AppEvent::OpenAgentsOverview + | AppEvent::ShowMoreAgentsOverview + | AppEvent::AgentsOverviewThreadsLoaded { .. } | AppEvent::AgentsOverviewUsageLoaded { .. } | AppEvent::AppendMessageHistoryEntry { .. } | AppEvent::BeginInitialHistoryReplayBuffer @@ -3382,13 +3385,14 @@ impl App { self.toggle_agents_overview_pin(app_server, thread_id, pinned); } AppEvent::AgentsOverviewPinToggled { + backend_id, request_id, thread_id, pinned, result, } => { self.complete_agents_overview_pin( - app_server, request_id, thread_id, pinned, result, + app_server, backend_id, request_id, thread_id, pinned, result, ); } AppEvent::SuggestThreadName { diff --git a/codex-rs/tui/src/app/reconnect.rs b/codex-rs/tui/src/app/reconnect.rs index 12c82e1984..c253f8fc3f 100644 --- a/codex-rs/tui/src/app/reconnect.rs +++ b/codex-rs/tui/src/app/reconnect.rs @@ -270,24 +270,40 @@ impl App { self.overlay = None; self.commit_animation = None; self.clear_recap_request(crate::app_event::RecapTrigger::Manual); - if let Some(task) = self.agents_overview.refresh_task.take() { - task.abort(); - } - self.agents_overview.active_refresh = None; - if let Some(owner) = self.app_server_backend_id { + let displayed_backend = self.displayed_conversation_backend_id(); + if let Some(backend_id) = displayed_backend { + self.backend_registry.disconnect(backend_id); + self.cancel_agents_overview_refresh(backend_id); + self.reset_agents_overview_discovery(backend_id); + let registry = &self.backend_registry; + let other_backend = + |id: &ThreadId| registry.owner(*id).is_some_and(|owner| owner != backend_id); self.agents_overview - .invalidate_discovery(owner, /*displayed*/ true); + .refresh_notifications + .retain(|id, _| other_backend(id)); + self.agents_overview.usage.retain(|id, _| other_backend(id)); + self.agents_overview + .activity + .retain(|id, _| other_backend(id)); + self.agents_overview + .last_messages + .retain(|id, _| other_backend(id)); + } else { + if let Some(task) = self.agents_overview.refresh_task.take() { + task.abort(); + } + self.agents_overview.active_refresh = None; + self.agents_overview.refresh_show_more = false; + self.agents_overview.active_refresh_thread_ids.clear(); + self.agents_overview.pending_refresh_backends.clear(); + self.agents_overview.refresh_notifications.clear(); + self.agents_overview.usage.clear(); + self.agents_overview.activity.clear(); + self.agents_overview.last_messages.clear(); } - self.agents_overview.refresh_show_more = false; - self.agents_overview.active_refresh_thread_ids.clear(); - self.agents_overview.refresh_pending = false; - self.agents_overview.refresh_notifications.clear(); self.agents_overview.pending_pin_change = None; self.agents_overview.pending_usage = None; self.agents_overview.usage_disabled = false; - self.agents_overview.usage.clear(); - self.agents_overview.activity.clear(); - self.agents_overview.last_messages.clear(); self.reconnect.presentation = if self .chat_widget .selected_index_for_active_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID) @@ -470,10 +486,9 @@ impl App { cancellation.cancel(); } self.agents_overview.dispatched_requests.clear(); - self.agents_overview.active_refresh = None; - self.agents_overview.refresh_show_more = false; - self.agents_overview.active_refresh_thread_ids.clear(); - self.agents_overview.refresh_pending = false; + if let Some((_, owner)) = self.agents_overview.active_refresh { + self.cancel_agents_overview_refresh(owner); + } for input in self.agents_overview.input_states.values_mut() { input.reconnect_pending = true; } @@ -591,9 +606,8 @@ impl App { self.refresh_pending_thread_approvals().await; // Discover tasks whose notifications were missed, without clearing retained rows. // A hidden overview performs this discovery when it is next opened. - self.agents_overview - .initialized - .remove(&app_server.backend_id()); + self.reset_agents_overview_discovery(app_server.backend_id()); + self.backend_registry.connect(app_server); if self.reconnect.presentation == ReconnectPresentation::Overview { let threads = self .agents_overview @@ -604,7 +618,6 @@ impl App { .collect(); let view = self.agents_overview_view(threads, selected); self.chat_widget.show_bottom_pane_view(Box::new(view)); - self.refresh_agents_overview_threads(app_server); // The Overview survived request cleanup, but terminal typeahead may have survived too. if self.startup_protected_input_boundary { self.render_startup_frame(tui, app_event_rx)?; @@ -622,6 +635,9 @@ impl App { server.reconnect(app_server.request_handle(), self.app_event_tx.clone()); } self.reconnect.offline = false; + if self.reconnect.presentation == ReconnectPresentation::Overview { + self.refresh_agents_overview_threads(app_server); + } self.chat_widget.update_account_state( bootstrap.status_account_display, bootstrap.plan_type, diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs index 1c45d9966e..0bdd7b1ce9 100644 --- a/codex-rs/tui/src/app/startup.rs +++ b/codex-rs/tui/src/app/startup.rs @@ -1141,10 +1141,14 @@ See the Codex keymap documentation for supported actions and examples." /*server_version*/ None, ); } + app.backend_registry.connect(&app_server); if let Some(thread_id) = app.current_displayed_thread_id() { app.backend_registry .observe(app_server.backend_id(), thread_id); } + for session in &other_backends { + app.backend_registry.connect(session); + } if start_in_agents_overview { app.open_agents_overview(&app_server); } else { @@ -1627,6 +1631,10 @@ See the Codex keymap documentation for supported actions and examples." backends.defer_side_startup(event); } Some(event) if owner != displayed_owner || !app.reconnect.offline => { + if matches!(&event.event, codex_app_server_client::AppServerEvent::Disconnected { .. }) { + app.backend_registry.disconnect(owner); + app.cancel_agents_overview_refresh(owner); + } if let Some(slot) = backends.slot(owner) { let (session, parked_inputs) = backends.session_and_parked_inputs(slot); app.handle_polled_backend_event(session, displayed_owner, parked_inputs, event).await; @@ -1634,8 +1642,9 @@ See the Codex keymap documentation for supported actions and examples." } Some(_) => {} None => { - app.agents_overview - .invalidate_discovery(owner, owner == displayed_owner); + app.backend_registry.disconnect(owner); + app.cancel_agents_overview_refresh(owner); + app.reset_agents_overview_discovery(owner); if owner == displayed_owner { if app.reconnect.offline && app.pending_startup_thread_start { reconnect = None; diff --git a/codex-rs/tui/src/app/tests/backend_event_tests.rs b/codex-rs/tui/src/app/tests/backend_event_tests.rs index 2e88a84b9b..cbe0c37594 100644 --- a/codex-rs/tui/src/app/tests/backend_event_tests.rs +++ b/codex-rs/tui/src/app/tests/backend_event_tests.rs @@ -31,7 +31,7 @@ async fn background_archive_and_delete_remove_only_owned_rows() -> Result<()> { .threads .insert(collision, Some(collision_row.clone())); - for deleted in [false, true] { + for (index, deleted) in [false, true].into_iter().enumerate() { let id = ThreadId::new(); assert!(app.backend_registry.observe(owner, id)); let row = overview_thread( @@ -66,8 +66,9 @@ async fn background_archive_and_delete_remove_only_owned_rows() -> Result<()> { } assert!(!app.agents_overview.threads.contains_key(&id)); assert!(app.agents_overview.threads.contains_key(&collision)); - assert!(app.agents_overview.refresh_invalidated); - assert_eq!(app.agents_overview.refill_count, 0); + assert!(app.agents_overview.active_refresh.is_none()); + assert_eq!(app.agents_overview.refill_count(displayed), 0); + assert_eq!(app.agents_overview.refill_count(owner), index + 1); app.apply_agents_overview_thread_refresh( &server, request_id, @@ -102,8 +103,16 @@ async fn background_archive_and_delete_remove_only_owned_rows() -> Result<()> { assert!(!app.agents_overview.removed_threads.contains(&id)); } } + app.backend_registry.connect(&server); + app.agents_overview + .discovery + .insert(owner, Default::default()); app.show_more_agents_overview(&server); - assert!(app.agents_overview.refresh_show_more); + assert_eq!( + app.agents_overview.active_refresh.map(|(_, id)| id), + Some(owner) + ); + assert!(!app.agents_overview.refresh_show_more); if let Some(task) = app.agents_overview.refresh_task.take() { task.abort(); } @@ -201,7 +210,7 @@ async fn foreign_backend_events_leave_thread_cache_and_connection_untouched() -> assert!(!app.agents_overview.discovery.contains_key(&owner)); assert!(!app.agents_overview.initialized.contains(&owner)); assert!(app.agents_overview.initialized.contains(&foreign)); - assert!(app.agents_overview.refresh_invalidated); + assert_eq!(app.agents_overview.active_refresh, None); } } assert!(!app.reconnect.offline); diff --git a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs index b048790c9c..ba7ce83286 100644 --- a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs +++ b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs @@ -159,7 +159,6 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv let stale_request = Uuid::new_v4(); let refresh_owner = crate::backend_id::BackendId::new(); app.agents_overview.active_refresh = Some((stale_request, refresh_owner)); - app.agents_overview.refresh_pending = true; let refresh = tokio::spawn(std::future::pending::<()>()); app.agents_overview.refresh_task = Some(refresh.abort_handle()); let directory = tempfile::tempdir()?; @@ -255,9 +254,23 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv crate::connect_remote_app_server(endpoint).await?, ThreadParamsMode::Embedded, ); + app.app_server_backend_id = Some(session.backend_id()); + app.backend_registry.connect(&session); + let parked = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?; + let parked_owner = parked.backend_id(); + app.backend_registry.connect(&parked); + app.backend_registry.observe(session.backend_id(), added); + + app.agents_overview.pending_refresh_backends = [session.backend_id()].into(); if overview_initialized { app.agents_overview.initialized.insert(session.backend_id()); } + if let Some(thread_id) = previous_thread { + assert!( + app.backend_registry + .observe(session.backend_id(), thread_id) + ); + } assert!( session .thread_loaded_list(ThreadLoadedListParams { @@ -279,15 +292,16 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv app.handle_backend_event(&session, disconnected).await; assert_eq!(app.agents_overview.pending_usage, None); assert!(app.reconnect.offline); + assert!( + app.backend_registry + .request_handle(session.backend_id()) + .is_none() + ); + assert!(app.backend_registry.request_handle(parked_owner).is_some()); assert!(app.agents_overview.last_messages.is_empty()); assert!(refresh.await.unwrap_err().is_cancelled()); - assert_eq!( - ( - app.agents_overview.active_refresh.map(|(id, _)| id), - app.agents_overview.refresh_pending - ), - (None, false) - ); + assert_eq!(app.agents_overview.active_refresh, None); + assert!(app.agents_overview.pending_refresh_backends.is_empty()); app.apply_agents_overview_thread_refresh( &session, stale_request, @@ -384,6 +398,13 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv Ok::<_, color_eyre::Report>(()) }) .await??; + assert!( + app.backend_registry + .request_handle(session.backend_id()) + .is_some() + ); + assert!(app.backend_registry.request_handle(parked_owner).is_some()); + parked.shutdown().await?; assert!(app.agents_overview.visible_thread_ids.contains(&vanished)); // Missing metadata alone does not evict a retained row; an archive notification does. diff --git a/codex-rs/tui/src/app/tests/new_session_tests.rs b/codex-rs/tui/src/app/tests/new_session_tests.rs index 0a6078c627..05da1107b4 100644 --- a/codex-rs/tui/src/app/tests/new_session_tests.rs +++ b/codex-rs/tui/src/app/tests/new_session_tests.rs @@ -454,6 +454,7 @@ async fn replacement_uses_server_defaults_and_preserves_explicit_launch_settings socket_path: client_home.path().join("daemon.sock").abs(), }, }; + app.backend_registry.connect(&server); app.open_agents_overview(&server); } let mut tui = crate::tui::test_support::make_test_tui()?; @@ -1211,6 +1212,8 @@ async fn check_retained_draft_handoff( let retained = app.chat_widget.capture_thread_input_state().unwrap(); app.chat_widget .restore_user_message_to_composer("draft for the displayed task".into()); + app.backend_registry.connect(&source); + app.backend_registry.connect(&destination); let mut backends = BackendSessions::from_initial(source, vec![destination]); let destination_slot = backends .slot(destination_id) @@ -1262,7 +1265,7 @@ async fn check_retained_draft_handoff( } app.agents_overview.initialized.insert(outgoing); - app.agents_overview.show_more_requested = true; + app.agents_overview.show_more_backends.insert(outgoing); let mut tui = crate::tui::test_support::make_test_tui()?; let pages_before = recorded_params(&requests, "thread/turns/list").len(); let reads_before = recorded_params(&requests, "thread/read").len(); @@ -1284,9 +1287,22 @@ async fn check_retained_draft_handoff( recorded_params(&requests, "thread/turns/list"), recorded_params(&requests, "thread/resume"), ); + assert_eq!( + app.backend_registry.request_handle(outgoing).is_some(), + history_capabilities != HistoryCapabilities::LegacyOnly, + ); + assert!( + app.backend_registry + .request_handle(destination_id) + .is_some() + ); assert!(app.agents_overview.initialized.contains(&outgoing)); assert!(!app.agents_overview.initialized.contains(&destination_id)); - assert!(!app.agents_overview.show_more_requested); + assert!( + !app.agents_overview + .show_more_backends + .contains(&destination_id) + ); assert_eq!(app.chat_widget.thread_id(), Some(thread_id)); if saved_history || parked_policy.is_some() { assert_eq!( diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs index 461c1821f0..ab81d8e989 100644 --- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs +++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs @@ -4534,7 +4534,7 @@ async fn agents_overview_seeds_loaded_threads_when_recent_listing_is_unavailable ), ( HistoryCapabilities::ThreadListFails, - vec!["recency_at", "recency_at"], + vec!["recency_at", "recency_at", "recency_at"], ), ] { let (mut app, _codex_home) = make_history_test_app().await?; @@ -4576,14 +4576,18 @@ async fn agents_overview_seeds_loaded_threads_when_recent_listing_is_unavailable .collect::>(), vec![started.session.thread_id] ); - assert!( + let initial_list_failed = + attempt == 0 && capabilities == HistoryCapabilities::ThreadListFails; + assert_eq!( app.agents_overview .initialized - .contains(&app_server.backend_id()) + .contains(&app_server.backend_id()), + !initial_list_failed ); assert_eq!( - app.agents_overview.has_more(app_server.backend_id()), - capabilities == HistoryCapabilities::ThreadListFails + app.agents_overview + .has_more_for(&app.backend_registry, app_server.backend_id()), + initial_list_failed ); if attempt == 0 { app.handle_app_server_event( diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index a2e020b9a9..d3c4f25e74 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -51,6 +51,7 @@ use uuid::Uuid; use crate::app_command::AppCommand; use crate::app_server_session::AppServerStartedThread; +use crate::backend_id::BackendId; use crate::bottom_pane::ApprovalRequest; use crate::bottom_pane::StatusLineItem; use crate::bottom_pane::TerminalTitleItem; @@ -426,6 +427,7 @@ pub(crate) enum AppEvent { }, /// Finish moving a task into or out of the shared pinned section. AgentsOverviewPinToggled { + backend_id: BackendId, request_id: Uuid, thread_id: ThreadId, pinned: bool,