From ea6b64fd12b804ca1fbce54f772df6ac44d538ad Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Tue, 17 Nov 2026 22:14:35 +0000 Subject: [PATCH] Use the local session index in the multi-backend resume picker (#62127) ## Why The resume picker starts local-only listings from the state database. When multiple backends are available, the shared listing mode makes local backends use the default thread store listing too. ## What changed Choose the initial page mode per backend. Local workspaces start with `StateDbOnly`, and remote workspaces use `StoreDefault`. Each backend paginates in its current mode and can fall back to `StoreDefault` independently. Explicit recovery requests keep their requested mode. ## Testing Cover mixed local and remote listings, per-backend fallback and pagination, and an explicit recovery request after fallback fails. GitOrigin-RevId: d0c9284211b86bb781b3df6642660054cb3c6ccf --- codex-rs/tui/src/resume_picker.rs | 6 + codex-rs/tui/src/resume_picker/sources.rs | 23 +++- .../tui/src/resume_picker/sources_tests.rs | 128 +++++++++++++++++- 3 files changed, 145 insertions(+), 12 deletions(-) diff --git a/codex-rs/tui/src/resume_picker.rs b/codex-rs/tui/src/resume_picker.rs index cde3d3c8cc..fc5d0ee84c 100644 --- a/codex-rs/tui/src/resume_picker.rs +++ b/codex-rs/tui/src/resume_picker.rs @@ -954,6 +954,11 @@ fn spawn_app_server_source(backend: AppServerPickerBackend) -> sources::Source { config, } = backend; let backend_id = app_server.backend_id(); + let initial_mode = if app_server.uses_remote_workspace() { + PageLoadMode::StoreDefault + } else { + PageLoadMode::StateDbOnly + }; let (bg_tx, events) = mpsc::unbounded_channel(); let (request_tx, mut request_rx) = mpsc::unbounded_channel::(); @@ -1098,6 +1103,7 @@ fn spawn_app_server_source(backend: AppServerPickerBackend) -> sources::Source { sources::Source { backend_id, + initial_mode, loader: Arc::new(move |request: PickerLoadRequest| { let _ = request_tx.send(request); }), diff --git a/codex-rs/tui/src/resume_picker/sources.rs b/codex-rs/tui/src/resume_picker/sources.rs index 705fc121c0..56cc59f493 100644 --- a/codex-rs/tui/src/resume_picker/sources.rs +++ b/codex-rs/tui/src/resume_picker/sources.rs @@ -26,6 +26,7 @@ fn completion_page(catalog: &catalog::ThreadCatalog, failed: &HashSet pub(super) struct Source { pub(super) backend_id: BackendId, + pub(super) initial_mode: PageLoadMode, pub(super) loader: PickerLoader, pub(super) events: mpsc::UnboundedReceiver, pub(super) task: tokio::task::JoinHandle<()>, @@ -42,12 +43,13 @@ pub(super) fn spawn( let mut tasks = Vec::new(); for Source { backend_id, + initial_mode, loader, events: receiver, task, } in sources { - assert!(workers.insert(backend_id, loader).is_none()); + assert!(workers.insert(backend_id, (loader, initial_mode)).is_none()); tasks.push(task); events.push( UnboundedReceiverStream::new(receiver) @@ -77,9 +79,20 @@ pub(super) fn spawn( } let request_token = request.request_token; let mut started = false; - for (id, worker) in &workers { + for (id, (worker, source_initial_mode)) in &workers { if failed.contains(id) { continue; } - if let Some(page) = catalog.begin_page(*id, request.mode) { + // A listing starts with listing_token == request_token; recovery + // keeps that listing token but allocates a new request token. + // Only the first load can use a source's preferred mode. + let initial_mode = if request.cursor.is_none() + && request.request_token == request.listing_token + && request.mode == PageLoadMode::StoreDefault + { + *source_initial_mode + } else { + request.mode + }; + if let Some(page) = catalog.begin_page(*id, initial_mode) { let mut source_request = request.clone(); source_request.cursor = page.cursor.clone(); source_request.mode = page.mode; @@ -116,7 +129,7 @@ pub(super) fn spawn( | PickerLoadRequest::Unarchive { backend_id, .. } => *backend_id, PickerLoadRequest::Page(_) => unreachable!(), }; - if let Some(worker) = workers.get(&backend) { + if let Some((worker, _)) = workers.get(&backend) { worker(request); } else { let error = std::io::Error::other("The session's backend is unavailable."); @@ -171,7 +184,7 @@ pub(super) fn spawn( pending_page.page.mode = PageLoadMode::StoreDefault; pending_page.request = fallback.clone(); pending.insert(id, pending_page); - workers[&id](PickerLoadRequest::Page(fallback)); + (workers[&id].0)(PickerLoadRequest::Page(fallback)); continue; } let mut wait_for_other_source = false; diff --git a/codex-rs/tui/src/resume_picker/sources_tests.rs b/codex-rs/tui/src/resume_picker/sources_tests.rs index f53c2e7188..eecbaec747 100644 --- a/codex-rs/tui/src/resume_picker/sources_tests.rs +++ b/codex-rs/tui/src/resume_picker/sources_tests.rs @@ -15,6 +15,7 @@ fn source() -> ( ( Source { backend_id: BackendId::new(), + initial_mode: PageLoadMode::StoreDefault, loader: Arc::new(move |request| { let _ = requests.send(request); }), @@ -45,6 +46,19 @@ async fn next(receiver: &mut mpsc::UnboundedReceiver) -> Backgr .unwrap() .unwrap() } +async fn next_page_request( + receiver: &mut mpsc::UnboundedReceiver, + expected: &str, +) -> PageLoadRequest { + let request = tokio::time::timeout(std::time::Duration::from_secs(2), receiver.recv()) + .await + .unwrap_or_else(|_| panic!("timed out waiting for {expected}")) + .unwrap_or_else(|| panic!("worker closed before {expected}")); + let PickerLoadRequest::Page(page) = request else { + panic!("expected {expected} to be a page request"); + }; + page +} fn reply(token: usize, thread: ThreadId, cursor: Option<&str>) -> BackgroundEvent { let mut row = make_row("/tmp/worker.jsonl", "2025-01-01T00:00:00Z", "conversation"); row.thread_id = Some(thread); @@ -60,6 +74,100 @@ fn reply(token: usize, thread: ThreadId, cursor: Option<&str>) -> BackgroundEven )), } } + +#[tokio::test] +async fn mixed_sources_keep_indexed_and_recovery_modes_separate() { + let (mut indexed, mut indexed_requests, indexed_events) = source(); + indexed.initial_mode = PageLoadMode::StateDbOnly; + let (mut recovering, mut recovering_requests, recovering_events) = source(); + recovering.initial_mode = PageLoadMode::StateDbOnly; + let (remote, mut remote_requests, remote_events) = source(); + let (output, mut events) = mpsc::unbounded_channel(); + let PickerBackground { loader, task } = spawn(vec![indexed, recovering, remote], output); + + loader(request(/*token*/ 1, /*cursor*/ None)); + for (requests, expected) in [ + (&mut indexed_requests, PageLoadMode::StateDbOnly), + (&mut recovering_requests, PageLoadMode::StateDbOnly), + (&mut remote_requests, PageLoadMode::StoreDefault), + ] { + let page = next_page_request(requests, "initial source listing").await; + assert_eq!(page.mode, expected); + } + + remote_events + .send(reply( + /*token*/ 1, + ThreadId::new(), + /*cursor*/ None, + )) + .unwrap(); + assert!(matches!( + next(&mut events).await, + BackgroundEvent::PartialPage { .. } + )); + assert!(matches!( + next(&mut events).await, + BackgroundEvent::Page { .. } + )); + indexed_events + .send(reply( + /*token*/ 1, + ThreadId::new(), + Some("indexed-next"), + )) + .unwrap(); + assert!(matches!( + next(&mut events).await, + BackgroundEvent::PartialPage { .. } + )); + recovering_events + .send(BackgroundEvent::Page { + request_token: 1, + search_token: None, + mode: PageLoadMode::StateDbOnly, + page: Err(std::io::Error::other("indexed listing failed")), + }) + .unwrap(); + let fallback = next_page_request(&mut recovering_requests, "source-specific repair").await; + assert_eq!(fallback.mode, PageLoadMode::StoreDefault); + recovering_events + .send(reply( + /*token*/ 1, + ThreadId::new(), + Some("recovery-next"), + )) + .unwrap(); + assert!(matches!( + next(&mut events).await, + BackgroundEvent::PartialPage { .. } + )); + + loader(request(/*token*/ 2, Some(PageCursor::Catalog))); + for (requests, expected_mode, expected_cursor) in [ + ( + &mut indexed_requests, + PageLoadMode::StateDbOnly, + "indexed-next", + ), + ( + &mut recovering_requests, + PageLoadMode::StoreDefault, + "recovery-next", + ), + ] { + let page = next_page_request(requests, "continuation page").await; + assert_eq!(page.mode, expected_mode); + assert!( + matches!(page.cursor, Some(PageCursor::AppServer(cursor)) if cursor == expected_cursor) + ); + } + assert!(remote_requests.try_recv().is_err()); + + drop(loader); + task.await.unwrap(); +} + #[tokio::test] async fn sources_stream_rows_and_route_actions_to_each_source() { let (first, mut first_requests, first_events) = source(); @@ -329,7 +437,8 @@ async fn late_source_failure_finishes_catalog_progress() { #[tokio::test] async fn single_source_initial_failure_preserves_fallback_error() { - let (source, mut requests, replies) = source(); + let (mut source, mut requests, replies) = source(); + source.initial_mode = PageLoadMode::StateDbOnly; let (output, mut events) = mpsc::unbounded_channel(); let PickerBackground { loader, task } = spawn(vec![source], output); let PickerLoadRequest::Page(mut initial) = request(/*token*/ 1, /*cursor*/ None) else { @@ -337,9 +446,7 @@ async fn single_source_initial_failure_preserves_fallback_error() { }; initial.mode = PageLoadMode::StateDbOnly; loader(PickerLoadRequest::Page(initial)); - let Some(PickerLoadRequest::Page(initial)) = requests.recv().await else { - panic!("expected initial listing") - }; + let initial = next_page_request(&mut requests, "initial listing").await; assert_eq!(initial.mode, PageLoadMode::StateDbOnly); replies .send(BackgroundEvent::Page { @@ -349,9 +456,7 @@ async fn single_source_initial_failure_preserves_fallback_error() { page: Err(std::io::Error::other("indexed listing failed")), }) .unwrap(); - let Some(PickerLoadRequest::Page(fallback)) = requests.recv().await else { - panic!("expected store fallback") - }; + let fallback = next_page_request(&mut requests, "store fallback").await; assert_eq!(fallback.mode, PageLoadMode::StoreDefault); replies .send(BackgroundEvent::Page { @@ -375,6 +480,14 @@ async fn single_source_initial_failure_preserves_fallback_error() { }; assert_eq!(mode, PageLoadMode::StoreDefault); assert_eq!(err.to_string(), "store listing failed"); + + let PickerLoadRequest::Page(mut recovery) = request(/*token*/ 2, /*cursor*/ None) else { + unreachable!() + }; + recovery.listing_token = 1; + loader(PickerLoadRequest::Page(recovery)); + let recovery = next_page_request(&mut requests, "explicit recovery request").await; + assert_eq!(recovery.mode, PageLoadMode::StoreDefault); drop(loader); task.await.unwrap(); } @@ -499,6 +612,7 @@ async fn detached_picker_cleanup_drains_accepted_mutations() { }); let source = Source { backend_id, + initial_mode: PageLoadMode::StoreDefault, loader: Arc::new(move |request| { let _ = requests.send(request); }),