Lightweight coding agent that runs in your terminal
Rust
Harden internal Guardian session isolation (#40497)
Won Park8476434a97d3
diff --git a/codex-rs/core/src/codex_delegate.rs b/codex-rs/core/src/codex_delegate.rsindex 70c9fda438..52a72b8970 100644--- a/codex-rs/core/src/codex_delegate.rs+++ b/codex-rs/core/src/codex_delegate.rs@@ -80,7 +80,7 @@ pub(crate) async fn run_codex_thread_interactive(warnings: Vec::new(),};let session_source = SessionSource::SubAgent(subagent_source.clone());- let is_guardian_reviewer = crate::guardian::is_guardian_reviewer_source(&session_source);+ let is_guardian_reviewer = crate::guardian::is_basic_session_source(&session_source);let extensions = if is_guardian_reviewer {codex_extension_api::empty_extension_registry()} else {diff --git a/codex-rs/core/src/guardian/mod.rs b/codex-rs/core/src/guardian/mod.rsindex 0486ccb063..eaf2826c84 100644--- a/codex-rs/core/src/guardian/mod.rs+++ b/codex-rs/core/src/guardian/mod.rs@@ -38,7 +38,7 @@ pub(crate) use prompt::BUNDLED_GUARDIAN_POLICY;pub(crate) use prompt::guardian_truncate_text;pub(crate) use review::GuardianReviewOptions;pub(crate) use review::guardian_timeout_message;-pub(crate) use review::is_guardian_reviewer_source;+pub(crate) use review::is_basic_session_source;pub(crate) use review::new_guardian_review_id;#[cfg(test)]pub(crate) use review::record_guardian_denial_for_test;diff --git a/codex-rs/core/src/guardian/review.rs b/codex-rs/core/src/guardian/review.rsindex 29c5c08e08..de63bd97db 100644--- a/codex-rs/core/src/guardian/review.rs+++ b/codex-rs/core/src/guardian/review.rs@@ -19,7 +19,9 @@ use codex_protocol::protocol::GuardianAssessmentEvent;use codex_protocol::protocol::GuardianAssessmentStatus;use codex_protocol::protocol::GuardianRiskLevel;use codex_protocol::protocol::GuardianUserAuthorization;+use codex_protocol::protocol::InternalSessionSource;use codex_protocol::protocol::ReviewDecision;+use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::SubAgentSource;use codex_protocol::protocol::TurnAbortReason;use codex_protocol::protocol::WarningEvent;@@ -209,14 +211,12 @@ pub(crate) fn routes_approval_policy_to_guardian() && approvals_reviewer == ApprovalsReviewer::AutoReview}-pub(crate) fn is_guardian_reviewer_source(- session_source: &codex_protocol::protocol::SessionSource,-) -> bool {- matches!(- session_source,- codex_protocol::protocol::SessionSource::SubAgent(SubAgentSource::Other(label))- if label == GUARDIAN_REVIEWER_NAME- )+pub(crate) fn is_basic_session_source(session_source: &SessionSource) -> bool {+ match session_source {+ SessionSource::SubAgent(SubAgentSource::Other(label)) => label == GUARDIAN_REVIEWER_NAME,+ SessionSource::Internal(InternalSessionSource::Guardian) => true,+ _ => false,+ }}fn track_guardian_review(diff --git a/codex-rs/core/src/session/mcp_runtime.rs b/codex-rs/core/src/session/mcp_runtime.rsindex 9802e7e4c3..e569bf1ac2 100644--- a/codex-rs/core/src/session/mcp_runtime.rs+++ b/codex-rs/core/src/session/mcp_runtime.rs@@ -150,7 +150,7 @@ impl Session {mut projection: McpRuntimeProjection,) -> BoxFuture<'a, McpRuntimeProjection> {Box::pin(async move {- if crate::guardian::is_guardian_reviewer_source(session_source) {+ if crate::guardian::is_basic_session_source(session_source) {return projection;}diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 10b2b6b696..3fc12c2d71 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -547,11 +547,16 @@ impl Session {config.startup_warnings.extend(user_instruction_provider_warnings);- let exec_policy = if crate::guardian::is_guardian_reviewer_source(&session_source) {- // Guardian review should rely on the built-in shell safety checks,- // not on caller-provided exec-policy rules that could shape the- // reviewer or silently auto-approve commands.- Arc::new(ExecPolicyManager::default())+ let exec_policy = if crate::guardian::is_basic_session_source(&session_source) {+ let managed_policy = config+ .config_layer_stack+ .requirements()+ .exec_policy+ .as_deref()+ .map_or_else(codex_execpolicy::Policy::empty, |policy| {+ policy.as_ref().clone()+ });+ Arc::new(ExecPolicyManager::new(Arc::new(managed_policy)))} else if let Some(exec_policy) = &inherited_exec_policy {Arc::clone(exec_policy)} else {@@ -602,9 +607,8 @@ impl Session {config.http_client_factory(),).await;- let trusted_guardian_reviewer =- crate::guardian::is_guardian_reviewer_source(&session_source)- && !matches!(conversation_history, InitialHistory::Resumed(_));+ let trusted_guardian_reviewer = crate::guardian::is_basic_session_source(&session_source)+ && !matches!(conversation_history, InitialHistory::Resumed(_));if config.config_layer_stack.requirements()@@ -3592,7 +3596,7 @@ impl Session {)};let separate_guardian_developer_message =- crate::guardian::is_guardian_reviewer_source(&session_source);+ crate::guardian::is_basic_session_source(&session_source);// Keep the guardian policy prompt out of the aggregated developer bundle so it// stays isolated as its own top-level developer message for guardian subagents.if !separate_guardian_developer_messagediff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex 244c116de5..792b2bf4c8 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -659,7 +659,7 @@ async fn required_mcp_servers_for_input(turn_context: &TurnContext,user_input: &[UserInput],) -> (Vec<String>, Vec<crate::plugins::PluginCapabilitySummary>) {- if crate::guardian::is_guardian_reviewer_source(&turn_context.session_source) {+ if crate::guardian::is_basic_session_source(&turn_context.session_source) {return (Vec::new(), Vec::new());}@@ -765,7 +765,7 @@ async fn build_skills_and_plugins(let turn_context = step_context.turn.as_ref();// Guardian input embeds the parent transcript as untrusted evidence. Do not interpret skill or// plugin mentions from that generated prompt as requests to inject additional instructions.- if crate::guardian::is_guardian_reviewer_source(&turn_context.session_source) {+ if crate::guardian::is_basic_session_source(&turn_context.session_source) {return Some((Vec::new(), HashSet::new()));}@@ -1322,7 +1322,7 @@ pub(crate) fn build_prompt(parallel_tool_calls: true,base_instructions,output_schema: turn_context.final_output_json_schema.clone(),- output_schema_strict: !crate::guardian::is_guardian_reviewer_source(+ output_schema_strict: !crate::guardian::is_basic_session_source(&turn_context.session_source,),}diff --git a/codex-rs/core/src/session/world_state.rs b/codex-rs/core/src/session/world_state.rsindex 90a5328a87..d9640fcb20 100644--- a/codex-rs/core/src/session/world_state.rs+++ b/codex-rs/core/src/session/world_state.rs@@ -285,14 +285,16 @@ impl Session {world_state.add_section(usage_hint);}world_state.add_section(multi_agent_mode);- world_state.add_section(ManagedDeveloperInstructionsState::new(- turn_context- .config- .config_layer_stack- .requirements()- .additional_developer_instructions- .as_ref(),- ));+ if !crate::guardian::is_basic_session_source(&turn_context.session_source) {+ world_state.add_section(ManagedDeveloperInstructionsState::new(+ turn_context+ .config+ .config_layer_stack+ .requirements()+ .additional_developer_instructions+ .as_ref(),+ ));+ }Ok(world_state)}}diff --git a/codex-rs/core/src/thread_manager.rs b/codex-rs/core/src/thread_manager.rsindex 33d9adee7e..5cbba9778b 100644--- a/codex-rs/core/src/thread_manager.rs+++ b/codex-rs/core/src/thread_manager.rs@@ -1882,21 +1882,44 @@ impl ThreadManagerState {threads.remove(&resumed.conversation_id);}}- let user_instructions = self- .user_instructions_for_spawn(&session_source, parent_thread_id, forked_from_thread_id)- .await;+ let (+ user_instructions,+ inherited_exec_policy,+ extensions,+ mcp_manager,+ multi_agent_version,+ ) = if crate::guardian::is_basic_session_source(&session_source) {+ (+ LoadedUserInstructions::default(),+ None,+ empty_extension_registry(),+ Arc::new(McpManager::new(Arc::clone(&self.plugins_manager))),+ Some(MultiAgentVersion::Disabled),+ )+ } else {+ (+ self.user_instructions_for_spawn(+ &session_source,+ parent_thread_id,+ forked_from_thread_id,+ )+ .await,+ inherited_exec_policy,+ Arc::clone(&self.extensions),+ Arc::clone(&self.mcp_manager),+ self.initial_multi_agent_version_for_spawn(+ &initial_history,+ Some(&session_source),+ parent_thread_id,+ forked_from_thread_id,+ )+ .await,+ )+ };let parent_rollout_thread_trace = self.parent_rollout_thread_trace_for_source(&session_source, &initial_history).await;let tracked_session_source = session_source.clone();- let multi_agent_version = self- .initial_multi_agent_version_for_spawn(- &initial_history,- Some(&session_source),- parent_thread_id,- forked_from_thread_id,- )- .await;let originator = self.effective_originator(&initial_history,@@ -1925,9 +1948,9 @@ impl ThreadManagerState {environment_manager: Arc::clone(&self.environment_manager),skills_service: Arc::clone(&self.skills_service),plugins_manager: Arc::clone(&self.plugins_manager),- mcp_manager: Arc::clone(&self.mcp_manager),+ mcp_manager,code_mode_session_provider: Arc::clone(&self.code_mode_session_provider),- extensions: Arc::clone(&self.extensions),+ extensions,conversation_history: initial_history,requested_history_mode: history_mode,fork_persistence,diff --git a/codex-rs/core/src/thread_manager_tests.rs b/codex-rs/core/src/thread_manager_tests.rsindex 017745548a..fea6e44ecc 100644--- a/codex-rs/core/src/thread_manager_tests.rs+++ b/codex-rs/core/src/thread_manager_tests.rs@@ -878,18 +878,106 @@ async fn start_thread_keeps_internal_threads_hidden_from_normal_lookups() {#[tokio::test]async fn spawn_internal_session_preserves_parent_lineage_without_forking_history() {+ struct ParentLifecycleContributor {+ observed_mcp_sources: Arc<std::sync::Mutex<Vec<SessionSource>>>,+ }++ impl codex_extension_api::ThreadLifecycleContributor<Config> for ParentLifecycleContributor {}++ impl codex_extension_api::McpServerContributor<Config> for ParentLifecycleContributor {+ fn id(&self) -> &'static str {+ "parent_mcp_contributor"+ }++ fn contribute<'a>(+ &'a self,+ context: codex_extension_api::McpServerContributionContext<'a, Config>,+ ) -> codex_extension_api::ExtensionFuture<'a, Vec<codex_extension_api::McpServerContribution>>+ {+ Box::pin(async move {+ if let Some(session_source) = context.session_source() {+ self.observed_mcp_sources+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .push(session_source.clone());+ }+ Vec::new()+ })+ }+ }++ struct ParentInstructionsProvider(codex_extension_api::UserInstructions);++ impl codex_extension_api::UserInstructionsProvider for ParentInstructionsProvider {+ fn load_user_instructions(&self) -> codex_extension_api::LoadUserInstructionsFuture<'_> {+ Box::pin(async move {+ codex_extension_api::LoadedUserInstructions {+ instructions: Some(self.0.clone()),+ warnings: Vec::new(),+ }+ })+ }+ }+let temp_dir = tempdir().expect("tempdir");let mut config = test_config().await;config.codex_home = temp_dir.path().join("codex-home").abs();config.cwd = config.codex_home.abs();std::fs::create_dir_all(&config.codex_home).expect("create codex home");- let manager = ThreadManager::with_models_provider_and_home_for_tests(+ let mut managed_exec_policy = codex_execpolicy::Policy::empty();+ managed_exec_policy+ .add_prefix_rule(&["rm".to_string()], codex_execpolicy::Decision::Forbidden)+ .expect("add managed execution restriction");+ let mut requirements = config.config_layer_stack.requirements().clone();+ requirements.exec_policy = Some(codex_config::Sourced::new(+ codex_execpolicy::RequirementsExecPolicy::new(managed_exec_policy),+ codex_config::RequirementSource::Unknown,+ ));+ requirements.additional_developer_instructions = Some(codex_config::Sourced::new(+ "managed instructions must not shape the reviewer".to_string(),+ codex_config::RequirementSource::Unknown,+ ));+ let mut requirements_toml = config.config_layer_stack.requirements_toml().clone();+ requirements_toml.additional_developer_instructions =+ Some("managed instructions must not shape the reviewer".to_string());+ config.config_layer_stack = codex_config::ConfigLayerStack::new(+ config+ .config_layer_stack+ .all_layers_low_to_high()+ .cloned()+ .collect(),+ requirements,+ requirements_toml,+ )+ .expect("managed requirements stack");++ let parent_instructions = codex_extension_api::UserInstructions {+ text: "parent user instructions must not be inherited".to_string(),+ source: config.codex_home.join("AGENTS.md"),+ };+ let mut manager = ThreadManager::with_models_provider_and_home_for_tests(CodexAuth::from_api_key("dummy"),config.model_provider.clone(),config.codex_home.to_path_buf(),Arc::new(codex_exec_server::EnvironmentManager::default_for_tests()),);+ let observed_mcp_sources = Arc::new(std::sync::Mutex::new(Vec::new()));+ let parent_contributor = Arc::new(ParentLifecycleContributor {+ observed_mcp_sources: Arc::clone(&observed_mcp_sources),+ });+ let mut extensions = codex_extension_api::ExtensionRegistryBuilder::new();+ extensions.thread_lifecycle_contributor(parent_contributor.clone());+ extensions.mcp_server_contributor(parent_contributor);+ let manager_state = Arc::get_mut(&mut manager.state).expect("unshared thread manager state");+ manager_state.extensions = Arc::new(extensions.build());+ manager_state.mcp_manager = Arc::new(McpManager::new_with_extensions(+ Arc::clone(&manager_state.plugins_manager),+ Arc::clone(&manager_state.extensions),+ manager_state.mcp_manager.codex_apps_tools_cache(),+ ));+ manager_state.user_instructions_provider =+ Arc::new(ParentInstructionsProvider(parent_instructions.clone()));let parent = manager.start_thread(StartThreadOptions {metrics_service_name: Some("codex_work_desktop".to_string()),@@ -897,6 +985,45 @@ async fn spawn_internal_session_preserves_parent_lineage_without_forking_history}).await.expect("start parent thread");+ parent+ .thread+ .session+ .set_multi_agent_version_if_unset(MultiAgentVersion::V2);+ assert_eq!(+ parent.thread.session.user_instructions().await,+ Some(parent_instructions)+ );+ assert_eq!(+ parent+ .thread+ .session+ .services+ .extensions+ .thread_lifecycle_contributors()+ .len(),+ 1+ );+ let mut reviewer_environments = parent+ .thread+ .session+ .services+ .turn_environments+ .selections();+ let reviewer_environment = reviewer_environments+ .first_mut()+ .expect("parent should have an environment");+ reviewer_environment.config =+ EnvironmentConfigState::Ready(codex_protocol::protocol::EnvironmentConfig {+ allow_login_shell: true,+ permission_profile: config.permissions.permission_profile_state().snapshot(),+ shell_environment_policy: Default::default(),+ exec_policy: Some(codex_execpolicy::RequirementsExecPolicy::new(+ codex_execpolicy::Policy::empty(),+ )),+ mcp_policy: None,+ network_policy: None,+ selected_capability_roots: Vec::new(),+ });let reviewer = manager.spawn_internal_session(parent.thread_id,@@ -905,7 +1032,7 @@ async fn spawn_internal_session_preserves_parent_lineage_without_forking_historyinitial_history: InitialHistory::Forked(vec![RolloutItem::ResponseItem(user_msg("parent history must not be inherited").into(),)]),- environments: Some(Vec::new()),+ environments: Some(reviewer_environments),..StartThreadOptions::new(config)},)@@ -934,11 +1061,70 @@ async fn spawn_internal_session_preserves_parent_lineage_without_forking_historyassert_eq!(reviewer_config.parent_thread_id, Some(parent.thread_id));assert_eq!(reviewer_config.forked_from_thread_id, None);assert_eq!(reviewer_config.originator, "codex_work_desktop");+ assert_eq!(+ reviewer.thread.multi_agent_version(),+ Some(MultiAgentVersion::Disabled)+ );assert_eq!(reviewer.session_configured.parent_thread_id,Some(parent.thread_id));assert_eq!(reviewer.session_configured.forked_from_id, None);+ assert!(reviewer.thread.session.user_instructions().await.is_none());+ assert!(+ reviewer+ .thread+ .session+ .services+ .exec_policy+ .current()+ .rules()+ .contains_key("rm")+ );+ let reviewer_turn = reviewer.thread.session.new_default_turn().await;+ let reviewer_world_state =+ build_world_state_from_turn_context(&reviewer.thread.session, &reviewer_turn).await;+ let reviewer_context = reviewer+ .thread+ .session+ .build_initial_context_with_world_state(&reviewer_turn, &reviewer_world_state)+ .await;+ assert!(+ !serde_json::to_string(&reviewer_context)+ .expect("reviewer context should serialize")+ .contains("managed instructions must not shape the reviewer")+ );+ let reviewer_environment = reviewer+ .thread+ .environment_selections()+ .await+ .into_iter()+ .next()+ .expect("reviewer should retain its selected environment");+ assert!(matches!(+ reviewer_environment.config,+ EnvironmentConfigState::Ready(config) if config.exec_policy.is_some()+ ));+ assert!(+ reviewer+ .thread+ .session+ .services+ .extensions+ .thread_lifecycle_contributors()+ .is_empty()+ );+ {+ let observed_mcp_sources = observed_mcp_sources+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ assert!(!observed_mcp_sources.is_empty());+ assert!(+ observed_mcp_sources+ .iter()+ .all(|source| !source.is_internal())+ );+ }assert_eq!(manager.list_thread_ids().await, vec![parent.thread_id]);assert!(manager.get_thread(reviewer.thread_id).await.is_err());assert!(diff --git a/codex-rs/core/src/tools/spec_plan.rs b/codex-rs/core/src/tools/spec_plan.rsindex f0ab350319..b317ca2c02 100644--- a/codex-rs/core/src/tools/spec_plan.rs+++ b/codex-rs/core/src/tools/spec_plan.rs@@ -141,8 +141,7 @@ pub(crate) fn build_tool_router(let mut registry = ToolRegistry::default();add_core_tool_sources(&context, &mut registry);- let hosted_specs = if crate::guardian::is_guardian_reviewer_source(&turn_context.session_source)- {+ let hosted_specs = if crate::guardian::is_basic_session_source(&turn_context.session_source) {Vec::new()} else {let registered_mcp_tools = session.services.mcp_handler_cache.append_mcp_tools(@@ -278,7 +277,7 @@ pub(crate) fn append_source_tools(extension_tool_executors: impl IntoIterator<Item = Arc<dyn ToolExecutor<ExtensionToolCall>>>,dynamic_tools: &[DynamicToolSpec],) -> Vec<ToolSpec> {- if crate::guardian::is_guardian_reviewer_source(&turn_context.session_source) {+ if crate::guardian::is_basic_session_source(&turn_context.session_source) {return Vec::new();}@@ -549,7 +548,7 @@ fn hosted_model_tool_specs() -> Vec<ToolSpec> {// Responses Lite accepts schemas for client-executed tools, not hosted Responses tools.if turn_context.model_info.use_responses_lite- || crate::guardian::is_guardian_reviewer_source(&turn_context.session_source)+ || crate::guardian::is_basic_session_source(&turn_context.session_source){return Vec::new();}@@ -890,27 +889,40 @@ fn add_core_tool_sources(context: &CoreToolPlanContext<'_>, registry: &mut ToolR// Guardian reviewers receive only `exec_command`, `write_stdin`, and `view_image`// when a managed sandbox can enforce the parent's filesystem restrictions;// all general tool sources stay excluded.- if crate::guardian::is_guardian_reviewer_source(&context.turn_context.session_source) {+ if crate::guardian::is_basic_session_source(&context.turn_context.session_source) {let turn_context = context.turn_context;if !matches!(turn_context.permission_profile(),PermissionProfile::Managed { .. }- ) {+ ) || context.environments.turn_environments().any(|environment| {+ !matches!(+ environment.permission_profile(),+ PermissionProfile::Managed { .. }+ )+ }) {return;}let environment_mode = tool_environment_mode(context.environments);if environment_mode.has_environment() {let include_environment_id = matches!(environment_mode, ToolEnvironmentMode::Multiple);- registry.add(ExecCommandHandler::new(ExecCommandHandlerOptions {- allow_login_shell: any_environment_allows_login_shell(context.environments),- exec_permission_approvals_enabled: false,- include_environment_id,- include_shell_parameter: unified_exec_should_include_shell_parameter(- turn_context,- context.environments,- ),- }));- registry.add(WriteStdinHandler);+ if turn_context.config.features.enabled(Feature::ShellTool)+ && turn_context.config.features.enabled(Feature::UnifiedExec)+ && !matches!(+ turn_context.model_info.shell_type,+ ConfigShellToolType::Disabled+ )+ {+ registry.add(ExecCommandHandler::new(ExecCommandHandlerOptions {+ allow_login_shell: any_environment_allows_login_shell(context.environments),+ exec_permission_approvals_enabled: false,+ include_environment_id,+ include_shell_parameter: unified_exec_should_include_shell_parameter(+ turn_context,+ context.environments,+ ),+ }));+ registry.add(WriteStdinHandler);+ }if turn_context.config.features.enabled(Feature::ViewImage) {registry.add(ViewImageHandler::new(ViewImageToolOptions {can_request_original_image_detail: can_request_original_image_detail(diff --git a/codex-rs/core/src/tools/spec_plan_tests.rs b/codex-rs/core/src/tools/spec_plan_tests.rsindex a31e576788..a476cf1518 100644--- a/codex-rs/core/src/tools/spec_plan_tests.rs+++ b/codex-rs/core/src/tools/spec_plan_tests.rs@@ -22,6 +22,7 @@ use codex_protocol::openai_models::InputModality;use codex_protocol::openai_models::ToolMode;use codex_protocol::openai_models::WebSearchToolType;use codex_protocol::protocol::EnvironmentConfigState;+use codex_protocol::protocol::InternalSessionSource;use codex_protocol::protocol::MultiAgentVersion;use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::SubAgentSource;@@ -476,6 +477,191 @@ fn apply_patch_accepts_environment_id(spec: &ToolSpec) -> bool {}}+#[tokio::test]+async fn internal_guardian_sessions_exclude_optional_core_tools() {+ let (session, mut turn) = make_session_and_context().await;+ turn.session_source = SessionSource::Internal(InternalSessionSource::Guardian);+ set_feature(&mut turn, Feature::ViewImage, /*enabled*/ true);+ Arc::make_mut(&mut turn.config).update_plan_enabled = true;+ turn.multi_agent_version = MultiAgentVersion::V2;+ let turn = Arc::new(turn);+ let step_context = StepContext::for_test(Arc::clone(&turn));++ let router = super::build_tool_router(+ &session,+ step_context.turn.as_ref(),+ &step_context.environments,+ &step_context.mcp,+ /*apps_enabled*/ false,+ &turn.extension_data,+ /*tool_suggest_candidates*/ None,+ )+ .expect("build internal Guardian tool router");++ assert_eq!(+ router+ .model_visible_specs()+ .iter()+ .map(codex_tools::ToolSpec::name)+ .collect::<Vec<_>>(),+ vec!["exec_command", "write_stdin", "view_image"]+ );+}++#[tokio::test]+async fn internal_guardian_sessions_respect_managed_shell_restrictions() {+ for (disabled_feature, shell_type) in [+ (Some(Feature::ShellTool), ConfigShellToolType::UnifiedExec),+ (Some(Feature::UnifiedExec), ConfigShellToolType::UnifiedExec),+ (None, ConfigShellToolType::Disabled),+ ] {+ let (session, mut turn) = make_session_and_context().await;+ turn.session_source = SessionSource::Internal(InternalSessionSource::Guardian);+ set_feature(&mut turn, Feature::ViewImage, /*enabled*/ true);+ set_feature(&mut turn, Feature::CodeMode, /*enabled*/ true);+ if let Some(feature) = disabled_feature {+ let config = Arc::make_mut(&mut turn.config);+ config.features = crate::config::ManagedFeatures::from_configured(+ config.features.get().clone(),+ Some(codex_config::Sourced::new(+ codex_config::FeatureRequirementsToml {+ entries: BTreeMap::from([(feature.key().to_string(), false)]),+ },+ codex_config::RequirementSource::Unknown,+ )),+ )+ .expect("managed shell restriction should be valid");+ }+ Arc::make_mut(&mut turn.model_info).shell_type = shell_type;+ let turn = Arc::new(turn);+ let step_context = StepContext::for_test(Arc::clone(&turn));++ let router = super::build_tool_router(+ &session,+ step_context.turn.as_ref(),+ &step_context.environments,+ &step_context.mcp,+ /*apps_enabled*/ false,+ &turn.extension_data,+ /*tool_suggest_candidates*/ None,+ )+ .expect("build internal Guardian tool router");++ assert_eq!(+ router+ .model_visible_specs()+ .iter()+ .map(codex_tools::ToolSpec::name)+ .collect::<Vec<_>>(),+ vec![+ codex_code_mode::PUBLIC_TOOL_NAME,+ codex_code_mode::WAIT_TOOL_NAME,+ "view_image",+ ],+ "disabled feature: {disabled_feature:?}, shell type: {shell_type:?}"+ );+ }+}++#[tokio::test]+async fn internal_guardian_sessions_preserve_code_mode() {+ let (session, mut turn) = make_session_and_context().await;+ turn.session_source = SessionSource::Internal(InternalSessionSource::Guardian);+ set_feature(&mut turn, Feature::CodeMode, /*enabled*/ true);+ let turn = Arc::new(turn);+ let step_context = StepContext::for_test(Arc::clone(&turn));++ let router = super::build_tool_router(+ &session,+ step_context.turn.as_ref(),+ &step_context.environments,+ &step_context.mcp,+ /*apps_enabled*/ false,+ &turn.extension_data,+ /*tool_suggest_candidates*/ None,+ )+ .expect("build internal Guardian tool router");++ assert!(+ router+ .model_visible_specs()+ .iter()+ .any(|tool| tool.name() == codex_code_mode::PUBLIC_TOOL_NAME)+ );+ assert!(+ router+ .model_visible_specs()+ .iter()+ .any(|tool| tool.name() == codex_code_mode::WAIT_TOOL_NAME)+ );+}++#[tokio::test]+async fn internal_guardian_sessions_require_managed_secondary_environments() {+ for (secondary_profile, expected_tools) in [+ (+ codex_protocol::models::PermissionProfile::workspace_write(),+ vec!["exec_command", "write_stdin", "view_image"],+ ),+ (+ codex_protocol::models::PermissionProfile::Disabled,+ Vec::new(),+ ),+ ] {+ let (session, mut turn) = make_session_and_context().await;+ turn.session_source = SessionSource::Internal(InternalSessionSource::Guardian);+ set_feature(&mut turn, Feature::ViewImage, /*enabled*/ true);+ let TurnEnvironmentState::Ready(primary) = turn+ .environments+ .environments+ .first_mut()+ .expect("primary environment")+ else {+ panic!("primary environment should be ready");+ };+ primary.config_mut().permission_profile =+ codex_protocol::models::PermissionProfileSnapshot::legacy(+ codex_protocol::models::PermissionProfile::workspace_write(),+ );+ duplicate_primary_environment(&mut turn);+ let secondary_workspace_root =+ codex_utils_path_uri::PathUri::from_abs_path(&turn.config.cwd.join("secondary"));+ let TurnEnvironmentState::Ready(secondary) = turn+ .environments+ .environments+ .get_mut(1)+ .expect("secondary environment")+ else {+ panic!("secondary environment should be ready");+ };+ secondary.selection.workspace_roots = vec![secondary_workspace_root];+ secondary.config_mut().permission_profile =+ codex_protocol::models::PermissionProfileSnapshot::legacy(secondary_profile);+ let turn = Arc::new(turn);+ let step_context = StepContext::for_test(Arc::clone(&turn));++ let router = super::build_tool_router(+ &session,+ step_context.turn.as_ref(),+ &step_context.environments,+ &step_context.mcp,+ /*apps_enabled*/ false,+ &turn.extension_data,+ /*tool_suggest_candidates*/ None,+ )+ .expect("build internal Guardian tool router");++ assert_eq!(+ router+ .model_visible_specs()+ .iter()+ .map(codex_tools::ToolSpec::name)+ .collect::<Vec<_>>(),+ expected_tools+ );+ }+}+#[tokio::test]async fn wait_for_environment_requires_feature_and_uses_host_config_when_present() {const TOOL_DESCRIPTION: &str = "Host-provided wait tool description";