Keep agent overview refresh state scoped to each backend (#61596)

## 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
This commit is contained in:
Benjamin Carlsson
2026-11-15 01:50:45 +00:00
committed by copyberry
parent e8e5108c97
commit b7056f3408
18 changed files with 777 additions and 227 deletions
+171 -62
View File
@@ -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<BackendId>,
pub(super) discovery:
HashMap<BackendId, super::agents_overview_discovery::AgentsOverviewDiscovery>,
pub(super) show_more_requested: bool,
pub(super) show_more_backends: HashSet<BackendId>,
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<BackendId>,
/// Vacancies left by lifecycle removals, tracked by the backend that owned the row.
pub(super) refill_by_backend: HashMap<BackendId, usize>,
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<BackendId>,
pub(super) pin_refresh_requested: bool,
pub(super) refresh_thread_ids: HashSet<ThreadId>,
pub(super) active_refresh_thread_ids: HashSet<ThreadId>,
@@ -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(&notification);
}
}
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();
}
+14 -31
View File
@@ -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(|| {
@@ -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
@@ -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!(
+189 -7
View File
@@ -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::<HashSet<_>>(),
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,
}),
);
+106 -41
View File
@@ -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::<HashSet<_>, _>(|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
+20 -14
View File
@@ -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;
+2 -5
View File
@@ -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()
+17 -1
View File
@@ -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<ThreadId, BackendId>,
connections: HashMap<BackendId, AppServerRequestHandle>,
}
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<AppServerRequestHandle> {
self.connections.get(&owner).cloned()
}
}
+7 -4
View File
@@ -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);
+5 -1
View File
@@ -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 {
+37 -21
View File
@@ -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,
+11 -2
View File
@@ -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;
@@ -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);
@@ -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.
@@ -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!(
@@ -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<_>>(),
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(
+2
View File
@@ -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,