Refresh Guardian policy on config reload and account changes (#62614)

## Why

Running threads need to pick up changes to approval requirements and
Guardian policy when users reload configuration, sign in, or sign out.

## What changed

Refresh Guardian policy after publishing local config layers so the first
reload uses updated policy fallbacks. Attempt the refresh even if unrelated
user configuration fails to load.

Refresh policy after login while the account owner is still current, and
after logout. If reading account details fails after login, report the
error in the login completion notification and still send the account
update.

## Testing

Extend coverage for changing and removing Guardian policy requirements,
applying requirements despite a config load error, and picking up local
fallbacks on the first reload. Verify that a late low-risk score cannot
release a pending adaptive approval while stricter requirements apply.

GitOrigin-RevId: 95453807a06a0d3c39dcfd9a0f66fd63f41294b9
This commit is contained in:
rreichel3-oai
2026-11-19 22:31:45 +00:00
committed by copyberry
parent 6a8a81166a
commit db263d4f54
4 changed files with 203 additions and 23 deletions
@@ -2,6 +2,7 @@ use super::bedrock_auth::BedrockProviderConfig;
use super::bedrock_auth::clear_user_model_provider_if_bedrock;
use super::bedrock_auth::prepare_bedrock_provider;
use super::config_processor::map_error as map_config_error;
use super::config_processor::refresh_guardian_policy;
use super::*;
use crate::auth_mode::auth_mode_to_api;
use crate::external_auth::ExternalAuthBridge;
@@ -991,13 +992,15 @@ impl AccountRequestProcessor {
) {
let auth_changes = self.auth_manager.auth_change_state_receiver();
let owner_generation = auth_changes.borrow().owner_generation;
if payload.success
&& let Err(error) = self.read_account(/*request*/ None).await
{
let logged_in = payload.success;
if logged_in && let Err(error) = self.read_account(/*request*/ None).await {
payload.success = false;
payload.error = Some(error.to_string());
}
if payload.success && auth_changes.borrow().owner_generation == owner_generation {
if logged_in && auth_changes.borrow().owner_generation == owner_generation {
refresh_guardian_policy(&self.thread_manager).await;
}
if logged_in && auth_changes.borrow().owner_generation == owner_generation {
Self::maybe_refresh_plugin_caches_for_current_config(
&self.config_manager,
&self.thread_manager,
@@ -1006,7 +1009,6 @@ impl AccountRequestProcessor {
.await;
}
let success = payload.success;
self.outgoing
.send_account_notification(
/*connection_id*/ None,
@@ -1016,7 +1018,7 @@ impl AccountRequestProcessor {
)
.await;
if success {
if logged_in {
let notification = self.current_account_updated_notification();
self.outgoing
.send_account_notification(
@@ -1073,6 +1075,7 @@ impl AccountRequestProcessor {
self.model_catalog.invalidate().await;
*self.workspace_routing.lock().await = None;
refresh_guardian_policy(&self.thread_manager).await;
Self::maybe_refresh_plugin_caches_for_current_config(
&self.config_manager,
&self.thread_manager,
@@ -427,8 +427,16 @@ pub(super) async fn reload_user_config(
config_manager: &ConfigManager,
thread_manager: &ThreadManager,
) {
// Reload owns several config snapshots; do not inline that future into dispatch.
// Publish local layers first so Guardian resolves their new policy fallbacks.
Box::pin(reload_user_config_inner(config_manager, thread_manager)).await;
// Guardian still refreshes when unrelated configuration could not load.
refresh_guardian_policy(thread_manager).await;
}
pub(super) async fn refresh_guardian_policy(thread_manager: &ThreadManager) {
if let Err(error) = Box::pin(thread_manager.refresh_guardian_policy()).await {
tracing::warn!(kind = ?error.kind(), "failed to refresh Guardian policy");
}
}
async fn reload_user_config_inner(config_manager: &ConfigManager, thread_manager: &ThreadManager) {
@@ -7,6 +7,8 @@ use codex_config::types::AuthKeyringBackendKind;
use codex_core::config::ConfigOverrides;
use codex_exec_server::EnvironmentManager;
use codex_login::CodexAuth;
use codex_protocol::config_types::ApprovalsReviewer::AutoReview;
use codex_protocol::config_types::ApprovalsReviewer::User;
use pretty_assertions::assert_eq;
use serde_json::json;
use std::collections::HashMap;
@@ -69,14 +71,17 @@ async fn reloads_accept_a_provider_supplied_by_thread_overrides() -> anyhow::Res
}
#[tokio::test]
async fn user_reload_promotes_plugin_and_feature_requirements_without_server_changes()
async fn user_reload_refreshes_independent_requirements_without_server_changes()
-> anyhow::Result<()> {
let home = tempfile::tempdir()?;
let requirements_path = home.path().join("requirements.toml");
std::fs::write(&requirements_path, "")?;
std::fs::write(
&requirements_path,
"allowed_approvals_reviewers = ['auto_review']\nguardian_policy_config = 'first policy'\nguardian_extra_policy = 'first extra'\n",
)?;
std::fs::write(
home.path().join(codex_config::CONFIG_TOML_FILE),
"[features]\nenable_mcp_apps = true\n",
"approvals_reviewer = 'user'\n[features]\nenable_mcp_apps = true\n",
)?;
let mut overrides = codex_config::LoaderOverrides::without_managed_config_for_tests();
overrides.ignore_managed_requirements = false;
@@ -99,7 +104,8 @@ async fn user_reload_promotes_plugin_and_feature_requirements_without_server_cha
initial.model_provider.clone(),
initial.codex_home.to_path_buf(),
Arc::new(EnvironmentManager::default_for_tests()),
),
)
.with_guardian_policy_loader(Arc::new(manager.clone())),
);
assert!(
initial
@@ -111,17 +117,17 @@ async fn user_reload_promotes_plugin_and_feature_requirements_without_server_cha
.start_thread(codex_core::StartThreadOptions::new(initial))
.await?
.thread;
assert_eq!(
thread.config_snapshot().await.approvals_reviewer,
AutoReview
);
std::fs::write(
&requirements_path,
"[features]\nenable_mcp_apps = false\n[plugins.example.mcp_servers]\n",
"guardian_policy_config = 'first policy'\nguardian_extra_policy = 'first extra'\n[features]\nenable_mcp_apps = false\n[plugins.example.mcp_servers]\n",
)?;
tokio::time::timeout(
std::time::Duration::from_secs(10),
reload_user_config(&manager, &threads),
)
.await
.expect("policy promotion must terminate");
reload_user_config(&manager, &threads).await;
let config = thread.config().await;
assert_eq!(config.approvals_reviewer, User);
assert_eq!(config.mcp_servers.get(), &original_servers);
assert!(
!config
@@ -150,6 +156,85 @@ async fn user_reload_promotes_plugin_and_feature_requirements_without_server_cha
.feature_requirements
.is_some()
);
for requirements in [
"guardian_policy_config = 'replacement policy'\nguardian_extra_policy = 'first extra'",
"guardian_policy_config = 'replacement policy'\nguardian_extra_policy = 'replacement extra'",
"",
] {
let requirements = format!(
"{requirements}\n[features]\nenable_mcp_apps = false\n[plugins.example.mcp_servers]\n"
);
std::fs::write(&requirements_path, &requirements)?;
let expected: codex_config::ConfigRequirementsToml = toml::from_str(&requirements)?;
reload_user_config(&manager, &threads).await;
let config = thread.config().await;
assert_eq!(config.mcp_servers.get(), &original_servers);
assert_eq!(
(
config.guardian_policy_config.as_deref(),
config.guardian_extra_policy.as_deref()
),
(
expected.guardian_policy_config.as_deref(),
expected.guardian_extra_policy.as_deref()
)
);
}
// Guardian still applies changed requirements when user config cannot load.
let model = thread.config_snapshot().await.model;
std::fs::write(
&requirements_path,
format!(
"allowed_approvals_reviewers = ['auto_review']\n[auto_review]\nrequired_on_models = ['{model}']"
),
)?;
std::fs::write(
home.path().join(codex_config::CONFIG_TOML_FILE),
"model_provider = 'missing-provider'",
)?;
reload_user_config(&manager, &threads).await;
assert_eq!(
thread.config_snapshot().await.approvals_reviewer,
AutoReview
);
let config = thread.config().await;
assert!(
config
.config_layer_stack
.requirements()
.approvals_reviewer
.can_set(&AutoReview)
.is_ok()
);
let restored = thread.restorable_thread_settings().await;
thread.restore_thread_settings(restored).await?;
// An explicit user reload resolves new local fallbacks on its first invocation.
std::fs::write(&requirements_path, "")?;
std::fs::write(
home.path().join(codex_config::CONFIG_TOML_FILE),
"[auto_review]\npolicy = 'new user fallback'",
)?;
reload_user_config(&manager, &threads).await;
let config = thread.config().await;
assert_eq!(
(
config.guardian_policy_config.as_deref(),
config.guardian_extra_policy.as_deref(),
config.approvals_reviewer
),
(Some("new user fallback"), None, User)
);
thread
.restore_thread_settings(codex_core::CodexThreadSettingsOverrides {
approvals_reviewer: Some(AutoReview),
..Default::default()
})
.await?;
reload_user_config(&manager, &threads).await;
assert_eq!(
thread.config_snapshot().await.approvals_reviewer,
AutoReview
);
Ok(())
}
@@ -2,9 +2,14 @@ use crate::async_scorer::conversation::ConversationBackend;
use std::collections::BTreeMap;
use std::sync::Arc;
use std::sync::Mutex;
use std::task::Poll;
use std::time::Duration;
use anyhow::Result;
use codex_config::CloudConfigBundleLoader;
use codex_config::GuardianPolicySnapshot;
use codex_config::loader::load_guardian_policy_snapshot;
use codex_config::test_support::CloudConfigBundleFixture;
use codex_core::config::Config;
use codex_core::config::ConfigBuilder;
use codex_core::config::LoaderOverrides;
@@ -67,6 +72,7 @@ use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
use core_test_support::skip_if_no_network;
use core_test_support::test_codex::TestCodex;
use core_test_support::test_codex::TestEnv;
use core_test_support::test_codex::test_codex;
use core_test_support::wait_for_event;
use pretty_assertions::assert_eq;
@@ -1771,6 +1777,49 @@ classifier_instructions = "Predict future violations.\n# Security Policy\n{{ ten
.await,
Some(ReviewDecision::Approved)
);
// Tightening while a review is pending must prevent a late low-risk score from releasing it.
const TIGHTENED_REVISION: u64 = 1;
const RELAXED_REVISION: u64 = TIGHTENED_REVISION + 1;
let fs = TestEnv::local().await?.environment().get_filesystem();
let overrides = LoaderOverrides::without_managed_config_for_tests();
let load = |loader, revision| {
load_guardian_policy_snapshot(
fs.as_ref(),
test.codex_home_path(),
&overrides,
loader,
revision,
)
};
let tightened = CloudConfigBundleFixture::loader_with_enterprise_requirement(
"allowed_approvals_reviewers = ['auto_review']",
);
store.insert(vec![
load(&tightened, TIGHTENED_REVISION).await?,
load(&CloudConfigBundleLoader::default(), RELAXED_REVISION).await?,
]);
store.insert_arc(Arc::clone(&test.codex));
let mut score = cached_score(&turn_store).unwrap();
score.scores.insert("action_risk".to_owned(), 1.0);
set_cached_score(&turn_store, score);
let scored_action = r#"{"id":"call-1","tool":"read_file"}"#;
assert_eq!(
cached_approval(
&registry,
store,
&turn_store,
scored_action,
/*metrics*/ None,
)
.await,
None
);
assert_eq!(
test.codex.config().await.guardian_policy_revision,
RELAXED_REVISION
);
store.remove::<Vec<GuardianPolicySnapshot>>();
store.remove::<codex_core::CodexThread>();
Ok(())
}
@@ -3975,14 +4024,46 @@ async fn assert_parent_compaction_reuse(parent_context_for_review: bool) -> Resu
Ok(())
}
struct CacheMiss;
impl codex_extension_api::SynchronousApprovalReviewer for CacheMiss {
struct CacheMiss<'a> {
thread_store: &'a ExtensionData,
turn_store: &'a ExtensionData,
}
impl codex_extension_api::SynchronousApprovalReviewer for CacheMiss<'_> {
fn review<'a>(
&'a self,
_reason: codex_protocol::approvals::GuardianReviewReason,
_async_approval: Option<codex_extension_api::ExtensionFuture<'a, ()>>,
async_approval: Option<codex_extension_api::ExtensionFuture<'a, ()>>,
) -> codex_extension_api::ExtensionFuture<'a, Option<ReviewDecision>> {
Box::pin(async { Some(ReviewDecision::denied("cache miss")) })
Box::pin(async move {
if let Some(snapshots) = self.thread_store.get::<Vec<GuardianPolicySnapshot>>() {
let mut pending = async_approval.expect("adaptive review should be pending");
assert!(
std::future::poll_fn(|context| Poll::Ready(pending.as_mut().poll(context)))
.await
.is_pending()
);
let thread = self.thread_store.get::<codex_core::CodexThread>().unwrap();
let cache =
ConversationBackend::for_turn(self.thread_store, self.turn_store).unwrap();
let progress = &cache.progress;
for (snapshot, expected) in snapshots.iter().zip([Poll::Pending, Poll::Ready(())]) {
assert_eq!(
thread.refresh_guardian_policy(snapshot).await,
codex_core::ConfigRefreshOutcome::Published
);
let mut score = cached_score(self.turn_store).unwrap();
score.scores.insert("action_risk".to_owned(), 0.0);
set_cached_score(self.turn_store, score);
progress.updates.send_replace(());
assert_eq!(
std::future::poll_fn(|context| Poll::Ready(pending.as_mut().poll(context)))
.await,
expected
);
}
}
Some(ReviewDecision::denied("cache miss"))
})
}
}
@@ -4189,7 +4270,10 @@ async fn cached_approval(
require_fresh_review: false,
full_access: false,
metrics,
synchronous_reviewer: &CacheMiss,
synchronous_reviewer: &CacheMiss {
thread_store,
turn_store,
},
};
match registry.decide_approval(&input).await {
Some(codex_extension_api::ApprovalDecision::Allow) => Some(ReviewDecision::Approved),