diff --git a/codex-rs/core/src/guardian/attached_review.rs b/codex-rs/core/src/guardian/attached_review.rs new file mode 100644 index 0000000000..248b885b1c --- /dev/null +++ b/codex-rs/core/src/guardian/attached_review.rs @@ -0,0 +1,216 @@ +//! Holds one action's prepared reviewer and its pre-capture authorization revision. +//! Native retries take a new reservation under the original verdict deadline. +use super::super::*; +use super::PreparedApproval; +use super::ReviewAuthorization; +use crate::guardian::input_budget::PendingReviewContext; +use crate::guardian::review_session::PreparedVerdictTurn; +use crate::guardian::review_session::ensure_guardian_followup_reminder; +use crate::guardian::review_session::prepare_verdict_session; +use crate::guardian::review_session::review_turn; +use crate::guardian_review::BoundReviewer; +use crate::guardian_review::PreparedAssessment; +use crate::guardian_review::ReviewPreparationError; +use codex_analytics::GuardianReviewSessionKind; +use codex_guardian_context::ComposedContext; +use codex_guardian_reviewer::GuardianReviewSessionOutcome; +use codex_guardian_reviewer::SessionDisposition; +use codex_protocol::user_input::UserInput; +use tokio::sync::Mutex; + +pub(super) struct AttachedApproval { + provider: BoundReviewer, + config: GuardianReviewSessionConfig, + first: Mutex)>>, +} + +impl AttachedApproval { + pub async fn prepare( + provider: BoundReviewer, + authorization: ReviewAuthorization, + parent: &Arc, + context: &GuardianReviewContext, + deadline: ReviewDeadline, + cancel: &CancellationToken, + ) -> Result { + let prepare = async { + let config = guardian_review_session_config(parent, context, provider.retrieval) + .await + .map_err(|_| ReviewPreparationError::ReviewerUnavailable)?; + let reserved = Self::reserve(&provider, &config, parent, context, cancel).await?; + Ok(Self { + provider, + config, + first: Mutex::new(Some((authorization, reserved))), + }) + }; + tokio::select! { + biased; + _ = cancel.cancelled() => Err(ReviewPreparationError::Cancelled), + _ = deadline.wait() => Err(ReviewPreparationError::PreparationTimedOut), + result = prepare => result, + } + } + + async fn reserve( + provider: &BoundReviewer, + config: &GuardianReviewSessionConfig, + parent: &Arc, + context: &GuardianReviewContext, + cancel: &CancellationToken, + ) -> Result, ReviewPreparationError> { + let setup = crate::guardian_review::PreparedGuardianContext::prepare( + parent.clone(), + context.clone(), + config.spawn_config.clone(), + &parent.clone_history().await, + &config.node_repl_policy, + ) + .await + .map_err(|_| ReviewPreparationError::ReviewerUnavailable)?; + provider.preparation.prepare(&setup, cancel).await + } + + pub async fn attempt( + &self, + parent: &Arc, + approval: &PreparedApproval, + reasons: &ApprovalRequestReasons, + authorization: ReviewAuthorization, + deadline: ReviewDeadline, + cancel: &CancellationToken, + ) -> (GuardianReviewOutcome, GuardianReviewAnalyticsResult) { + let mut reservation = None; + let mut analytics = GuardianReviewAnalyticsResult::without_session(); + let mut usage_at_start = None; + let operation = async { + let first = self.first.lock().await.take(); + let (authorization, model) = match first { + Some(first) => first, + None => ( + authorization, + Self::reserve( + &self.provider, + &self.config, + parent, + &approval.context, + cancel, + ) + .await?, + ), + }; + let model = reservation.insert(model); + let config = &self.config; + let kind = model.session_kind(); + let runtime = model.runtime(); + analytics = runtime.analytics( + &config.review_model, + config.default_reasoning_effort.as_ref(), + &config.spawn_config.model_provider_id, + kind, + matches!(kind, GuardianReviewSessionKind::TrunkReused), + ); + if let Some(stale) = authorization.invalidation(parent, Some(cancel)).await { + analytics.context_changed = stale.context_changed; + return anyhow::Ok((stale.outcome, SessionDisposition::Discard)); + } + let action = codex_guardian_reviewer::build_guardian_planned_action( + &approval.request, + reasons.retry.clone().or_else(|| reasons.approval.clone()), + approval.context.enclosing_invocation_id.as_deref(), + )?; + let permissions = super::super::super::permissions::for_request( + &approval.request, + Some(&approval.context), + )?; + let action_context = ComposedContext::for_pending_action(action, permissions.as_ref())?; + let request = review_turn( + parent, + &approval.context, + &config.spawn_config, + &config.review_model, + // Final admission replaces the turn-start marker with the typed action and permissions. + vec![UserInput::Text { + text: super::super::super::prompt::GUARDIAN_TRANSCRIPT_START.to_owned(), + text_elements: Vec::new(), + }], + guardian_output_schema(), + ); + let turn = PreparedVerdictTurn { + request, + evidence: PendingReviewContext { + context: action_context, + elastic: None, + }, + node_repl_evidence_sequence: None, + }; + usage_at_start = Some(runtime.token_usage_baseline().await); + if matches!(kind, GuardianReviewSessionKind::TrunkReused) { + ensure_guardian_followup_reminder(runtime).await; + } + let result = async { + prepare_verdict_session( + runtime, + &approval.context, + approval.category, + &config.node_repl_policy, + ) + .await + .map_err(GuardianReviewSessionOutcome::PromptBuildFailed)?; + runtime + .run_sync_verdict( + &approval.context, + turn, + deadline, + Some(cancel), + &mut analytics, + ) + .await + } + .await; + if let Some(stale) = authorization.invalidation(parent, Some(cancel)).await { + analytics.context_changed |= stale.context_changed; + return Ok((stale.outcome, SessionDisposition::Discard)); + } + Ok(match result { + Ok((turn, _)) => (turn.outcome, turn.disposition), + Err(outcome) => (outcome, SessionDisposition::Discard), + }) + }; + let result = run_before_review_deadline(deadline, Some(cancel), operation) + .await + .and_then(|inner| inner.map_err(GuardianReviewSessionOutcome::PromptBuildFailed)); + let (outcome, disposition) = + result.unwrap_or_else(|outcome| (outcome, SessionDisposition::Discard)); + let Some(model) = reservation else { + return (outcome.into(), analytics); + }; + if let Some(start) = usage_at_start { + model + .runtime() + .record_verdict_usage(&start, &mut analytics) + .await; + } + model + .runtime() + .record_failed_review( + parent, + &approval.context, + &approval.request, + &self.config.review_model.model, + codex_guardian_reviewer::ReviewFeedbackSettings { + enabled: self.config.spawn_config.feedback_enabled, + ephemeral: self.config.spawn_config.ephemeral, + }, + &outcome, + ) + .await; + let outcome = GuardianReviewOutcome::from(outcome); + model.finish(if matches!(outcome, GuardianReviewOutcome::Completed(_)) { + disposition + } else { + SessionDisposition::Discard + }); + (outcome, analytics) + } +} diff --git a/codex-rs/core/src/guardian/decision.rs b/codex-rs/core/src/guardian/decision.rs index 6bf60c883e..a0fb870e11 100644 --- a/codex-rs/core/src/guardian/decision.rs +++ b/codex-rs/core/src/guardian/decision.rs @@ -4,6 +4,7 @@ use codex_async_utils::THREAD_STACK_SIZE_BYTES; use codex_protocol::config_types::ApprovalsReviewer; use codex_protocol::openai_models::GuardianScope; +use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::ReviewDecision; use std::sync::Arc; use tokio::sync::oneshot; @@ -54,6 +55,20 @@ pub(crate) fn decide_approval( ) -> futures::future::BoxFuture<'static, Option> { let mut context: GuardianReviewContext = context.into(); let request: ReviewAction = request.into(); + let bind_reviewer = |session: &Session| { + session + .services + .thread_extension_data + .get::>() + .map(|reviewer| Arc::clone(reviewer.as_ref()).bind()) + }; + // Only Never can grant full access. Bind other requests before scheduling as usual. + let may_have_full_access = context.approval_policy == AskForApproval::Never; + let attached_reviewer = if may_have_full_access { + None + } else { + bind_reviewer(&session) + }; // Bind the invocation before scheduling. Async review cleanup can outlive // the decision, but must not extend the time blocking this tool. let review_timing = if context @@ -136,7 +151,13 @@ pub(crate) fn decide_approval( context.approval_policy, &turn.config.permissions.effective_permission_profile(), ); - let mut require_synchronous_review = options.require_synchronous_review; + let attached_reviewer = if may_have_full_access && !full_access { + bind_reviewer(&session) + } else { + attached_reviewer + }; + let mut require_synchronous_review = + options.require_synchronous_review || attached_reviewer.is_some(); if let Some(assessment) = &context.serving_assessment { let permissions = request.request.as_ref().ok().and_then(|request| { super::permissions::for_environment(&context, request.target_environment_id()).ok() @@ -167,6 +188,7 @@ pub(crate) fn decide_approval( let decision = codex_guardian_reviewer::ReviewRequest { serving_assessment: context.serving_assessment.as_ref().map(|value| value.requires_review), host: ReviewRuntime { + attached_reviewer, session: Arc::clone(&session), history_reset: history_reset.clone(), context: context.clone(), diff --git a/codex-rs/core/src/guardian/review.rs b/codex-rs/core/src/guardian/review.rs index 0fec45c0a9..2d13552461 100644 --- a/codex-rs/core/src/guardian/review.rs +++ b/codex-rs/core/src/guardian/review.rs @@ -106,6 +106,7 @@ pub(super) struct GuardianReviewSessionConfig { pub(super) spawn_config: crate::config::Config, pub(super) node_repl_policy: GuardianNodeReplPolicy, review_model: ReviewModel, + default_reasoning_effort: Option, } /// Selects the thread's reviewer and leaves configuration resolution under the caller's deadline. @@ -169,6 +170,7 @@ pub(super) async fn guardian_review_session_config( spawn_config, node_repl_policy: GuardianNodeReplPolicy::from_messages(model_messages), review_model, + default_reasoning_effort: guardian_model_info.default_reasoning_level.clone(), }) } diff --git a/codex-rs/core/src/guardian/review_request.rs b/codex-rs/core/src/guardian/review_request.rs index eeff43b739..400881388e 100644 --- a/codex-rs/core/src/guardian/review_request.rs +++ b/codex-rs/core/src/guardian/review_request.rs @@ -1,9 +1,13 @@ //! Binds an immutable action and root lifetime to fresh per-attempt authorization evidence. //! The extension chooses effects; this adapter supplies evidence, validation and publication. +#[path = "attached_review.rs"] +mod attached; use super::super::runtime::validate; use super::*; use crate::codex_thread::GuardianAuthorizationVersion; +use crate::guardian_review::ReviewPreparationError; +use attached::AttachedApproval; use codex_config::config_toml::CircuitBreakAction; use codex_guardian_reviewer::ReviewDeadline; use codex_guardian_reviewer::ReviewHost; @@ -12,10 +16,12 @@ use codex_protocol::protocol::ErrorEvent; pub(in crate::guardian) struct PreparedApproval { request: GuardianApprovalRequest, + category: GuardianScope, context: GuardianReviewContext, // Unlike authorization, the original history lifetime cannot advance on retry. root_history: Option<(codex_protocol::ThreadId, u64)>, formatted_action: Option, + attached: Option, } pub(in crate::guardian) struct ApprovalEvidence { @@ -123,6 +129,7 @@ impl ReviewHost for super::super::runtime::ReviewRuntime { let super::super::runtime::ReviewRuntime { session, history_reset: _, + attached_reviewer, mut context, request, reasons: _, @@ -174,34 +181,91 @@ impl ReviewHost for super::super::runtime::ReviewRuntime { .as_ref() .map(PluginCommandAttribution::serialized_fields) .unzip(); - let report = - codex_guardian_reviewer::ReviewReport::new(codex_guardian_reviewer::ReviewMetadata { - thread_id: session.thread_id.to_string(), - turn_id: assessment_turn_id, - turn_trigger: turn.turn_metadata_state.current_turn_trigger(), - review_id: review_id.to_owned(), - target_item_id, - plugin_id, - script_path, - approval_request_source, - reviewed_action: guardian_reviewed_action(&request), - action: guardian_assessment_action(&request), - review_reason, - model_context, - timeout: turn.config.guardian_review_timeout, - }); - let root_history = session + let metadata = codex_guardian_reviewer::ReviewMetadata { + thread_id: session.thread_id.to_string(), + turn_id: assessment_turn_id, + turn_trigger: turn.turn_metadata_state.current_turn_trigger(), + review_id: review_id.to_owned(), + target_item_id, + plugin_id, + script_path, + approval_request_source, + reviewed_action: guardian_reviewed_action(&request), + action: guardian_assessment_action(&request), + review_reason, + model_context, + timeout: turn.config.guardian_review_timeout, + }; + let root = session .services .agent_control - .get_guardian_package(session.thread_id) - .await - .map(|snapshot| (snapshot.root_thread_id, snapshot.history_reset_version)); + .get_guardian_package(session.thread_id); + let (report, root_history, attached) = if let Some(provider) = attached_reviewer { + let root = root.await; + let root_history = root + .as_ref() + .map(|root| (root.root_thread_id, root.history_reset_version)); + let history = session.conversation_history_snapshot().await; + let authorization = ReviewAuthorization { + user_message_revision: history.user_message_revision(), + review_context_revision: history.guardian_review_context_revision(), + root_history, + root_authorization_version: root.as_ref().map(|root| root.authorization_version), + root_review_context_revision: root + .as_ref() + .map(|root| root.review_context_revision), + history_reset: self.history_reset.clone(), + }; + drop(history); + let started = Instant::now(); + tracing::info!(%review_id, "Guardian V3 review preparation started"); + let result = AttachedApproval::prepare( + provider, + authorization, + &session, + &context, + deadline, + cancellation, + ) + .await; + let result = if cancellation.is_cancelled() { + Err(ReviewPreparationError::Cancelled) + } else { + result + }; + tracing::info!( + %review_id, + ready = result.is_ok(), + failure_reason = result.as_ref().err().map(tracing::field::display), + preparation_ms = started.elapsed().as_millis() as u64, + "Guardian V3 review preparation finished" + ); + let prepared = result.map_err(|error| match error { + ReviewPreparationError::Cancelled => ReviewDecision::Abort, + _ => ReviewDecision::denied(format!( + "Guardian V3 could not prepare the evidence for this action: {error}" + )), + })?; + ( + codex_guardian_reviewer::ReviewReport::new(metadata), + root_history, + Some(prepared), + ) + } else { + let report = codex_guardian_reviewer::ReviewReport::new(metadata); + let root_history = root + .await + .map(|root| (root.root_thread_id, root.history_reset_version)); + (report, root_history, None) + }; Ok(( PreparedApproval { formatted_action: format_guardian_action_pretty(&request).ok(), request, + category: self.request.category, context, root_history, + attached, }, report, )) @@ -265,26 +329,40 @@ impl ReviewHost for super::super::runtime::ReviewRuntime { root_versions, }); drop(history); - let (outcome, analytics) = run_guardian_review_session_before_deadline( - Arc::clone(&self.session), - prepared.context.clone(), - prepared.request.clone(), - self.request.category, - self.reasons.clone(), - ReviewAttemptOptions { - authorization: Some(ReviewAuthorization { - user_message_revision, - review_context_revision, - root_history: prepared.root_history, - root_authorization_version, - root_review_context_revision, - history_reset: self.history_reset.clone(), - }), - external_cancel: Some(cancellation.clone()), - deadline, - }, - ) - .await; + let authorization = ReviewAuthorization { + user_message_revision, + review_context_revision, + root_history: prepared.root_history, + root_authorization_version, + root_review_context_revision, + history_reset: self.history_reset.clone(), + }; + let (outcome, analytics) = if let Some(attached) = &prepared.attached { + attached + .attempt( + session, + prepared, + &self.reasons, + authorization, + deadline, + cancellation, + ) + .await + } else { + run_guardian_review_session_before_deadline( + Arc::clone(&self.session), + prepared.context.clone(), + prepared.request.clone(), + prepared.category, + self.reasons.clone(), + ReviewAttemptOptions { + authorization: Some(authorization), + external_cancel: Some(cancellation.clone()), + deadline, + }, + ) + .await + }; let review_evidence = match &outcome { GuardianReviewOutcome::Completed(_) => review_evidence, diff --git a/codex-rs/core/src/guardian/review_session.rs b/codex-rs/core/src/guardian/review_session.rs index 6d3328d2b4..3f27b19a00 100644 --- a/codex-rs/core/src/guardian/review_session.rs +++ b/codex-rs/core/src/guardian/review_session.rs @@ -97,6 +97,7 @@ use super::prompt::GuardianPromptMode; #[cfg(test)] use super::prompt::GuardianTranscriptCursor; use super::prompt::GuardianTranscriptHistory; +use super::request_budget::ExhaustedReviewBudget; use super::review::guardian_review_session_config; pub(crate) use super::reviewer_config::build_guardian_review_session_config; use codex_guardian_reviewer::run_before_review_deadline; @@ -654,36 +655,14 @@ async fn run_review_on_session( state.transcript_history_version = reviewer_history_version; state.transcript_source = Some(transcript_source); } - let budget_exhausted = review_session - .session - .services - .thread_extension_data - .remove::(); - let result = match turn_result.outcome { - GuardianReviewSessionOutcome::SessionFailed { - error_info: Some(CodexErrorInfo::ContextWindowExceeded), - .. - } if matches!( - budget_exhausted.as_deref(), - Some(super::request_budget::ExhaustedReviewBudget::Detected) - ) => - { - GuardianReviewSessionOutcome::InputBudgetExceeded - } - result => result, - }; ReviewSessionResult { - outcome: result, - disposition: if budget_exhausted.is_some() { - SessionDisposition::Discard - } else { - turn_result.disposition - }, + outcome: turn_result.outcome, + disposition: turn_result.disposition, analytics: analytics_result, } } -async fn ensure_guardian_followup_reminder(review_session: &GuardianReviewSession) { +pub(super) async fn ensure_guardian_followup_reminder(review_session: &GuardianReviewSession) { let followup_reminder = GuardianFollowupReviewReminder .body() .into_text() @@ -712,7 +691,7 @@ async fn ensure_guardian_followup_reminder(review_session: &GuardianReviewSessio .await; } -async fn prepare_verdict_session( +pub(super) async fn prepare_verdict_session( review_session: &GuardianReviewSession, context: &GuardianReviewContext, category: GuardianScope, @@ -783,6 +762,26 @@ async fn prepare_verdict_session( Ok(()) } +fn finish_budgeted_verdict( + mut turn: ReviewTurnResult, + budget: Option<&ExhaustedReviewBudget>, +) -> ReviewTurnResult { + let Some(budget) = budget else { return turn }; + turn.disposition = SessionDisposition::Discard; + if matches!(budget, ExhaustedReviewBudget::Detected) + && matches!( + turn.outcome, + GuardianReviewSessionOutcome::SessionFailed { + error_info: Some(CodexErrorInfo::ContextWindowExceeded), + .. + } + ) + { + turn.outcome = GuardianReviewSessionOutcome::InputBudgetExceeded; + } + turn +} + /// Input for one verdict, with the evidence that replaces the prompt marker at admission. pub(super) struct PreparedVerdictTurn { pub(super) request: TurnInputRequest, @@ -821,7 +820,8 @@ impl GuardianReviewSession { } let result = wait_for_guardian_review(self, &id, deadline, cancel, analytics).await; observation.finish(result.turn_completed); - Ok(result) + let budget = store.remove::(); + Ok(finish_budgeted_verdict(result, budget.as_deref())) } .await; store.remove::(); diff --git a/codex-rs/core/src/guardian/review_session_setup.rs b/codex-rs/core/src/guardian/review_session_setup.rs index 96501a959e..7e8f913d6f 100644 --- a/codex-rs/core/src/guardian/review_session_setup.rs +++ b/codex-rs/core/src/guardian/review_session_setup.rs @@ -30,7 +30,7 @@ pub struct PreparedGuardianContext { } impl PreparedGuardianContext { - async fn prepare( + pub(in crate::guardian) async fn prepare( parent: Arc, mut context: GuardianReviewContext, config: Config, diff --git a/codex-rs/core/src/guardian/review_session_tests.rs b/codex-rs/core/src/guardian/review_session_tests.rs index ddf4721a03..0da23e35a9 100644 --- a/codex-rs/core/src/guardian/review_session_tests.rs +++ b/codex-rs/core/src/guardian/review_session_tests.rs @@ -907,6 +907,49 @@ async fn wait_for_guardian_review_preserves_structured_session_error() { assert!(turn_completed); } +#[test_case::test_case(CodexErrorInfo::ContextWindowExceeded, Some(ExhaustedReviewBudget::Detected), true; "local exhaustion asks the user")] +#[test_case::test_case(CodexErrorInfo::ContextWindowExceeded, None, false; "backend context limit denies")] +#[test_case::test_case(CodexErrorInfo::ContextWindowExceeded, Some(ExhaustedReviewBudget::Compacting), false; "compaction failure denies")] +#[test_case::test_case(CodexErrorInfo::ServerOverloaded, Some(ExhaustedReviewBudget::Detected), false; "unrelated server failure denies")] +fn optional_sync_verdict_falls_back_only_for_local_input_exhaustion( + error_info: CodexErrorInfo, + budget: Option, + expect_user_approval: bool, +) { + let turn = ReviewTurnResult { + outcome: GuardianReviewSessionOutcome::SessionFailed { + error: anyhow::anyhow!("review failed"), + error_info: Some(error_info), + retry_at: None, + }, + disposition: SessionDisposition::Reusable, + turn_completed: true, + }; + let turn = finish_budgeted_verdict(turn, budget.as_ref()); + let completion = codex_guardian_reviewer::complete_review( + turn.outcome.into(), + &model_info_from_slug("active-model"), + /*require_guardian*/ false, + /*event*/ None, + GuardianReviewAnalyticsResult::without_session(), + ); + match completion.decision { + None => assert!(expect_user_approval), + Some(codex_protocol::protocol::ReviewDecision::Denied { .. }) => { + assert!(!expect_user_approval) + } + other => panic!("unexpected review decision: {other:?}"), + } + assert_eq!( + turn.disposition, + if budget.is_some() { + SessionDisposition::Discard + } else { + SessionDisposition::Reusable + } + ); +} + #[tokio::test] async fn wait_for_guardian_review_ignores_prior_turn_aborts() { let (review_session, tx_event, _rx_sub) = test_review_session().await; diff --git a/codex-rs/core/src/guardian/runtime.rs b/codex-rs/core/src/guardian/runtime.rs index ff50d95ea6..dd9405b1d9 100644 --- a/codex-rs/core/src/guardian/runtime.rs +++ b/codex-rs/core/src/guardian/runtime.rs @@ -83,6 +83,7 @@ pub(super) fn validate<'a>( #[derive(Clone)] pub(super) struct ReviewRuntime { + pub(super) attached_reviewer: Option, pub(super) session: Arc, pub(super) history_reset: CancellationToken, pub(super) context: GuardianReviewContext, diff --git a/codex-rs/core/src/guardian_review.rs b/codex-rs/core/src/guardian_review.rs index 116ee310c2..2578f851eb 100644 --- a/codex-rs/core/src/guardian_review.rs +++ b/codex-rs/core/src/guardian_review.rs @@ -36,3 +36,51 @@ pub fn reviewer_headers(config: &crate::config::Config) -> crate::CodexResponses )]), } } + +/// A thread's synchronous reviewer. Bind the evidence catch-up to the action before it waits. +pub trait AttachedReviewer: Send + Sync { + fn bind(self: std::sync::Arc) -> BoundReviewer; +} + +/// Evidence preparation bound to one action, shared by its review attempts. +#[derive(Clone)] +pub struct BoundReviewer { + pub preparation: std::sync::Arc, + pub retrieval: ReviewRetrieval, +} + +/// Safe to report with a review ID before a verdict has started. +#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)] +pub enum ReviewPreparationError { + #[error("Guardian board evidence is unavailable")] + EvidenceUnavailable, + #[error("timed out preparing Guardian review")] + PreparationTimedOut, + #[error("reviewer is unavailable")] + ReviewerUnavailable, + #[error("evidence delivery failed")] + DeliveryFailed, + #[error("preparation was cancelled")] + Cancelled, +} + +/// Reserve the actor's reviewer after routing and delivery have covered the bound action. +pub trait ReviewerPreparation: Send + Sync { + fn prepare<'a>( + &'a self, + setup: &'a PreparedGuardianContext, + cancel: &'a tokio_util::sync::CancellationToken, + ) -> codex_extension_api::ExtensionFuture< + 'a, + Result, ReviewPreparationError>, + >; +} + +/// Holds the model session until the host finishes validating the original authority. +/// Dropping an interrupted reservation discards its partially admitted conversation. +pub trait PreparedAssessment: Send + Sync { + fn runtime(&self) -> &GuardianReviewSession; + /// Whether this reservation opened a reviewer or continued a retained one. + fn session_kind(&self) -> codex_analytics::GuardianReviewSessionKind; + fn finish(self: Box, disposition: codex_guardian_reviewer::SessionDisposition); +} diff --git a/codex-rs/ext/guardian-reviewer/src/review_tests.rs b/codex-rs/ext/guardian-reviewer/src/review_tests.rs index ec6d79eadb..9b3b68b0b1 100644 --- a/codex-rs/ext/guardian-reviewer/src/review_tests.rs +++ b/codex-rs/ext/guardian-reviewer/src/review_tests.rs @@ -34,7 +34,7 @@ struct GatedHost { } impl ReviewHost for GatedHost { - type Prepared = (); + type Prepared = ReviewDeadline; type Evidence = (); fn permissions(&self) -> Option { @@ -50,11 +50,13 @@ impl ReviewHost for GatedHost { &self, approval_id: &str, reason: GuardianReviewReason, - _: ReviewDeadline, + deadline: ReviewDeadline, _: &CancellationToken, - ) -> Result<((), ReviewReport), ReviewDecision> { + ) -> Result<(Self::Prepared, ReviewReport), ReviewDecision> { + // Make a fresh timeout at verdict time distinguishable from the original deadline. + tokio::time::advance(std::time::Duration::from_secs(1)).await; Ok(( - (), + deadline, ReviewReport::new(ReviewMetadata { thread_id: "thread".into(), turn_id: "turn".into(), @@ -80,14 +82,15 @@ impl ReviewHost for GatedHost { } async fn attempt( &self, - _: &(), - _: ReviewDeadline, + preparation_deadline: &Self::Prepared, + deadline: ReviewDeadline, cancellation: &CancellationToken, ) -> ( GuardianReviewOutcome, GuardianReviewAnalyticsResult, Option<()>, ) { + assert_eq!(deadline, *preparation_deadline); self.started.notify_one(); cancellation.cancelled().await; self.cleaning.notify_one(); @@ -102,12 +105,12 @@ impl ReviewHost for GatedHost { Some(()), ) } - async fn cached_approval_is_current(&self, _: &()) -> bool { + async fn cached_approval_is_current(&self, _: &Self::Prepared) -> bool { self.validations.fetch_add(/*val*/ 1, Ordering::SeqCst); self.current } async fn emit(&self, _: EventMsg) {} - async fn record_evidence(&self, _: &(), _: (), _: &GuardianAssessmentEvent) { + async fn record_evidence(&self, _: &Self::Prepared, _: (), _: &GuardianAssessmentEvent) { self.evidence_recorded.store(true, Ordering::SeqCst); } async fn interrupt(&self, _: &str, _: EventMsg, _: ErrorEvent) { @@ -125,7 +128,7 @@ enum ApprovalState { #[test_case::test_case(ApprovalState::Current; "current action")] #[test_case::test_case(ApprovalState::Invalidated; "invalidated action")] #[test_case::test_case(ApprovalState::Cancelled; "cancelled action")] -#[tokio::test] +#[tokio::test(start_paused = true)] async fn async_approval_revalidates_without_waiting_for_tracked_cleanup(state: ApprovalState) { let host = GatedHost { started: Arc::new(Notify::new()),