From 1e66885a16161048215a3782ecdd1739aab0aabf Mon Sep 17 00:00:00 2001 From: jif Date: Mon, 7 Sep 2026 17:02:46 +0000 Subject: [PATCH] Discount an approval's own code-mode wrapper from Guardian score lag (#43527) ## Why A code-mode `exec` wrapper and its nested tool calls each advance Guardian's score lag. Counting the unscored wrapper against its own nested approval can trigger a synchronous review sooner than needed. ## What changed Track originating response items and approval tool-call IDs so cached approvals discount their own wrapper when it is newer than the latest score. Preserve wrapper identity across yields and waits, and retain the full lag when provenance is missing or evicted. Other wrappers and scoring failures still count. Use the current `write_stdin` call's identity for approval freshness, and omit tool-call identity for `execve` intercepts that only retain the launch ID. ## Testing Add coverage for wrapper-specific discounts, already-scored wrappers, missing and evicted provenance, identity across code-mode resumes, and approval identities for stdin writes and `execve` intercepts. GitOrigin-RevId: 4002a06d64c4e1e0a13c072303503d6ddfacad09 --- codex-rs/core/src/guardian/decision.rs | 14 +++ codex-rs/core/src/tools/lifecycle.rs | 2 + codex-rs/core/tests/suite/code_mode.rs | 21 ++++ codex-rs/core/tests/suite/guardian_review.rs | 3 +- .../suite/unified_exec_stdin_approval.rs | 37 +++++- .../suite/unified_exec_zsh_fork_approvals.rs | 21 ++++ .../src/contributors/approval_review.rs | 2 + .../src/contributors/tool_lifecycle.rs | 3 + codex-rs/ext/extension-api/tests/registry.rs | 1 + .../guardian-v2/src/async_scorer/approval.rs | 7 +- .../guardian-v2/src/async_scorer/extension.rs | 10 +- .../src/async_scorer/extension_tests.rs | 117 ++++++++++++++++++ .../ext/guardian-v2/src/async_scorer/mod.rs | 1 + .../src/async_scorer/wrapper_lag.rs | 75 +++++++++++ 14 files changed, 306 insertions(+), 8 deletions(-) create mode 100644 codex-rs/ext/guardian-v2/src/async_scorer/wrapper_lag.rs diff --git a/codex-rs/core/src/guardian/decision.rs b/codex-rs/core/src/guardian/decision.rs index 11f9b641f2..aa3d039cde 100644 --- a/codex-rs/core/src/guardian/decision.rs +++ b/codex-rs/core/src/guardian/decision.rs @@ -119,6 +119,20 @@ pub(crate) async fn decide_approval( }; let input = ApprovalDecisionInput { approval_id: &review_id, + tool_call_id: request + .request + .as_ref() + .ok() + .and_then(|request| match request { + // Stdin's target is the terminal launch; freshness belongs to this write. + GuardianApprovalRequest::WriteStdin { approval_id, .. } => { + Some(approval_id.as_str()) + } + // Intercepts retain the launch ID, not the current triggering call. + #[cfg(unix)] + GuardianApprovalRequest::Execve { .. } => None, + _ => super::approval_request::guardian_request_target_item_id(request), + }), action, thread_id: session.thread_id, thread_store: &session.services.thread_extension_data, diff --git a/codex-rs/core/src/tools/lifecycle.rs b/codex-rs/core/src/tools/lifecycle.rs index bea620e154..0d3a0ecf1a 100644 --- a/codex-rs/core/src/tools/lifecycle.rs +++ b/codex-rs/core/src/tools/lifecycle.rs @@ -29,6 +29,7 @@ pub(crate) async fn notify_tool_start( let thread_store = &invocation.session.services.thread_extension_data; let conversation_history = invocation.session.conversation_history_snapshot().await; let root_turn_id = invocation.turn.turn_metadata_state.root_turn_id(); + let originating_item_id = invocation.originating_item_id().await; for contributor in contributors { contributor @@ -39,6 +40,7 @@ pub(crate) async fn notify_tool_start( turn_id: invocation.turn.sub_id.as_str(), root_turn_id: root_turn_id.as_deref(), call_id: invocation.call_id.as_str(), + originating_item_id: originating_item_id.as_ref(), tool_name: &invocation.tool_name, mcp_tool, payload: &invocation.payload, diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rs index b7c6b3c1b9..1d5cc70a0e 100644 --- a/codex-rs/core/tests/suite/code_mode.rs +++ b/codex-rs/core/tests/suite/code_mode.rs @@ -2375,12 +2375,19 @@ async fn code_mode_wait_timeout_reconnects_on_next_exec() -> Result<()> { #[derive(Default)] struct ResponseIdObserver { response_ids: Mutex)>>, + originating_items: Mutex)>>, wait_started: tokio::sync::Notify, } impl ToolLifecycleContributor for ResponseIdObserver { fn on_tool_start<'a>(&'a self, input: ToolStartInput<'a>) -> ToolLifecycleFuture<'a> { Box::pin(async move { + if matches!(input.tool_name.name.as_str(), "exec" | "exec_command") { + self.originating_items.lock().unwrap().push(( + input.tool_name.name.clone(), + input.originating_item_id.cloned(), + )); + } if matches!(input.tool_name.name.as_str(), "exec_command" | "wait") { self.response_ids.lock().unwrap().push(( input.tool_name.name.clone(), @@ -2551,6 +2558,20 @@ text((await tools.exec_command({{cmd: "printf 'phase 3'"}})).output); ); assert_eq!(text_item(&third_items, /*index*/ 1), "phase 3"); + // Resuming the cell changes the response id, but its nested calls retain + // the original exec item's identity for request-local freshness accounting. + let originating_items = observer.originating_items.lock().unwrap(); + let wrapper_item = originating_items[0] + .1 + .clone() + .expect("wrapper item identity"); + assert!(originating_items.len() >= 3); + assert!( + originating_items + .iter() + .all(|(_, item)| item.as_ref() == Some(&wrapper_item)) + ); + let observed = observer.response_ids.lock().unwrap(); let mut nested_response_ids = observed .iter() diff --git a/codex-rs/core/tests/suite/guardian_review.rs b/codex-rs/core/tests/suite/guardian_review.rs index ea0a27b8b4..e7645e2d55 100644 --- a/codex-rs/core/tests/suite/guardian_review.rs +++ b/codex-rs/core/tests/suite/guardian_review.rs @@ -1568,9 +1568,10 @@ async fn guardian_timeout_rejects_tool_call_with_acting_model_instructions( impl codex_extension_api::ApprovalReviewContributor for TimedOutReviewContributor { fn decide<'a>( &'a self, - _input: &'a codex_extension_api::ApprovalDecisionInput<'_>, + input: &'a codex_extension_api::ApprovalDecisionInput<'_>, ) -> codex_extension_api::ExtensionFuture<'a, Option> { + assert_eq!(input.tool_call_id, Some("exec-call-timed-out")); Box::pin(async { Some(codex_extension_api::ApprovalDecision::Reviewed( ReviewDecision::TimedOut, diff --git a/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs b/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs index dce26e37f5..d602b03a49 100644 --- a/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs +++ b/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs @@ -2,7 +2,9 @@ use anyhow::Result; use codex_core::TurnInputRequest; +use codex_core::config::Config; use codex_core::config::Constrained; +use codex_extension_api::ExtensionRegistryBuilder; use codex_features::Feature; use codex_protocol::approvals::ExecApprovalKind; use codex_protocol::models::AdditionalPermissionProfile; @@ -26,6 +28,7 @@ use core_test_support::responses::sse; use core_test_support::skip_if_no_network; use core_test_support::skip_if_sandbox; use core_test_support::skip_if_target_windows; +use core_test_support::test_codex::TestCodexBuilder; use core_test_support::test_codex::TestCodexHarness; use core_test_support::test_codex::test_codex; use core_test_support::wait_for_event; @@ -33,6 +36,8 @@ use core_test_support::wait_for_event_match; use pretty_assertions::assert_eq; use serde_json::Value; use serde_json::json; +use std::sync::Arc; +use std::sync::Mutex; fn tool_response(id: &str, tool: &str, args: Value) -> String { sse(vec![ @@ -41,8 +46,8 @@ fn tool_response(id: &str, tool: &str, args: Value) -> String { ]) } -async fn harness() -> Result { - TestCodexHarness::with_auto_env_builder(test_codex().with_config(|config| { +async fn harness(builder: TestCodexBuilder) -> Result { + TestCodexHarness::with_auto_env_builder(builder.with_config(|config| { for feature in [ Feature::WriteStdinApproval, Feature::ExecPermissionApprovals, @@ -67,7 +72,7 @@ async fn stdin_reviews_retained_grants_after_turn_permissions_expire() -> Result skip_if_target_windows!(Ok(()), "uses a POSIX interactive shell"); skip_if_no_network!(Ok(())); skip_if_sandbox!(Ok(())); - let harness = harness().await?; + let harness = harness(test_codex()).await?; let test = harness.test(); harness.create_dir_all("allowed").await?; let directory = test @@ -193,7 +198,27 @@ async fn strict_stdin_review_reaches_guardian_with_sandbox_prompts_disabled() -> skip_if_target_windows!(Ok(()), "uses a POSIX interactive shell"); skip_if_no_network!(Ok(())); skip_if_sandbox!(Ok(())); - let harness = harness().await?; + #[derive(Default)] + struct ReviewedCalls(Mutex>); + + impl codex_extension_api::ApprovalReviewContributor for ReviewedCalls { + fn decide<'a>( + &'a self, + input: &'a codex_extension_api::ApprovalDecisionInput<'_>, + ) -> codex_extension_api::ExtensionFuture<'a, Option> + { + self.0 + .lock() + .unwrap() + .push(input.tool_call_id.expect("reviewed call id").to_owned()); + Box::pin(async { None }) + } + } + + let calls = Arc::new(ReviewedCalls::default()); + let mut extensions = ExtensionRegistryBuilder::::new(); + extensions.approval_review_contributor(calls.clone()); + let harness = harness(test_codex().with_extensions(Arc::new(extensions.build()))).await?; let test = harness.test(); let opened = mount_sse_sequence( harness.server(), @@ -269,6 +294,10 @@ async fn strict_stdin_review_reaches_guardian_with_sandbox_prompts_disabled() -> }) .await; let requests = writes.requests(); + assert_eq!( + *calls.0.lock().unwrap(), + vec!["strict", "denied", "allowed"] + ); assert_eq!( requests .iter() diff --git a/codex-rs/core/tests/suite/unified_exec_zsh_fork_approvals.rs b/codex-rs/core/tests/suite/unified_exec_zsh_fork_approvals.rs index cbef67fbb0..d8c8a9677b 100644 --- a/codex-rs/core/tests/suite/unified_exec_zsh_fork_approvals.rs +++ b/codex-rs/core/tests/suite/unified_exec_zsh_fork_approvals.rs @@ -4,7 +4,9 @@ use codex_config::permissions_toml::FilesystemPermissionToml; use codex_config::permissions_toml::PermissionProfileToml; use codex_config::types::ApprovalsReviewer; use codex_core::TurnInputRequest; +use codex_core::config::Config; use codex_core::sandboxing::SandboxPermissions; +use codex_extension_api::ExtensionRegistryBuilder; use codex_features::Feature; use codex_protocol::config_types::CollaborationMode; use codex_protocol::config_types::ModeKind; @@ -50,6 +52,7 @@ use serde_json::Value; use serde_json::json; use std::fs; use std::path::Path; +use std::sync::Arc; use std::time::Duration; use toml_edit::Key as TomlKey; use wiremock::MockServer; @@ -649,8 +652,26 @@ where return Ok(None); }; + struct ExecveIdentityCheck; + + impl codex_extension_api::ApprovalReviewContributor for ExecveIdentityCheck { + fn decide<'a>( + &'a self, + input: &'a codex_extension_api::ApprovalDecisionInput<'_>, + ) -> codex_extension_api::ExtensionFuture<'a, Option> + { + if input.action.get("program").is_some() { + assert_eq!(input.tool_call_id, None); + } + Box::pin(async { None }) + } + } + + let mut extensions = ExtensionRegistryBuilder::::new(); + extensions.approval_review_contributor(Arc::new(ExecveIdentityCheck)); let server = start_mock_server().await; let test = zsh_fork_test_builder(runtime, approval_policy) + .with_extensions(Arc::new(extensions.build())) .with_pre_build_hook(pre_build_hook) .with_config(move |config| { config diff --git a/codex-rs/ext/extension-api/src/contributors/approval_review.rs b/codex-rs/ext/extension-api/src/contributors/approval_review.rs index fe1c342b26..218998c61e 100644 --- a/codex-rs/ext/extension-api/src/contributors/approval_review.rs +++ b/codex-rs/ext/extension-api/src/contributors/approval_review.rs @@ -74,6 +74,8 @@ pub trait SynchronousApprovalReviewer: Send + Sync { /// Inputs to Guardian's policy choice. Conversation and scores stay thread-owned. pub struct ApprovalDecisionInput<'a> { pub approval_id: &'a str, + /// Host tool invocation being approved, absent for approvals without a tool call. + pub tool_call_id: Option<&'a str>, pub action: &'a serde_json::Value, pub thread_id: ThreadId, pub thread_store: &'a ExtensionData, diff --git a/codex-rs/ext/extension-api/src/contributors/tool_lifecycle.rs b/codex-rs/ext/extension-api/src/contributors/tool_lifecycle.rs index 7842805c83..eb8c8154d4 100644 --- a/codex-rs/ext/extension-api/src/contributors/tool_lifecycle.rs +++ b/codex-rs/ext/extension-api/src/contributors/tool_lifecycle.rs @@ -127,6 +127,9 @@ pub struct ToolStartInput<'a> { pub root_turn_id: Option<&'a str>, /// Model-visible tool call id. pub call_id: &'a str, + /// Responses item that issued this call or started its code-mode cell. + /// Hosts preserve the original wrapper identity across yields and waits. + pub originating_item_id: Option<&'a codex_protocol::ResponseItemId>, /// Tool name as routed by the host. pub tool_name: &'a ToolName, /// Read-only metadata and provenance from the exact MCP call that will execute. diff --git a/codex-rs/ext/extension-api/tests/registry.rs b/codex-rs/ext/extension-api/tests/registry.rs index c354628382..b58f45384a 100644 --- a/codex-rs/ext/extension-api/tests/registry.rs +++ b/codex-rs/ext/extension-api/tests/registry.rs @@ -205,6 +205,7 @@ async fn build_round_trips_every_contributor_category() { let thread_store = ExtensionData::new("thread"); let input = codex_extension_api::ApprovalDecisionInput { approval_id: "approval-1", + tool_call_id: None, action: &serde_json::Value::Null, thread_id: codex_protocol::ThreadId::new(), thread_store: &thread_store, diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/approval.rs b/codex-rs/ext/guardian-v2/src/async_scorer/approval.rs index fb96cbcac4..9f7ebb085f 100644 --- a/codex-rs/ext/guardian-v2/src/async_scorer/approval.rs +++ b/codex-rs/ext/guardian-v2/src/async_scorer/approval.rs @@ -183,7 +183,12 @@ async fn cached_evidence( let lag = progress .latest_tool_call .load(Ordering::Acquire) - .saturating_sub(latest_scored); + .saturating_sub(latest_scored) + .saturating_sub( + progress + .wrapper_lag + .discount(input.tool_call_id, latest_scored), + ); if let Some(metrics) = metrics { metrics.histogram( TOOL_CALL_LAG_METRIC, diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs index 08659e95a4..53936df385 100644 --- a/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs +++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs @@ -64,6 +64,7 @@ use super::truncation::ClassificationTruncations; use super::trusted_skills::TrustedSkillInvocations; use super::trusted_skills::TrustedSkillRoots; use super::trusted_tools::trusted_tool_context; +use super::wrapper_lag::WrapperLag; enum ClassificationOutcome { Scored, @@ -72,6 +73,7 @@ enum ClassificationOutcome { #[derive(Default)] pub(super) struct GuardianV2ScoreProgress { + pub(super) wrapper_lag: WrapperLag, pub(super) latest_tool_call: AtomicUsize, // Setup and reset calls must not consume the first JS execution allowance. pub(super) js_executions: AtomicUsize, @@ -276,15 +278,18 @@ impl GuardianV2Extension { match policy.unscored_action { UnscoredAction::Ignore => {} UnscoredAction::AgeScore => { - score_progress + let index = score_progress .latest_tool_call - .fetch_add(/*val*/ 1, Ordering::Relaxed); + .fetch_add(/*val*/ 1, Ordering::Relaxed) + .saturating_add(/*rhs*/ 1); + score_progress.wrapper_lag.record(&input, index); } UnscoredAction::InvalidateScore => { let index = score_progress .latest_tool_call .fetch_add(/*val*/ 1, Ordering::Relaxed) .saturating_add(/*rhs*/ 1); + score_progress.wrapper_lag.record(&input, index); score_progress .latest_failed_tool_call .fetch_max(index, Ordering::Release); @@ -307,6 +312,7 @@ impl GuardianV2Extension { .latest_tool_call .fetch_add(/*val*/ 1, Ordering::Relaxed) .saturating_add(/*rhs*/ 1); + score_progress.wrapper_lag.record(&input, tool_call_index); 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(); 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.rs index 19be463a6b..e3a7cc6314 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 @@ -270,6 +270,7 @@ async fn installed_extension_uses_http_after_warm_socket_auth_expires() -> Resul turn_id: "turn-1", root_turn_id: None, call_id, + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &payload, @@ -543,6 +544,7 @@ async fn sandboxed_shell_classification_respects_review_scope() -> Result<()> { turn_id: "turn-1", root_turn_id: None, call_id: "call-2", + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &payload, @@ -634,6 +636,7 @@ async fn computer_use_only_scores_cannot_approve_other_actions() -> Result<()> { turn_id: "turn-1", root_turn_id: None, call_id: "ordinary-call", + originating_item_id: None, tool_name: &ordinary_tool, mcp_tool: None, payload: &payload, @@ -946,6 +949,7 @@ async fn sample_configured_conversation_history_with_source( turn_id: "turn-1", root_turn_id: Some("root-turn"), call_id: "call-1", + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &tool_payload, @@ -1080,6 +1084,7 @@ impl GuardianFailureFixture { turn_id: "turn-1", root_turn_id: None, call_id: "call-1", + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &payload, @@ -2248,6 +2253,7 @@ async fn contributor_skips_required_models_in_standard_scope() -> Result<()> { turn_id: "turn-1", root_turn_id: None, call_id: "protected.md", + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &payload, @@ -2505,6 +2511,7 @@ async fn contributor_counts_failed_thread_lookups_toward_score_lag() -> Result<( turn_id: "turn-1", root_turn_id: None, call_id: "missing.md", + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &payload, @@ -2997,6 +3004,7 @@ async fn assert_parent_compaction_reuse(thread_context_enabled: bool) -> Result< turn_id: "turn-1", root_turn_id: None, call_id: "call-1", + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &tool_payload, @@ -3072,6 +3080,7 @@ async fn assert_parent_compaction_reuse(thread_context_enabled: bool) -> Result< turn_id: "turn-1", root_turn_id: None, call_id: "call-2", + originating_item_id: None, tool_name: &tool_name, mcp_tool: None, payload: &tool_payload, @@ -3249,6 +3258,113 @@ impl codex_extension_api::SynchronousApprovalReviewer for CacheMiss { } } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn cached_approval_discounts_only_its_own_unscored_wrapper() -> Result<()> { + skip_if_no_network!(Ok(())); + let fixture = GuardianFailureFixture::new().await?; + let store = fixture.test.codex.thread_extension_data(); + let progress = store.get::().unwrap(); + let mut score = store.get::().unwrap().as_ref().clone(); + score.scores.insert("action_risk".to_owned(), 0.0); + store.insert(score); + // Hold the cached score fixed while advancing real tool-start metadata. + let start = |call_id: &str, origin: &ResponseItemId, source: ToolCallSource| { + let tool_name = match source { + ToolCallSource::Direct => ToolName::plain("exec"), + ToolCallSource::CodeMode { .. } => ToolName::namespaced("mcp__example", "read"), + }; + let payload = match source { + ToolCallSource::Direct => ToolPayload::Custom { + input: String::new(), + }, + ToolCallSource::CodeMode { .. } => ToolPayload::Function { + arguments: "{}".to_owned(), + }, + }; + let index = progress + .latest_tool_call + .fetch_add(/*val*/ 1, Ordering::Relaxed) + + 1; + progress.wrapper_lag.record( + &ToolStartInput { + session_store: &fixture.session_store, + thread_store: store, + turn_store: &fixture.session_store, + turn_id: "turn", + root_turn_id: None, + call_id, + originating_item_id: Some(origin), + tool_name: &tool_name, + mcp_tool: None, + payload: &payload, + conversation_history: Arc::new(TestConversationHistory(Vec::new())), + source, + }, + index, + ); + index + }; + let approve = async |call_id: &str| { + cached_approval( + &fixture.registry, + store, + &json!({"tool": "mcp_tool_call", "server": "example", "id": call_id}).to_string(), + /*metrics*/ None, + ) + .await + }; + let nested = ToolCallSource::CodeMode { + cell_id: "cell".to_owned(), + runtime_tool_call_id: "nested".to_owned(), + }; + let origin = ResponseItemId::from_server("wrapper".to_owned()); + let wrapper = start("wrapper", &origin, ToolCallSource::Direct); + for (call_id, expected) in [ + ("first", Some(ReviewDecision::Approved)), + ("second", Some(ReviewDecision::Approved)), + ("third", None), + ] { + start(call_id, &origin, nested.clone()); + assert_eq!(approve(call_id).await, expected); + } + // A score covering the wrapper must not receive another discount. + progress + .latest_scored_tool_call + .store(wrapper, Ordering::Release); + assert_eq!(approve("third").await, None); + progress + .latest_scored_tool_call + .store(wrapper + 3, Ordering::Release); + let output = start("output-only", &origin, ToolCallSource::Direct); + let other = ResponseItemId::from_server("other-wrapper".to_owned()); + start("other-wrapper", &other, ToolCallSource::Direct); + start("other-first", &other, nested.clone()); + assert_eq!(approve("other-first").await, Some(ReviewDecision::Approved)); + assert_eq!(approve("unknown").await, None); + start("other-second", &other, nested.clone()); + assert_eq!(approve("other-second").await, None); + // Covering a different wrapper still leaves this call's parent in its lag. + progress + .latest_scored_tool_call + .store(output, Ordering::Release); + assert_eq!( + approve("other-second").await, + Some(ReviewDecision::Approved) + ); + // Evicted provenance falls back to the full lag. + for _ in 0..300 { + start("output-only", &origin, ToolCallSource::Direct); + } + start("late-child", &other, nested); + assert_eq!( + progress + .wrapper_lag + .discount(Some("late-child"), /*latest_scored*/ 0), + 0 + ); + Ok(()) +} + /// Exercises decision routing; a fresh review is observed as a cache miss. async fn cached_approval( registry: &codex_extension_api::ExtensionRegistry, @@ -3275,6 +3391,7 @@ async fn cached_approval( }; let input = codex_extension_api::ApprovalDecisionInput { approval_id: "cache-probe", + tool_call_id: action.get("id").and_then(serde_json::Value::as_str), action: &action, thread_id: codex_protocol::ThreadId::from_string(store.level_id()).unwrap(), thread_store: store, diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/mod.rs b/codex-rs/ext/guardian-v2/src/async_scorer/mod.rs index 82ce4d2036..5c404d2c92 100644 --- a/codex-rs/ext/guardian-v2/src/async_scorer/mod.rs +++ b/codex-rs/ext/guardian-v2/src/async_scorer/mod.rs @@ -12,6 +12,7 @@ mod transcript; mod truncation; mod trusted_skills; mod trusted_tools; +mod wrapper_lag; pub(crate) use config::DEFAULT_MODEL_CONTEXT_ITEM_TOKENS; pub(crate) use config::GuardianV2Config; diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/wrapper_lag.rs b/codex-rs/ext/guardian-v2/src/async_scorer/wrapper_lag.rs new file mode 100644 index 0000000000..bde42597b3 --- /dev/null +++ b/codex-rs/ext/guardian-v2/src/async_scorer/wrapper_lag.rs @@ -0,0 +1,75 @@ +//! Discounts only an approval's own unscored code-mode wrapper. Missing provenance +//! keeps the full lag; the bounded history never changes scoring or failure order. + +use std::collections::VecDeque; +use std::sync::Mutex; + +use codex_extension_api::ToolCallSource; +use codex_extension_api::ToolPayload; +use codex_extension_api::ToolStartInput; +use codex_protocol::ResponseItemId; + +struct ToolStart { + call_id: String, + index: usize, + wrapper_item_id: Option, + parent_wrapper_index: Option, +} + +#[derive(Default)] +pub(super) struct WrapperLag(Mutex>); + +impl WrapperLag { + pub(super) fn record(&self, input: &ToolStartInput<'_>, index: usize) { + let mut starts = self + .0 + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let parent_wrapper_index = match &input.source { + ToolCallSource::CodeMode { .. } => input.originating_item_id.and_then(|item_id| { + starts + .iter() + .rev() + .find(|start| start.wrapper_item_id.as_ref() == Some(item_id)) + .map(|start| start.index) + }), + ToolCallSource::Direct => None, + }; + let wrapper_item_id = if input.tool_name.is_default_namespace() + && input.tool_name.name == "exec" + && matches!(input.payload, ToolPayload::Custom { .. }) + && matches!(input.source, ToolCallSource::Direct) + { + input.originating_item_id.cloned() + } else { + None + }; + if starts.len() == 256 { + starts.pop_front(); + } + starts.push_back(ToolStart { + call_id: input.call_id.to_owned(), + index, + wrapper_item_id, + parent_wrapper_index, + }); + } + + pub(super) fn discount(&self, call_id: Option<&str>, latest_scored: usize) -> usize { + let starts = self + .0 + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + usize::from( + call_id + .and_then(|call_id| { + starts + .iter() + .rev() + .find(|start| start.call_id == call_id) + .and_then(|start| start.parent_wrapper_index) + }) + .is_some_and(|parent| parent > latest_scored), + ) + } +}