Lightweight coding agent that runs in your terminal
Rust
Add conversation mode to Guardian v2 async classification (#49793)
felixxia-oai726f1492db90
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_stateful_async_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_stateful_async_tests.rsnew file mode 100644index 0000000000..d430225bdd--- /dev/null+++ b/codex-rs/app-server/tests/suite/v2/guardian_stateful_async_tests.rs@@ -0,0 +1,38 @@+use super::*;+use codex_protocol::openai_models::AsyncClassifierMode;+use test_case::test_case;++#[test_case(GuardianRisk::Low, ThreadLifecycle::New, ModelReviewRequirement::Optional; "low")]+#[test_case(GuardianRisk::Low, ThreadLifecycle::RootUserRestriction, ModelReviewRequirement::Optional; "new_user_instruction_resets_conversation")]+#[test_case(GuardianRisk::LowWithStreamFailure, ThreadLifecycle::New, ModelReviewRequirement::Optional; "failure_after_early_score")]+#[test_case(GuardianRisk::Low, ThreadLifecycle::RootRestrictionDuringClassification, ModelReviewRequirement::Optional; "authorization_changed_during_classification")]+#[test_case(GuardianRisk::High, ThreadLifecycle::New, ModelReviewRequirement::Optional; "high")]+#[test_case(GuardianRisk::InvalidResponse, ThreadLifecycle::New, ModelReviewRequirement::Optional; "failed")]+#[test_case(GuardianRisk::Low, ThreadLifecycle::Resume, ModelReviewRequirement::Optional; "resume")]+#[test_case(GuardianRisk::Low, ThreadLifecycle::Fork, ModelReviewRequirement::Optional; "fork")]+#[test_case(GuardianRisk::Low, ThreadLifecycle::New, ModelReviewRequirement::Required; "mandatory_review")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn classifier_modes_preserve_approval_matrix(+ risk: GuardianRisk,+ lifecycle: ThreadLifecycle,+ requirement: ModelReviewRequirement,+) -> Result<()> {+ skip_if_no_network!(Ok(()));+ for mode in [+ AsyncClassifierMode::Snapshot,+ AsyncClassifierMode::Conversation,+ ] {+ guardian_v2_routes_scoped_tool_approvals(+ risk,+ lifecycle,+ requirement,+ ReviewOutcome::Allow,+ TranscriptContent::Normal,+ GuardianToolScope::AllTools,+ /*sensitive_action*/ None,+ mode,+ )+ .await?;+ }+ Ok(())+}diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2.rsindex b084707a4e..a8935aac26 100644--- a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2.rs@@ -188,6 +188,7 @@ struct MockResponsesState {context_metrics_recorded: Notify,luna_score: f64,invalid_classification: bool,+ fail_after_classification: bool,review_outcome: ReviewOutcome,transcript_content: TranscriptContent,mcp_server_name: Option<&'static str>,@@ -220,6 +221,7 @@ enum TranscriptContent {#[derive(Clone, Copy)]enum GuardianRisk {Low,+ LowWithStreamFailure,Threshold,High,InvalidResponse,@@ -524,10 +526,10 @@ async fn parent_response(item["call_id"] == "guardian-action-0" && item["type"] == "function_call_output"}).expect("first tool result after root revocation");+ let output = output.to_string();assert!(- output- .to_string()- .contains("Tool execution was declined by Guardian."),+ output.contains("Tool execution was declined by Guardian.")+ || output.contains("This action was rejected due to unacceptable risk."),"the refreshed review must deny the first tool after revocation: {output}");}@@ -623,7 +625,11 @@ async fn luna_response(state: &MockResponsesState, request: Value) -> Vec<Value>responses::ev_response_created("luna-score"),responses::ev_output_text_delta(classification),responses::ev_assistant_message("luna-score-message", classification),- responses::ev_completed("luna-score"),+ if state.fail_after_classification {+ json!({"type":"response.failed", "response":{"id":"luna-score", "error":{"code":"server_error", "message":"stream failed after score"}}})+ } else {+ responses::ev_completed("luna-score")+ },]}@@ -666,10 +672,13 @@ async fn guardian_v2_routes_tool_approvals(transcript_content,GuardianToolScope::AllTools,/*sensitive_action*/ None,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}+// Keep the independent approval scenario inputs explicit at each call site.+#[allow(clippy::too_many_arguments)]async fn guardian_v2_routes_scoped_tool_approvals(risk: GuardianRisk,lifecycle: ThreadLifecycle,@@ -678,7 +687,14 @@ async fn guardian_v2_routes_scoped_tool_approvals(transcript_content: TranscriptContent,scope: GuardianToolScope,sensitive_action: Option<bool>,+ classifier_mode: codex_protocol::openai_models::AsyncClassifierMode,) -> Result<()> {+ let fail_after_classification = matches!(risk, GuardianRisk::LowWithStreamFailure);+ let risk = if fail_after_classification {+ GuardianRisk::Low+ } else {+ risk+ };let server_name = match scope {GuardianToolScope::AllTools => TEST_SERVER_NAME,GuardianToolScope::ComputerUseOnly { server_name } => server_name,@@ -705,7 +721,9 @@ async fn guardian_v2_routes_scoped_tool_approvals({(0.25, 1)}- GuardianRisk::Low | GuardianRisk::InvalidResponse => (0.25, 2),+ GuardianRisk::Low | GuardianRisk::LowWithStreamFailure | GuardianRisk::InvalidResponse => {+ (0.25, 2)+ }GuardianRisk::Threshold => (0.5, 2),GuardianRisk::High => (0.95, 2),};@@ -719,6 +737,7 @@ async fn guardian_v2_routes_scoped_tool_approvals(let responses_state = Arc::new(MockResponsesState {luna_score,invalid_classification: matches!(risk, GuardianRisk::InvalidResponse),+ fail_after_classification,review_outcome,transcript_content,mcp_server_name: Some(server_name),@@ -874,6 +893,10 @@ async fn guardian_v2_routes_scoped_tool_approvals(} else {"prompt"};+ let classifier_mode = match classifier_mode {+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot => "snapshot",+ codex_protocol::openai_models::AsyncClassifierMode::Conversation => "conversation",+ };let mut mock_config = MockResponsesConfig::new(&responses_url).with_model(MODEL).with_provider_config("supports_websockets = false")@@ -883,7 +906,7 @@ async fn guardian_v2_routes_scoped_tool_approvals(analytics_server.uri(),)).with_extra_config(&format!(- "[mcp_servers.{server_name}]\nurl = \"{mcp_server_url}/mcp\"\ndefault_tools_approval_mode = \"{tool_approval_mode}\"\n\n[analytics]\nenabled = true\n\n[otel]\nmetrics_exporter = {{ otlp-http = {{ endpoint = \"{responses_url}/metrics\", protocol = \"json\" }} }}\n\n[features.guardianv2]\nenabled = true{guardian_scope_config}"+ "[mcp_servers.{server_name}]\nurl = \"{mcp_server_url}/mcp\"\ndefault_tools_approval_mode = \"{tool_approval_mode}\"\n\n[analytics]\nenabled = true\n\n[otel]\nmetrics_exporter = {{ otlp-http = {{ endpoint = \"{responses_url}/metrics\", protocol = \"json\" }} }}\n\n[features.guardianv2]\nenabled = true\nasync_classifier_mode = \"{classifier_mode}\"{guardian_scope_config}")).enable_feature(Feature::GuardianApproval);if lifecycle.has_user_input() || lifecycle.has_root_user_input() {@@ -1177,6 +1200,57 @@ async fn guardian_v2_routes_scoped_tool_approvals(submit_user_input_response(&mut app_server, answers).await?;}let second_sample = wait_for_luna_request(responses_state.as_ref(), /*index*/ 1).await?;+ if matches!(+ lifecycle,+ ThreadLifecycle::New+ | ThreadLifecycle::Resume+ | ThreadLifecycle::Fork+ | ThreadLifecycle::RootUserRestriction+ | ThreadLifecycle::RootRestrictionDuringClassification+ ) {+ let retained = classifier_mode == "conversation"+ && !fail_after_classification+ && !matches!(risk, GuardianRisk::InvalidResponse)+ && !late_root_restriction;+ let input = second_sample["input"]+ .as_array()+ .expect("second Luna request input should be an array");+ assert_eq!(+ input.iter().any(|item| item["id"] == "luna-score-message"),+ retained+ );+ if retained {+ let first = luna_request["input"]+ .as_array()+ .expect("first Luna request input should be an array");+ assert_eq!(&input[..first.len()], first);+ let delta = serde_json::to_string(&input[first.len()..])?;+ assert!(delta.contains("TRANSCRIPT DELTA START"));+ if matches!(+ lifecycle,+ ThreadLifecycle::New | ThreadLifecycle::RootUserRestriction+ ) {+ assert!(+ delta.contains("guardian-0"),+ "the new tool evidence must be included"+ );+ assert!(+ !delta.contains(USER_CONTEXT),+ "unchanged user instructions must stay in the retained prefix instead of being appended again"+ );+ assert!(+ !delta.contains(">>> RETAINED USER INSTRUCTIONS START"),+ "a tool-only delta must not append the old retained-instruction section"+ );+ }+ } else {+ assert!(!second_sample.to_string().contains("TRANSCRIPT DELTA START"));+ assert!(+ second_sample.to_string().contains(USER_CONTEXT),+ "snapshot requests and rebuilt conversations must include the user instructions"+ );+ }+ }if mixed_evidence {let input = second_sample["input"].as_array().expect("Luna input");assert_eq!(@@ -1675,6 +1749,23 @@ async fn guardian_v2_routes_scoped_tool_approvals(}let post_authorization_change_sample =wait_for_luna_request(responses_state.as_ref(), /*index*/ 2).await?;+ if classifier_mode == "conversation"+ && matches!(lifecycle, ThreadLifecycle::RootUserRestriction)+ {+ let input = post_authorization_change_sample["input"]+ .as_array()+ .expect("fresh classifier input");+ assert!(+ !input.iter().any(|item| item["id"] == "luna-score-message"),+ "new user instructions must invalidate the previous classifier conversation"+ );+ let text = serde_json::to_string(input)?;+ assert!(!text.contains("TRANSCRIPT DELTA START"));+ assert!(+ text.contains(USER_CONTEXT),+ "rebuilding must restore the earlier user instructions"+ );+ }assert_eq!(post_authorization_change_sample["prompt_cache_key"],format!("guardian-v2:{reviewed_thread_id}")@@ -1833,7 +1924,8 @@ async fn guardian_v2_routes_scoped_tool_approvals(event["event_params"]["risk_level"]]),match risk {- GuardianRisk::Low => json!(["success", "low"]),+ GuardianRisk::Low | GuardianRisk::LowWithStreamFailure =>+ json!(["success", "low"]),GuardianRisk::Threshold | GuardianRisk::High => json!(["success", "high"]),GuardianRisk::InvalidResponse => json!(["failure", null]),}@@ -1876,19 +1968,6 @@ async fn guardian_v2_routes_scoped_tool_approvals(Ok(())}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn guardian_v2_low_risk_actions_skip_subsequent_reviews() -> Result<()> {- skip_if_no_network!(Ok(()));- guardian_v2_routes_tool_approvals(- GuardianRisk::Low,- ThreadLifecycle::New,- ModelReviewRequirement::Optional,- ReviewOutcome::Allow,- TranscriptContent::Normal,- )- .await-}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn guardian_v2_trusts_invoked_user_skills_but_rejects_repository_forgery() -> Result<()> {skip_if_no_network!(Ok(()));@@ -2120,6 +2199,7 @@ async fn guardian_v2_inherits_root_user_skills_for_delegated_workers() -> Resultserver_name: "node_repl",},/*sensitive_action*/ None,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}@@ -2142,6 +2222,7 @@ async fn guardian_v2_computer_use_only_scopes_classification_and_fast_reviews(TranscriptContent::Normal,GuardianToolScope::ComputerUseOnly { server_name },/*sensitive_action*/ None,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}@@ -2439,6 +2520,7 @@ async fn guardian_v2_required_model_computer_use_preserves_strict_approval(TranscriptContent::Normal,GuardianToolScope::ComputerUseOnly { server_name },sensitive_action,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}@@ -2460,6 +2542,7 @@ async fn guardian_v2_discards_sync_reviews_after_user_input_answer(server_name: "node_repl",},/*sensitive_action*/ None,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}@@ -2482,6 +2565,7 @@ async fn guardian_v2_validates_user_input_before_history_truncation(server_name: "node_repl",},/*sensitive_action*/ None,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}@@ -2504,6 +2588,7 @@ async fn guardian_v2_propagates_root_user_input_to_worker_reviews(server_name: "node_repl",},/*sensitive_action*/ None,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}@@ -2541,19 +2626,6 @@ async fn guardian_v2_threshold_score_requires_full_reviews() -> Result<()> {.await}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn guardian_v2_required_model_bypasses_scoring_and_runs_full_reviews() -> Result<()> {- skip_if_no_network!(Ok(()));- guardian_v2_routes_tool_approvals(- GuardianRisk::Low,- ThreadLifecycle::New,- ModelReviewRequirement::Required,- ReviewOutcome::Allow,- TranscriptContent::Normal,- )- .await-}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn guardian_v2_required_model_cannot_reuse_a_cached_score_for_skipped_exec() -> Result<()> {skip_if_no_network!(Ok(()));@@ -2571,32 +2643,6 @@ async fn guardian_v2_required_model_cannot_reuse_a_cached_score_for_skipped_exec.await}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn resumed_thread_ignores_persisted_guardian_score() -> Result<()> {- skip_if_no_network!(Ok(()));- guardian_v2_routes_tool_approvals(- GuardianRisk::Low,- ThreadLifecycle::Resume,- ModelReviewRequirement::Optional,- ReviewOutcome::Allow,- TranscriptContent::Normal,- )- .await-}--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn forked_thread_ignores_persisted_guardian_score() -> Result<()> {- skip_if_no_network!(Ok(()));- guardian_v2_routes_tool_approvals(- GuardianRisk::Low,- ThreadLifecycle::Fork,- ModelReviewRequirement::Optional,- ReviewOutcome::Allow,- TranscriptContent::Normal,- )- .await-}-#[test_case(ThreadLifecycle::RootRestriction; "worker_root_restriction")]#[test_case(ThreadLifecycle::RootUserRestriction; "root_user_restriction")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]@@ -2635,6 +2681,10 @@ async fn guardian_v2_low_scores_require_current_authorization(server_name: "node_repl",},/*sensitive_action*/ None,+ codex_protocol::openai_models::AsyncClassifierMode::Snapshot,).await}++#[path = "guardian_stateful_async_tests.rs"]+mod stateful_async;diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex de866e4609..f3a1811f04 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -336,6 +336,14 @@}]},+ "AsyncClassifierMode": {+ "description": "Async classifier experiment, resolved once for each parent task.",+ "enum": [+ "snapshot",+ "conversation"+ ],+ "type": "string"+ },"AuthCredentialsStoreMode": {"description": "Determine where Codex should store CLI auth credentials.","oneOf": [@@ -1853,6 +1861,20 @@"additionalProperties": false,"description": "User-configurable prompt, approval, and context settings for Guardian v2.","properties": {+ "async_classifier_conversation_token_limit": {+ "description": "Reset retained async history when the next request exceeds this token estimate. Defaults to 100,000. Fresh requests remain subject to the model's input limit.",+ "format": "uint",+ "minimum": 1.0,+ "type": "integer"+ },+ "async_classifier_mode": {+ "allOf": [+ {+ "$ref": "#/definitions/AsyncClassifierMode"+ }+ ],+ "description": "Classifier experiment override. Otherwise use the model default, then snapshots."+ },"classifier_instructions": {"type": "string"},diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/authorization.rs b/codex-rs/ext/guardian-v2/src/async_scorer/authorization.rsindex 5150c6f84f..bdcb08384b 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/authorization.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/authorization.rs@@ -17,6 +17,10 @@ pub(super) struct ScoreAuthorization {}impl ScoreAuthorization {+ pub(super) async fn is_current(&self, thread: &CodexThread) -> bool {+ self == &Self::current(thread, &self.permissions).await+ }+pub(super) async fn current(thread: &CodexThread,permissions: &codex_guardian_context::PermissionContext,diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/classification.rs b/codex-rs/ext/guardian-v2/src/async_scorer/classification.rsindex fe78b54f51..23118ea7db 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/classification.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/classification.rs@@ -39,6 +39,8 @@ use codex_protocol::security_risk::SecurityRiskScore;use super::authorization::ScoreAuthorization;use super::config::GuardianV2Config;+use super::conversation::ConversationRequest;+use super::conversation::Reservation;use super::metrics::record_classification;use super::metrics::record_classification_risk;use super::metrics::sampler_failure_reason;@@ -46,12 +48,15 @@ use super::sampler::LunaSampler;use super::sampler::LunaSamplerError;use super::sampler::LunaSamplingRequest;use super::score::GuardianV2ScoreProgress;+use super::transcript::CollectedTranscript;use super::transcript::ContextInput;use super::truncation::ClassificationTruncations;use super::trusted_skills::TrustedSkillInvocations;use super::trusted_tools::trusted_tool_context;+use codex_guardian_context::ComposedContext;pub(super) struct Classification {+ pub(super) reservation: Option<Reservation>,pub(super) classification_started_at: Instant,pub(super) sampler: Arc<LunaSampler>,pub(super) guardian_config: GuardianV2Config,@@ -86,6 +91,14 @@ pub(super) struct Classification {pub(super) score_authorization: ScoreAuthorization,}+enum ClassificationContext {+ Snapshot(ComposedContext),+ Conversation {+ evidence: CollectedTranscript,+ reservation: Reservation,+ },+}+enum ClassificationOutcome {Scored,Superseded,@@ -94,6 +107,7 @@ enum ClassificationOutcome {impl Classification {pub(super) async fn run(self) {let Self {+ reservation,classification_started_at,sampler,guardian_config,@@ -127,6 +141,9 @@ impl Classification {root_snapshot,score_authorization,} = self;+ let generation = reservation+ .as_ref()+ .map(|reservation| reservation.generation.clone());let mut truncations = ClassificationTruncations::default();let trusted_tool_context = match mcp_tool.as_ref() {Some(tool) => {@@ -192,7 +209,7 @@ impl Classification {.collect::<Vec<_>>();let transcript =PreviousReviews::try_from_fragments(review_fragments).and_then(|reviews| {- guardian_config.transcript.build_context(ContextInput {+ let context_input = ContextInput {target: ContextTarget::Async,history: history.as_ref(),root_conversation: root_conversation.as_deref().unwrap_or_default(),@@ -203,7 +220,20 @@ impl Classification {trusted_tool: trusted_tool_context.as_ref(),trusted_skill_paths: &trusted_skill_paths,node_repl_images: Some(&node_repl_images),- })+ };+ match reservation {+ Some(reservation) => guardian_config+ .transcript+ .collect_context(context_input)+ .map(|evidence| ClassificationContext::Conversation {+ evidence,+ reservation,+ }),+ None => guardian_config+ .transcript+ .build_context(context_input)+ .map(ClassificationContext::Snapshot),+ }});let mut transcript = match transcript {Ok(transcript) => transcript,@@ -226,24 +256,10 @@ impl Classification {};drop(history);drop(node_repl_images);- truncations.extend(std::mem::take(&mut transcript.truncations));- if let Some(metrics) = metrics.as_deref() {- for (section, cost) in transcript.section_costs() {- for (measurement, value) in cost.measurements() {- metrics.histogram_with_boundaries(- codex_guardian_context::SECTION_COST_METRIC,- i64::try_from(value).unwrap_or(i64::MAX),- codex_guardian_context::SECTION_COST_BOUNDARIES,- &[- ("target", "async"),- ("section", section),- ("measurement", measurement),- ],- );- }- }+ if let ClassificationContext::Snapshot(context) = &mut transcript {+ truncations.extend(std::mem::take(&mut context.truncations));+ super::metrics::record_section_costs(metrics.as_deref(), context.section_costs());}- let classification_input = transcript.into_messages();let mut failure_reason = "invalid_output";let mut classification_risk = None;let mut classification_finished_at = None;@@ -275,19 +291,40 @@ impl Classification {let policy = config.resolve_guardian_policy(model_messages);let extra_policy = config.guardian_extra_policy.as_deref().unwrap_or_default();let instructions = guardian_config.render_classifier_instructions(policy, extra_policy);- let output = match sampler- .sample(LunaSamplingRequest {- parent_response_id,- instructions,- input: classification_input,- parent_compaction,- parent_compaction_hash,- reasoning_effort: guardian_config.reasoning_effort.clone(),- parent_turn_id: turn_id.clone(),- root_turn_id,- })- .await- {+ let mut sampling = LunaSamplingRequest {+ parent_response_id,+ instructions,+ input: Vec::new(),+ parent_compaction,+ parent_compaction_hash,+ reasoning_effort: guardian_config.reasoning_effort.clone(),+ parent_turn_id: turn_id.clone(),+ root_turn_id,+ };+ let result = match transcript {+ ClassificationContext::Snapshot(context) => {+ sampling.input = context.into_messages();+ sampler.sample(sampling).await+ }+ ClassificationContext::Conversation {+ evidence,+ reservation,+ } => {+ let (ready, score) = tokio::sync::oneshot::channel();+ reservation.submit(ConversationRequest {+ evidence,+ sampling,+ reset_token_limit: guardian_config+ .async_classifier_conversation_token_limit,+ ready,+ authorization: score_authorization.clone(),+ thread: Arc::clone(&thread),+ metrics: metrics.clone(),+ });+ score.await.unwrap_or(Err(LunaSamplerError::Superseded))+ }+ };+ let output = match result {Ok(output) => output,Err(LunaSamplerError::Superseded) => {return Ok(ClassificationOutcome::Superseded);@@ -312,8 +349,10 @@ impl Classification {),sampled_at: Some(sampled_at.into()),};- if score_authorization- != ScoreAuthorization::current(&thread, &score_authorization.permissions).await+ if !score_authorization.is_current(&thread).await+ || generation+ .as_ref()+ .is_some_and(|generation| generation.strong_count() == 0){return Ok(ClassificationOutcome::Superseded);}diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/config.rs b/codex-rs/ext/guardian-v2/src/async_scorer/config.rsindex 896b8e445e..f0bf74386c 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/config.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/config.rs@@ -28,6 +28,7 @@ const MAX_MODEL_CONTEXT_ITEM_TOKENS: usize = 100_000;const DEFAULT_REVIEW_THRESHOLD: f64 = 0.5;const LEGACY_REVIEW_THRESHOLD: f64 = 0.8;const DEFAULT_MAX_TOOL_CALL_LAG: usize = 2;+const DEFAULT_ASYNC_CLASSIFIER_CONVERSATION_TOKEN_LIMIT: usize = 100_000;pub(crate) const CLASSIFICATION_OUTPUT_INSTRUCTIONS: &str = "Your first output token is the entire classification: `high` for high risk or `low` for low risk. Output that token immediately and nothing else.";#[derive(Clone, Debug, PartialEq)]@@ -37,6 +38,7 @@ pub(crate) struct GuardianV2Config {pub(crate) classifier_instructions: String,pub(crate) review_threshold: f64,pub(crate) max_tool_call_lag: usize,+ pub(crate) async_classifier_conversation_token_limit: usize,pub(crate) reasoning_effort: ReasoningEffort,pub(crate) max_action_tokens: usize,/// No truncation limit is applied unless local or model configuration supplies one.@@ -48,6 +50,16 @@ pub(crate) struct GuardianV2Config {}impl GuardianV2Config {+ pub(super) fn classifier_mode(+ &self,+ model_defaults: Option<&GuardianV2ModelConfig>,+ ) -> codex_protocol::openai_models::AsyncClassifierMode {+ self.local_overrides+ .async_classifier_mode+ .or_else(|| model_defaults.and_then(|defaults| defaults.async_classifier_mode))+ .unwrap_or_default()+ }+pub(crate) fn resolve(config: &Config) -> Result<Self, String> {let effective_config = config.config_layer_stack.effective_config();let configured = match effective_config@@ -102,6 +114,9 @@ impl GuardianV2Config {configured.max_tool_call_lag = configured.max_tool_call_lag.or(model_defaults.max_tool_call_lag);+ configured.async_classifier_conversation_token_limit = configured+ .async_classifier_conversation_token_limit+ .or(model_defaults.async_classifier_conversation_token_limit);configured.reasoning_effort = configured.reasoning_effort.or_else(|| model_defaults.reasoning_effort.clone());@@ -167,6 +182,14 @@ impl GuardianV2Config {}fn from_overrides(configured: GuardianV2ConfigToml) -> Result<Self, String> {+ let async_classifier_conversation_token_limit = configured+ .async_classifier_conversation_token_limit+ .unwrap_or(DEFAULT_ASYNC_CLASSIFIER_CONVERSATION_TOKEN_LIMIT);+ if async_classifier_conversation_token_limit == 0 {+ return Err(+ "Guardian v2 async_classifier_conversation_token_limit must be positive".to_owned(),+ );+ }// Existing custom and model-owned prompts retain their original calibration// unless their owner explicitly supplies a matching threshold.let review_threshold = configured.review_threshold.unwrap_or_else(|| {@@ -253,6 +276,7 @@ impl GuardianV2Config {);Ok(Self {local_overrides: configured.clone(),+ async_classifier_conversation_token_limit,persist_scores: configured.persist_scores.unwrap_or(false),classifier_instructions: configured.classifier_instructions.unwrap_or_else(|| {ResolvedModelMessages::bundled()diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/config_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/config_tests.rsindex ac02d87d60..7ad9acbd5d 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/config_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/config_tests.rs@@ -213,6 +213,7 @@ fn model_runtime_settings_preserve_local_overrides() {classifier_instructions: Some(prompt.clone()),max_classifier_instruction_tokens: Some(256),max_tool_call_lag: Some(1),+ async_classifier_conversation_token_limit: Some(80_000),reuse_parent_compaction: Some(false),transcript: Some(GuardianV2TranscriptModelConfig {include_images: Some(true),@@ -228,15 +229,17 @@ fn model_runtime_settings_preserve_local_overrides() {(inherited.max_classifier_instruction_tokens,inherited.max_tool_call_lag,+ inherited.async_classifier_conversation_token_limit,inherited.reuse_parent_compaction,inherited.transcript.include_images,),- (Some(256), 1, false, true)+ (Some(256), 1, 80_000, false, true));let overridden = GuardianV2Config::from_overrides(GuardianV2ConfigToml {max_classifier_instruction_tokens: Some(512),max_tool_call_lag: Some(4),+ async_classifier_conversation_token_limit: Some(120_000),reuse_parent_compaction: Some(true),transcript: Some(GuardianV2TranscriptConfigToml {include_images: Some(false),@@ -251,10 +254,11 @@ fn model_runtime_settings_preserve_local_overrides() {(overridden.max_classifier_instruction_tokens,overridden.max_tool_call_lag,+ overridden.async_classifier_conversation_token_limit,overridden.reuse_parent_compaction,overridden.transcript.include_images,),- (Some(512), 4, true, false)+ (Some(512), 4, 120_000, true, false));let uncapped_defaults = GuardianV2ModelConfig {@@ -271,3 +275,31 @@ fn model_runtime_settings_preserve_local_overrides() {));}++#[test]+fn classifier_mode_uses_local_override_then_model_default() {+ use codex_protocol::openai_models::AsyncClassifierMode;+ for local in [+ None,+ Some(AsyncClassifierMode::Snapshot),+ Some(AsyncClassifierMode::Conversation),+ ] {+ let config = GuardianV2Config::from_overrides(GuardianV2ConfigToml {+ async_classifier_mode: local,+ ..Default::default()+ })+ .unwrap();+ let defaults = GuardianV2ModelConfig {+ async_classifier_mode: Some(AsyncClassifierMode::Conversation),+ ..Default::default()+ };+ assert_eq!(+ config.classifier_mode(Some(&defaults)),+ local.unwrap_or(AsyncClassifierMode::Conversation)+ );+ assert_eq!(+ config.classifier_mode(/*model_defaults*/ None),+ local.unwrap_or_default()+ );+ }+}diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/conversation.rs b/codex-rs/ext/guardian-v2/src/async_scorer/conversation.rsnew file mode 100644index 0000000000..e4af93e6fd--- /dev/null+++ b/codex-rs/ext/guardian-v2/src/async_scorer/conversation.rs@@ -0,0 +1,194 @@+//! One worker owns each treatment conversation and commits only completed requests.+//! Admission reserves order before async preparation; permits bound active and queued work.+//! Backend replacement invalidates its generation without changing snapshot shutdown policy.+//! Oversized retained requests rebuild from fresh evidence before the model's hard limit.+//! Prepared requests own their history; only progress remains in state during sampling.+//! Host-only instruction delivery metadata is committed with its completed input messages.++use std::sync::Arc;+use std::sync::Mutex;+use std::sync::Weak;++use codex_context_fragments::RenderedFragment;+use codex_core::CodexThread;+use codex_extension_api::ExtensionMetrics;+use codex_guardian_reviewer::ConversationState;+use codex_history::ResponseItemEnvelope;+use codex_protocol::models::ResponseItem;+use tokio::sync::OwnedSemaphorePermit;+use tokio::sync::Semaphore;+use tokio::sync::mpsc;+use tokio::sync::oneshot;++use super::authorization::ScoreAuthorization;+use super::sampler::LunaSampler;+use super::sampler::LunaSamplerError;+use super::sampler::LunaSamplingRequest;+use super::transcript::CollectedTranscript;++const MAX_OUTSTANDING: usize = 16;++pub(super) struct ConversationBackend {+ queue: Mutex<mpsc::UnboundedSender<QueuedRequest>>,+ capacity: Arc<Semaphore>,+ generation: Arc<()>,+}++struct QueuedRequest {+ request: oneshot::Receiver<ConversationRequest>,+ _permit: OwnedSemaphorePermit,+}++pub(super) struct Reservation {+ request: oneshot::Sender<ConversationRequest>,+ pub(super) generation: Weak<()>,+}++pub(super) struct ConversationRequest {+ pub(super) evidence: CollectedTranscript,+ pub(super) sampling: LunaSamplingRequest,+ pub(super) reset_token_limit: usize,+ pub(super) authorization: ScoreAuthorization,+ pub(super) thread: Arc<CodexThread>,+ pub(super) ready: oneshot::Sender<Result<String, LunaSamplerError>>,+ pub(super) metrics: Option<Arc<dyn ExtensionMetrics>>,+}++// Authorization covers model settings; local config changes replace the backend.+#[derive(PartialEq)]+struct ReuseKey {+ authorization: ScoreAuthorization,+ instructions: RenderedFragment,+ parent_compaction: Option<ResponseItem>,+}++impl ConversationBackend {+ pub(super) fn new(sampler: Arc<LunaSampler>) -> Self {+ let (sender, receiver) = mpsc::unbounded_channel();+ let generation = Arc::new(());+ tokio::spawn(run(receiver, sampler, Arc::downgrade(&generation)));+ Self {+ queue: Mutex::new(sender),+ capacity: Arc::new(Semaphore::new(MAX_OUTSTANDING)),+ generation,+ }+ }++ pub(super) fn reserve(+ &self,+ observe: impl FnOnce() -> usize,+ ) -> (usize, Result<Reservation, LunaSamplerError>) {+ // Keep the tool index and queue position in the same admission order.+ let queue = self+ .queue+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ let index = observe();+ let reservation = (|| {+ let permit = Arc::clone(&self.capacity)+ .try_acquire_owned()+ .map_err(|_| LunaSamplerError::QueueFull)?;+ let (sender, request) = oneshot::channel();+ queue+ .send(QueuedRequest {+ request,+ _permit: permit,+ })+ .map_err(|_| LunaSamplerError::Superseded)?;+ Ok(Reservation {+ request: sender,+ generation: Arc::downgrade(&self.generation),+ })+ })();+ (index, reservation)+ }+}++impl Reservation {+ pub(super) fn submit(self, request: ConversationRequest) {+ if let Err(request) = self.request.send(request) {+ let _ = request.ready.send(Err(LunaSamplerError::Superseded));+ }+ }+}++async fn run(+ mut queue: mpsc::UnboundedReceiver<QueuedRequest>,+ sampler: Arc<LunaSampler>,+ generation: Weak<()>,+) {+ // Only completed requests have reusable history and a matching reuse key.+ let mut committed: Option<(ReuseKey, ConversationState<Vec<ResponseItemEnvelope>>)> = None;+ while let Some(queued) = queue.recv().await {+ // A preparation error drops its sender, preserving the order of later observations.+ let Ok(request) = queued.request.await else {+ continue;+ };+ if generation.strong_count() == 0+ || !request.authorization.is_current(&request.thread).await+ {+ committed = None;+ let _ = request.ready.send(Err(LunaSamplerError::Superseded));+ continue;+ }+ let key = ReuseKey {+ authorization: request.authorization.clone(),+ instructions: request.sampling.instructions.clone(),+ parent_compaction: request.sampling.parent_compaction.clone(),+ };+ let mut state = committed+ .take()+ .filter(|(previous, _)| previous == &key)+ .map(|(_, state)| state)+ .unwrap_or_default();+ let had_history = state.snapshot().is_some();+ let prepared = request+ .sampling+ .prepare_retained(&request.evidence, &mut state, sampler.max_input_tokens())+ .filter(|prepared| {+ prepared.existing_context_tokens == 0+ || prepared.input_tokens <= request.reset_token_limit+ })+ .or_else(|| {+ if !had_history {+ return None;+ }+ state = ConversationState::default();+ request.sampling.prepare_retained(+ &request.evidence,+ &mut state,+ sampler.max_input_tokens(),+ )+ });+ let Some(mut prepared) = prepared else {+ let _ = request.ready.send(Err(LunaSamplerError::InputTooLarge));+ continue;+ };+ super::metrics::record_section_costs(+ request.metrics.as_deref(),+ prepared.section_costs.iter().copied(),+ );+ super::metrics::record_request_tokens(+ request.metrics.as_deref(),+ prepared.existing_context_tokens,+ prepared.input_tokens,+ );+ drop(request.evidence);+ let cursor = prepared.cursor;+ let pending_truncations = std::mem::take(&mut prepared.truncations);+ let history = sampler.sample_retained(prepared, request.ready).await;+ if let Some(history) = history+ && generation.strong_count() > 0+ && request.authorization.is_current(&request.thread).await+ {+ let mut truncations = super::truncation::ClassificationTruncations::default();+ truncations.extend(pending_truncations);+ truncations.emit(request.metrics.as_deref());+ state.complete_review(cursor);+ state.commit_snapshot(history);+ committed = Some((key, state));+ }+ // The permit is released only after completion and commit, not after the early score.+ drop(queued._permit);+ }+}diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/conversation_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/conversation_tests.rsnew file mode 100644index 0000000000..c79f20fea9--- /dev/null+++ b/codex-rs/ext/guardian-v2/src/async_scorer/conversation_tests.rs@@ -0,0 +1,218 @@+use super::*;+use crate::async_scorer::authorization::ScoreAuthorization;+use crate::async_scorer::conversation::ConversationBackend;+use crate::async_scorer::conversation::ConversationRequest;+use crate::async_scorer::sampler::LunaSampler;+use crate::async_scorer::sampler::LunaSamplerError;+use crate::async_scorer::sampler::LunaSamplingRequest;+use crate::async_scorer::sampler::tests::sample_request;+use crate::async_scorer::sampler::tests::sampler_config;+use crate::async_scorer::transcript::ContextInput;+use codex_extension_api::ThreadStopInput;+use codex_guardian_context::ContextTarget;+use pretty_assertions::assert_eq;++async fn pending_request(+ fixture: &GuardianFailureFixture,+ label: &str,+) -> Result<(+ ConversationRequest,+ tokio::sync::oneshot::Receiver<Result<String, LunaSamplerError>>,+)> {+ let thread = Arc::clone(&fixture.test.codex);+ let config = thread+ .thread_extension_data()+ .get::<GuardianV2Config>()+ .unwrap();+ let history = thread.conversation_history_snapshot().await;+ let instructions = config.render_classifier_instructions(TEST_GUARDIAN_POLICY, "");+ let evidence = config.transcript.collect_context(ContextInput {+ target: ContextTarget::Async,+ history: history.as_ref(),+ root_conversation: &[],+ trusted_user_answers: &[],+ planned_action: None,+ permissions: None,+ previous_reviews: None,+ trusted_tool: None,+ trusted_skill_paths: &[],+ node_repl_images: None,+ })?;+ let (ready, score) = tokio::sync::oneshot::channel();+ let authorization = ScoreAuthorization::current(&thread, &Default::default()).await;+ Ok((+ ConversationRequest {+ evidence,+ reset_token_limit: config.async_classifier_conversation_token_limit,+ authorization,+ thread,+ ready,+ metrics: None,+ sampling: LunaSamplingRequest {+ instructions,+ input: Vec::new(),+ ..sample_request(label)+ },+ },+ score,+ ))+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn configured_reset_limit_rebuilds_history_without_rejecting_fresh_evidence() -> Result<()> {+ skip_if_no_network!(Ok(()));+ for (limit, reused) in [(1, false), (100_000, true)] {+ let server = responses::start_mock_server().await;+ let fixture = GuardianFailureFixture::with_config(&format!(+ "[features.guardianv2]\nasync_classifier_mode = 'conversation'\nasync_classifier_conversation_token_limit = {limit}"+ ))+ .await?;+ let sampler = Arc::new(LunaSampler::new(sampler_config(server.uri())));+ let backend = ConversationBackend::new(sampler);+ let events = responses::sse(vec![+ ev_assistant_message("score", "low"),+ ev_completed("score"),+ ]);+ let mock = responses::mount_sse_sequence(&server, vec![events; 2]).await;+ for index in 0..2 {+ let (request, score) = pending_request(&fixture, "parent").await?;+ backend.reserve(|| index).1.unwrap().submit(request);+ assert_eq!(score.await??, "low");+ }+ let requests = mock.requests();+ assert_eq!(requests.len(), 2);+ let input = requests[1].input();+ assert_eq!(input.iter().any(|item| item["id"] == "score"), reused);+ assert_eq!(+ serde_json::to_string(&input)?.contains("TRANSCRIPT DELTA START"),+ reused+ );+ drop(backend);+ fixture.test.codex.shutdown_and_wait().await?;+ }+ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn admission_orders_delayed_preparation_and_bounds_active_plus_pending_work() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let fixture = GuardianFailureFixture::with_config(+ "[features.guardianv2]\nasync_classifier_mode = 'conversation'",+ )+ .await?;+ let sampler = Arc::new(LunaSampler::new(sampler_config(server.uri())));+ fixture+ .test+ .codex+ .thread_extension_data()+ .insert(ConversationBackend::new(sampler));+ let events = responses::sse(vec![+ ev_assistant_message("score", "low"),+ ev_completed("score"),+ ]);+ let mock = responses::mount_sse_sequence(&server, vec![events; 3]).await;+ let backend = fixture+ .test+ .codex+ .thread_extension_data()+ .get::<ConversationBackend>()+ .unwrap();+ let store = fixture.test.codex.thread_extension_data();+ let progress = store.get::<GuardianV2ScoreProgress>().unwrap();+ let mut reservations = (0..16)+ .map(|index| backend.reserve(|| index).1.unwrap())+ .collect::<Vec<_>>();+ fixture.score_tool(ToolName::plain("read_file")).await;+ let cached = progress.inspect(/*call_id*/ None);+ assert!(cached.has_unscored_failure);+ assert_eq!(cached.action_risk, Some(1.0));+ assert_eq!(+ cached_approval(+ &fixture.registry,+ store,+ "review action",+ /*metrics*/ None+ )+ .await,+ None+ );+ let c = reservations.remove(/*index*/ 2);+ let b = reservations.remove(/*index*/ 1);+ let a = reservations.remove(/*index*/ 0);+ drop(reservations);+ let mut scores = Vec::new();+ for (reservation, label) in [(c, "C"), (b, "B"), (a, "A")] {+ let (request, score) = pending_request(&fixture, label).await?;+ reservation.submit(request);+ scores.push(score);+ }+ for score in scores {+ assert_eq!(score.await??, "low");+ }+ let turns = mock+ .requests()+ .iter()+ .map(|request| {+ request.body_json()["client_metadata"]["parent_turn_id"]+ .as_str()+ .unwrap()+ .to_owned()+ })+ .collect::<Vec<_>>();+ assert_eq!(turns, ["A", "B", "C"]);+ fixture.test.codex.shutdown_and_wait().await?;+ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn queued_authorization_and_stopped_generations_cannot_continue() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let fixture = GuardianFailureFixture::with_config(+ "[features.guardianv2]\nasync_classifier_mode = 'conversation'",+ )+ .await?;+ let sampler = Arc::new(LunaSampler::new(sampler_config(server.uri())));+ fixture+ .test+ .codex+ .thread_extension_data()+ .insert(ConversationBackend::new(sampler));+ let thread_store = fixture.test.codex.thread_extension_data();+ let backend = thread_store.get::<ConversationBackend>().unwrap();+ let blocker = backend.reserve(|| 0).1.unwrap();+ let stale = backend.reserve(|| 0).1.unwrap();+ let (request, score) = pending_request(&fixture, "stale").await?;+ fixture+ .test+ .codex+ .inject_response_items(vec![user_instruction(+ "Stop. Do not inspect any more files.",+ )])+ .await?;+ stale.submit(request);+ drop(blocker);+ assert!(matches!(score.await?, Err(LunaSamplerError::Superseded)));+ let stopped = backend.reserve(|| 0).1.unwrap();+ let (request, score) = pending_request(&fixture, "stopped").await?;+ drop(backend);+ fixture.registry.thread_lifecycle_contributors()[0]+ .on_thread_stop(ThreadStopInput {+ session_store: &fixture.session_store,+ thread_store,+ })+ .await;+ stopped.submit(request);+ assert!(matches!(score.await?, Err(LunaSamplerError::Superseded)));+ assert!(+ server+ .received_requests()+ .await+ .unwrap()+ .iter()+ .all(|request| request.method.as_str() != "POST")+ );+ fixture.test.codex.shutdown_and_wait().await?;+ Ok(())+}diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension.rsindex f6af94c22d..86020d125e 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs@@ -16,6 +16,7 @@ use codex_extension_api::SkillInvocationContributor;use codex_extension_api::SkillInvocationInput;use codex_extension_api::ThreadLifecycleContributor;use codex_extension_api::ThreadStartInput;+use codex_extension_api::ThreadStopInput;use codex_extension_api::ToolFinishInput;use codex_extension_api::ToolLifecycleContributor;use codex_extension_api::ToolLifecycleFuture;@@ -23,10 +24,12 @@ use codex_extension_api::ToolStartInput;use codex_features::Feature;use codex_login::AuthManager;use codex_protocol::config_types::ApprovalsReviewer;+use codex_protocol::openai_models::AsyncClassifierMode;use codex_protocol::openai_models::ModelInfo;use codex_protocol::protocol::has_full_access;use super::config::GuardianV2Config;+use super::conversation::ConversationBackend;use super::sampler::LunaSampler;use super::score::GuardianV2ScoreProgress;use super::trusted_skills::TrustedSkillRoots;@@ -83,10 +86,22 @@ impl ThreadLifecycleContributor<Config> for GuardianV2Extension {.get_or_init(NodeReplReviewEvidence::default).enable_image_capture();}+ let mode = guardian_config.classifier_mode(+ model+ .as_ref()+ .and_then(|model| model.model_messages.as_ref())+ .and_then(|messages| messages.guardian_v2.as_ref()),+ );+ input.thread_store.remove::<ConversationBackend>();input.thread_store.remove::<LunaSampler>();let sampler = input.thread_store.get_or_init(|| LunaSampler::new(sampler_config));+ if mode == AsyncClassifierMode::Conversation {+ input+ .thread_store+ .insert(ConversationBackend::new(Arc::clone(&sampler)));+ }input.thread_store.insert(guardian_config);input.thread_store.insert(GuardianV2ScoreProgress::new(input.extension_metrics.clone(),@@ -121,6 +136,11 @@ impl ThreadLifecycleContributor<Config> for GuardianV2Extension {}})}+ fn on_thread_stop<'a>(&'a self, input: ThreadStopInput<'a>) -> ExtensionFuture<'a, ()> {+ Box::pin(async move {+ input.thread_store.remove::<ConversationBackend>();+ })+ }}impl SkillInvocationContributor for GuardianV2Extension {diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rsindex e9cb616503..4dd694228f 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs@@ -71,6 +71,9 @@ use pretty_assertions::assert_eq;use serde_json::json;use crate::async_scorer::authorization::ScoreAuthorization;++#[path = "conversation_tests.rs"]+mod conversation;use crate::async_scorer::config::CLASSIFICATION_OUTPUT_INSTRUCTIONS;use crate::async_scorer::config::DEFAULT_PARENT_COMPACTION_TOKENS;use crate::async_scorer::config::GuardianV2Config;@@ -1830,6 +1833,8 @@ async fn contributor_uses_model_defaults_and_preserves_local_overrides() -> Resuskip_if_no_network!(Ok(()));let model_defaults = GuardianV2ModelConfig {+ async_classifier_mode: None,+ async_classifier_conversation_token_limit: None,classifier_instructions: Some("Use the experimental model-owned prompt.".to_owned()),review_threshold_basis_points: Some(6_000),max_tool_call_lag: Some(2),diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/metrics.rs b/codex-rs/ext/guardian-v2/src/async_scorer/metrics.rsindex 92e7828fe1..fcea468a4d 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/metrics.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/metrics.rs@@ -27,6 +27,7 @@ pub(super) fn sampler_failure_reason(error: &LunaSamplerError) -> &'static str {LunaSamplerError::Superseded => "superseded",LunaSamplerError::IncompatibleCompaction => "incompatible_compaction",LunaSamplerError::InputTooLarge => "input_too_large",+ LunaSamplerError::QueueFull => "queue_full",LunaSamplerError::Api(error) => match error {ApiError::Transport(TransportError::Http { status, .. })| ApiError::Api { status, .. } => match status.as_u16() {@@ -110,3 +111,48 @@ pub(super) fn record_fast_decision(&[("decision", decision), ("reason", reason)],);}++pub(super) fn record_section_costs(+ metrics: Option<&dyn ExtensionMetrics>,+ costs: impl IntoIterator<Item = (&'static str, codex_guardian_context::SectionCost)>,+) {+ let Some(metrics) = metrics else {+ return;+ };+ for (section, cost) in costs {+ for (measurement, value) in cost.measurements() {+ metrics.histogram_with_boundaries(+ codex_guardian_context::SECTION_COST_METRIC,+ i64::try_from(value).unwrap_or(i64::MAX),+ codex_guardian_context::SECTION_COST_BOUNDARIES,+ &[+ ("target", "async"),+ ("section", section),+ ("measurement", measurement),+ ],+ );+ }+ }+}++pub(super) fn record_request_tokens(+ metrics: Option<&dyn ExtensionMetrics>,+ existing: usize,+ total: usize,+) {+ let Some(metrics) = metrics else {+ return;+ };+ for (component, tokens) in [+ ("existing_context", existing),+ ("new_input", total.saturating_sub(existing)),+ ("total", total),+ ] {+ metrics.histogram_with_boundaries(+ codex_guardian_context::REQUEST_TOKENS_METRIC,+ i64::try_from(tokens).unwrap_or(i64::MAX),+ codex_guardian_context::REQUEST_TOKENS_BOUNDARIES,+ &[("target", "async"), ("component", component)],+ );+ }+}diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/mod.rs b/codex-rs/ext/guardian-v2/src/async_scorer/mod.rsindex dea634a6ea..d5207f7c10 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/mod.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/mod.rs@@ -3,13 +3,12 @@ mod approval;mod authorization;mod classification;mod config;+mod conversation;mod coverage;mod extension;mod metrics;mod observation;mod parent_compaction;-// The treatment backend wires this builder into sampling in the next PR.-#[allow(dead_code)]mod request;mod sampler;mod score;diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/observation.rs b/codex-rs/ext/guardian-v2/src/async_scorer/observation.rsindex 7c1189a133..3c13957a90 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/observation.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/observation.rs@@ -26,6 +26,7 @@ use super::action::GuardianAction;use super::authorization::ScoreAuthorization;use super::classification::Classification;use super::config::GuardianV2Config;+use super::conversation::ConversationBackend;use super::coverage::scores_tool;use super::extension::GuardianV2Extension;use super::metrics::record_classification;@@ -121,7 +122,28 @@ impl GuardianV2Extension {let context_mode = GuardianContextMode::from_history(input.conversation_history.as_ref());let analytics = input.session_store.get::<AnalyticsEventsClient>();let sampled_at = SystemTime::now();- let tool_call_index = score_progress.observe(&input);+ let (tool_call_index, reservation) = match input.thread_store.get::<ConversationBackend>() {+ Some(conversation) => {+ let (index, reservation) = conversation.reserve(|| score_progress.observe(&input));+ (index, reservation.map(Some))+ }+ None => (score_progress.observe(&input), Ok(None)),+ };+ let reservation = match reservation {+ Ok(reservation) => reservation,+ Err(error) => {+ score_progress.invalidate(tool_call_index);+ score_progress.fail_closed(sampled_at);+ record_classification(+ metrics.as_deref(),+ context_mode,+ classification_started_at.elapsed(),+ "failure",+ Some(super::metrics::sampler_failure_reason(&error)),+ );+ return;+ }+ };let event_sink = Arc::clone(&self.event_sink);let thread_id = input.thread_store.level_id().to_owned();let turn_id = input.turn_id.to_owned();@@ -328,6 +350,7 @@ impl GuardianV2Extension {};let score_authorization = ScoreAuthorization::current(&thread, &permissions).await;let classification = Classification {+ reservation,classification_started_at,sampler,guardian_config,diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/request.rs b/codex-rs/ext/guardian-v2/src/async_scorer/request.rsindex 9cdf67cc4d..3e5f27c6fa 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/request.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/request.rs@@ -35,7 +35,7 @@ impl LunaSamplingRequest {}) {return None;}- let (mut context, _) = evidence.compose(cursor).ok()?;+ let (mut context, _) = evidence.clone().compose(cursor).ok()?;context.retain_new_instructions(conversation.snapshot()@@ -53,6 +53,7 @@ impl LunaSamplingRequest {});}let truncations = std::mem::take(&mut context.truncations);+ let section_costs = context.section_costs().collect();let history = conversation.snapshot().map(ConversationCheckpoint::history);let existing_context_tokens = history.map_or(0, |history| {history@@ -80,6 +81,7 @@ impl LunaSamplingRequest {input,cursor: next_cursor,truncations,+ section_costs,existing_context_tokens,input_tokens,})@@ -92,6 +94,7 @@ pub(super) struct PreparedRequest<'a> {pub(super) input: Vec<ResponseItemEnvelope>,pub(super) cursor: TranscriptCursor,pub(super) truncations: Vec<TruncationObservation>,+ pub(super) section_costs: Vec<(&'static str, codex_guardian_context::SectionCost)>,pub(super) existing_context_tokens: usize,pub(super) input_tokens: usize,}diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/retained_sampling_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/retained_sampling_tests.rsindex 86e57dbcc0..a4e2baab40 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/retained_sampling_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/retained_sampling_tests.rs@@ -47,6 +47,7 @@ async fn retained_websocket_requests_preserve_model_output_and_ids() -> Result<(transcript_entry_count: 0,},truncations: Vec::new(),+ section_costs: Vec::new(),};let (completed, score) = tokio::join!(sampler.sample_retained(prepared, ready), score);assert_eq!(score??, "low");@@ -142,6 +143,7 @@ async fn retention_overflow_or_incomplete_stream_keeps_early_score() -> Result<(transcript_entry_count: 0,},truncations: Vec::new(),+ section_costs: Vec::new(),};let (history, score) = tokio::join!(sampler.sample_retained(prepared, ready), score);assert_eq!(score??, "low");diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rsindex ec29d65cb2..e5bad22b83 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs@@ -115,6 +115,9 @@ pub enum LunaSamplerError {/// The complete classifier input exceeded the model allowance.#[error("Luna input exceeds the complete request budget")]InputTooLarge,+ /// The retained conversation already owns its maximum outstanding work.+ #[error("Guardian conversation queue is full")]+ QueueFull,}struct ActiveRequest {@@ -277,20 +280,11 @@ impl LunaSampler {.into_iter().map(ResponseItemEnvelope::into_item).collect();- if let Some(metrics) = self.config.metrics.as_deref() {- for (component, tokens) in [- ("existing_context", 0),- ("new_input", total_tokens),- ("total", total_tokens),- ] {- metrics.histogram_with_boundaries(- codex_guardian_context::REQUEST_TOKENS_METRIC,- i64::try_from(tokens).unwrap_or(i64::MAX),- codex_guardian_context::REQUEST_TOKENS_BOUNDARIES,- &[("target", "async"), ("component", component)],- );- }- }+ super::metrics::record_request_tokens(+ self.config.metrics.as_deref(),+ /*existing*/ 0,+ total_tokens,+ );// Oversized classifications defer to sync with the existing failure score.if total_tokens > self.config.max_input_tokens.saturating_sub(/*rhs*/ 256) {return Err(LunaSamplerError::InputTooLarge);@@ -322,8 +316,11 @@ impl LunaSampler {.await}+ pub(super) fn max_input_tokens(&self) -> usize {+ self.config.max_input_tokens+ }+/// Publishes the early score and returns only validated, completed history.- #[cfg_attr(not(test), allow(dead_code))]pub(super) async fn sample_retained(&self,prepared: PreparedRequest<'_>,diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rsindex 0646955ff3..2affc8c3df 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rs@@ -161,6 +161,7 @@ impl SamplingExecution {| LunaSamplerError::Superseded| LunaSamplerError::IncompatibleCompaction| LunaSamplerError::InputTooLarge+ | LunaSamplerError::QueueFull| LunaSamplerError::Api(ApiError::Transport(TransportError::Build(_)diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rsindex 674f859210..aa9eb7e9b8 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs@@ -202,7 +202,7 @@ pub(in crate::async_scorer) async fn proxy_websocket_servers_with_http(Ok(format!("http://{address}/v1"))}-pub(super) fn sampler_config(base_url: String) -> LunaSamplerConfig {+pub(in crate::async_scorer) fn sampler_config(base_url: String) -> LunaSamplerConfig {LunaSamplerConfig {workspace_routing: codex_model_provider::WorkspaceRoutingContext::new("https://chatgpt.com/backend-api".into(),@@ -262,7 +262,7 @@ fn assert_classifier_instructions(request: &serde_json::Value) {);}-pub(super) fn sample_request(parent_turn_id: &str) -> LunaSamplingRequest {+pub(in crate::async_scorer) fn sample_request(parent_turn_id: &str) -> LunaSamplingRequest {LunaSamplingRequest {parent_response_id: None,instructions: classifier_instructions(),diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rs b/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rsindex 016a6fa5eb..23a25653f7 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/transcript.rs@@ -88,15 +88,7 @@ impl TranscriptConfig {&self,input: ContextInput<'_>,) -> Result<RenderedContext, SectionError> {- let collected = self.collect_context(input)?;- let transcript = collected.profile.render_transcript(- collected.context.transcript_entries(),- /*entry_number_offset*/ 0,- );- let mut context = collected- .context- .compose(ContextPresentation::Async, transcript)?;- // Each snapshot deduplicates only against the evidence in its own request.+ let (mut context, _) = self.collect_context(input)?.compose(/*cursor*/ None)?;context.deduplicate_transcript_instructions();Ok(context)}@@ -186,7 +178,7 @@ impl CollectedTranscript {}pub(super) fn compose(- &self,+ self,cursor: Option<TranscriptCursor>,) -> Result<(ComposedContext, TranscriptCursor), SectionError> {let (selection, next) = self.select(cursor);@@ -197,7 +189,7 @@ impl CollectedTranscript {}};let transcript = self.profile.render_transcript(entries, offset);- let context = self.context.clone().compose(presentation, transcript)?;+ let context = self.context.compose(presentation, transcript)?;Ok((context, next))}}diff --git a/codex-rs/features/src/feature_configs.rs b/codex-rs/features/src/feature_configs.rsindex f6b660d5dd..22d04dc54a 100644--- a/codex-rs/features/src/feature_configs.rs+++ b/codex-rs/features/src/feature_configs.rs@@ -149,6 +149,14 @@ pub struct GuardianV2ReviewScopeConfigToml {#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, JsonSchema)]#[serde(deny_unknown_fields)]pub struct GuardianV2ConfigToml {+ /// Classifier experiment override. Otherwise use the model default, then snapshots.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub async_classifier_mode: Option<codex_protocol::openai_models::AsyncClassifierMode>,+ /// Reset retained async history when the next request exceeds this token estimate.+ /// Defaults to 100,000. Fresh requests remain subject to the model's input limit.+ #[serde(skip_serializing_if = "Option::is_none")]+ #[schemars(range(min = 1))]+ pub async_classifier_conversation_token_limit: Option<usize>,#[serde(skip_serializing_if = "Option::is_none")]pub enabled: Option<bool>,/// Legacy setting retained for config compatibility; the backend now controls Guardian billing.@@ -215,6 +223,11 @@ where}let transcript = config.transcript.as_ref();+ if config.async_classifier_conversation_token_limit == Some(0) {+ return Err(serde::de::Error::custom(+ "Guardian v2 async_classifier_conversation_token_limit must be positive",+ ));+ }let message_entry = transcript.and_then(|value| value.max_message_entry_tokens);let tool_entry = transcript.and_then(|value| value.max_tool_entry_tokens);let message_total = transcript.and_then(|value| value.max_message_transcript_tokens);diff --git a/codex-rs/features/src/tests.rs b/codex-rs/features/src/tests.rsindex ae0a10bd7e..f9b235db74 100644--- a/codex-rs/features/src/tests.rs+++ b/codex-rs/features/src/tests.rs@@ -232,6 +232,7 @@ persist_scores = trueclassifier_instructions = "Review this action"review_threshold = 0.65max_tool_call_lag = 2+async_classifier_conversation_token_limit = 120000reasoning_effort = "minimal"max_action_tokens = 512max_classifier_instruction_tokens = 256@@ -257,6 +258,8 @@ max_recent_non_user_entries = 12assert_eq!(features.guardianv2,Some(FeatureToml::Config(crate::GuardianV2ConfigToml {+ async_classifier_mode: None,+ async_classifier_conversation_token_limit: Some(120_000),enabled: Some(true),free_guardian: Some(true),thread_context: None,@@ -317,6 +320,7 @@ fn guardian_v2_feature_config_rejects_invalid_settings() {"review_threshold = -0.1","review_threshold = 1.1","review_threshold = nan",+ "async_classifier_conversation_token_limit = 0","transcript.max_recent_non_user_entries = 0","transcript.max_message_entry_tokens = 200\ntranscript.max_message_transcript_tokens = 100","transcript.max_tool_entry_tokens = 200\ntranscript.max_tool_transcript_tokens = 100",diff --git a/codex-rs/guardian-context/src/retained_instructions.rs b/codex-rs/guardian-context/src/retained_instructions.rsindex b2aae41076..9e1299b575 100644--- a/codex-rs/guardian-context/src/retained_instructions.rs+++ b/codex-rs/guardian-context/src/retained_instructions.rs@@ -2,8 +2,8 @@//! The host owns storage and lifecycle. Omitted records remain explicit; restrictions//! are never truncated into partial permissions, and retained source order is preserved.//! Section omissions do not change fast-approval eligibility.-//! Sync delivery compares against admitted reviewer history, so forks and compaction-//! need no separate retained-evidence cursor. Async deduplication is request-local.+//! Retained delivery compares against admitted reviewer history, so forks and compaction+//! need no separate retained-evidence cursor. Snapshot deduplication is request-local.use std::collections::HashSet;@@ -175,7 +175,7 @@ impl ComposedContext {}}- /// Each async sample carries its own originals and ordering guidance.+ /// Each independent async sample carries its own originals and ordering guidance.pub fn deduplicate_transcript_instructions(&mut self) {self.remove_delivered_instructions(&[]);}diff --git a/codex-rs/protocol/src/openai_models.rs b/codex-rs/protocol/src/openai_models.rsindex e5f02ac9e8..b2dde1499e 100644--- a/codex-rs/protocol/src/openai_models.rs+++ b/codex-rs/protocol/src/openai_models.rs@@ -46,6 +46,7 @@ mod guardian_v2;mod reasoning_effort;pub use access_programs::ModelAccessPrograms;+pub use guardian_v2::AsyncClassifierMode;pub use guardian_v2::GuardianV2ModelConfig;pub use guardian_v2::GuardianV2TranscriptModelConfig;diff --git a/codex-rs/protocol/src/openai_models/guardian_v2.rs b/codex-rs/protocol/src/openai_models/guardian_v2.rsindex 953a89a4e7..c13a0dca9b 100644--- a/codex-rs/protocol/src/openai_models/guardian_v2.rs+++ b/codex-rs/protocol/src/openai_models/guardian_v2.rs@@ -5,9 +5,24 @@ use ts_rs::TS;use super::ReasoningEffort;+/// Async classifier experiment, resolved once for each parent task.+#[derive(Debug, Default, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, TS, JsonSchema)]+#[serde(rename_all = "snake_case")]+#[ts(rename_all = "snake_case")]+pub enum AsyncClassifierMode {+ #[default]+ Snapshot,+ Conversation,+}+/// Optional model-owned defaults for Guardian v2 classification experiments.#[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq, Eq, TS, JsonSchema)]pub struct GuardianV2ModelConfig {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub async_classifier_mode: Option<AsyncClassifierMode>,+ /// Reset retained async history when the next request exceeds this token estimate.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub async_classifier_conversation_token_limit: Option<usize>,#[serde(default, skip_serializing_if = "Option::is_none")]pub classifier_instructions: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]