Lightweight coding agent that runs in your terminal
Rust
Roll back interrupted Guardian reviews to preserve evidence (#55395)
jifaffa861ddf35
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rsindex bf92296307..94aa771c48 100644--- a/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs@@ -20,6 +20,7 @@ use axum::response::IntoResponse;use axum::routing::get;use codex_app_server_protocol::ApprovalsReviewer;use codex_app_server_protocol::CyberAccessProgram;+use codex_app_server_protocol::ItemGuardianApprovalReviewCompletedNotification;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;use codex_app_server_protocol::TurnCompletedNotification;@@ -319,10 +320,16 @@ computer_use_only = false"prior turn evidence remains available after changing programs");classifier_requests.push(classifier_request);- // Wait for the reviewer to start before releasing a low classifier score.+ // Complete the review before a low score can cancel it: this test checks+ // that program changes alone preserve reviewer session reuse.wait_for_guardian_reviews(&state, index + 1).await?;- state.allow_luna.notify_one();state.allow_guardian_review.notify_one();+ let _: ItemGuardianApprovalReviewCompletedNotification = timeout(+ TIMEOUT,+ app_server.read_notification("item/autoApprovalReview/completed"),+ )+ .await??;+ state.allow_luna.notify_one();let completed: TurnCompletedNotification =timeout(TIMEOUT, app_server.read_notification("turn/completed")).await??;assert_eq!(completed.turn.status, TurnStatus::Completed);diff --git a/codex-rs/core/src/guardian/review_session_tests.rs b/codex-rs/core/src/guardian/review_session_tests.rsindex e1ac1cb9bf..131c456d0d 100644--- a/codex-rs/core/src/guardian/review_session_tests.rs+++ b/codex-rs/core/src/guardian/review_session_tests.rs@@ -981,7 +981,7 @@ async fn wait_for_guardian_review_timeout_drains_expected_turn_after_stale_termi.await.expect("interrupt response task should complete");assert!(matches!(outcome, GuardianReviewSessionOutcome::TimedOut));- assert_eq!(disposition, SessionDisposition::Reusable);+ assert_eq!(disposition, SessionDisposition::Rollback);assert!(!turn_completed);}@@ -1022,7 +1022,7 @@ async fn wait_for_guardian_review_cancel_drains_expected_turn_after_stale_termin.await.expect("interrupt response task should complete");assert!(matches!(outcome, GuardianReviewSessionOutcome::Aborted));- assert_eq!(disposition, SessionDisposition::Reusable);+ assert_eq!(disposition, SessionDisposition::Rollback);assert!(!turn_completed);}@@ -1048,7 +1048,7 @@ async fn interrupt_and_drain_turn_ignores_prior_turn_completion() {&mut GuardianReviewAnalyticsResult::without_session(),).await;- assert_eq!(result.disposition, SessionDisposition::Reusable);+ assert_eq!(result.disposition, SessionDisposition::Rollback);assert!(review_session.io.rx_event.try_recv().is_err());}diff --git a/codex-rs/core/tests/suite/guardian_retry.rs b/codex-rs/core/tests/suite/guardian_retry.rsindex 6c9064816d..09af5467ed 100644--- a/codex-rs/core/tests/suite/guardian_retry.rs+++ b/codex-rs/core/tests/suite/guardian_retry.rs@@ -23,6 +23,201 @@ use pretty_assertions::assert_eq;use serde_json::Value;use serde_json::json;use std::time::Duration;+use test_case::test_case;++#[derive(Clone, Copy)]+enum ReviewInterruption {+ Cancellation,+ Timeout,+}++#[test_case(ReviewInterruption::Cancellation; "cancellation")]+#[test_case(ReviewInterruption::Timeout; "timeout")]+#[tokio::test]+async fn interrupted_guardian_review_preserves_evidence_once(+ interruption: ReviewInterruption,+) -> Result<()> {+ skip_if_no_network!(Ok(()));+ skip_if_wine_exec!(+ Ok(()),+ "Guardian approval actions require host-native paths"+ );+ let command = |id: &str| {+ sse(vec![+ ev_function_call(+ id,+ "exec_command",+ &json!({+ "cmd": "echo unexpected > guardian-interrupted.txt",+ "sandbox_permissions": "require_escalated",+ "justification": "Exercise interrupted Guardian review recovery",+ })+ .to_string(),+ ),+ ev_completed(id),+ ])+ };+ let denial = |id: &str| {+ sse(vec![+ ev_assistant_message(+ id,+ r#"{"risk_level":"low","user_authorization":"low","outcome":"deny","rationale":"Fixture denial."}"#,+ ),+ ev_completed(id),+ ])+ };+ let (hold_review, review_gate) = tokio::sync::oneshot::channel();+ let mut responses = vec![+ (None, sse(vec![ev_completed("waiting-for-evidence")])),+ (None, command("committed-command")),+ (None, denial("msg_committed_review")),+ (None, sse(vec![ev_completed("first-parent-done")])),+ (None, command("interrupted-command")),+ (Some(review_gate), denial("msg_interrupted_review")),+ ];+ if matches!(interruption, ReviewInterruption::Timeout) {+ responses.push((None, sse(vec![ev_completed("timed-out-parent-done")])));+ }+ responses.extend([+ (None, command("followup-command")),+ (None, denial("msg_followup_review")),+ (None, sse(vec![ev_completed("last-parent-done")])),+ ]);+ let (model, _) = start_streaming_sse_server(+ responses+ .into_iter()+ .map(|(gate, body)| vec![StreamingSseChunk { gate, body }])+ .collect(),+ )+ .await;+ let server = start_mock_server().await;+ let base_url = format!("{}/v1", model.uri());+ let test = test_codex()+ .with_config(move |config| {+ config.model_provider.base_url = Some(base_url);+ config.model_provider.stream_idle_timeout_ms = Some(180_000);+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ config+ .set_legacy_sandbox_policy(SandboxPolicy::new_workspace_write_policy())+ .expect("set sandbox policy");+ })+ .build_with_auto_env(&server)+ .await?;+ test.submit_text_turn("Wait for the parent's instructions before requesting the command.")+ .await?;+ // Commit one review, then deliver new encrypted evidence for the interrupted attempt.+ for evidence in ["committed-evidence", "pending-evidence"] {+ test.codex+ .submit(Op::InterAgentCommunication {+ communication: InterAgentCommunication::new_encrypted(+ AgentPath::root(),+ AgentPath::root().join("worker").expect("worker path"),+ Vec::new(),+ evidence.into(),+ /*trigger_turn*/ true,+ ),+ start_options: Default::default(),+ })+ .await?;+ if evidence == "committed-evidence" {+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ }+ }+ // The request reaching the server proves Guardian has admitted the pending evidence.+ tokio::time::timeout(+ Duration::from_secs(20),+ model.wait_for_request_count(/*count*/ 6),+ )+ .await+ .context("wait for pending Guardian review")?;+ match interruption {+ ReviewInterruption::Cancellation => {+ test.codex.submit(Op::Interrupt).await?;+ }+ ReviewInterruption::Timeout => {+ tokio::time::pause();+ tokio::time::advance(codex_guardian_reviewer::REVIEW_TIMEOUT + Duration::from_secs(1))+ .await;+ tokio::time::resume();+ }+ }+ let expected_status = match interruption {+ ReviewInterruption::Cancellation => GuardianAssessmentStatus::Aborted,+ ReviewInterruption::Timeout => GuardianAssessmentStatus::TimedOut,+ };+ let mut review_finished = false;+ let mut parent_finished = false;+ while !review_finished || !parent_finished {+ match test.codex.next_event().await?.msg {+ EventMsg::GuardianAssessment(review) if review.status == expected_status => {+ review_finished = true;+ }+ EventMsg::TurnAborted(_)+ if matches!(interruption, ReviewInterruption::Cancellation) =>+ {+ parent_finished = true;+ }+ EventMsg::TurnComplete(_) if matches!(interruption, ReviewInterruption::Timeout) => {+ parent_finished = true;+ }+ _ => {}+ }+ }+ test.submit_text_turn("Request the command again.").await?;+ let requests = model+ .requests()+ .await+ .into_iter()+ .map(|body| serde_json::from_slice::<Value>(&body))+ .collect::<serde_json::Result<Vec<_>>>()?;+ let reviews = requests+ .iter()+ .filter(|request| request["client_metadata"]["x-openai-subagent"] == "guardian")+ .collect::<Vec<_>>();+ assert_eq!(reviews.len(), 3);+ let pending_messages = reviews[1]["input"]+ .as_array()+ .expect("pending input")+ .iter()+ .filter(|item| item["type"] == "agent_message")+ .collect::<Vec<_>>();+ assert_eq!(pending_messages.len(), 2);+ let followup = reviews[2]["input"].as_array().expect("followup input");+ assert_eq!(+ followup+ .iter()+ .filter(|item| item["type"] == "agent_message")+ .collect::<Vec<_>>(),+ pending_messages,+ "the next review must receive both encrypted messages exactly once",+ );+ assert_eq!(+ followup+ .iter()+ .filter(|item| item["id"] == "msg_committed_review")+ .count(),+ 1,+ "the last completed review must survive rollback",+ );+ let marker_error = test+ .fs()+ .get_metadata(+ &test.workspace_path_uri("guardian-interrupted.txt")?,+ Default::default(),+ /*sandbox*/ None,+ )+ .await+ .expect_err("interrupted or denied commands must not execute");+ assert_eq!(marker_error.kind(), std::io::ErrorKind::NotFound);+ test.codex.shutdown_and_wait().await?;+ drop(hold_review);+ model.shutdown().await;+ Ok(())+}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn guardian_retry_executes_only_after_a_completed_approval() -> Result<()> {diff --git a/codex-rs/ext/guardian-reviewer/src/execution.rs b/codex-rs/ext/guardian-reviewer/src/execution.rsindex fabc89b77f..7d1653d426 100644--- a/codex-rs/ext/guardian-reviewer/src/execution.rs+++ b/codex-rs/ext/guardian-reviewer/src/execution.rs@@ -1,5 +1,6 @@//! Executes reviewer turns, including deadlines, cancellation and terminal event matching.//! A session is reusable only after its submitted turn has completed or drained.+//! Interrupted turns roll back admitted context; completed inference errors can retain it.use std::future::Future;use std::time::Duration;@@ -78,7 +79,7 @@ pub async fn wait_for_guardian_review(tokio::select! {_ = &mut timeout => {let disposition = if interrupt_and_drain_turn(runtime, expected_turn_id).await.is_ok() {- SessionDisposition::Reusable+ SessionDisposition::Rollback} else {SessionDisposition::Discard};@@ -96,7 +97,7 @@ pub async fn wait_for_guardian_review(}} => {let disposition = if interrupt_and_drain_turn(runtime, expected_turn_id).await.is_ok() {- SessionDisposition::Reusable+ SessionDisposition::Rollback} else {SessionDisposition::Discard};@@ -142,7 +143,7 @@ pub async fn wait_for_guardian_review(EventMsg::TurnAborted(_) => {return ReviewTurnResult {outcome: GuardianReviewSessionOutcome::Aborted,- disposition: SessionDisposition::Reusable,+ disposition: SessionDisposition::Rollback,turn_completed: false,};}