Lightweight coding agent that runs in your terminal
Rust
Preserve saved permissions when resuming or forking remote tasks (#43330)
Eric Traut1fb5158b3496
diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rsindex 96bef76a94..6c423b978a 100644--- a/codex-rs/tui/src/app/agents_overview.rs+++ b/codex-rs/tui/src/app/agents_overview.rs@@ -398,6 +398,9 @@ impl App {}}};+ if unloaded && self.reject_remote_resume_permission_override(&resume_config) {+ return Ok(AppRunControl::Continue);+ }let baseline_approval = resume_config.permissions.approval_policy.value();let baseline_permissions =RuntimePermissionProfileOverride::from_config(&resume_config);diff --git a/codex-rs/tui/src/app/app_server_events.rs b/codex-rs/tui/src/app/app_server_events.rsindex 9957812d9a..a8317b3145 100644--- a/codex-rs/tui/src/app/app_server_events.rs+++ b/codex-rs/tui/src/app/app_server_events.rs@@ -550,7 +550,7 @@ impl App {},}).await;- let Ok(ThreadReadResponse { thread }) = thread else {+ let Ok(ThreadReadResponse { thread, .. }) = thread else {return;};let SessionSource::SubAgent(SubAgentSource::ThreadSpawn {diff --git a/codex-rs/tui/src/app/config_persistence.rs b/codex-rs/tui/src/app/config_persistence.rsindex c13ec6b5da..10f9209687 100644--- a/codex-rs/tui/src/app/config_persistence.rs+++ b/codex-rs/tui/src/app/config_persistence.rs@@ -52,6 +52,39 @@ pub(super) fn resume_model_settings_for_overrides(}}+pub(super) fn has_explicit_resume_permission_override(+ config: &Config,+ overrides: &ConfigOverrides,+) -> bool {+ overrides.approval_policy.is_some()+ || overrides.approvals_reviewer.is_some()+ || overrides.sandbox_mode.is_some()+ || overrides.permission_profile.is_some()+ || overrides.default_permissions.is_some()+ || !overrides.additional_writable_roots.is_empty()+ || overrides.workspace_roots.is_some()+ || config.config_layer_stack.layers_high_to_low().any(|layer| {+ matches!(+ &layer.name,+ ConfigLayerSource::SessionFlags+ | ConfigLayerSource::User {+ profile: Some(_),+ ..+ }+ ) && [+ "approval_policy",+ "approvals_reviewer",+ "sandbox_mode",+ "default_permissions",+ "permissions",+ "network",+ "sandbox_workspace_write",+ ]+ .iter()+ .any(|key| layer.config.get(*key).is_some())+ })+}+impl App {pub(super) async fn rebuild_config_for_cwd(&self, cwd: PathBuf) -> Result<Config> {let mut overrides = self.harness_overrides.clone();@@ -881,6 +914,33 @@ impl App {resume_model_settings_for_overrides(&self.config, &self.harness_overrides)}+ pub(super) fn reject_remote_resume_permission_override(&mut self, config: &Config) -> bool {+ if self.app_server_target.thread_params_mode()+ != crate::app_server_session::ThreadParamsMode::Remote+ {+ return false;+ }+ let explicitly_selected =+ has_explicit_resume_permission_override(config, &self.harness_overrides)+ || matches!(+ self.runtime_approval_policy_override,+ Some(RuntimeApprovalPolicyOverride::Explicit(_))+ )+ || self+ .runtime_permission_profile_override+ .as_ref()+ .is_some_and(|profile| {+ profile.turn_override == RuntimePermissionProfileTurnOverride::LegacySandbox+ });+ if explicitly_selected {+ self.chat_widget.add_error_message(+ "Permission overrides are not supported when resuming a remote task.".into(),+ );+ return true;+ }+ false+ }+pub(super) fn on_update_personality(&mut self, personality: Personality) {self.config.personality = Some(personality);self.chat_widget.set_personality(personality);diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rsindex 1994e2176a..70a4b7b28f 100644--- a/codex-rs/tui/src/app/session_lifecycle.rs+++ b/codex-rs/tui/src/app/session_lifecycle.rs@@ -1146,6 +1146,11 @@ impl App {Ok(config) => config,Err(control) => return Ok(control),};+ if self.reject_remote_resume_permission_override(&resume_config) {+ return Ok(AppRunControl::Continue);+ }+ let baseline_approval = resume_config.permissions.approval_policy.value();+ let baseline_permissions = RuntimePermissionProfileOverride::from_config(&resume_config);self.apply_runtime_policy_overrides(&mut resume_config, RuntimePolicyOverrideScope::All);let summary = session_summary(@@ -1229,6 +1234,15 @@ impl App {.mark_external_writer();self.chat_widget.show_external_writer_thread();}+ if self.app_server_target.uses_remote_workspace() {+ let config = self.chat_widget.config_ref();+ let approval = config.permissions.approval_policy.value();+ self.runtime_approval_policy_override = (approval != baseline_approval)+ .then_some(RuntimeApprovalPolicyOverride::Restored(approval.into()));+ self.runtime_permission_profile_override = (!baseline_permissions+ .matches_config(config))+ .then(|| RuntimePermissionProfileOverride::from_restored_config(config));+ }self.backfill_loaded_subagent_threads(app_server).await;if !read_only {self.replay_agents_overview_requests(app_server, resumed_thread_id)diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rsindex 62939f6ee6..c579ed7c70 100644--- a/codex-rs/tui/src/app/startup.rs+++ b/codex-rs/tui/src/app/startup.rs@@ -432,6 +432,21 @@ impl App {(chat_widget, None)}SessionSelection::Resume(target_session) => {+ if app_server_target.thread_params_mode()+ == crate::app_server_session::ThreadParamsMode::Remote+ && config_persistence::has_explicit_resume_permission_override(+ &config,+ &harness_overrides,+ )+ {+ return shutdown_on_startup_error(+ app_server,+ color_eyre::eyre::eyre!(+ "Permission overrides are not supported when resuming a remote task."+ ),+ )+ .await;+ }if let Some(history_mode) = target_session.history_mode {app_server.remember_thread_history_mode(target_session.thread_id, history_mode);}@@ -528,6 +543,28 @@ impl App {(ChatWidget::new_with_app_event(init), Some(resumed))}SessionSelection::Fork(target_session) => {+ let explicit_permission_override =+ config_persistence::has_explicit_resume_permission_override(+ &config,+ &harness_overrides,+ );+ if explicit_permission_override+ && app_server_target.thread_params_mode()+ == crate::app_server_session::ThreadParamsMode::Remote+ {+ return shutdown_on_startup_error(+ app_server,+ color_eyre::eyre::eyre!(+ "Permission overrides are not supported when forking a remote task."+ ),+ )+ .await;+ }+ let permission_mode = if explicit_permission_override {+ crate::app_server_session::ForkPermissionMode::OverrideFromCurrentConfig+ } else {+ crate::app_server_session::ForkPermissionMode::InheritSaved+ };session_telemetry.counter("codex.thread.fork",/*inc*/ 1,@@ -536,10 +573,11 @@ impl App {let forked = match startup_draft.run_until(tui,- app_server.fork_thread(+ app_server.fork_thread_with_permission_mode(&local_settings,config.clone(),target_session.thread_id,+ permission_mode,),).await@@ -547,7 +585,7 @@ impl App {Ok(forked) => forked,Err(err) => return shutdown_on_startup_error(app_server, err).await,};- let action = SessionStartAction::Fork;+ let action = SessionStartAction::Fork(permission_mode);let Some(forked) = complete_session_start(&mut app_server,&config,diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex 4e0c3bcae0..2758813e55 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -2896,6 +2896,91 @@ async fn reset_memories_clears_local_memory_directories() -> Result<()> {.await}+#[tokio::test]+async fn resume_rejects_selected_config_profile_permission_definitions() -> Result<()> {+ let home = tempdir()?;+ std::fs::write(+ home.path().join("config.toml"),+ "default_permissions = \":workspace\"\n",+ )?;+ let selected = home.path().join("work.config.toml");+ std::fs::write(+ &selected,+ "default_permissions = \":workspace\"\n[permissions.unused]\nextends = \":read-only\"\n",+ )?;+ let mut loader = codex_config::LoaderOverrides::without_managed_config_for_tests();+ loader.user_config_path = Some(selected.abs());+ loader.user_config_profile = Some("work".parse()?);+ let config = ConfigBuilder::default()+ .codex_home(home.path().to_path_buf())+ .loader_overrides(loader)+ .build()+ .await?;+ assert!(config_persistence::has_explicit_resume_permission_override(+ &config,+ &ConfigOverrides::default()+ ));+ Ok(())+}++#[tokio::test]+async fn remote_resume_rejects_explicit_permission_override() -> Result<()> {+ let (mut app, mut events, _ops) = make_test_app_with_channels().await;+ let endpoint = crate::resolve_remote_addr("ws://127.0.0.1:8765")?;+ app.app_server_target = crate::AppServerTarget::Remote { endpoint };+ let home = tempdir()?;+ std::fs::write(+ home.path().join("config.toml"),+ "default_permissions = \":workspace\"\n",+ )?;+ app.config.codex_home = home.path().to_path_buf().abs();+ let mut server = crate::start_embedded_app_server_for_picker(&app.config).await?;+ let selected = home.path().join("work.config.toml");+ std::fs::write(+ &selected,+ "[permissions.unused]\nextends = \":read-only\"\n",+ )?;+ app.loader_overrides.user_config_path = Some(selected.abs());+ app.loader_overrides.user_config_profile = Some("work".parse()?);+ assert!(+ !config_persistence::has_explicit_resume_permission_override(+ &app.config,+ &app.harness_overrides+ )+ );+ let refreshed = app+ .rebuild_config_for_cwd(app.config.cwd.to_path_buf())+ .await?;+ assert!(config_persistence::has_explicit_resume_permission_override(+ &refreshed,+ &app.harness_overrides+ ));+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.resume_target_session(+ &mut tui,+ &mut server,+ SessionTarget {+ thread_id: ThreadId::new(),+ path: None,+ history_mode: None,+ },+ )+ .await?;+ assert_eq!(app.active_thread_id, None);+ let cell = std::iter::from_fn(|| events.try_recv().ok())+ .find_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => Some(cell),+ _ => None,+ })+ .expect("permission override error");+ insta::assert_snapshot!(+ lines_to_single_string(&cell.display_lines(/*width*/ 80)),+ @"■ Permission overrides are not supported when resuming a remote task."+ );+ server.shutdown().await?;+ Ok(())+}+#[tokio::test]async fn apply_permission_profile_selection_preserves_loader_overrides() -> Result<()> {let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;@@ -7169,7 +7254,25 @@ async fn remote_resume_keeps_server_only_cwd_out_of_local_config() -> Result<()>let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?.with_remote_cwd_override(Some(remote_cwd.clone()));+ app_server+ .resume_thread(+ &crate::local_settings::LocalSettings::from(&app.config),+ app.config.clone(),+ ThreadId::from_string(&thread_id)?,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;let mut tui = crate::tui::test_support::make_test_tui()?;+ app.runtime_approval_policy_override = Some(RuntimeApprovalPolicyOverride::Restored(+ AskForApproval::Never,+ ));+ let mut prior_config = app.config.clone();+ prior_config+ .permissions+ .set_permission_profile(PermissionProfile::read_only())?;+ app.runtime_permission_profile_override = Some(+ RuntimePermissionProfileOverride::from_restored_config(&prior_config),+ );let control = app.resume_target_session(@@ -7190,6 +7293,8 @@ async fn remote_resume_keeps_server_only_cwd_out_of_local_config() -> Result<()>&local_cwd,));assert_eq!(app.config.workspace_roots, local_workspace_roots);+ assert_eq!(app.runtime_approval_policy_override, None);+ assert!(app.runtime_permission_profile_override.is_none());app_server.shutdown().await?;Ok(())}diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex 0c96354fdb..d1a5641587 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -169,6 +169,12 @@ pub(crate) enum ForkGoalContinuation {DeferUntilNextTurn,}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum ForkPermissionMode {+ InheritSaved,+ OverrideFromCurrentConfig,+}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]enum ForkPresentation {Regular,@@ -830,13 +836,31 @@ impl AppServerSession {config: Config,thread_id: ThreadId,) -> Result<AppServerStartedThread> {- self.fork_thread_at(+ self.fork_thread_with_permission_mode(+ local_settings,+ config,+ thread_id,+ ForkPermissionMode::InheritSaved,+ )+ .await+ }++ pub(crate) async fn fork_thread_with_permission_mode(+ &mut self,+ local_settings: &LocalSettings,+ config: Config,+ thread_id: ThreadId,+ permission_mode: ForkPermissionMode,+ ) -> Result<AppServerStartedThread> {+ self.fork_thread_at_with_presentation(local_settings,config,thread_id,/*last_turn_id*/ None,/*before_turn_id*/ None,ForkGoalContinuation::StartIfIdle,+ ForkPresentation::Regular,+ permission_mode,).await}@@ -858,6 +882,7 @@ impl AppServerSession {before_turn_id,goal_continuation,ForkPresentation::Regular,+ ForkPermissionMode::InheritSaved,).await}@@ -876,6 +901,7 @@ impl AppServerSession {/*before_turn_id*/ None,ForkGoalContinuation::StartIfIdle,ForkPresentation::SideConversation,+ ForkPermissionMode::InheritSaved,).await}@@ -893,6 +919,7 @@ impl AppServerSession {before_turn_id: Option<String>,goal_continuation: ForkGoalContinuation,presentation: ForkPresentation,+ permission_mode: ForkPermissionMode,) -> Result<AppServerStartedThread> {let fork_parent = match presentation {ForkPresentation::Regular => self@@ -920,6 +947,15 @@ impl AppServerSession {self.remote_cwd_override.as_deref(),)};+ if self.thread_params_mode() == ThreadParamsMode::Remote+ && permission_mode == ForkPermissionMode::InheritSaved+ {+ params.approval_policy = None;+ params.approvals_reviewer = None;+ params.sandbox = None;+ params.permissions = None;+ remove_permission_config_overrides(&mut params.config);+ }self.thread_tool_transport().configure_mcp(&mut params.config);let response: ThreadForkResponse = match self@@ -1816,6 +1852,22 @@ fn config_request_overrides_from_config(Some(overrides)}+fn remove_permission_config_overrides(config: &mut Option<HashMap<String, serde_json::Value>>) {+ if let Some(overrides) = config.as_mut() {+ for key in [+ "default_permissions",+ "permissions",+ "network",+ "sandbox_workspace_write",+ ] {+ overrides.remove(key);+ }+ }+ if config.as_ref().is_some_and(HashMap::is_empty) {+ *config = None;+ }+}+fn service_tier_override_from_config(config: &Config) -> Option<Option<String>> {let local_settings = LocalSettings::from(config);config.service_tier.clone().map(Some).or_else(|| {@@ -2001,7 +2053,7 @@ fn thread_resume_params_from_config((None, None)}};- ThreadResumeParams {+ let mut params = ThreadResumeParams {thread_id: thread_id.to_string(),model,model_provider,@@ -2017,7 +2069,16 @@ fn thread_resume_params_from_config(&config, /*control_instructions*/ None,),..ThreadResumeParams::default()- }+ };+ if thread_params_mode == ThreadParamsMode::Remote {+ // Resuming restores the server's saved permission settings, including named profiles.+ params.approval_policy = None;+ params.approvals_reviewer = None;+ params.sandbox = None;+ params.permissions = None;+ remove_permission_config_overrides(&mut params.config);+ }+ params}fn thread_fork_params_from_config(@@ -3052,7 +3113,9 @@ mod tests {assert_eq!(resume.model_provider, None);assert_eq!(fork.model_provider, None);assert_eq!(start.sandbox, expected_sandbox);- assert_eq!(resume.sandbox, expected_sandbox);+ assert_eq!(resume.sandbox, None);+ assert_eq!(resume.approval_policy, None);+ assert_eq!(resume.approvals_reviewer, None);assert_eq!(fork.sandbox, expected_sandbox);assert_eq!(start.permissions, None);assert_eq!(resume.permissions, None);@@ -3062,7 +3125,7 @@ mod tests {}#[tokio::test]- async fn remote_resume_params_keep_local_roots_with_cross_platform_cwd_override() {+ async fn remote_resume_params_keep_cwd_without_overriding_saved_permissions() {let temp_dir = tempfile::tempdir().expect("tempdir");let config = build_config(&temp_dir).await;let expected_workspace_roots = config.workspace_roots.clone();@@ -3192,7 +3255,7 @@ mod tests {assert_eq!(resume.model_provider, None);assert_eq!(fork.model_provider, None);assert_eq!(start.sandbox, expected_sandbox);- assert_eq!(resume.sandbox, expected_sandbox);+ assert_eq!(resume.sandbox, None);assert_eq!(fork.sandbox, expected_sandbox);assert_eq!(start.permissions, None);assert_eq!(resume.permissions, None);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.rsindex 1beabab80b..adc0154dca 100644--- a/codex-rs/tui/src/app_server_session/rollout_history_tests.rs+++ b/codex-rs/tui/src/app_server_session/rollout_history_tests.rs@@ -1,4 +1,6 @@+use super::super::ForkPermissionMode;use super::super::ResumeModelSettings;+use super::super::ThreadParamsMode;use crate::legacy_core::config::Config;use crate::legacy_core::config::ConfigBuilder;use app_test_support::create_fake_paginated_rollout;@@ -19,6 +21,159 @@ async fn build_config(temp_dir: &TempDir) -> Config {.expect("config should build")}+#[tokio::test]+async fn remote_resume_restores_saved_server_profile_without_permission_overrides() -> Result<()> {+ let home = tempfile::tempdir()?;+ std::fs::write(+ home.path().join("config.toml"),+ "default_permissions = \":workspace\"\n[permissions.server-only]\nextends = \":read-only\"\n",+ )?;+ let config = build_config(&home).await;+ let client_config = ConfigBuilder::default()+ .codex_home(home.path().to_path_buf())+ .cli_overrides(vec![(+ "default_permissions".to_string(),+ ":workspace".into(),+ )])+ .harness_overrides(crate::legacy_core::config::ConfigOverrides {+ default_permissions: Some(":read-only".into()),+ ..Default::default()+ })+ .build()+ .await?;+ let thread_id = ThreadId::from_string(+ &create_fake_rollout(+ 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 server = crate::start_embedded_app_server_for_picker(&config).await?;+ server.thread_params_mode = ThreadParamsMode::Remote;+ let local_settings = crate::local_settings::LocalSettings::from(&client_config);+ let initial = server+ .resume_thread(+ &local_settings,+ client_config.clone(),+ thread_id,+ ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ assert_eq!(+ initial+ .session+ .active_permission_profile+ .map(|profile| profile.id),+ Some(":workspace".to_string())+ );+ server+ .thread_settings_update(codex_app_server_protocol::ThreadSettingsUpdateParams {+ thread_id: thread_id.to_string(),+ permissions: Some("server-only".into()),+ approval_policy: Some(codex_app_server_protocol::AskForApproval::Never),+ approvals_reviewer: Some(codex_app_server_protocol::ApprovalsReviewer::AutoReview),+ ..Default::default()+ })+ .await?;+ tokio::time::timeout(std::time::Duration::from_secs(5), async {+ loop {+ if let Some(codex_app_server_client::AppServerEvent::ServerNotification(notification)) =+ server.next_event().await+ && let codex_app_server_protocol::ServerNotification::ThreadSettingsUpdated(+ settings,+ ) = *notification+ && settings.thread_id == thread_id.to_string()+ && settings+ .thread_settings+ .active_permission_profile+ .as_ref()+ .is_some_and(|profile| profile.id == "server-only")+ {+ break;+ }+ }+ })+ .await?;+ server.shutdown().await?;++ let mut server = crate::start_embedded_app_server_for_picker(&config).await?;+ server.thread_params_mode = ThreadParamsMode::Remote;+ let resumed = server+ .resume_thread(+ &local_settings,+ client_config.clone(),+ thread_id,+ ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ assert_eq!(+ resumed+ .session+ .active_permission_profile+ .as_ref()+ .map(|profile| profile.id.as_str()),+ Some("server-only")+ );+ assert_eq!(+ resumed.session.approval_policy,+ codex_app_server_protocol::AskForApproval::Never+ );+ assert_eq!(+ resumed.session.approvals_reviewer,+ codex_protocol::config_types::ApprovalsReviewer::AutoReview+ );+ let forked = server+ .fork_thread(&local_settings, client_config, thread_id)+ .await?;+ assert_eq!(+ forked+ .session+ .active_permission_profile+ .as_ref()+ .map(|profile| profile.id.as_str()),+ Some("server-only")+ );+ assert_eq!(+ forked.session.approval_policy,+ codex_app_server_protocol::AskForApproval::Never+ );+ assert_eq!(+ forked.session.approvals_reviewer,+ codex_protocol::config_types::ApprovalsReviewer::AutoReview+ );+ let explicit_config = ConfigBuilder::default()+ .codex_home(home.path().to_path_buf())+ .harness_overrides(crate::legacy_core::config::ConfigOverrides {+ sandbox_mode: Some(codex_protocol::config_types::SandboxMode::ReadOnly),+ approval_policy: Some(codex_protocol::protocol::AskForApproval::OnRequest),+ ..Default::default()+ })+ .build()+ .await?;+ let explicit_fork = server+ .fork_thread_with_permission_mode(+ &local_settings,+ explicit_config,+ thread_id,+ ForkPermissionMode::OverrideFromCurrentConfig,+ )+ .await?;+ assert_eq!(+ explicit_fork.session.approval_policy,+ codex_app_server_protocol::AskForApproval::OnRequest+ );+ assert_eq!(+ explicit_fork.session.permission_profile,+ codex_protocol::models::PermissionProfile::read_only()+ );+ server.shutdown().await?;+ Ok(())+}+#[tokio::test]async fn viewing_thread_reads_history_without_resuming_it() -> Result<()> {let codex_home = tempfile::tempdir()?;diff --git a/codex-rs/tui/src/session_start.rs b/codex-rs/tui/src/session_start.rsindex bbeecb5b74..1c562fafb9 100644--- a/codex-rs/tui/src/session_start.rs+++ b/codex-rs/tui/src/session_start.rs@@ -4,6 +4,7 @@ use crate::app::AppExitInfo;use crate::app::ExitReason;use crate::app_server_session::AppServerSession;use crate::app_server_session::AppServerStartedThread;+use crate::app_server_session::ForkPermissionMode;use crate::app_server_session::ResumeModelSettings;use crate::legacy_core::config::Config;use crate::resume_picker::SessionTarget;@@ -14,14 +15,14 @@ use color_eyre::eyre::WrapErr;#[derive(Clone, Copy)]pub(crate) enum SessionStartAction {Resume(ResumeModelSettings),- Fork,+ Fork(ForkPermissionMode),}impl SessionStartAction {pub(crate) fn verb(self) -> &'static str {match self {Self::Resume(_) => "resume",- Self::Fork => "fork",+ Self::Fork(_) => "fork",}}@@ -38,9 +39,14 @@ impl SessionStartAction {.resume_thread(&local_settings, config.clone(), target.thread_id, settings).await}- Self::Fork => {+ Self::Fork(permission_mode) => {app_server- .fork_thread(&local_settings, config.clone(), target.thread_id)+ .fork_thread_with_permission_mode(+ &local_settings,+ config.clone(),+ target.thread_id,+ permission_mode,+ ).await}}diff --git a/codex-rs/tui/src/session_start_tests.rs b/codex-rs/tui/src/session_start_tests.rsindex 0694175b34..e101904d78 100644--- a/codex-rs/tui/src/session_start_tests.rs+++ b/codex-rs/tui/src/session_start_tests.rs@@ -23,7 +23,7 @@ async fn start_session(async fn archived_session_requires_confirmation_before_resume_or_fork() -> Result<()> {for action in [SessionStartAction::Resume(ResumeModelSettings::RestoreFromThread),- SessionStartAction::Fork,+ SessionStartAction::Fork(crate::app_server_session::ForkPermissionMode::InheritSaved),] {let codex_home = TempDir::new()?;let config = ConfigBuilder::default()@@ -79,7 +79,7 @@ async fn archived_session_requires_confirmation_before_resume_or_fork() -> ResulSessionStartAction::Resume(_) => {assert_eq!(started.session.thread_id, target.thread_id)}- SessionStartAction::Fork => {+ SessionStartAction::Fork(_) => {assert_ne!(started.session.thread_id, target.thread_id);assert_eq!(app_serverdiff --git a/codex-rs/tui/src/unarchive_prompt_tests.rs b/codex-rs/tui/src/unarchive_prompt_tests.rsindex bf3bbb1cfb..b3175f6eeb 100644--- a/codex-rs/tui/src/unarchive_prompt_tests.rs+++ b/codex-rs/tui/src/unarchive_prompt_tests.rs@@ -46,7 +46,9 @@ fn resume_prompt_snapshot() {#[test]fn fork_prompt_cancel_snapshot() {- let mut screen = prompt(SessionStartAction::Fork);+ let mut screen = prompt(SessionStartAction::Fork(+ crate::app_server_session::ForkPermissionMode::InheritSaved,+ ));assert_eq!(screen.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE)),None@@ -68,7 +70,9 @@ fn fork_prompt_cancel_snapshot() {#[test]fn confirmation_requires_an_accept_key() {- let mut screen = prompt(SessionStartAction::Fork);+ let mut screen = prompt(SessionStartAction::Fork(+ crate::app_server_session::ForkPermissionMode::InheritSaved,+ ));for key in [KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),@@ -92,7 +96,9 @@ fn confirmation_requires_an_accept_key() {}fn render_inline(width: u16) -> String {- let screen = prompt(SessionStartAction::Fork);+ let screen = prompt(SessionStartAction::Fork(+ crate::app_server_session::ForkPermissionMode::InheritSaved,+ ));let height = screen.content().desired_height(width);let mut terminal = Terminal::new(VT100Backend::new(width, height + 2)).unwrap();terminal@@ -133,7 +139,9 @@ async fn inline_prompt_only_claims_content_height() -> Result<()> {/*x*/ 0, /*y*/ 3, /*width*/ 80, /*height*/ 0,);tui.terminal.set_viewport_area(original);- let screen = prompt(SessionStartAction::Fork);+ let screen = prompt(SessionStartAction::Fork(+ crate::app_server_session::ForkPermissionMode::InheritSaved,+ ));{let mut guard = PromptScreenGuard::enter(&mut tui)?;guard.draw(&screen)?;@@ -159,7 +167,9 @@ async fn alternate_prompt_restores_original_viewport() -> Result<()> {tui.terminal.set_viewport_area(original);{let mut guard = PromptScreenGuard::enter(&mut tui)?;- guard.draw(&prompt(SessionStartAction::Fork))?;+ guard.draw(&prompt(SessionStartAction::Fork(+ crate::app_server_session::ForkPermissionMode::InheritSaved,+ )))?;assert!(guard.tui.is_alt_screen_active());assert_eq!(guard.tui.terminal.viewport_area,