Lightweight coding agent that runs in your terminal
Rust
Avoid paginated resume requests for verified legacy rollouts (#38604)
Charlie Marsh1bb6384c1971
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 915b599fa5..55724a8c17 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -946,6 +946,9 @@ impl App {(chat_widget, None)}SessionSelection::Resume(target_session) => {+ if let Some(history_mode) = target_session.history_mode {+ app_server.remember_thread_history_mode(target_session.thread_id, history_mode);+ }let model_settings = config_persistence::resume_model_settings_for_overrides(&config,&harness_overrides,diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rsindex 5b09fab403..9c27f0ee15 100644--- a/codex-rs/tui/src/app/session_lifecycle.rs+++ b/codex-rs/tui/src/app/session_lifecycle.rs@@ -1011,6 +1011,9 @@ impl App {self.chat_widget.thread_name(),self.chat_widget.rollout_path().as_deref(),);+ if let Some(history_mode) = target_session.history_mode {+ app_server.remember_thread_history_mode(target_session.thread_id, history_mode);+ }match app_server.resume_thread(resume_config.clone(),diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex 2656614cb0..17e4b963aa 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -5820,6 +5820,7 @@ fn session_start_error_surfaces_archived_guidance_without_rollout_path() {"/Users/me/.codex/archived_sessions/rollout.jsonl",)),thread_id,+ history_mode: None,};let expected = format!("session {thread_id} is archived. Run `codex unarchive {thread_id}` to unarchive it first."@@ -6123,6 +6124,7 @@ async fn remote_resume_current_cwd_rejection_snapshot() -> Result<()> {crate::resume_picker::SessionTarget {path: None,thread_id: ThreadId::new(),+ history_mode: None,},).await?;@@ -6165,6 +6167,7 @@ async fn remote_exec_resume_current_cwd_is_rejected() -> Result<()> {crate::resume_picker::SessionTarget {path: None,thread_id: ThreadId::new(),+ history_mode: None,},).await?;@@ -6202,6 +6205,7 @@ async fn in_app_resume_session_cwd_without_metadata_is_non_fatal() -> Result<()>crate::resume_picker::SessionTarget {path: None,thread_id: ThreadId::new(),+ history_mode: None,},).await?;@@ -6264,6 +6268,7 @@ async fn remote_resume_keeps_server_only_cwd_out_of_local_config() -> Result<()>crate::resume_picker::SessionTarget {path: Some(rollout_path),thread_id: ThreadId::from_string(&thread_id)?,+ history_mode: None,},).await?;@@ -6382,6 +6387,7 @@ async fn in_app_resume_uses_configured_or_explicit_cwd() -> Result<()> {crate::resume_picker::SessionTarget {path: Some(rollout_path),thread_id,+ history_mode: None,},).await?;@@ -6494,6 +6500,7 @@ async fn remembered_current_cwd_stays_at_launch_across_in_app_resumes() -> Resultargets.push(crate::resume_picker::SessionTarget {path: Some(rollout_path),thread_id: ThreadId::from_string(&thread_id)?,+ history_mode: None,});}let state_db =diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rsindex aaaac62a12..234275913a 100644--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs@@ -1064,6 +1064,7 @@ async fn paginated_workflows_never_request_full_thread_history() -> Result<()> {).await?;+ app_server.remember_thread_history_mode(paginated_thread_id, ThreadHistoryMode::Legacy);let resumed = app_server.resume_thread(app.config.clone(),@@ -1072,6 +1073,10 @@ async fn paginated_workflows_never_request_full_thread_history() -> Result<()> {).await?;assert_eq!(resumed.session.thread_id, paginated_thread_id);+ assert!(recorded_params(&requests, "thread/read").is_empty());+ let resume_requests = recorded_params(&requests, "thread/resume");+ assert_eq!(resume_requests.len(), 1);+ assert_eq!(resume_requests[0]["excludeTurns"], true);let cells = crate::thread_transcript::load_session_transcript(&mut app_server,paginated_thread_id,@@ -1542,6 +1547,7 @@ fn session_lifecycle_avoids_redundant_subagent_metadata_reads() -> Result<()> {crate::resume_picker::SessionTarget {path: Some(root_rollout_path),thread_id: root_thread_id,+ history_mode: None,},).await?;diff --git a/codex-rs/tui/src/app/tests/startup.rs b/codex-rs/tui/src/app/tests/startup.rsindex 193ea5aa12..ffbdfc3b41 100644--- a/codex-rs/tui/src/app/tests/startup.rs+++ b/codex-rs/tui/src/app/tests/startup.rs@@ -19,6 +19,7 @@ fn startup_waiting_gate_is_only_for_fresh_or_exit_session_selection() {crate::resume_picker::SessionTarget {path: Some(PathBuf::from("/tmp/restore")),thread_id: ThreadId::new(),+ history_mode: None,})),false@@ -28,6 +29,7 @@ fn startup_waiting_gate_is_only_for_fresh_or_exit_session_selection() {crate::resume_picker::SessionTarget {path: Some(PathBuf::from("/tmp/fork")),thread_id: ThreadId::new(),+ history_mode: None,})),false@@ -39,10 +41,12 @@ fn startup_paused_goal_prompt_gate_is_only_for_quiet_resume() {let resume = SessionSelection::Resume(crate::resume_picker::SessionTarget {path: Some(PathBuf::from("/tmp/restore")),thread_id: ThreadId::new(),+ history_mode: None,});let fork = SessionSelection::Fork(crate::resume_picker::SessionTarget {path: Some(PathBuf::from("/tmp/fork")),thread_id: ThreadId::new(),+ history_mode: None,});let no_images: Vec<PathBuf> = Vec::new();let initial_images = vec![PathBuf::from("/tmp/image.png")];@@ -111,6 +115,7 @@ fn startup_waiting_gate_not_applied_for_resume_or_fork_session_selection() {crate::resume_picker::SessionTarget {path: Some(PathBuf::from("/tmp/restore")),thread_id: ThreadId::new(),+ history_mode: None,},));assert_eq!(@@ -124,6 +129,7 @@ fn startup_waiting_gate_not_applied_for_resume_or_fork_session_selection() {crate::resume_picker::SessionTarget {path: Some(PathBuf::from("/tmp/fork")),thread_id: ThreadId::new(),+ history_mode: None,},));assert_eq!(@@ -268,6 +274,7 @@ async fn ignore_same_thread_resume_reports_noop_for_current_thread() {let ignored = app.ignore_same_thread_resume(&crate::resume_picker::SessionTarget {path: Some(test_path_buf("/tmp/project")),thread_id,+ history_mode: None,});assert!(ignored);@@ -292,6 +299,7 @@ async fn ignore_same_thread_resume_allows_reattaching_displayed_inactive_thread(let ignored = app.ignore_same_thread_resume(&crate::resume_picker::SessionTarget {path: Some(test_path_buf("/tmp/project")),thread_id,+ history_mode: None,});assert!(!ignored);diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex 4149dac6ee..515c653696 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -5,6 +5,7 @@mod fs;mod history;+mod rollout_history;pub(crate) use history::HISTORY_ITEM_PAGE_LIMIT;pub(crate) use history::HISTORY_ITEM_SCAN_LIMIT;@@ -265,6 +266,7 @@ pub(crate) struct AppServerSession {history_pagination: HashMap<ThreadId, history::ThreadHistoryPagination>,remote_cwd_override: Option<PathBuf>,thread_params_mode: ThreadParamsMode,+ background_rollout_migration_enabled: bool,history_support: ThreadHistorySupport,thread_settings_update_supported: bool,default_model: Option<String>,@@ -339,6 +341,7 @@ impl AppServerSession {history_pagination: HashMap::new(),remote_cwd_override: None,thread_params_mode,+ background_rollout_migration_enabled: true,history_support: ThreadHistorySupport::Paginated,thread_settings_update_supported: true,default_model: None,@@ -616,77 +619,6 @@ impl AppServerSession {started_thread_from_start_response(response, config, self.thread_params_mode()).await}- pub(crate) async fn resume_thread(- &mut self,- config: Config,- thread_id: ThreadId,- model_settings: ResumeModelSettings,- ) -> Result<AppServerStartedThread> {- let request_id = self.next_request_id();- let session_config = if model_settings == ResumeModelSettings::RestoreFromThread {- config.clone()- } else {- self.session_config_with_effective_service_tier(&config)- };- let mut params = thread_resume_params_from_config(- session_config,- thread_id,- self.thread_params_mode(),- self.remote_cwd_override.as_deref(),- model_settings,- );- params.exclude_turns = self.history_support == ThreadHistorySupport::Paginated- && self- .history_pagination- .get(&thread_id)- .is_none_or(|state| state.history_mode == ThreadHistoryMode::Paginated);- let mut response: ThreadResumeResponse = match self- .client- .request_typed(ClientRequest::ThreadResume {- request_id,- params: params.clone(),- })- .await- {- Ok(response) => response,- Err(TypedRequestError::Server { source, .. })- if params.exclude_turns && is_history_pagination_unsupported(&source) =>- {- self.history_support = ThreadHistorySupport::LegacyOnly;- params.exclude_turns = false;- let request_id = self.next_request_id();- self.client- .request_typed(ClientRequest::ThreadResume { request_id, params })- .await- .map_err(|err| {- bootstrap_request_error("thread/resume failed during TUI bootstrap", err)- })?- }- Err(err) => {- return Err(bootstrap_request_error(- "thread/resume failed during TUI bootstrap",- err,- ));- }- };- self.hydrate_initial_thread_history(- &mut response.thread,- response.turns_backwards_cursor.clone(),- response.items_backwards_cursor.clone(),- Some(&config),- HistoryHydrationScope::Initial,- )- .await?;- let fork_parent_title = self- .fork_parent_title_from_app_server(response.thread.forked_from_id.as_deref())- .await;- let mut started =- started_thread_from_resume_response(response, &config, self.thread_params_mode())- .await?;- started.session.fork_parent_title = fork_parent_title;- Ok(started)- }-pub(crate) async fn fork_thread(&mut self,config: Config,diff --git a/codex-rs/tui/src/app_server_session/rollout_history.rs b/codex-rs/tui/src/app_server_session/rollout_history.rsnew file mode 100644index 0000000000..94d3f37ca5--- /dev/null+++ b/codex-rs/tui/src/app_server_session/rollout_history.rs@@ -0,0 +1,150 @@+//! Resume history policy for local rollouts that may migrate between formats.++use super::AppServerSession;+use super::AppServerStartedThread;+use super::HistoryHydrationScope;+use super::ResumeModelSettings;+use super::ThreadHistorySupport;+use super::bootstrap_request_error;+use super::is_history_pagination_unsupported;+use super::started_thread_from_resume_response;+use super::thread_resume_params_from_config;+use crate::legacy_core::config::Config;+use codex_app_server_client::TypedRequestError;+use codex_app_server_protocol::ClientRequest;+use codex_app_server_protocol::ThreadHistoryMode;+use codex_app_server_protocol::ThreadResumeResponse;+use codex_features::Feature;+use codex_protocol::ThreadId;+use color_eyre::eyre::Result;++impl AppServerSession {+ /// Captures the server's startup migration policy before workspace config can change.+ ///+ /// Sessions without a recorded startup config conservatively assume migration is enabled.+ pub(crate) fn with_startup_config(mut self, config: &Config) -> Self {+ self.background_rollout_migration_enabled = config+ .features+ .enabled(Feature::BackgroundPaginatedRolloutMigration);+ self+ }++ /// Retains trusted embedded-server history metadata for a later resume.+ ///+ /// Remote hints are ignored because another process can migrate the thread before resume.+ pub(crate) fn remember_thread_history_mode(+ &mut self,+ thread_id: ThreadId,+ history_mode: ThreadHistoryMode,+ ) {+ if !self.uses_embedded_app_server() {+ return;+ }+ self.history_pagination+ .entry(thread_id)+ .or_default()+ .history_mode = history_mode;+ }++ pub(crate) async fn resume_thread(+ &mut self,+ config: Config,+ thread_id: ThreadId,+ model_settings: ResumeModelSettings,+ ) -> Result<AppServerStartedThread> {+ let session_config = if model_settings == ResumeModelSettings::RestoreFromThread {+ config.clone()+ } else {+ self.session_config_with_effective_service_tier(&config)+ };+ let mut params = thread_resume_params_from_config(+ session_config,+ thread_id,+ self.thread_params_mode(),+ self.remote_cwd_override.as_deref(),+ model_settings,+ );+ let mut rollout_maintenance_guard = None;+ params.exclude_turns = if self.history_support == ThreadHistorySupport::Paginated {+ let known_legacy_history = self+ .history_pagination+ .get(&thread_id)+ .is_some_and(|state| state.history_mode == ThreadHistoryMode::Legacy)+ && (!self.uses_embedded_app_server()+ || (!self.background_rollout_migration_enabled+ && !config+ .features+ .enabled(Feature::BackgroundPaginatedRolloutMigration)+ && {+ rollout_maintenance_guard =+ codex_rollout::try_acquire_rollout_maintenance_lock(+ config.codex_home.as_path(),+ )+ .ok()+ .flatten();+ rollout_maintenance_guard.is_some()+ }+ && self+ .thread_read(thread_id, /*include_turns*/ false)+ .await+ .is_ok_and(|thread| thread.history_mode == ThreadHistoryMode::Legacy)));+ !known_legacy_history+ } else {+ false+ };+ if params.exclude_turns {+ rollout_maintenance_guard = None;+ }+ let request_id = self.next_request_id();+ let resume_response = self+ .client+ .request_typed(ClientRequest::ThreadResume {+ request_id,+ params: params.clone(),+ })+ .await;+ drop(rollout_maintenance_guard);+ let mut response: ThreadResumeResponse = match resume_response {+ Ok(response) => response,+ Err(TypedRequestError::Server { source, .. })+ if params.exclude_turns && is_history_pagination_unsupported(&source) =>+ {+ self.history_support = ThreadHistorySupport::LegacyOnly;+ params.exclude_turns = false;+ let request_id = self.next_request_id();+ self.client+ .request_typed(ClientRequest::ThreadResume { request_id, params })+ .await+ .map_err(|err| {+ bootstrap_request_error("thread/resume failed during TUI bootstrap", err)+ })?+ }+ Err(err) => {+ return Err(bootstrap_request_error(+ "thread/resume failed during TUI bootstrap",+ err,+ ));+ }+ };+ self.hydrate_initial_thread_history(+ &mut response.thread,+ response.turns_backwards_cursor.clone(),+ response.items_backwards_cursor.clone(),+ Some(&config),+ HistoryHydrationScope::Initial,+ )+ .await?;+ let fork_parent_title = self+ .fork_parent_title_from_app_server(response.thread.forked_from_id.as_deref())+ .await;+ let mut started =+ started_thread_from_resume_response(response, &config, self.thread_params_mode())+ .await?;+ started.session.fork_parent_title = fork_parent_title;+ Ok(started)+ }+}++#[cfg(test)]+#[path = "rollout_history_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app_server_session/rollout_history_tests.rs b/codex-rs/tui/src/app_server_session/rollout_history_tests.rsnew file mode 100644index 0000000000..0fac8e9ac8--- /dev/null+++ b/codex-rs/tui/src/app_server_session/rollout_history_tests.rs@@ -0,0 +1,225 @@+use super::super::ResumeModelSettings;+use crate::legacy_core::config::Config;+use crate::legacy_core::config::ConfigBuilder;+use app_test_support::create_fake_paginated_rollout;+use app_test_support::create_fake_rollout;+use codex_app_server_protocol::ThreadHistoryMode;+use codex_features::Feature;+use codex_protocol::ThreadId;+use color_eyre::eyre::Result;+use pretty_assertions::assert_eq;+use tempfile::TempDir;++async fn build_config(temp_dir: &TempDir) -> Config {+ ConfigBuilder::default()+ .codex_home(temp_dir.path().to_path_buf())+ .build()+ .await+ .expect("config should build")+}++#[tokio::test]+async fn legacy_resume_preserves_history_mode_after_picker_server_replacement() -> Result<()> {+ let codex_home = tempfile::tempdir().expect("tempdir");+ let config = build_config(&codex_home).await;+ let thread_id = ThreadId::from_string(+ &create_fake_rollout(+ codex_home.path(),+ "2025-01-05T12-00-00",+ "2025-01-05T12:00:00Z",+ "Saved user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create source rollout"),+ )?;+ let mut picker_app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ let history_mode = picker_app_server+ .thread_read(thread_id, /*include_turns*/ false)+ .await?+ .history_mode;+ picker_app_server.shutdown().await?;++ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ app_server.remember_thread_history_mode(thread_id, history_mode);+ let next_request_id = app_server.next_request_id;+ let resumed = app_server+ .resume_thread(config, thread_id, ResumeModelSettings::RestoreFromThread)+ .await?;++ assert_eq!(app_server.next_request_id, next_request_id + 2);+ assert!(!resumed.turns.is_empty());+ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn background_migration_disables_cached_legacy_resume_shortcut() -> Result<()> {+ let codex_home = tempfile::tempdir().expect("tempdir");+ let config = build_config(&codex_home).await;+ let legacy_thread_id = ThreadId::from_string(+ &create_fake_rollout(+ codex_home.path(),+ "2025-01-05T12-00-00",+ "2025-01-05T12:00:00Z",+ "Saved legacy user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create legacy rollout"),+ )?;+ let thread_id = ThreadId::from_string(+ &create_fake_paginated_rollout(+ codex_home.path(),+ "2025-01-05T12-00-01",+ "2025-01-05T12:00:01Z",+ "Saved paginated user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create paginated rollout"),+ )?;+ let mut migration_config = config.clone();+ migration_config+ .features+ .enable(Feature::BackgroundPaginatedRolloutMigration)?;++ for (startup_config, resume_config) in+ [(&config, &migration_config), (&migration_config, &config)]+ {+ // Keep the real worker disabled while exercising both startup/request mismatches.+ let mut app_server = crate::start_embedded_app_server_for_picker(&config)+ .await?+ .with_startup_config(startup_config);+ app_server.remember_thread_history_mode(legacy_thread_id, ThreadHistoryMode::Legacy);+ let next_request_id = app_server.next_request_id;+ let legacy = app_server+ .resume_thread(+ resume_config.clone(),+ legacy_thread_id,+ ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ assert_eq!(app_server.next_request_id, next_request_id + 2);+ assert!(!legacy.turns.is_empty());++ app_server.remember_thread_history_mode(thread_id, ThreadHistoryMode::Legacy);+ let next_request_id = app_server.next_request_id;++ let resumed = app_server+ .resume_thread(+ resume_config.clone(),+ thread_id,+ ResumeModelSettings::RestoreFromThread,+ )+ .await?;++ assert!(app_server.next_request_id > next_request_id + 1);+ assert_eq!(resumed.session.thread_id, thread_id);+ assert_eq!(+ app_server+ .history_pagination+ .get(&thread_id)+ .map(|state| state.history_mode),+ Some(ThreadHistoryMode::Paginated)+ );+ app_server.shutdown().await?;+ }++ Ok(())+}++#[tokio::test]+async fn rollout_maintenance_contention_disables_cached_legacy_resume_shortcut() -> Result<()> {+ let codex_home = tempfile::tempdir().expect("tempdir");+ let config = build_config(&codex_home).await;+ let thread_id = ThreadId::from_string(+ &create_fake_paginated_rollout(+ codex_home.path(),+ "2025-01-05T12-00-00",+ "2025-01-05T12:00:00Z",+ "Saved paginated user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create paginated rollout"),+ )?;+ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ app_server.remember_thread_history_mode(thread_id, ThreadHistoryMode::Legacy);+ let _maintenance_guard =+ codex_rollout::try_acquire_rollout_maintenance_lock(codex_home.path())?+ .expect("acquire rollout maintenance lock");+ let next_request_id = app_server.next_request_id;++ let resumed = app_server+ .resume_thread(config, thread_id, ResumeModelSettings::RestoreFromThread)+ .await?;++ assert_eq!(app_server.next_request_id, next_request_id + 3);+ assert_eq!(resumed.session.thread_id, thread_id);+ assert_eq!(+ app_server+ .history_pagination+ .get(&thread_id)+ .map(|state| state.history_mode),+ Some(ThreadHistoryMode::Paginated)+ );++ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn stale_legacy_history_mode_is_revalidated_before_resume() -> Result<()> {+ let codex_home = tempfile::tempdir().expect("tempdir");+ let config = build_config(&codex_home).await;+ let thread_id = ThreadId::from_string(+ &create_fake_paginated_rollout(+ codex_home.path(),+ "2025-01-05T12-00-00",+ "2025-01-05T12:00:00Z",+ "Saved paginated user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create paginated rollout"),+ )?;+ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ app_server.remember_thread_history_mode(thread_id, ThreadHistoryMode::Legacy);+ let next_request_id = app_server.next_request_id;++ let resumed = app_server+ .resume_thread(+ config.clone(),+ thread_id,+ ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ assert_eq!(resumed.session.thread_id, thread_id);+ assert!(app_server.next_request_id >= next_request_id + 4);+ assert_eq!(+ app_server+ .history_pagination+ .get(&thread_id)+ .map(|state| state.history_mode),+ Some(ThreadHistoryMode::Paginated)+ );++ let missing_thread_id = ThreadId::new();+ app_server.remember_thread_history_mode(missing_thread_id, ThreadHistoryMode::Legacy);+ let next_request_id = app_server.next_request_id;+ assert!(+ app_server+ .resume_thread(+ config,+ missing_thread_id,+ ResumeModelSettings::RestoreFromThread+ )+ .await+ .is_err()+ );+ assert_eq!(app_server.next_request_id, next_request_id + 2);++ app_server.shutdown().await?;+ Ok(())+}diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rsindex a77d13e30f..233d3efdb1 100644--- a/codex-rs/tui/src/lib.rs+++ b/codex-rs/tui/src/lib.rs@@ -511,10 +511,7 @@ pub(crate) async fn start_app_server_for_picker(environment_manager,).await?;- Ok(AppServerSession::new(- app_server,- target.thread_params_mode(),- ))+ Ok(AppServerSession::new(app_server, target.thread_params_mode()).with_startup_config(config))}#[cfg(test)]@@ -601,6 +598,7 @@ fn session_target_from_app_server_thread(Ok(thread_id) => Some(resume_picker::SessionTarget {path: thread.path,thread_id,+ history_mode: Some(thread.history_mode),}),Err(err) => {warn!(@@ -1384,7 +1382,8 @@ async fn run_ratatui_app().await{- Ok(app_server) => AppServerSession::new(app_server, app_server_target.thread_params_mode()),+ Ok(app_server) => AppServerSession::new(app_server, app_server_target.thread_params_mode())+ .with_startup_config(&initial_config),Err(err) => {terminal_restore_guard.restore_silently();session_log::log_session_end();@@ -1751,6 +1750,7 @@ async fn run_ratatui_app({Ok(app_server) => {AppServerSession::new(app_server, app_server_target.thread_params_mode())+ .with_startup_config(&config).with_remote_cwd_override(remote_cwd_override.clone())}Err(err) => {@@ -2277,6 +2277,7 @@ mod tests {let target_session = resume_picker::SessionTarget {path: Some(rollout_path),thread_id,+ history_mode: None,};let session_selection = match action {CwdPromptAction::Resume => resume_picker::SessionSelection::Resume(target_session),@@ -2364,6 +2365,7 @@ mod tests {&resume_picker::SessionSelection::Resume(resume_picker::SessionTarget {path: None,thread_id: ThreadId::new(),+ history_mode: None,}),/*cwd_override*/ None,/*uses_remote_workspace*/ false,@@ -2400,6 +2402,7 @@ mod tests {&resume_picker::SessionSelection::Resume(resume_picker::SessionTarget {path: None,thread_id: ThreadId::new(),+ history_mode: None,}),/*cwd_override*/ None,/*uses_remote_workspace*/ false,@@ -2441,6 +2444,7 @@ mod tests {let target = crate::resume_picker::SessionTarget {path: None,thread_id,+ history_mode: None,};assert_eq!(target.display_label(), format!("thread {thread_id}"));diff --git a/codex-rs/tui/src/named_session_lookup.rs b/codex-rs/tui/src/named_session_lookup.rsindex e1ab21bc8d..1fbadade78 100644--- a/codex-rs/tui/src/named_session_lookup.rs+++ b/codex-rs/tui/src/named_session_lookup.rs@@ -131,6 +131,7 @@ async fn lookup_legacy_index_target(return Ok(Some(SessionTarget {path: Some(path),thread_id: session_meta.meta.id,+ history_mode: Some(thread.history_mode),}));}Ok(None)diff --git a/codex-rs/tui/src/resume_picker.rs b/codex-rs/tui/src/resume_picker.rsindex 3b231cae76..c031cc3fb8 100644--- a/codex-rs/tui/src/resume_picker.rs+++ b/codex-rs/tui/src/resume_picker.rs@@ -104,6 +104,8 @@ const PICKER_LIST_HORIZONTAL_INSET: u16 = 4;pub struct SessionTarget {pub path: Option<PathBuf>,pub thread_id: ThreadId,+ /// History mode observed during selection, if the server provided one.+ pub history_mode: Option<ThreadHistoryMode>,}impl SessionTarget {@@ -150,8 +152,7 @@ impl SessionPickerAction {}}- fn selection(self, path: Option<PathBuf>, thread_id: ThreadId) -> SessionSelection {- let target_session = SessionTarget { path, thread_id };+ fn selection(self, target_session: SessionTarget) -> SessionSelection {match self {SessionPickerAction::Resume => SessionSelection::Resume(target_session),SessionPickerAction::Fork => SessionSelection::Fork(target_session),@@ -315,6 +316,7 @@ enum PageCursor {struct PickerPage {rows: Vec<Row>,+ history_modes: HashMap<ThreadId, ThreadHistoryMode>,next_cursor: Option<PageCursor>,num_scanned_files: usize,reached_scan_cap: bool,@@ -724,6 +726,7 @@ fn spawn_app_server_page_loader(.map(|response| SessionTarget {path: response.thread.path,thread_id,+ history_mode: Some(response.thread.history_mode),}).map_err(std::io::Error::other);let _ = bg_tx.send(BackgroundEvent::Unarchive { thread_id, result });@@ -774,6 +777,7 @@ struct PickerState {pagination: PaginationState,all_rows: Vec<Row>,filtered_rows: Vec<Row>,+ thread_history_modes: HashMap<ThreadId, ThreadHistoryMode>,seen_rows: HashSet<SeenRowKey>,selected: usize,scroll_top: usize,@@ -858,13 +862,20 @@ async fn load_app_server_page(.await.map_err(std::io::Error::other)?;let num_scanned_files = response.data.len();+ let (rows, history_modes): (Vec<_>, HashMap<_, _>) = response+ .data+ .into_iter()+ .filter_map(|thread| {+ let history_mode = thread.history_mode;+ let row = row_from_app_server_thread(thread)?;+ let thread_id = row.thread_id?;+ Some((row, (thread_id, history_mode)))+ })+ .unzip();Ok(PickerPage {- rows: response- .data- .into_iter()- .filter_map(row_from_app_server_thread)- .collect(),+ rows,+ history_modes,next_cursor: response.next_cursor.map(PageCursor::AppServer),num_scanned_files,reached_scan_cap: false,@@ -1101,6 +1112,7 @@ impl PickerState {pagination: PaginationState::new(),all_rows: Vec::new(),filtered_rows: Vec::new(),+ thread_history_modes: HashMap::new(),seen_rows: HashSet::new(),selected: 0,scroll_top: 0,@@ -1362,7 +1374,11 @@ impl PickerState {self.request_unarchive(thread_id);return Ok(None);}- return Ok(Some(self.action.selection(path, thread_id)));+ return Ok(Some(self.action.selection(SessionTarget {+ path,+ thread_id,+ history_mode: self.thread_history_modes.get(&thread_id).copied(),+ })));}self.inline_error = Some(match path {Some(path) => {@@ -1497,6 +1513,7 @@ impl PickerState {self.reset_pagination();self.all_rows.clear();self.filtered_rows.clear();+ self.thread_history_modes.clear();self.seen_rows.clear();self.selected = 0;self.pending_page_down_target = None;@@ -1629,12 +1646,14 @@ impl PickerState {fn ingest_page(&mut self, page: PickerPage) {let PickerPage {rows,+ history_modes,next_cursor,num_scanned_files,reached_scan_cap,} = page;self.pagination.complete_page(next_cursor, num_scanned_files, reached_scan_cap);+ self.thread_history_modes.extend(history_modes);for row in rows {if let Some(seen_key) = row.seen_key() {@@ -3573,6 +3592,7 @@ mod tests {) -> PickerPage {PickerPage {rows,+ history_modes: HashMap::new(),next_cursor: next_cursor.map(|cursor| PageCursor::AppServer(cursor.to_string())),num_scanned_files,reached_scan_cap,@@ -3843,12 +3863,12 @@ mod tests {"indexed metadata",);row.thread_id = Some(thread_id);- deliver_page(- &mut state,- &db_request,- ok_page(vec![row], /*next_cursor*/ None),- )- .await;+ let mut listed_page = ok_page(vec![row], /*next_cursor*/ None)+ .expect("indexed thread page should be available");+ listed_page+ .history_modes+ .insert(thread_id, ThreadHistoryMode::Legacy);+ deliver_page(&mut state, &db_request, Ok(listed_page)).await;let selection = state.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))@@ -3858,6 +3878,7 @@ mod tests {selection,Some(SessionSelection::Resume(SessionTarget {thread_id: selected_thread_id,+ history_mode: Some(ThreadHistoryMode::Legacy),..})) if selected_thread_id == thread_id));@@ -6342,6 +6363,7 @@ session_picker_view = "dense"Some(SessionSelection::Resume(SessionTarget {path: None,thread_id: selected_thread_id,+ history_mode: None,})) => assert_eq!(selected_thread_id, thread_id),other => panic!("unexpected selection: {other:?}"),}diff --git a/codex-rs/tui/src/resume_picker/archive_tests.rs b/codex-rs/tui/src/resume_picker/archive_tests.rsindex 51f0d61c11..abbf48935e 100644--- a/codex-rs/tui/src/resume_picker/archive_tests.rs+++ b/codex-rs/tui/src/resume_picker/archive_tests.rs@@ -256,6 +256,7 @@ async fn archived_session_restore_resumes_after_completion() {Ok(SessionTarget {path: None,thread_id,+ history_mode: None,}),);@@ -264,6 +265,7 @@ async fn archived_session_restore_resumes_after_completion() {Some(SessionSelection::Resume(SessionTarget {path: None,thread_id: resumed_thread_id,+ history_mode: None,})) if resumed_thread_id == thread_id));assert_eq!(state.archive_state, ArchiveState::Idle);diff --git a/codex-rs/tui/src/session_resume.rs b/codex-rs/tui/src/session_resume.rsindex 4d84497e52..445c1f4cc6 100644--- a/codex-rs/tui/src/session_resume.rs+++ b/codex-rs/tui/src/session_resume.rs@@ -502,6 +502,7 @@ mod tests {&SessionTarget {path: Some(rollout_path.clone()),thread_id,+ history_mode: None,},CwdPromptAction::Fork,ResumeCwdContext {@@ -535,6 +536,7 @@ mod tests {&SessionTarget {path: None,thread_id: ThreadId::new(),+ history_mode: None,},CwdPromptAction::Resume,ResumeCwdContext {