Lightweight coding agent that runs in your terminal
Rust
Restore permission profiles when resuming threads (#39153)
Shijie Rao539a09cb28ca
diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.mdindex bbd0476e5c..67642f9e4d 100644--- a/codex-rs/app-server/README.md+++ b/codex-rs/app-server/README.md@@ -358,7 +358,7 @@ Start a fresh thread when you need a new Codex conversation.Valid `personality` values are `"friendly"`, `"pragmatic"`, and `"none"`. When `"none"` is selected, the personality placeholder is replaced with an empty string.-To continue a stored session, call `thread/resume` with the `thread.id` you previously recorded. The response shape matches `thread/start`. When the stored session includes persisted token usage, the server emits `thread/tokenUsage/updated` immediately after the response so clients can render restored usage before the next turn starts. You can also pass the same configuration overrides supported by `thread/start`, including `approvalsReviewer`. On cold resume, approval policy uses the first allowed value in this order: request override, latest persisted thread setting, current configured default.+To continue a stored session, call `thread/resume` with the `thread.id` you previously recorded. The response shape matches `thread/start`. When the stored session includes persisted token usage, the server emits `thread/tokenUsage/updated` immediately after the response so clients can render restored usage before the next turn starts. You can also pass the same configuration overrides supported by `thread/start`, including `approvalsReviewer`. On cold resume, approval policy and the active permission-profile ID select a source in this order: request override, latest persisted thread setting, current configured default. The persisted profile ID is resolved through the same config and requirements path as a `permissions` override. Threads without an active profile ID use current config instead of restoring their concrete historical permissions.By default, `thread/resume` includes the reconstructed turn history in `thread.turns`. Experimental clients can pass `excludeTurns: true` to return only thread metadata and live resume state, then call `thread/turns/list` separately if they want to page the turn history over the network. A cold paginated resume can still replay persisted `thread/tokenUsage/updated` when it can identify the corresponding stored turn; resuming an already-loaded thread waits for the next live update.diff --git a/codex-rs/app-server/src/request_processors/persisted_resume_settings.rs b/codex-rs/app-server/src/request_processors/persisted_resume_settings.rsindex 55e28953fb..5e408b02c9 100644--- a/codex-rs/app-server/src/request_processors/persisted_resume_settings.rs+++ b/codex-rs/app-server/src/request_processors/persisted_resume_settings.rs@@ -1,10 +1,14 @@use codex_protocol::config_types::ApprovalsReviewer;+use codex_protocol::models::ActivePermissionProfile;+use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::EventMsg;use codex_rollout::RolloutItem;#[derive(Debug, PartialEq, Eq)]pub(super) struct PersistedResumeSettings {+ pub(super) approval_policy: AskForApproval,pub(super) approvals_reviewer: Option<ApprovalsReviewer>,+ pub(super) active_permission_profile: Option<ActivePermissionProfile>,}pub(super) fn latest_persisted_resume_settings(@@ -16,6 +20,7 @@ pub(super) fn latest_persisted_resume_settings(.rev().find_map(|(index, item)| match item {RolloutItem::TurnContext(turn_context) => Some(PersistedResumeSettings {+ approval_policy: turn_context.approval_policy,approvals_reviewer: turn_context.approvals_reviewer.or_else(|| {history[..index].iter().rev().find_map(|item| match item {RolloutItem::TurnContext(turn_context) => turn_context.approvals_reviewer,@@ -25,10 +30,16 @@ pub(super) fn latest_persisted_resume_settings(_ => None,})}),+ active_permission_profile: turn_context.active_permission_profile.clone(),}),RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => {Some(PersistedResumeSettings {+ approval_policy: event.thread_settings.approval_policy,approvals_reviewer: Some(event.thread_settings.approvals_reviewer),+ active_permission_profile: event+ .thread_settings+ .active_permission_profile+ .clone(),})}_ => None,diff --git a/codex-rs/app-server/src/request_processors/persisted_resume_settings_tests.rs b/codex-rs/app-server/src/request_processors/persisted_resume_settings_tests.rsindex 48fc65cd0c..ed96867eb1 100644--- a/codex-rs/app-server/src/request_processors/persisted_resume_settings_tests.rs+++ b/codex-rs/app-server/src/request_processors/persisted_resume_settings_tests.rs@@ -4,6 +4,7 @@ use codex_protocol::config_types::ApprovalsReviewer;use codex_protocol::config_types::CollaborationMode;use codex_protocol::config_types::ModeKind;use codex_protocol::config_types::Settings;+use codex_protocol::models::ActivePermissionProfile;use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::EventMsg;@@ -20,17 +21,21 @@ fn cwd() -> AbsolutePathBuf {.expect("absolute current directory")}-fn settings_item(approvals_reviewer: ApprovalsReviewer) -> RolloutItem {+fn settings_item(+ approval_policy: AskForApproval,+ approvals_reviewer: ApprovalsReviewer,+ active_permission_profile: Option<ActivePermissionProfile>,+) -> RolloutItem {RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(ThreadSettingsAppliedEvent {thread_settings: ThreadSettingsSnapshot {model: "gpt-5".to_string(),model_provider_id: "openai".to_string(),service_tier: None,- approval_policy: AskForApproval::OnRequest,+ approval_policy,approvals_reviewer,permission_profile: PermissionProfile::read_only(),- active_permission_profile: None,+ active_permission_profile,cwd: cwd(),reasoning_effort: None,reasoning_summary: None,@@ -48,18 +53,23 @@ fn settings_item(approvals_reviewer: ApprovalsReviewer) -> RolloutItem {))}-fn turn_context_item(turn_id: &str, approvals_reviewer: Option<ApprovalsReviewer>) -> RolloutItem {+fn turn_context_item(+ turn_id: &str,+ approval_policy: AskForApproval,+ approvals_reviewer: Option<ApprovalsReviewer>,+ active_permission_profile: Option<ActivePermissionProfile>,+) -> RolloutItem {RolloutItem::TurnContext(TurnContextItem {turn_id: Some(turn_id.to_string()),cwd: cwd(),- workspace_roots: None,+ workspace_roots: Some(vec![cwd()]),current_date: None,timezone: None,- approval_policy: AskForApproval::OnRequest,+ approval_policy,approvals_reviewer,sandbox_policy: SandboxPolicy::new_read_only_policy(),- permission_profile: None,- active_permission_profile: None,+ permission_profile: Some(PermissionProfile::read_only()),+ active_permission_profile,network: None,file_system_sandbox_policy: None,model: "gpt-5".to_string(),@@ -76,45 +86,74 @@ fn turn_context_item(turn_id: &str, approvals_reviewer: Option<ApprovalsReviewer#[test]fn latest_settings_snapshot_wins() {+ let expected = PersistedResumeSettings {+ approval_policy: AskForApproval::OnRequest,+ approvals_reviewer: Some(ApprovalsReviewer::AutoReview),+ active_permission_profile: Some(ActivePermissionProfile::new("dev")),+ };let history = vec![- settings_item(ApprovalsReviewer::User),- settings_item(ApprovalsReviewer::AutoReview),+ settings_item(+ AskForApproval::Never,+ ApprovalsReviewer::User,+ /*active_permission_profile*/ None,+ ),+ settings_item(+ AskForApproval::OnRequest,+ ApprovalsReviewer::AutoReview,+ Some(ActivePermissionProfile::new("dev")),+ ),];- assert_eq!(- latest_persisted_resume_settings(&history),- Some(PersistedResumeSettings {- approvals_reviewer: Some(ApprovalsReviewer::AutoReview),- })- );+ assert_eq!(latest_persisted_resume_settings(&history), Some(expected));}#[test]fn latest_turn_context_wins_over_earlier_settings_update() {+ let expected = PersistedResumeSettings {+ approval_policy: AskForApproval::UnlessTrusted,+ approvals_reviewer: Some(ApprovalsReviewer::User),+ active_permission_profile: Some(ActivePermissionProfile::read_only()),+ };let history = vec![- settings_item(ApprovalsReviewer::AutoReview),- turn_context_item("turn-2", Some(ApprovalsReviewer::User)),+ settings_item(+ AskForApproval::Never,+ ApprovalsReviewer::AutoReview,+ Some(ActivePermissionProfile::new("dev")),+ ),+ turn_context_item(+ "turn-2",+ AskForApproval::UnlessTrusted,+ Some(ApprovalsReviewer::User),+ Some(ActivePermissionProfile::read_only()),+ ),];- assert_eq!(- latest_persisted_resume_settings(&history),- Some(PersistedResumeSettings {- approvals_reviewer: Some(ApprovalsReviewer::User),- })- );+ assert_eq!(latest_persisted_resume_settings(&history), Some(expected));}#[test]fn older_reviewer_is_used_when_latest_turn_context_omits_it() {let history = vec![- turn_context_item("turn-1", Some(ApprovalsReviewer::AutoReview)),- turn_context_item("turn-2", /*approvals_reviewer*/ None),+ turn_context_item(+ "turn-1",+ AskForApproval::Never,+ Some(ApprovalsReviewer::AutoReview),+ /*active_permission_profile*/ None,+ ),+ turn_context_item(+ "turn-2",+ AskForApproval::OnRequest,+ /*approvals_reviewer*/ None,+ /*active_permission_profile*/ None,+ ),];assert_eq!(latest_persisted_resume_settings(&history),Some(PersistedResumeSettings {+ approval_policy: AskForApproval::OnRequest,approvals_reviewer: Some(ApprovalsReviewer::AutoReview),+ active_permission_profile: None,}));}diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex 4fda4b08a3..313e14576e 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -1,3 +1,4 @@+use super::persisted_resume_settings::PersistedResumeSettings;use super::persisted_resume_settings::latest_persisted_resume_settings;use super::thread_enrichment::enrich_loaded_threads;use super::thread_fork_goal::inherit_thread_goal_snapshot;@@ -226,42 +227,6 @@ fn merge_persisted_resume_metadata(}}-fn latest_persisted_approval_policy(- history: &[RolloutItem],-) -> Option<codex_protocol::protocol::AskForApproval> {- history- .iter()- .enumerate()- .rev()- .find_map(|(index, item)| match item {- RolloutItem::TurnContext(turn_context) => {- let updated_policy = turn_context.turn_id.as_ref().and_then(|turn_id| {- let turn_start = history[..index].iter().rposition(|item| {- matches!(- item,- RolloutItem::EventMsg(EventMsg::TurnStarted(event))- if &event.turn_id == turn_id- )- })?;- history[turn_start + 1..index]- .iter()- .rev()- .find_map(|item| match item {- RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => {- Some(event.thread_settings.approval_policy)- }- _ => None,- })- });- Some(updated_policy.unwrap_or(turn_context.approval_policy))- }- RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => {- Some(event.thread_settings.approval_policy)- }- _ => None,- })-}-fn normalize_thread_list_cwd_filters(cwd: Option<ThreadListCwdFilter>,) -> Result<Option<Vec<PathBuf>>, JSONRPCErrorError> {@@ -297,6 +262,18 @@ fn has_model_resume_override(.is_some_and(|overrides| overrides.contains_key("model_reasoning_effort"))}+fn has_permission_override(+ request_overrides: Option<&HashMap<String, serde_json::Value>>,+ typesafe_overrides: &ConfigOverrides,+) -> bool {+ typesafe_overrides.sandbox_mode.is_some()+ || typesafe_overrides.permission_profile.is_some()+ || typesafe_overrides.default_permissions.is_some()+ || request_overrides.is_some_and(|overrides| {+ overrides.contains_key("sandbox_mode") || overrides.contains_key("default_permissions")+ })+}+fn validate_dynamic_tools(tools: &[DynamicToolSpec]) -> Result<(), String> {const DYNAMIC_TOOL_NAME_MAX_LEN: usize = 128;const DYNAMIC_TOOL_NAMESPACE_MAX_LEN: usize = 64;@@ -3931,18 +3908,23 @@ impl ThreadRequestProcessor {let InitialHistory::Resumed(resumed_history) = thread_history else {return None;};- if typesafe_overrides.approvals_reviewer.is_none()- && !request_overrides- .as_ref()- .is_some_and(|overrides| overrides.contains_key("approvals_reviewer"))+ if let Some(persisted_settings) = latest_persisted_resume_settings(&resumed_history.history){- typesafe_overrides.approvals_reviewer =- latest_persisted_resume_settings(&resumed_history.history)- .and_then(|settings| settings.approvals_reviewer);- }- if typesafe_overrides.approval_policy.is_none() {- typesafe_overrides.approval_policy =- latest_persisted_approval_policy(&resumed_history.history);+ if typesafe_overrides.approval_policy.is_none() {+ typesafe_overrides.approval_policy = Some(persisted_settings.approval_policy);+ }+ if typesafe_overrides.approvals_reviewer.is_none()+ && !request_overrides+ .as_ref()+ .is_some_and(|overrides| overrides.contains_key("approvals_reviewer"))+ {+ typesafe_overrides.approvals_reviewer = persisted_settings.approvals_reviewer;+ }+ if !has_permission_override(request_overrides.as_ref(), typesafe_overrides) {+ typesafe_overrides.persisted_permission_profile_id = persisted_settings+ .active_permission_profile+ .map(|profile| profile.id);+ }}let state_db_ctx = self.state_db.clone()?;let persisted_metadata = state_db_ctx@@ -4669,44 +4651,66 @@ impl ThreadRequestProcessor {/*personality*/ None,);typesafe_overrides.ephemeral = ephemeral.then_some(true);- let latest_context = if paginated_source- && typesafe_overrides.approvals_reviewer.is_none()+ let restore_approval_policy = typesafe_overrides.approval_policy.is_none();+ let restore_approvals_reviewer = typesafe_overrides.approvals_reviewer.is_none()&& !request_overrides.as_ref()- .is_some_and(|overrides| overrides.contains_key("approvals_reviewer"))- {+ .is_some_and(|overrides| overrides.contains_key("approvals_reviewer"));+ let restore_permission_profile =+ !has_permission_override(request_overrides.as_ref(), &typesafe_overrides);+ let needs_latest_settings =+ restore_approval_policy || restore_approvals_reviewer || restore_permission_profile;+ let loaded_parent_settings = if paginated_source && needs_latest_settings {if let Ok(parent) = self.thread_manager.get_thread(source_thread_id).await {- typesafe_overrides.approvals_reviewer =- Some(parent.config_snapshot().await.approvals_reviewer);- None- } else if last_turn_id.is_some() || before_turn_id.is_some() {- Some(- self.thread_store- .load_latest_model_context(StoreLoadThreadHistoryParams {- thread_id: source_thread_id,- include_archived: true,- })- .await- .map_err(thread_store_resume_read_error)?- .items,- )+ let snapshot = parent.config_snapshot().await;+ Some(PersistedResumeSettings {+ approval_policy: snapshot.approval_policy,+ approvals_reviewer: Some(snapshot.approvals_reviewer),+ active_permission_profile: snapshot.active_permission_profile,+ })} else {None}} else {None};- if typesafe_overrides.approvals_reviewer.is_none()- && !request_overrides- .as_ref()- .is_some_and(|overrides| overrides.contains_key("approvals_reviewer"))+ let latest_context = if paginated_source+ && needs_latest_settings+ && loaded_parent_settings.is_none()+ && (last_turn_id.is_some() || before_turn_id.is_some()){- typesafe_overrides.approvals_reviewer = latest_persisted_resume_settings(+ Some(+ self.thread_store+ .load_latest_model_context(StoreLoadThreadHistoryParams {+ thread_id: source_thread_id,+ include_archived: true,+ })+ .await+ .map_err(thread_store_resume_read_error)?+ .items,+ )+ } else {+ None+ };+ let persisted_settings = loaded_parent_settings.or_else(|| {+ latest_persisted_resume_settings(latest_context.as_deref().unwrap_or_else(|| source_history_items.as_ref()),)- .and_then(|settings| settings.approvals_reviewer);+ });+ if let Some(persisted_settings) = persisted_settings {+ if restore_approval_policy {+ typesafe_overrides.approval_policy = Some(persisted_settings.approval_policy);+ }+ if restore_approvals_reviewer {+ typesafe_overrides.approvals_reviewer = persisted_settings.approvals_reviewer;+ }+ if restore_permission_profile {+ typesafe_overrides.persisted_permission_profile_id = persisted_settings+ .active_permission_profile+ .map(|profile| profile.id);+ }}// Derive a Config using the same logic as new conversation, honoring overrides if provided.let config = selfdiff --git a/codex-rs/app-server/src/request_processors/thread_processor_tests.rs b/codex-rs/app-server/src/request_processors/thread_processor_tests.rsindex f3bb53d46b..ffba9ba44f 100644--- a/codex-rs/app-server/src/request_processors/thread_processor_tests.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor_tests.rs@@ -36,137 +36,6 @@ mod thread_list_cwd_filter_tests {}}-mod persisted_resume_approval_policy_tests {- use super::super::latest_persisted_approval_policy;- use codex_protocol::config_types::ApprovalsReviewer;- use codex_protocol::config_types::CollaborationMode;- use codex_protocol::config_types::ModeKind;- use codex_protocol::config_types::Settings;- use codex_protocol::models::PermissionProfile;- use codex_protocol::protocol::AskForApproval;- use codex_protocol::protocol::EventMsg;- use codex_protocol::protocol::SandboxPolicy;- use codex_protocol::protocol::ThreadSettingsAppliedEvent;- use codex_protocol::protocol::ThreadSettingsSnapshot;- use codex_protocol::protocol::TurnContextItem;- use codex_protocol::protocol::TurnStartedEvent;- use codex_rollout::RolloutItem;- use codex_utils_absolute_path::AbsolutePathBuf;- use pretty_assertions::assert_eq;-- fn cwd() -> AbsolutePathBuf {- AbsolutePathBuf::try_from(std::env::current_dir().expect("current directory"))- .expect("absolute current directory")- }-- fn settings_item(approval_policy: AskForApproval) -> RolloutItem {- RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(- ThreadSettingsAppliedEvent {- thread_settings: ThreadSettingsSnapshot {- model: "gpt-5".to_string(),- model_provider_id: "openai".to_string(),- service_tier: None,- approval_policy,- approvals_reviewer: ApprovalsReviewer::User,- permission_profile: PermissionProfile::read_only(),- active_permission_profile: None,- cwd: cwd(),- reasoning_effort: None,- reasoning_summary: None,- personality: None,- collaboration_mode: CollaborationMode {- mode: ModeKind::Default,- settings: Settings {- model: "gpt-5".to_string(),- reasoning_effort: None,- developer_instructions: None,- },- },- },- },- ))- }-- fn turn_started_item(turn_id: &str) -> RolloutItem {- RolloutItem::EventMsg(EventMsg::TurnStarted(TurnStartedEvent {- turn_id: turn_id.to_string(),- trace_id: None,- started_at: None,- model_context_window: None,- collaboration_mode_kind: ModeKind::Default,- }))- }-- fn turn_context_item(turn_id: &str, approval_policy: AskForApproval) -> RolloutItem {- RolloutItem::TurnContext(TurnContextItem {- turn_id: Some(turn_id.to_string()),- cwd: cwd(),- workspace_roots: None,- current_date: None,- timezone: None,- approval_policy,- approvals_reviewer: None,- sandbox_policy: SandboxPolicy::new_read_only_policy(),- permission_profile: None,- active_permission_profile: None,- network: None,- file_system_sandbox_policy: None,- model: "gpt-5".to_string(),- comp_hash: None,- personality: None,- collaboration_mode: None,- multi_agent_version: None,- multi_agent_mode: None,- realtime_active: None,- effort: None,- summary: codex_protocol::config_types::ReasoningSummary::Auto,- })- }-- #[test]- fn latest_settings_snapshot_wins() {- let history = vec![- settings_item(AskForApproval::Never),- settings_item(AskForApproval::OnRequest),- ];-- assert_eq!(- latest_persisted_approval_policy(&history),- Some(AskForApproval::OnRequest)- );- }-- #[test]- fn settings_applied_during_turn_wins_over_stale_compaction_context() {- let history = vec![- turn_started_item("turn-1"),- settings_item(AskForApproval::Never),- turn_context_item("turn-1", AskForApproval::OnRequest),- ];-- assert_eq!(- latest_persisted_approval_policy(&history),- Some(AskForApproval::Never)- );- }-- #[test]- fn later_turn_context_wins_over_earlier_settings_update() {- let history = vec![- turn_started_item("turn-1"),- settings_item(AskForApproval::Never),- turn_context_item("turn-1", AskForApproval::OnRequest),- turn_started_item("turn-2"),- turn_context_item("turn-2", AskForApproval::OnRequest),- ];-- assert_eq!(- latest_persisted_approval_policy(&history),- Some(AskForApproval::OnRequest)- );- }-}-mod background_terminal_pagination_tests {use super::super::paginate_background_terminals;use codex_app_server_protocol::ThreadBackgroundTerminal;diff --git a/codex-rs/app-server/tests/suite/v2/model_auto_review.rs b/codex-rs/app-server/tests/suite/v2/model_auto_review.rsindex 9d95eb21c9..2a5b6fc98e 100644--- a/codex-rs/app-server/tests/suite/v2/model_auto_review.rs+++ b/codex-rs/app-server/tests/suite/v2/model_auto_review.rs@@ -346,7 +346,12 @@ async fn thread_resume_and_fork_upgrade_legacy_protected_model_settings() -> Res)).await?;let fork: ForkResponse = timeout(TIMEOUT, server.read_response(id)).await??;- assert_protected(&fork.model, fork.approval_policy, fork.approvals_reviewer);+ assert_protected_with_policy(+ &fork.model,+ fork.approval_policy,+ fork.approvals_reviewer,+ Never,+ );let id = server.send_thread_resume_request(params!(ResumeParams,diff --git a/codex-rs/app-server/tests/suite/v2/thread_fork.rs b/codex-rs/app-server/tests/suite/v2/thread_fork.rsindex 4175230d59..f27dd8d554 100644--- a/codex-rs/app-server/tests/suite/v2/thread_fork.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_fork.rs@@ -10,12 +10,16 @@ use app_test_support::create_mock_responses_server_sequence_unchecked;use app_test_support::rollout_path;use app_test_support::to_response;use app_test_support::write_chatgpt_auth;+use codex_app_server_protocol::ActivePermissionProfile;use codex_app_server_protocol::ApprovalsReviewer;+use codex_app_server_protocol::AskForApproval;use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::JSONRPCError;use codex_app_server_protocol::JSONRPCMessage;use codex_app_server_protocol::JSONRPCResponse;use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::SandboxMode;+use codex_app_server_protocol::SandboxPolicy;use codex_app_server_protocol::ServerNotification;use codex_app_server_protocol::SessionSource;use codex_app_server_protocol::ThreadForkParams;@@ -293,6 +297,115 @@ async fn paginated_thread_fork_preserves_persisted_approvals_reviewer() -> Resulassert_thread_fork_preserves_persisted_approvals_reviewer(ThreadHistoryMode::Paginated).await}+#[tokio::test]+async fn thread_fork_preserves_persisted_permission_profile_and_honors_overrides() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;++ for history_mode in [ThreadHistoryMode::Legacy, ThreadHistoryMode::Paginated] {+ let codex_home = TempDir::new()?;+ MockResponsesConfig::new(&server.uri())+ .with_root_config("default_permissions = \":danger-full-access\"")+ .with_extra_config("[permissions.dev]\nextends = \":read-only\"")+ .write(codex_home.path())?;++ let source_thread_id = {+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let start_id = mcp+ .send_thread_start_request_with_auto_env(ThreadStartParams {+ history_mode: Some(history_mode),+ approval_policy: Some(AskForApproval::OnRequest),+ permissions: Some("dev".to_string()),+ ..Default::default()+ })+ .await?;+ let ThreadStartResponse { thread, .. } =+ timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(start_id)).await??;+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![UserInput::Text {+ text: "persist permission profile".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ }),+ )+ .await??;+ thread.id+ };++ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let fork_id = mcp+ .send_thread_fork_request(ThreadForkParams {+ thread_id: source_thread_id.clone(),+ ..Default::default()+ })+ .await?;+ let ThreadForkResponse {+ approval_policy,+ sandbox,+ active_permission_profile,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(fork_id)).await??;+ assert!(matches!(sandbox, SandboxPolicy::ReadOnly { .. }));+ assert_eq!(approval_policy, AskForApproval::OnRequest);+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile {+ id: "dev".to_string(),+ extends: Some(":read-only".to_string()),+ })+ );++ let fork_id = mcp+ .send_thread_fork_request(ThreadForkParams {+ thread_id: source_thread_id.clone(),+ approval_policy: Some(AskForApproval::Never),+ sandbox: Some(SandboxMode::DangerFullAccess),+ ..Default::default()+ })+ .await?;+ let ThreadForkResponse {+ approval_policy,+ sandbox,+ active_permission_profile,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(fork_id)).await??;+ assert!(matches!(sandbox, SandboxPolicy::DangerFullAccess));+ assert_eq!(approval_policy, AskForApproval::Never);+ assert_eq!(active_permission_profile, None);++ let fork_id = mcp+ .send_thread_fork_request(ThreadForkParams {+ thread_id: source_thread_id,+ permissions: Some(":workspace".to_string()),+ ..Default::default()+ })+ .await?;+ let ThreadForkResponse {+ sandbox,+ active_permission_profile,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(fork_id)).await??;+ assert!(matches!(sandbox, SandboxPolicy::WorkspaceWrite { .. }));+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile::new(":workspace"))+ );+ }++ Ok(())+}+async fn assert_thread_fork_preserves_persisted_approvals_reviewer(history_mode: ThreadHistoryMode,) -> Result<()> {@@ -309,6 +422,7 @@ async fn assert_thread_fork_preserves_persisted_approvals_reviewer(let start_id = mcp.send_thread_start_request_with_auto_env(ThreadStartParams {history_mode: Some(history_mode),+ permissions: Some(":workspace".to_string()),..Default::default()}).await?;@@ -348,7 +462,9 @@ async fn assert_thread_fork_preserves_persisted_approvals_reviewer(text: "switch to auto-review".to_string(),text_elements: Vec::new(),}],+ approval_policy: Some(AskForApproval::OnRequest),approvals_reviewer: Some(ApprovalsReviewer::AutoReview),+ permissions: Some(":read-only".to_string()),..Default::default()}).await?;@@ -372,9 +488,17 @@ async fn assert_thread_fork_preserves_persisted_approvals_reviewer(}).await?;let ThreadForkResponse {- approvals_reviewer, ..+ approval_policy,+ approvals_reviewer,+ active_permission_profile,+ ..} = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(fork_id)).await??;+ assert_eq!(approval_policy, AskForApproval::OnRequest);assert_eq!(approvals_reviewer, ApprovalsReviewer::AutoReview);+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile::new(":read-only"))+ );}(thread.id, turn.id)@@ -397,24 +521,41 @@ async fn assert_thread_fork_preserves_persisted_approvals_reviewer().await??;let ThreadForkResponse {- approvals_reviewer, ..+ approval_policy,+ approvals_reviewer,+ active_permission_profile,+ ..} = to_response(fork_resp)?;+ assert_eq!(approval_policy, AskForApproval::OnRequest);assert_eq!(approvals_reviewer, ApprovalsReviewer::AutoReview);+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile::new(":read-only"))+ );if matches!(history_mode, ThreadHistoryMode::Paginated) {let fork_id = mcp.send_thread_fork_request(ThreadForkParams {thread_id: source_thread_id,last_turn_id: Some(source_turn_id),+ approval_policy: Some(AskForApproval::Never),approvals_reviewer: Some(ApprovalsReviewer::User),..Default::default()}).await?;let ThreadForkResponse {- approvals_reviewer, ..+ approval_policy,+ approvals_reviewer,+ active_permission_profile,+ ..} = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(fork_id)).await??;+ assert_eq!(approval_policy, AskForApproval::Never);assert_eq!(approvals_reviewer, ApprovalsReviewer::User);+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile::new(":read-only"))+ );}Ok(())diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rsindex a751490666..5dbcba6eef 100644--- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs@@ -16,6 +16,7 @@ use app_test_support::test_absolute_path;use app_test_support::to_response;use app_test_support::write_chatgpt_auth;use chrono::Utc;+use codex_app_server_protocol::ActivePermissionProfile;use codex_app_server_protocol::ApprovalsReviewer;use codex_app_server_protocol::AskForApproval;use codex_app_server_protocol::ClientInfo;@@ -30,6 +31,8 @@ use codex_app_server_protocol::McpToolCallAppContext;use codex_app_server_protocol::PatchApplyStatus;use codex_app_server_protocol::PatchChangeKind;use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::SandboxMode;+use codex_app_server_protocol::SandboxPolicy as AppSandboxPolicy;use codex_app_server_protocol::ServerNotification;use codex_app_server_protocol::ServerRequest;use codex_app_server_protocol::SessionSource;@@ -75,6 +78,9 @@ use codex_protocol::config_types::ModeKind;use codex_protocol::config_types::Personality;use codex_protocol::config_types::Settings;use codex_protocol::mcp::CallToolResult;+use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS;+use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_READ_ONLY;+use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_WORKSPACE;use codex_protocol::models::ContentItem;use codex_protocol::models::ResponseItem;use codex_protocol::openai_models::ReasoningEffort;@@ -1126,6 +1132,358 @@ async fn thread_resume_preserves_acknowledged_model_effort_and_approvals_revieweOk(())}+#[tokio::test]+async fn cold_resume_reresolves_persisted_active_permission_profile() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ for history_mode in [ThreadHistoryMode::Legacy, ThreadHistoryMode::Paginated] {+ let codex_home = TempDir::new()?;+ let previous_workspace_root = TempDir::new()?;+ write_dev_permission_config(&server.uri(), codex_home.path(), ":workspace")?;+ let thread_id = {+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let thread_id = materialize_dev_permission_thread(&mut mcp, history_mode).await?;+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread_id.clone(),+ runtime_workspace_roots: Some(vec![AbsolutePathBuf::from_absolute_path(+ previous_workspace_root.path(),+ )?]),+ input: vec![UserInput::Text {+ text: "update runtime workspace roots".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ }),+ )+ .await??;+ thread_id+ };++ write_dev_permission_config(&server.uri(), codex_home.path(), ":read-only")?;+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let resume_id = mcp+ .send_thread_resume_request(ThreadResumeParams {+ thread_id,+ ..Default::default()+ })+ .await?;+ let ThreadResumeResponse {+ sandbox,+ active_permission_profile,+ runtime_workspace_roots,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(resume_id)).await??;++ assert!(matches!(sandbox, AppSandboxPolicy::ReadOnly { .. }));+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile {+ id: "dev".to_string(),+ extends: Some(BUILT_IN_PERMISSION_PROFILE_READ_ONLY.to_string()),+ })+ );+ assert!(+ !runtime_workspace_roots.contains(&AbsolutePathBuf::from_absolute_path(+ previous_workspace_root.path(),+ )?)+ );+ }+ Ok(())+}++#[tokio::test]+async fn cold_resume_with_removed_permission_profile_uses_configured_default() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ for history_mode in [ThreadHistoryMode::Legacy, ThreadHistoryMode::Paginated] {+ let codex_home = TempDir::new()?;+ write_dev_permission_config(&server.uri(), codex_home.path(), ":workspace")?;+ let thread_id = {+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ materialize_dev_permission_thread(&mut mcp, history_mode).await?+ };++ MockResponsesConfig::new(&server.uri())+ .with_root_config(&format!(+ "default_permissions = \"{BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS}\""+ ))+ .write(codex_home.path())?;+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let resume_id = mcp+ .send_thread_resume_request(ThreadResumeParams {+ thread_id,+ ..Default::default()+ })+ .await?;+ let ThreadResumeResponse {+ sandbox,+ active_permission_profile,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(resume_id)).await??;++ assert!(matches!(sandbox, AppSandboxPolicy::DangerFullAccess));+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile::new(+ BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS,+ ))+ );+ }+ Ok(())+}++#[tokio::test]+async fn cold_resume_permission_overrides_win_over_persisted_profile() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ let codex_home = TempDir::new()?;+ write_dev_permission_config(&server.uri(), codex_home.path(), ":workspace")?;+ let thread_id = {+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ materialize_dev_permission_thread(&mut mcp, ThreadHistoryMode::Legacy).await?+ };++ for params in [+ ThreadResumeParams {+ thread_id: thread_id.clone(),+ sandbox: Some(SandboxMode::ReadOnly),+ ..Default::default()+ },+ ThreadResumeParams {+ thread_id: thread_id.clone(),+ permissions: Some(BUILT_IN_PERMISSION_PROFILE_READ_ONLY.to_string()),+ ..Default::default()+ },+ ThreadResumeParams {+ thread_id: thread_id.clone(),+ config: Some(std::collections::HashMap::from([(+ "default_permissions".to_string(),+ json!(BUILT_IN_PERMISSION_PROFILE_READ_ONLY),+ )])),+ ..Default::default()+ },+ ] {+ let expected_active_permission_profile = params+ .sandbox+ .is_none()+ .then(ActivePermissionProfile::read_only);+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let resume_id = mcp.send_thread_resume_request(params).await?;+ let ThreadResumeResponse {+ sandbox,+ active_permission_profile,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(resume_id)).await??;++ assert!(matches!(sandbox, AppSandboxPolicy::ReadOnly { .. }));+ assert_eq!(+ active_permission_profile,+ expected_active_permission_profile+ );+ }+ Ok(())+}++#[tokio::test]+async fn cold_resume_without_active_permission_profile_uses_current_config() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ let codex_home = TempDir::new()?;+ mock_responses_config(&server.uri()).write(codex_home.path())?;+ let thread_id = {+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let ThreadStartResponse { thread, .. } = mcp+ .start_thread(ThreadStartParams {+ model: Some("mock-model".to_string()),+ ..Default::default()+ })+ .await?;+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![UserInput::Text {+ text: "persist full access".to_string(),+ text_elements: Vec::new(),+ }],+ sandbox_policy: Some(AppSandboxPolicy::DangerFullAccess),+ ..Default::default()+ }),+ )+ .await??;+ thread.id+ };++ MockResponsesConfig::new(&server.uri())+ .with_root_config(&format!(+ "default_permissions = \"{BUILT_IN_PERMISSION_PROFILE_WORKSPACE}\""+ ))+ .write(codex_home.path())?;+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let resume_id = mcp+ .send_thread_resume_request(ThreadResumeParams {+ thread_id,+ ..Default::default()+ })+ .await?;+ let ThreadResumeResponse {+ sandbox,+ active_permission_profile,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(resume_id)).await??;++ assert!(matches!(sandbox, AppSandboxPolicy::WorkspaceWrite { .. }));+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile::new(+ BUILT_IN_PERMISSION_PROFILE_WORKSPACE+ ))+ );+ Ok(())+}++#[tokio::test]+async fn cold_resume_restores_profile_selected_by_settings_update() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ let codex_home = TempDir::new()?;+ mock_responses_config(&server.uri()).write(codex_home.path())?;+ let thread_id = {+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let ThreadStartResponse { thread, .. } = mcp+ .start_thread(ThreadStartParams {+ model: Some("mock-model".to_string()),+ ..Default::default()+ })+ .await?;+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![UserInput::Text {+ text: "persist permission profile".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ }),+ )+ .await??;+ let update_id = mcp+ .send_thread_settings_update_request(ThreadSettingsUpdateParams {+ thread_id: thread.id.clone(),+ permissions: Some(BUILT_IN_PERMISSION_PROFILE_WORKSPACE.to_string()),+ ..Default::default()+ })+ .await?;+ let _: ThreadSettingsUpdateResponse =+ timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(update_id)).await??;+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.read_stream_until_notification_message("thread/settings/updated"),+ )+ .await??;+ thread.id+ };++ mock_responses_config(&server.uri()).write(codex_home.path())?;+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let resume_id = mcp+ .send_thread_resume_request(ThreadResumeParams {+ thread_id,+ ..Default::default()+ })+ .await?;+ let ThreadResumeResponse {+ sandbox,+ active_permission_profile,+ ..+ } = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(resume_id)).await??;++ assert!(matches!(sandbox, AppSandboxPolicy::WorkspaceWrite { .. }));+ assert_eq!(+ active_permission_profile,+ Some(ActivePermissionProfile::new(+ BUILT_IN_PERMISSION_PROFILE_WORKSPACE+ ))+ );+ Ok(())+}++async fn materialize_dev_permission_thread(+ mcp: &mut TestAppServer,+ history_mode: ThreadHistoryMode,+) -> Result<String> {+ let ThreadStartResponse { thread, .. } = mcp+ .start_thread(ThreadStartParams {+ model: Some("mock-model".to_string()),+ history_mode: Some(history_mode),+ permissions: Some("dev".to_string()),+ ..Default::default()+ })+ .await?;+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![UserInput::Text {+ text: "persist permission profile".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ }),+ )+ .await??;+ Ok(thread.id)+}++fn write_dev_permission_config(+ server_uri: &str,+ codex_home: &Path,+ dev_extends: &str,+) -> std::io::Result<()> {+ MockResponsesConfig::new(server_uri)+ .with_root_config("default_permissions = \":danger-full-access\"")+ .with_extra_config(&format!("[permissions.dev]\nextends = \"{dev_extends}\""))+ .write(codex_home)+}+#[tokio::test]async fn thread_goal_get_rejects_unmaterialized_thread() -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rsindex 0f4332c30c..d3e147cd60 100644--- a/codex-rs/core/src/config/config_tests.rs+++ b/codex-rs/core/src/config/config_tests.rs@@ -2360,6 +2360,196 @@ async fn permission_profile_override_populates_runtime_permissions() -> std::io:Ok(())}+#[tokio::test]+async fn persisted_permission_profile_id_wins_over_configured_default() -> std::io::Result<()> {+ let codex_home = TempDir::new()?;+ let cwd = TempDir::new()?;+ let config_toml = toml::from_str(+ r#"+default_permissions = ":read-only"++[permissions.dev]+extends = ":workspace"+"#,+ )+ .expect("permission profile config should deserialize");++ let config = Config::load_from_base_config_with_overrides(+ config_toml,+ ConfigOverrides {+ cwd: Some(cwd.path().to_path_buf()),+ persisted_permission_profile_id: Some("dev".to_string()),+ ..Default::default()+ },+ codex_home.abs(),+ )+ .await?;++ assert_eq!(+ config.permissions.active_permission_profile(),+ Some(ActivePermissionProfile {+ id: "dev".to_string(),+ extends: Some(BUILT_IN_PERMISSION_PROFILE_WORKSPACE.to_string()),+ })+ );+ assert_eq!(+ config.legacy_sandbox_policy(),+ SandboxPolicy::new_workspace_write_policy()+ );+ Ok(())+}++#[tokio::test]+async fn missing_persisted_permission_profile_id_uses_configured_default() -> std::io::Result<()> {+ let codex_home = TempDir::new()?;+ let cwd = TempDir::new()?;+ let project_key = cwd.path().to_string_lossy().to_string();++ for (configured_default, configured_sandbox, expected_active_profile) in [+ (+ Some(BUILT_IN_PERMISSION_PROFILE_READ_ONLY.to_string()),+ None,+ Some(ActivePermissionProfile::read_only()),+ ),+ (None, Some(SandboxMode::ReadOnly), None),+ ] {+ let config = Config::load_from_base_config_with_overrides(+ ConfigToml {+ default_permissions: configured_default,+ sandbox_mode: configured_sandbox,+ projects: Some(HashMap::from([(+ project_key.clone(),+ ProjectConfig {+ trust_level: Some(TrustLevel::Trusted),+ },+ )])),+ ..Default::default()+ },+ ConfigOverrides {+ cwd: Some(cwd.path().to_path_buf()),+ persisted_permission_profile_id: Some("removed-profile".to_string()),+ ..Default::default()+ },+ codex_home.abs(),+ )+ .await?;++ assert_eq!(+ config.permissions.active_permission_profile(),+ expected_active_profile+ );+ assert_eq!(+ config.permissions.effective_permission_profile(),+ PermissionProfile::read_only()+ );+ }+ Ok(())+}++#[tokio::test]+async fn invalid_persisted_permission_profile_uses_configured_default() -> std::io::Result<()> {+ let codex_home = TempDir::new()?;+ let cwd = TempDir::new()?;+ for invalid_profile in [+ "extends = \"removed-parent\"",+ "extends = \":read-only\"\n\n[permissions.dev.filesystem]\nglob_scan_max_depth = 0",+ ] {+ let config_toml = toml::from_str(&format!(+ "default_permissions = \":danger-full-access\"\n\n[permissions.dev]\n{invalid_profile}"+ ))+ .expect("permission profile config should deserialize");++ let config = Config::load_from_base_config_with_overrides(+ config_toml,+ ConfigOverrides {+ cwd: Some(cwd.path().to_path_buf()),+ persisted_permission_profile_id: Some("dev".to_string()),+ ..Default::default()+ },+ codex_home.abs(),+ )+ .await?;++ assert_eq!(+ config.permissions.active_permission_profile(),+ Some(ActivePermissionProfile::new(+ BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS,+ ))+ );+ assert_eq!(+ config.permissions.effective_permission_profile(),+ PermissionProfile::Disabled+ );+ }+ Ok(())+}++#[tokio::test]+async fn persisted_profile_cycle_uses_configured_default() -> std::io::Result<()> {+ let codex_home = TempDir::new()?;+ let cwd = TempDir::new()?;+ let config_toml = toml::from_str(+ r#"+default_permissions = ":danger-full-access"++[permissions.dev]+extends = "base"++[permissions.base]+extends = "dev"+"#,+ )+ .expect("permission profile config should deserialize");++ let config = Config::load_from_base_config_with_overrides(+ config_toml,+ ConfigOverrides {+ cwd: Some(cwd.path().to_path_buf()),+ persisted_permission_profile_id: Some("dev".to_string()),+ ..Default::default()+ },+ codex_home.abs(),+ )+ .await?;++ assert_eq!(+ config.permissions.active_permission_profile(),+ Some(ActivePermissionProfile::new(+ BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS,+ ))+ );+ assert_eq!(+ config.permissions.effective_permission_profile(),+ PermissionProfile::Disabled+ );+ Ok(())+}++#[tokio::test]+async fn missing_explicit_default_permissions_remains_an_error() -> std::io::Result<()> {+ let codex_home = TempDir::new()?;+ let cwd = TempDir::new()?;++ let error = Config::load_from_base_config_with_overrides(+ ConfigToml::default(),+ ConfigOverrides {+ cwd: Some(cwd.path().to_path_buf()),+ default_permissions: Some("removed-profile".to_string()),+ ..Default::default()+ },+ codex_home.abs(),+ )+ .await+ .expect_err("explicit missing profile should be rejected");++ assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);+ assert_eq!(+ error.to_string(),+ "default_permissions requires a `[permissions]` table"+ );+ Ok(())+}+#[test]fn permission_snapshot_setter_preserves_permission_constraints() {let initial_profile = PermissionProfile::read_only();@@ -10383,32 +10573,46 @@ async fn permission_profile_override_falls_back_when_disallowed_by_requirements(#[tokio::test]async fn active_profile_is_cleared_when_requirements_force_fallback() -> std::io::Result<()> {let codex_home = TempDir::new()?;- let config = ConfigBuilder::without_managed_config_for_tests()- .codex_home(codex_home.path().to_path_buf())- .fallback_cwd(Some(codex_home.path().to_path_buf()))- .harness_overrides(ConfigOverrides {+ for overrides in [+ ConfigOverrides {default_permissions: Some(BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS.to_string()),..Default::default()- })- .cloud_config_bundle(- CloudConfigBundleFixture::loader_with_enterprise_requirement(- r#"allowed_sandbox_modes = ["read-only"]"#,+ },+ ConfigOverrides {+ persisted_permission_profile_id: Some(+ BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS.to_string(),),- )- .build()- .await?;+ ..Default::default()+ },+ ] {+ let config = ConfigBuilder::without_managed_config_for_tests()+ .codex_home(codex_home.path().to_path_buf())+ .fallback_cwd(Some(codex_home.path().to_path_buf()))+ .harness_overrides(overrides)+ .cloud_config_bundle(+ CloudConfigBundleFixture::loader_with_enterprise_requirement(+ r#"allowed_sandbox_modes = ["read-only"]"#,+ ),+ )+ .build()+ .await?;- assert_eq!(- config.permissions.effective_permission_profile(),- PermissionProfile::read_only()- );- assert_eq!(config.permissions.active_permission_profile(), None);- assert!(- config.startup_warnings.iter().any(|warning| warning- .contains("Configured value for `permission_profile` is disallowed by requirements")),- "{:?}",- config.startup_warnings- );+ assert_eq!(+ config.permissions.effective_permission_profile(),+ PermissionProfile::read_only()+ );+ assert_eq!(config.permissions.active_permission_profile(), None);+ assert!(+ config+ .startup_warnings+ .iter()+ .any(|warning| warning.contains(+ "Configured value for `permission_profile` is disallowed by requirements"+ )),+ "{:?}",+ config.startup_warnings+ );+ }Ok(())}diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex 10f4c0aa00..7cfa392daf 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -2388,6 +2388,7 @@ struct PermissionSelectionToml {struct EffectivePermissionSelection<'a> {profiles: Option<PermissionsToml>,selected_profile_id: Option<&'a str>,+ persisted_profile_id_was_provided: bool,requirements_force_profile_selection: bool,}@@ -2403,7 +2404,8 @@ impl EffectivePermissionSelection<'_> {default_permissions_override: Option<&str>,permission_config_syntax: Option<PermissionConfigSyntax>,) -> bool {- self.requirements_force_profile_selection+ self.persisted_profile_id_was_provided+ || self.requirements_force_profile_selection|| default_permissions_override.is_some()|| matches!(permission_config_syntax,@@ -2506,6 +2508,10 @@ pub struct ConfigOverrides {pub sandbox_mode: Option<SandboxMode>,pub permission_profile: Option<PermissionProfile>,pub default_permissions: Option<String>,+ /// Permission profile ID recovered from persisted thread state. Explicit+ /// permission overrides take precedence, and stale profile IDs fall back+ /// to the configured default.+ pub persisted_permission_profile_id: Option<String>,pub model_provider: Option<String>,pub service_tier: Option<Option<String>>,pub codex_self_exe: Option<PathBuf>,@@ -3153,6 +3159,7 @@ impl Config {sandbox_mode,permission_profile,default_permissions: default_permissions_override,+ persisted_permission_profile_id,model_provider,service_tier: service_tier_override,codex_self_exe,@@ -3297,9 +3304,23 @@ impl Config {sandbox_mode,);let requirements_toml = config_layer_stack.requirements_toml();+ let windows_sandbox_level = match effective_windows_sandbox_mode {+ Some(WindowsSandboxModeToml::Elevated) => WindowsSandboxLevel::Elevated,+ Some(WindowsSandboxModeToml::Unelevated) => WindowsSandboxLevel::RestrictedToken,+ None => WindowsSandboxLevel::Disabled,+ };+ let persisted_permission_profile_id = if sandbox_mode.is_some()+ || permission_profile.is_some()+ || default_permissions_override.is_some()+ {+ None+ } else {+ persisted_permission_profile_id.as_deref()+ };let effective_permission_selection = resolve_effective_permission_selection(cfg.permissions.as_ref(),default_permissions_override.as_deref(),+ persisted_permission_profile_id,cfg.default_permissions.as_deref(),requirements_toml,&mut startup_warnings,@@ -3318,11 +3339,6 @@ impl Config {));}- let windows_sandbox_level = match effective_windows_sandbox_mode {- Some(WindowsSandboxModeToml::Elevated) => WindowsSandboxLevel::Elevated,- Some(WindowsSandboxModeToml::Unelevated) => WindowsSandboxLevel::RestrictedToken,- None => WindowsSandboxLevel::Disabled,- };let memories_config: MemoriesConfig = cfg.memories.clone().unwrap_or_default().into();let memories_root = memory_root(&codex_home);@@ -3330,7 +3346,9 @@ impl Config {default_permissions_override.as_deref(),permission_config_syntax,);- let explicit_permission_profile_mode = default_permissions_override.is_some()+ let explicit_permission_profile_mode = effective_permission_selection+ .persisted_profile_id_was_provided+ || default_permissions_override.is_some()|| matches!(permission_config_syntax,Some(PermissionConfigSyntax::Profiles)@@ -3342,7 +3360,9 @@ impl Config {.into_iter().filter(|profile| !is_builtin_permission_profile_name(&profile.id)).collect();- let using_implicit_builtin_profile = permission_config_syntax.is_none()+ let using_implicit_builtin_profile = !effective_permission_selection+ .persisted_profile_id_was_provided+ && permission_config_syntax.is_none()&& effective_permission_selection.selected_profile_id.is_none();let should_seed_legacy_workspace_roots = effective_permission_selection.selected_profile_id@@ -4387,18 +4407,31 @@ fn merge_managed_permission_profiles(}fn resolve_effective_permission_selection<'a>(- configured_permissions: Option<&PermissionsToml>,+ configured_profiles: Option<&PermissionsToml>,default_permissions_override: Option<&'a str>,- configured_default_permissions: Option<&'a str>,+ persisted_profile_id: Option<&'a str>,+ configured_default_profile_id: Option<&'a str>,requirements_toml: &'a ConfigRequirementsToml,startup_warnings: &mut Vec<String>,) -> std::io::Result<EffectivePermissionSelection<'a>> {- let profiles = merge_managed_permission_profiles(configured_permissions, requirements_toml)?;+ let profiles = merge_managed_permission_profiles(configured_profiles, requirements_toml)?;validate_user_permission_profile_names(profiles.as_ref())?;validate_required_permission_profile_catalog(requirements_toml, profiles.as_ref())?;+ let valid_persisted_profile_id = persisted_profile_id.filter(|profile_id| {+ is_builtin_permission_profile_name(profile_id)+ || profiles.as_ref().is_some_and(|profiles| {+ compile_permission_profile_selection(+ Some(profiles),+ profile_id,+ /*workspace_write*/ None,+ &mut Vec::new(),+ )+ .is_ok()+ })+ });let selected_profile_id = resolve_default_permissions(- default_permissions_override,- configured_default_permissions,+ default_permissions_override.or(valid_persisted_profile_id),+ configured_default_profile_id,requirements_toml,startup_warnings,)?;@@ -4406,6 +4439,8 @@ fn resolve_effective_permission_selection<'a>(Ok(EffectivePermissionSelection {profiles,selected_profile_id,+ persisted_profile_id_was_provided: default_permissions_override.is_none()+ && valid_persisted_profile_id.is_some(),requirements_force_profile_selection: requirements_toml.allowed_permission_profiles.is_some(),diff --git a/codex-rs/exec/src/lib.rs b/codex-rs/exec/src/lib.rsindex 8143b72ff7..68bf5cea15 100644--- a/codex-rs/exec/src/lib.rs+++ b/codex-rs/exec/src/lib.rs@@ -413,6 +413,7 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Resultsandbox_mode,permission_profile: None,default_permissions: None,+ persisted_permission_profile_id: None,cwd: resolved_cwd,workspace_roots: None,model_provider: model_provider.clone(),