Lightweight coding agent that runs in your terminal
Rust
Defer environment selection changes until the next turn (#46310)
sayan-oaic775dd3c332d
diff --git a/codex-rs/core/src/agent/control/spawn.rs b/codex-rs/core/src/agent/control/spawn.rsindex 67081ab737..12ee357407 100644--- a/codex-rs/core/src/agent/control/spawn.rs+++ b/codex-rs/core/src/agent/control/spawn.rs@@ -322,18 +322,13 @@ impl AgentControl {parent: Option<Arc<CodexThread>>,) -> CodexResult<()> {let state = self.upgrade()?;- let parent = if let Some(parent) = parent {+ let owner_thread_id = parent.as_ref().map(|parent| parent.session.thread_id);+ if let Some(parent) = &parent {let parent_thread_id = parent.session.thread_id;- let turn = parent.session.new_default_turn().await;- config = build_agent_resume_config(&turn).map_err(|_| {- CodexErr::InvalidRequest(format!(- "cannot resume multi-agent v2 child {thread_id} with the current parent settings"- ))- })?;let registered_parent = state.get_thread(parent_thread_id).await.ok();if !registered_parent.as_ref()- .is_some_and(|registered| Arc::ptr_eq(registered, &parent))+ .is_some_and(|registered| Arc::ptr_eq(registered, parent))|| !parent.is_running()|| parent.multi_agent_version() != Some(MultiAgentVersion::V2)|| !Arc::ptr_eq(&self.state, &parent.session.services.agent_control.state)@@ -342,11 +337,7 @@ impl AgentControl {"cannot resume multi-agent v2 child {thread_id}: parent ownership is unavailable; resume the parent first")));}- Some((parent, turn.environments.clone()))- } else {- None- };- let owner_thread_id = parent.as_ref().map(|(parent, _)| parent.session.thread_id);+ }if owner_thread_id.is_none() && state.get_thread(thread_id).await.is_ok() {self.touch_loaded_v2_residency(&state, thread_id).await;return Ok(());@@ -400,6 +391,20 @@ impl AgentControl {return Ok(());}}+ let parent = if let Some(parent) = parent {+ let turn = parent+ .session+ .new_turn_with_default_settings(Uuid::now_v7().to_string(), Default::default())+ .await;+ config = build_agent_resume_config(&turn).map_err(|_| {+ CodexErr::InvalidRequest(format!(+ "cannot resume multi-agent v2 child {thread_id} with the current parent settings"+ ))+ })?;+ Some((parent, turn.environments.clone()))+ } else {+ None+ };config.model_reasoning_effort = stored_reasoning_effort;if let Some(role_name) = session_source.get_agent_role() {let runtime_approval_policy = config.permissions.approval_policy.value();diff --git a/codex-rs/core/src/agent/control_tests.rs b/codex-rs/core/src/agent/control_tests.rsindex 97d116b69e..f4bcc975a3 100644--- a/codex-rs/core/src/agent/control_tests.rs+++ b/codex-rs/core/src/agent/control_tests.rs@@ -14,6 +14,7 @@ use crate::context::ManagedDeveloperInstructions;use crate::context::MultiAgentRoleInstructions;use crate::context::SubagentNotification;use crate::init_state_db;+use crate::session::SessionSettingsUpdate;use crate::thread_manager::StartThreadOptions;use crate::tools::handlers::multi_agents_common::thread_spawn_source;use assert_matches::assert_matches;@@ -66,6 +67,7 @@ use codex_protocol::protocol::TokenUsageRecord;use codex_protocol::protocol::TurnAbortReason;use codex_protocol::protocol::TurnAbortedEvent;use codex_protocol::protocol::TurnCompleteEvent;+use codex_protocol::protocol::TurnEnvironmentSelections;use codex_protocol::protocol::TurnStartedEvent;use codex_thread_store::ArchiveThreadParams;use codex_thread_store::InMemoryThreadStore;@@ -897,17 +899,21 @@ async fn check_v2_agent_reload(route: V2ReloadRoute) {.environments.primary().expect("parent environment");- let thread_config = environment.config().clone();- let mut owner_config = thread_config.clone();+ let mut owner_config = environment.config().clone();owner_config.allow_login_shell = false;let mut selection = environment.selection();selection.config = EnvironmentConfigState::Ready(owner_config);parent_thread.session- .services- .turn_environments- .update_selections(std::slice::from_ref(&selection), &thread_config);- parent_turn = parent_thread.session.new_default_turn().await;+ .update_settings(SessionSettingsUpdate {+ environments: Some(TurnEnvironmentSelections::new(+ parent_turn.config.cwd.clone(),+ vec![selection],+ )),+ ..Default::default()+ })+ .await+ .expect("save parent environments");parent_thread.session.mark_interrupted();// The fixture has no task runner to finish the turn or consume child results.*parent_thread.session.active_turn.lock().await = None;@@ -921,6 +927,7 @@ async fn check_v2_agent_reload(route: V2ReloadRoute) {.ensure_multi_agent_v2_child_loaded(spawned_agent.thread_id).await.expect("known child should reload through its parent");+ parent_turn = parent_thread.session.new_default_turn().await;assert!(harness.manager.get_thread(parent_thread_id).await.is_err());}}diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rsindex a7cd6cf38f..9bbbfe79db 100644--- a/codex-rs/core/src/codex_thread.rs+++ b/codex-rs/core/src/codex_thread.rs@@ -908,8 +908,9 @@ impl CodexThread {self.session.refresh_codex_apps_tools().await}+ /// Returns the environments configured for future turns.pub async fn environment_selections(&self) -> Vec<TurnEnvironmentSelection> {- self.session.services.turn_environments.selections()+ self.session.configured_environment_selections().await}/// Installs resolved environment configuration and capability roots on this thread.diff --git a/codex-rs/core/src/environment_selection.rs b/codex-rs/core/src/environment_selection.rsindex 3dec829d5b..1416e359c1 100644--- a/codex-rs/core/src/environment_selection.rs+++ b/codex-rs/core/src/environment_selection.rs@@ -1,6 +1,7 @@use std::collections::HashMap;use std::collections::HashSet;use std::fmt;+use std::future::Future;use std::sync::Arc;use std::sync::OnceLock;@@ -490,15 +491,6 @@ impl ThreadEnvironments {.collect()}- pub(crate) fn primary_workspace_roots(&self) -> Vec<AbsolutePathBuf> {- self.environments- .load()- .first()- .map_or_else(Vec::new, |environment| {- Self::primary_workspace_roots_for(std::slice::from_ref(&environment.selection))- })- }-/// Returns installed owner configuration without treating pending attachments as ready.pub(crate) fn primary_config_for(selections: &[TurnEnvironmentSelection],@@ -806,45 +798,53 @@ impl ThreadEnvironments {})}+ /// Captures the selected list immediately, then returns a future that may wait for setup.+ /// This lets callers release their locks before waiting without accidentally using a newer+ /// selection. The trace still covers the setup wait itself.#[tracing::instrument(name = "environments.snapshot",skip_all,fields(- environment_count = self.environments.load().len(),- non_blocking = self.non_blocking_snapshots,+ environment_count = selected.len(),+ non_blocking = non_blocking_snapshots,))]- pub(crate) async fn snapshot(&self) -> TurnEnvironmentSnapshot {+ pub(crate) fn snapshot(+ &self,+ ) -> impl Future<Output = TurnEnvironmentSnapshot> + Send + 'static {let selected = self.environments.load_full();- let mut environments = Vec::with_capacity(selected.len());- for environment in selected.iter() {- if let EnvironmentConfigState::Failed(error) = &environment.selection.config {- environments.push(TurnEnvironmentState::Failed {+ let non_blocking_snapshots = self.non_blocking_snapshots;+ async move {+ let mut environments = Vec::with_capacity(selected.len());+ for environment in selected.iter() {+ if let EnvironmentConfigState::Failed(error) = &environment.selection.config {+ environments.push(TurnEnvironmentState::Failed {+ selection: environment.selection.clone(),+ error: error.clone(),+ });+ continue;+ }+ let pending = matches!(+ environment.selection.config,+ EnvironmentConfigState::Pending+ );+ let starting = StartingTurnEnvironment {selection: environment.selection.clone(),- error: error.clone(),- });- continue;+ config_origin: environment.config_origin,+ resolution: environment.resolution.clone(),+ };+ let resolved = if non_blocking_snapshots || pending {+ starting.resolution.clone().now_or_never()+ } else {+ Some(match starting.wait_until_ready().await {+ Ok(()) => starting.resolution.clone().await,+ Err(error) => Err(error),+ })+ };+ environments.push(TurnEnvironmentState::from_resolution(starting, resolved));}- let pending = matches!(- environment.selection.config,- EnvironmentConfigState::Pending- );- let starting = StartingTurnEnvironment {- selection: environment.selection.clone(),- config_origin: environment.config_origin,- resolution: environment.resolution.clone(),- };- let resolved = if self.non_blocking_snapshots || pending {- starting.resolution.clone().now_or_never()- } else {- Some(match starting.wait_until_ready().await {- Ok(()) => starting.resolution.clone().await,- Err(error) => Err(error),- })- };- environments.push(TurnEnvironmentState::from_resolution(starting, resolved));+ TurnEnvironmentSnapshot { environments }}- TurnEnvironmentSnapshot { environments }}pub(crate) fn environment_manager(&self) -> Arc<EnvironmentManager> {@@ -1000,6 +1000,17 @@ impl TurnEnvironmentSnapshot {self.turn_environments().next()}+ /// Returns the first selected environment's host folders, even if setup is not ready yet.+ pub(crate) fn primary_workspace_roots(&self) -> Vec<AbsolutePathBuf> {+ let selection = match self.environments.first() {+ Some(TurnEnvironmentState::Ready(environment)) => &environment.selection,+ Some(TurnEnvironmentState::Starting(environment)) => &environment.selection,+ Some(TurnEnvironmentState::Failed { selection, .. }) => selection,+ None => return Vec::new(),+ };+ ThreadEnvironments::primary_workspace_roots_for(std::slice::from_ref(selection))+ }+/// Returns the primary environment's resolved permissions, or the provided fallback.pub(crate) fn permission_profile_or_else(&self,diff --git a/codex-rs/core/src/session/environment.rs b/codex-rs/core/src/session/environment.rsindex 1be2fda061..2093251643 100644--- a/codex-rs/core/src/session/environment.rs+++ b/codex-rs/core/src/session/environment.rs@@ -14,6 +14,7 @@ use codex_protocol::protocol::TurnEnvironmentSelection;use crate::config::ConstraintError;use crate::config::ConstraintResult;use crate::config::NetworkProxySpec;+use crate::environment_selection::TurnEnvironmentSnapshot;use crate::session::session::Session;use crate::session::session::SessionConfiguration;use crate::session::session::SessionSettingsUpdate;@@ -108,7 +109,7 @@ impl Session {current: &SessionConfiguration,updates: &SessionSettingsUpdate,) -> ConstraintResult<SessionConfiguration> {- let current_environments = self.services.turn_environments.selections();+ let current_environments = ¤t.environments;if let Some(environments) = &updates.environments&& let Some(environment) = environments.environments.iter().find(|environment| {environment.config == EnvironmentConfigState::FromThread@@ -126,7 +127,47 @@ impl Session {});}- current.apply(updates, ¤t_environments)+ current.apply(updates, current_environments)+ }++ /// Activates the environments accepted for a new task. Configuration may have arrived for+ /// those same environments while its settings were being prepared.+ #[expect(+ clippy::await_holding_invalid_type,+ reason = "do not change environments while another task is running"+ )]+ pub(super) async fn activate_turn_environments(+ &self,+ configuration: &SessionConfiguration,+ ) -> TurnEnvironmentSnapshot {+ let snapshot = {+ let active = self.active_turn.lock().await;+ let state = self.state.lock().await;+ // Another task may have started while this one was preparing its settings.+ if active.as_ref().is_none_or(|turn| turn.task.is_none()) {+ let mut environments = configuration.environments.clone();+ let latest_environments = &state.session_configuration.environments;+ for environment in &mut environments {+ if let Some(latest) = latest_environments.iter().find(|latest| {+ latest.environment_id == environment.environment_id+ && latest.cwd == environment.cwd+ && latest.workspace_roots == environment.workspace_roots+ }) {+ environment.config = latest.config.clone();+ }+ }+ if environments != self.services.turn_environments.selections() {+ self.mark_mcp_runtime_dirty();+ self.services.turn_environments.update_selections(+ &environments,+ &configuration.inferred_environment_config(),+ );+ self.schedule_mcp_prewarm();+ }+ }+ self.services.turn_environments.snapshot()+ };+ snapshot.await}pub(crate) async fn environment_ready(@@ -148,39 +189,79 @@ impl Session {.await}+ /// Records configuration, or a failure to obtain it, for this environment and workspace.+ /// The running turn and future turns may use different environments. Update the matching+ /// selection or selections so work already waiting can still finish, and check successful+ /// configuration before saving either list.async fn update_environment_configuration(&self,selection: &TurnEnvironmentSelection,config: EnvironmentConfigState,) -> CodexResult<()> {// Serialize owner callbacks with ordinary thread settings updates.- let state = self.state.lock().await;- let mut environments = self.services.turn_environments.selections();- let Some(environment) = environments.iter_mut().find(|environment| {+ let mut state = self.state.lock().await;+ let mut current = self.services.turn_environments.selections();+ let mut future = state.session_configuration.environments.clone();+ let matches = |environment: &TurnEnvironmentSelection| {environment.environment_id == selection.environment_id&& environment.cwd == selection.cwd&& environment.workspace_roots == selection.workspace_roots- }) else {- return Err(CodexErr::InvalidRequest(format!(- "environment `{}` is not selected on this thread with the requested workspace",- selection.environment_id- )));};+ let (current_environment, future_environment) = match (+ current.iter_mut().find(|environment| matches(environment)),+ future.iter_mut().find(|environment| matches(environment)),+ ) {+ (None, None) => {+ return Err(CodexErr::InvalidRequest(format!(+ "environment `{}` is not selected on this thread with the requested workspace",+ selection.environment_id+ )));+ }+ (Some(current), Some(future)) if current.config != future.config => {+ // Update the selection still waiting for configuration. If neither is waiting,+ // keep the existing behavior of updating the current one.+ if matches!(future.config, EnvironmentConfigState::Pending) {+ (None, Some(future))+ } else {+ (Some(current), None)+ }+ }+ (Some(current), future) => (Some(current), future),+ (None, Some(future)) => (None, Some(future)),+ };+ let update_current = current_environment.is_some();+ let update_future = future_environment.is_some();- environment.config = config;- if matches!(environment.config, EnvironmentConfigState::Ready(_)) {- state- .session_configuration- .validate(&environments)- .map_err(|error| CodexErr::InvalidRequest(error.to_string()))?;+ if let Some(environment) = current_environment {+ environment.config = config.clone();+ }+ if let Some(environment) = future_environment {+ environment.config = config.clone();+ }+ if matches!(config, EnvironmentConfigState::Ready(_)) {+ let validate = |environments: &[TurnEnvironmentSelection]| {+ state+ .session_configuration+ .validate(environments)+ .map_err(|error| CodexErr::InvalidRequest(error.to_string()))+ };+ if update_current {+ validate(¤t)?;+ }+ if update_future && (!update_current || current != future) {+ validate(&future)?;+ }}- // Invalidate MCP before installed configuration can wake a waiting turn.- self.mark_mcp_runtime_dirty();- self.services.turn_environments.update_selections(- &environments,- &state.session_configuration.inferred_environment_config(),- );+ state.session_configuration.environments = future;+ if update_current {+ // Invalidate MCP before installed configuration can wake a waiting turn.+ self.mark_mcp_runtime_dirty();+ self.services.turn_environments.update_selections(+ ¤t,+ &state.session_configuration.inferred_environment_config(),+ );+ }Ok(())}diff --git a/codex-rs/core/src/session/handlers.rs b/codex-rs/core/src/session/handlers.rsindex dc739a59bf..dcea9a99d2 100644--- a/codex-rs/core/src/session/handlers.rs+++ b/codex-rs/core/src/session/handlers.rs@@ -241,6 +241,8 @@ pub async fn reload_user_config(sess: &Arc<Session>) {}pub async fn compact(sess: &Arc<Session>, sub_id: String) {+ // Stop the old turn before the compact task picks up the next turn's environments.+ sess.abort_all_tasks(TurnAbortReason::Replaced).await;let turn_context = sess.new_turn_with_default_settings(sub_id, Default::default()).await;diff --git a/codex-rs/core/src/session/mcp_runtime.rs b/codex-rs/core/src/session/mcp_runtime.rsindex 7d6c5e2cfb..fe05899606 100644--- a/codex-rs/core/src/session/mcp_runtime.rs+++ b/codex-rs/core/src/session/mcp_runtime.rs@@ -36,7 +36,6 @@ impl Session {&self,current: &SessionConfiguration,next: &SessionConfiguration,- updates: &SessionSettingsUpdate,) -> bool {current.cwd() != next.cwd()|| current.step_settings.approval_policy.value()@@ -44,9 +43,6 @@ impl Session {|| current.step_settings.approvals_reviewer != next.step_settings.approvals_reviewer|| current.permission_profile() != next.permission_profile()|| current.windows_sandbox_level != next.windows_sandbox_level- || updates.environments.as_ref().is_some_and(|environments| {- environments.environments != self.services.turn_environments.selections()- })}/// Waits on this session's refreshed server before tool execution is admitted.@@ -76,19 +72,25 @@ impl Session {&self,auth: Option<CodexAuth>,) -> McpDesiredState {- let (session_configuration, disabled_plugin_ids) = {+ let (session_configuration, disabled_plugin_ids, environments) = {let state = self.state.lock().await;+ // MCP tools must use current environments, not the selection saved for the next turn.(state.session_configuration.clone(),state.active_disabled_plugin_ids.clone(),+ self.services.turn_environments.snapshot(),)};- let environments = self.services.turn_environments.snapshot().await;+ let environments = environments.await;let cwd = environments.primary().and_then(|environment| environment.cwd().to_abs_path().ok()).unwrap_or_else(|| session_configuration.cwd().clone());- let config = self.build_per_turn_config(&session_configuration, cwd);+ let config = self.build_per_turn_config(+ &session_configuration,+ cwd,+ environments.primary_workspace_roots(),+ );let local_process_cwd = environments.local_environment_cwd().unwrap_or_else(|| session_configuration.cwd().clone())@@ -116,7 +118,11 @@ impl Session {) -> anyhow::Result<()> {let cwd = AbsolutePathBuf::from_absolute_path(mcp_runtime_cwd).unwrap_or_else(|_| session_configuration.cwd().clone());- let config = self.build_per_turn_config(session_configuration, cwd);+ let config = self.build_per_turn_config(+ session_configuration,+ cwd,+ resolved_environments.primary_workspace_roots(),+ );let local_process_cwd = resolved_environments.local_environment_cwd().unwrap_or_else(|| session_configuration.cwd().clone())diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 7a19a9078d..4b76ca52eb 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -835,6 +835,7 @@ impl Session {approval_policy: config.permissions.approval_policy.clone(),approvals_reviewer: config.approvals_reviewer,}),+ environments: environment_selections.clone(),model_info_overrides: config.to_models_manager_config().into(),developer_instructions: config.developer_instructions.clone(),base_instructions,@@ -1882,22 +1883,15 @@ impl Session {let updated_permission_profile = updated.permission_profile();let permission_profile_changed =previous_permission_profile != updated_permission_profile;- let mcp_inputs_changed =- self.mcp_inputs_differ(&state.session_configuration, &updated, &updates);let root_service_tier_changed = updated.parent_thread_id.is_none()&& state.session_configuration.step_settings.service_tier!= updated.step_settings.service_tier;+ let environment_config = updated.inferred_environment_config();+ let mcp_inputs_changed = self.mcp_inputs_differ(&state.session_configuration, &updated);if mcp_inputs_changed {self.mark_mcp_runtime_dirty();}- let environment_config = updated.inferred_environment_config();- if let Some(environments) = &updates.environments {- self.services- .turn_environments- .update_selections(&environments.environments, &environment_config);- } else if state.session_configuration.inferred_environment_config()- != environment_config- {+ if state.session_configuration.inferred_environment_config() != environment_config {self.services.turn_environments.update_thread_config(&environment_config);@@ -1918,7 +1912,7 @@ impl Session {configuration: state.session_configuration.clone(),snapshot: state.session_configuration- .thread_settings_snapshot(&self.services.turn_environments.selections()),+ .thread_settings_snapshot(&state.session_configuration.environments),};(commit,@@ -1945,32 +1939,33 @@ impl Session {) -> ConstraintResult<ThreadConfigSnapshot> {let state = self.state.lock().await;let configuration = self.apply_session_settings(&state.session_configuration, updates)?;- let environments = updates.environments.as_ref().map_or_else(- || self.services.turn_environments.selections(),- |environments| environments.environments.clone(),- );- Ok(configuration.thread_config_snapshot(environments))+ Ok(configuration.thread_config_snapshot(configuration.environments.clone()))}pub(crate) async fn thread_config_snapshot(&self) -> ThreadConfigSnapshot {let state = self.state.lock().await;state.session_configuration- .thread_config_snapshot(self.services.turn_environments.selections())+ .thread_config_snapshot(state.session_configuration.environments.clone())+ }++ pub(crate) async fn configured_environment_selections(&self) -> Vec<TurnEnvironmentSelection> {+ let state = self.state.lock().await;+ state.session_configuration.environments.clone()}pub(crate) async fn thread_settings_snapshot(&self) -> ThreadSettingsSnapshot {let state = self.state.lock().await;state.session_configuration- .thread_settings_snapshot(&self.services.turn_environments.selections())+ .thread_settings_snapshot(&state.session_configuration.environments)}pub(crate) async fn restorable_thread_settings(&self) -> CodexThreadSettingsOverrides {let state = self.state.lock().await;state.session_configuration- .restorable_thread_settings(self.services.turn_environments.selections())+ .restorable_thread_settings(state.session_configuration.environments.clone())}pub(crate) async fn set_app_server_client_info(diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex fc0f81acf6..8965f3b4ba 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -104,6 +104,8 @@ pub(crate) struct SessionConfiguration {/// Desired configured inputs inherited by future turns.pub(super) step_settings: Arc<StepSettings>,+ /// Ordered environments inherited by future turns.+ pub(super) environments: Vec<TurnEnvironmentSelection>,/// Explicit startup overrides used when resolving effective model metadata.pub(super) model_info_overrides: ModelInfoOverrides,@@ -419,6 +421,7 @@ impl SessionConfiguration {let current_cwd = self.cwd().clone();if let Some(environments) = &updates.environments {next_configuration.legacy_fallback_cwd = environments.legacy_fallback_cwd.clone();+ next_configuration.environments = environments.environments.clone();}let cwd_changed = next_configuration.legacy_fallback_cwd != current_cwd;if let Some(runtime_workspace_roots) = &updates.runtime_workspace_roots {@@ -1402,6 +1405,7 @@ impl Session {environment_selections,&session_configuration.inferred_environment_config(),);+ session_configuration.environments = turn_environments.selections();let resolved_environments = turn_environments.snapshot().await;let agents_md_manager = Arc::new(AgentsMdManager::new(instructions));let plugin_skill_warmup = warm_plugins_and_skills_for_session_init(diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex d242d6d311..dad95c7001 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -4014,6 +4014,7 @@ async fn set_rate_limits_retains_previous_credits() {};let session_configuration = SessionConfiguration {provider: create_model_provider(config.model_provider.clone(), /*auth_manager*/ None),+ environments: Vec::new(),step_settings: Arc::new(StepSettings {collaboration_mode,reasoning_summary: config.model_reasoning_summary,@@ -4136,6 +4137,7 @@ async fn set_rate_limits_updates_plan_type_when_present() {};let session_configuration = SessionConfiguration {provider: create_model_provider(config.model_provider.clone(), /*auth_manager*/ None),+ environments: Vec::new(),step_settings: Arc::new(StepSettings {collaboration_mode,reasoning_summary: config.model_reasoning_summary,@@ -4755,6 +4757,7 @@ pub(crate) async fn make_session_configuration_for_tests() -> SessionConfiguratiSessionConfiguration {provider: create_model_provider(config.model_provider.clone(), /*auth_manager*/ None),+ environments: Vec::new(),step_settings: Arc::new(StepSettings {collaboration_mode,reasoning_summary: config.model_reasoning_summary,@@ -5742,7 +5745,7 @@ async fn relative_cwd_update_without_environments_resolves_under_session_cwd() {let state = session.state.lock().await;assert_eq!(state.session_configuration.cwd(), &updated_cwd);- assert!(session.services.turn_environments.selections().is_empty());+ assert!(state.session_configuration.environments.is_empty());}#[tokio::test]@@ -5772,7 +5775,7 @@ async fn environment_settings_preserve_explicit_primary_cwd() {let state = session.state.lock().await;assert_eq!(state.session_configuration.cwd(), &updated_cwd);assert_eq!(- session.services.turn_environments.selections()[0].cwd,+ state.session_configuration.environments[0].cwd,PathUri::from_abs_path(&environment_cwd));}@@ -5841,6 +5844,7 @@ async fn session_new_fails_when_zsh_fork_enabled_without_packaged_zsh() {config.model_provider.clone(),Some(Arc::clone(&auth_manager)),),+ environments: Vec::new(),step_settings: Arc::new(StepSettings {collaboration_mode,reasoning_summary: config.model_reasoning_summary,@@ -6018,6 +6022,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),Some(Arc::clone(&auth_manager)),@@ -6234,8 +6239,13 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {forked_from_ordinal_exclusive: None,next_internal_sub_id: AtomicU64::new(0),};- let per_turn_config =- session.build_per_turn_config(&session_configuration, session_configuration.cwd().clone());+ let per_turn_config = session.build_per_turn_config(+ &session_configuration,+ session_configuration.cwd().clone(),+ crate::environment_selection::ThreadEnvironments::primary_workspace_roots_for(+ &session_configuration.environments,+ ),+ );let plugins_input = per_turn_config.plugins_config_input();let plugin_outcome = session.services@@ -6328,6 +6338,7 @@ async fn make_session_with_config_and_rx(};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),Some(Arc::clone(&auth_manager)),@@ -6460,6 +6471,7 @@ async fn make_session_with_history_source_and_agent_control_and_rx(};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),Some(Arc::clone(&auth_manager)),@@ -7536,7 +7548,55 @@ async fn turn_environments_set_primary_environment() {}#[tokio::test]-async fn default_turn_does_not_overlay_legacy_fallback_cwd_onto_stored_thread_environments() {+async fn new_task_does_not_change_an_already_running_tasks_environments() {+ let (session, running_turn, events) = make_session_and_context_with_rx().await;+ let current_cwd = running_turn.config.cwd.clone();+ let next_workspace = tempfile::tempdir().expect("next workspace");+ let next_cwd = next_workspace.path().abs();+ let finish = Arc::new(Notify::new());++ session+ .update_settings(SessionSettingsUpdate {+ environments: Some(TurnEnvironmentSelections::new(+ next_cwd.clone(),+ vec![local(next_cwd.clone())],+ )),+ ..Default::default()+ })+ .await+ .expect("save next task's settings");+ session+ .spawn_task(+ running_turn,+ Vec::new(),+ HeldStepTask {+ kind: TaskKind::Regular,+ finish: Arc::clone(&finish),+ },+ )+ .await;++ let candidate = session+ .new_turn_with_default_settings("candidate".into(), Default::default())+ .await;+ assert_eq!(candidate.config.cwd, current_cwd);+ assert_eq!(candidate.config.workspace_roots, vec![current_cwd.clone()]);+ assert_eq!(+ session.services.turn_environments.selections(),+ vec![local(current_cwd)]+ );++ finish.notify_one();+ recv_terminal_event(&events, TerminalEventKind::TurnComplete).await;+ let next = session+ .new_turn_with_default_settings("next".into(), Default::default())+ .await;+ assert_eq!(next.config.cwd, next_cwd);+ assert_eq!(next.config.workspace_roots, vec![next_cwd]);+}++#[tokio::test]+async fn task_turn_does_not_overlay_legacy_fallback_cwd_onto_stored_thread_environments() {let (session, _initial_turn, _rx) = make_session_and_context_with_rx().await;let session_cwd = session.get_config().await.cwd.clone();let selected_cwd =@@ -7551,7 +7611,9 @@ async fn default_turn_does_not_overlay_legacy_fallback_cwd_onto_stored_thread_en}).await.expect("environment selection update should succeed");- let turn_context = session.new_default_turn().await;+ let turn_context = session+ .new_turn_with_default_settings("task".into(), Default::default())+ .await;let turn_environments = &turn_context.environments;assert_eq!(turn_environments.turn_environments().count(), 1);@@ -7573,7 +7635,7 @@ async fn default_turn_does_not_overlay_legacy_fallback_cwd_onto_stored_thread_en}#[tokio::test]-async fn default_turn_honors_empty_stored_thread_environments() {+async fn task_turn_honors_empty_stored_thread_environments() {let (session, _initial_turn, _rx) = make_session_and_context_with_rx().await;let session_cwd = session.get_config().await.cwd.clone();@@ -7587,7 +7649,9 @@ async fn default_turn_honors_empty_stored_thread_environments() {}).await.expect("environment selection update should succeed");- let turn_context = session.new_default_turn().await;+ let turn_context = session+ .new_turn_with_default_settings("task".into(), Default::default())+ .await;assert!(turn_context.environments.primary().is_none());assert!(@@ -8202,6 +8266,7 @@ where};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),Some(Arc::clone(&auth_manager)),@@ -8421,8 +8486,13 @@ whereforked_from_ordinal_exclusive: None,next_internal_sub_id: AtomicU64::new(0),});- let per_turn_config =- session.build_per_turn_config(&session_configuration, session_configuration.cwd().clone());+ let per_turn_config = session.build_per_turn_config(+ &session_configuration,+ session_configuration.cwd().clone(),+ crate::environment_selection::ThreadEnvironments::primary_workspace_roots_for(+ &session_configuration.environments,+ ),+ );let plugins_input = per_turn_config.plugins_config_input();let plugin_outcome = session.servicesdiff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex ca07a5e1c1..d092a6bcbe 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -769,6 +769,7 @@ impl Session {&self,session_configuration: &SessionConfiguration,cwd: AbsolutePathBuf,+ workspace_roots: Vec<AbsolutePathBuf>,) -> Config {// todo(aibrahim): store this state somewhere else so we don't need to mut configlet config = session_configuration.original_config_do_not_use.clone();@@ -776,7 +777,6 @@ impl Session {per_turn_config.cwd = cwd;per_turn_config.permissions.approval_policy =session_configuration.step_settings.approval_policy.clone();- let workspace_roots = self.services.turn_environments.primary_workspace_roots();per_turn_config.workspace_roots = workspace_roots.clone();per_turn_config.permissions@@ -818,8 +818,15 @@ impl Session {&self,session_configuration: &SessionConfiguration,) -> Config {- let mut config =- self.build_per_turn_config(session_configuration, session_configuration.cwd().clone());+ let workspace_roots =+ crate::environment_selection::ThreadEnvironments::primary_workspace_roots_for(+ &session_configuration.environments,+ );+ let mut config = self.build_per_turn_config(+ session_configuration,+ session_configuration.cwd().clone(),+ workspace_roots,+ );config.model = Some(session_configuration.step_settings@@ -1008,22 +1015,25 @@ impl Session {if let Some(service_tier) = service_tier_for_turn {Arc::make_mut(&mut configuration.step_settings).service_tier = Some(service_tier);}+ let turn_environments = self.activate_turn_environments(&configuration).await;let turn_context = self- .new_turn_from_configuration(sub_id, configuration, options)+ .new_turn_from_configuration(sub_id, configuration, turn_environments, options).await;Ok(Some((turn_context, commit.snapshot)))}- /// Constructs a turn from the exact committed settings without starting a task.+ /// Builds a context from the caller's chosen settings and environments without starting work.async fn new_turn_from_configuration(&self,sub_id: String,session_configuration: SessionConfiguration,+ turn_environments: TurnEnvironmentSnapshot,options: NewTurnContextOptions,) -> Arc<TurnContext> {self.new_turn_context_from_configuration(sub_id,session_configuration,+ turn_environments,options,TurnMultiAgentRuntime::ResolveAndStore,self.git_enrichment_policy,@@ -1036,9 +1046,11 @@ impl Session {sub_id: String,session_configuration: SessionConfiguration,) -> Arc<TurnContext> {+ let turn_environments = self.services.turn_environments.snapshot().await;self.new_turn_context_from_configuration(sub_id,session_configuration,+ turn_environments,NewTurnContextOptions::default(),TurnMultiAgentRuntime::Preview,GitEnrichmentPolicy::Skip,@@ -1051,11 +1063,11 @@ impl Session {&self,sub_id: String,session_configuration: SessionConfiguration,+ turn_environments: TurnEnvironmentSnapshot,options: NewTurnContextOptions,multi_agent_runtime: TurnMultiAgentRuntime,git_enrichment_policy: GitEnrichmentPolicy,) -> Arc<TurnContext> {- let turn_environments = self.services.turn_environments.snapshot().await;let primary_turn_environment = turn_environments.primary();// TODO(anp): Migrate per-turn config and legacy TurnContext cwd consumers to PathUri so// a foreign primary environment does not fall back to the session's host cwd.@@ -1063,7 +1075,11 @@ impl Session {.as_ref().and_then(|turn_environment| turn_environment.cwd().to_abs_path().ok()).unwrap_or_else(|| session_configuration.cwd().clone());- let per_turn_config = self.build_per_turn_config(&session_configuration, cwd.clone());+ let per_turn_config = self.build_per_turn_config(+ &session_configuration,+ cwd.clone(),+ turn_environments.primary_workspace_roots(),+ );let network_permission_profile = primary_turn_environment.map(TurnEnvironment::permission_profile).cloned()@@ -1215,21 +1231,30 @@ impl Session {}}+ /// Builds a context without starting work or changing the current environments.pub(crate) async fn new_default_turn(&self) -> Arc<TurnContext> {- self.new_turn_with_default_settings(+ let session_configuration = self.default_turn_configuration().await;+ let turn_environments = self.services.turn_environments.snapshot().await;+ self.new_turn_from_configuration(self.next_internal_sub_id(),+ session_configuration,+ turn_environments,NewTurnContextOptions::default(),).await}+ /// Prepares new work on the saved environments; context-only callers keep the current ones.pub(crate) async fn new_turn_with_default_settings(&self,sub_id: String,options: NewTurnContextOptions,) -> Arc<TurnContext> {let session_configuration = self.default_turn_configuration().await;- self.new_turn_from_configuration(sub_id, session_configuration, options)+ let turn_environments = self+ .activate_turn_environments(&session_configuration)+ .await;+ self.new_turn_from_configuration(sub_id, session_configuration, turn_environments, options).await}diff --git a/codex-rs/core/src/session/turn_input_tests.rs b/codex-rs/core/src/session/turn_input_tests.rsindex 77dc3f4282..18f1368378 100644--- a/codex-rs/core/src/session/turn_input_tests.rs+++ b/codex-rs/core/src/session/turn_input_tests.rs@@ -645,7 +645,7 @@ async fn automatic_admission_rechecks_plan_mode_without_committing_sparse_settin.await.expect("explicit settings update accepts the same patch");assert_eq!(- session.services.turn_environments.selections(),+ session.configured_environment_selections().await,proposed_environments.environments);assert!(session.mcp_refresh.is_pending());diff --git a/codex-rs/core/tests/suite/hooks_executor.rs b/codex-rs/core/tests/suite/hooks_executor.rsindex 6af7942581..bfb265ba53 100644--- a/codex-rs/core/tests/suite/hooks_executor.rs+++ b/codex-rs/core/tests/suite/hooks_executor.rs@@ -288,7 +288,12 @@ async fn executor_stop_hook_stops_after_disconnection() -> Result<()> {async fn executor_stop_hook_rejects_mismatched_environment() -> Result<()> {skip_if_no_network!(Ok(()));- let fixture = executor_stop_hook_fixture().await?;+ let fixture = executor_hook_fixture(+ ["first-turn", "switch-environments", "second-turn"]+ .map(completed_turn_response)+ .to_vec(),+ )+ .await?;let selection = fixture.attach().await?;fixture.test@@ -372,6 +377,11 @@ async fn executor_stop_hook_rejects_mismatched_environment() -> Result<()> {},).await?;+ fixture+ .test+ .submit_text_turn("apply the new executor environment")+ .await?;+ fixture.wait_for_hook_call().await?;let mut mismatched_config = fixture.test.config.clone();let mut node_repl = mismatched_config@@ -391,7 +401,16 @@ async fn executor_stop_hook_rejects_mismatched_environment() -> Result<()> {.codex.refresh_mcp_config(mismatched_config).await;- wait_for_mcp_server(&fixture.test.codex, "node_repl").await?;+ fixture+ .test+ .codex+ .call_mcp_tool(+ "node_repl",+ "js",+ Some(json!({"code": "1 + 1"})),+ /*meta*/ None,+ )+ .await?;assert_eq!(fixture.test@@ -409,7 +428,15 @@ async fn executor_stop_hook_rejects_mismatched_environment() -> Result<()> {executor.abort();}- assert_eq!(fixture.calls().await?.len(), 1);+ assert_eq!(+ fixture+ .calls()+ .await?+ .iter()+ .filter(|call| call["params"]["name"] == "turn_ended")+ .count(),+ 2+ );Ok(())}diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex f4ce3b160c..6aa59c671d 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -9,6 +9,7 @@ use codex_core::EnvironmentConfig;use codex_core::EnvironmentNetworkPolicy;use codex_core::StartThreadOptions;use codex_core::TurnInputRequest;+use codex_core::TurnInputSubmission;use codex_core::WaitForEnvironmentToolConfig;use codex_core::compact::SUMMARIZATION_PROMPT;use codex_core::config::Config;@@ -1557,10 +1558,6 @@ async fn shared_executor_keeps_ready_capability_roots_scoped_to_each_attachment().await?;- assert_eq!(- test.codex.inspect_selected_capability_roots().ready_roots,- vec![root("first-root")]- );assert_eq!(second.thread@@ -1629,6 +1626,10 @@ async fn shared_executor_keeps_ready_capability_roots_scoped_to_each_attachment(wait_for_event(thread, |event| matches!(event, EventMsg::TurnComplete(_))).await;}+ assert_eq!(+ test.codex.inspect_selected_capability_roots().ready_roots,+ vec![root("first-updated-root")]+ );let requests = response_mock.requests();let root_fragments = requests.iter()@@ -1981,6 +1982,146 @@ async fn pending_attachment_installs_configuration_before_waiting_turn_resumes()Ok(())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn future_pending_environment_can_finish_without_retargeting_the_active_turn() -> Result<()> {+ let server = start_mock_server().await;+ let mut extensions = ExtensionRegistryBuilder::new();+ extensions.thread_lifecycle_contributor(Arc::new(WaitForEnvironmentTestExtension));+ extensions.prompt_contributor(Arc::new(ReadyCapabilityRootsTestExtension::default()));+ let mut builder = test_codex()+ .with_extensions(Arc::new(extensions.build()))+ .with_config(|config| {+ assert!(config.features.enable(Feature::DeferredExecutor).is_ok());+ });+ let test = builder.build_with_auto_env(&server).await?;+ let selection = test.codex.environment_selections().await.remove(0);+ let active = TurnEnvironmentSelection {+ config: EnvironmentConfigState::Pending,+ ..selection+ };+ let future_cwd = active.cwd.join("future-environment")?;+ test.fs()+ .create_directory(+ &future_cwd,+ CreateDirectoryOptions {+ recursive: false,+ follow_symlinks: true,+ },+ /*sandbox*/ None,+ )+ .await?;+ let future = TurnEnvironmentSelection {+ cwd: future_cwd.clone(),+ workspace_roots: vec![future_cwd],+ ..active.clone()+ };+ let owner_config = |selection: &TurnEnvironmentSelection, id: &str| EnvironmentConfig {+ allow_login_shell: test.config.permissions.allow_login_shell,+ workspace_roots: selection.workspace_roots.clone(),+ permission_profile: PermissionProfileSnapshot::legacy(PermissionProfile::read_only()),+ shell_environment_policy: Default::default(),+ windows_sandbox_level: WindowsSandboxLevel::from_config(&test.config),+ windows_sandbox_private_desktop: test.config.permissions.windows_sandbox_private_desktop,+ use_legacy_landlock: test.config.features.use_legacy_landlock(),+ exec_policy: None,+ mcp_policy: None,+ network_policy: None,+ selected_capability_roots: vec![SelectedCapabilityRoot {+ id: id.to_string(),+ location: CapabilityRootLocation::Environment {+ environment_id: selection.environment_id.clone(),+ path: selection.cwd.clone(),+ },+ }],+ };+ let thread = test+ .thread_manager+ .start_thread(StartThreadOptions {+ environments: Some(vec![active.clone()]),+ ..StartThreadOptions::new(test.config.clone())+ })+ .await?+ .thread;+ let response_mock = mount_sse_sequence(+ &server,+ vec![+ sse(vec![+ ev_function_call(+ "wait-for-active-environment",+ "wait_for_environment",+ &json!({ "environment_id": active.environment_id }).to_string(),+ ),+ ev_completed("waiting"),+ ]),+ sse(vec![ev_completed("active-done")]),+ sse(vec![ev_completed("future-done")]),+ ],+ )+ .await;+ let request = |text: &str| {+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: text.to_string(),+ text_elements: Vec::new(),+ }])+ };+ thread.start_or_steer_turn(request("wait")).await?;+ wait_for_response_request_count(&response_mock, /*expected_count*/ 1).await;+ assert!(matches!(+ thread+ .start_or_steer_turn(+ request("use the other environment next turn").with_thread_settings(+ ThreadSettingsOverrides {+ environments: Some(TurnEnvironmentSelections::new(+ test.config.cwd.clone(),+ vec![future.clone()],+ )),+ ..Default::default()+ },+ )+ )+ .await?,+ TurnInputSubmission::Steered { .. }+ ));+ thread+ .environment_ready(&future, owner_config(&future, "future-root"))+ .await?;+ assert!(matches!(+ thread.environment_selections().await[0].config,+ EnvironmentConfigState::Ready(_)+ ));+ thread+ .environment_ready(&active, owner_config(&active, "active-root"))+ .await?;+ wait_for_event(&thread, |event| matches!(event, EventMsg::TurnComplete(_))).await;+ thread.start_or_steer_turn(request("next turn")).await?;+ wait_for_event(&thread, |event| matches!(event, EventMsg::TurnComplete(_))).await;++ let requests = response_mock.requests();+ let (output, _) = requests[1]+ .function_call_output_content_and_success("wait-for-active-environment")+ .context("active wait output should be model visible")?;+ assert_eq!(+ serde_json::from_str::<Value>(&output.context("active wait output should contain JSON")?)?,+ json!({ "environment_id": active.environment_id, "status": "ready" })+ );+ let ready_roots = requests[1..]+ .iter()+ .map(|request| {+ request+ .message_input_texts("user")+ .into_iter()+ .rfind(|text| text.contains("<ready_capability_roots>"))+ })+ .collect::<Vec<_>>();+ assert_eq!(+ ready_roots,+ ["active-root", "future-root"].map(|root| Some(format!(+ "<ready_capability_roots>{root}</ready_capability_roots>"+ )))+ );+ Ok(())+}+#[test_case(true; "uses refreshed executor root")]#[test_case(false; "preserves persisted root when executor reports none")]#[tokio::test(flavor = "multi_thread", worker_threads = 4)]diff --git a/codex-rs/core/tests/suite/rmcp_client.rs b/codex-rs/core/tests/suite/rmcp_client.rsindex ccce14877a..cf9bfd27d7 100644--- a/codex-rs/core/tests/suite/rmcp_client.rs+++ b/codex-rs/core/tests/suite/rmcp_client.rs@@ -704,7 +704,7 @@ async fn environment_mcp_policy_filters_runtime_config_and_model_tools(skip_if_no_network!(Ok(()));let server = responses::start_mock_server().await;- let response = mount_sse_once(+ mount_sse_once(&server,responses::sse(vec![responses::ev_response_created("resp-1"),@@ -786,6 +786,9 @@ async fn environment_mcp_policy_filters_runtime_config_and_model_tools(},).await?;+ fixture+ .submit_text_turn("start with pending environment configuration")+ .await?;let (pending_config, _) = fixture.codex.current_mcp_config_and_runtime_context().await;let pending_servers = pending_config.mcp_server_catalog.configured_servers();assert!(!pending_servers["allowed"].enabled);@@ -856,6 +859,15 @@ async fn environment_mcp_policy_filters_runtime_config_and_model_tools().await?;+ let response = mount_sse_once(+ &server,+ responses::sse(vec![+ responses::ev_response_created("resp-2"),+ responses::ev_assistant_message("msg-2", "done"),+ responses::ev_completed("resp-2"),+ ]),+ )+ .await;fixture.submit_text_turn("show the available MCP tools").await?;