Lightweight coding agent that runs in your terminal
Rust
Measure Guardian approval blocking time per turn (#55591)
ioanbudea-OAI60d78332fc6a
diff --git a/codex-rs/core/src/tasks/lifecycle.rs b/codex-rs/core/src/tasks/lifecycle.rsindex afecaede5a..07a2c850a8 100644--- a/codex-rs/core/src/tasks/lifecycle.rs+++ b/codex-rs/core/src/tasks/lifecycle.rs@@ -21,6 +21,9 @@ impl Session {) {let metadata: Arc<dyn TurnAnalyticsMetadata> = turn_context.turn_metadata_state.clone();turn_context.extension_data.insert(metadata);+ turn_context+ .extension_data+ .insert(turn_context.session_telemetry.clone());let collaboration_mode = turn_context.collaboration_mode();for contributor in self.services.extensions.turn_lifecycle_contributors() {if contributor.turn_start_phase(&self.services.thread_extension_data) != phase {diff --git a/codex-rs/core/tests/suite/guardian_mcp_elicitation.rs b/codex-rs/core/tests/suite/guardian_mcp_elicitation.rsindex ab6bf48c1f..1193fe6648 100644--- a/codex-rs/core/tests/suite/guardian_mcp_elicitation.rs+++ b/codex-rs/core/tests/suite/guardian_mcp_elicitation.rs@@ -8,6 +8,8 @@ use codex_extension_api::ExtensionRegistryBuilder;use codex_extension_api::McpServerContribution;use codex_extension_api::McpServerContributionContext;use codex_extension_api::McpServerContributor;+use codex_otel::MetricsClient;+use codex_otel::MetricsConfig;use codex_protocol::config_types::ApprovalsReviewer;use codex_protocol::items::McpToolCallStatus;use codex_protocol::items::TurnItem;@@ -27,9 +29,12 @@ use core_test_support::test_codex::local_requests;use core_test_support::test_codex::test_codex;use core_test_support::wait_for_event;use core_test_support::wait_for_mcp_server;+use opentelemetry_sdk::metrics::data::AggregatedMetrics;+use opentelemetry_sdk::metrics::data::MetricData;use pretty_assertions::assert_eq;use serde_json::Value;use serde_json::json;+use std::collections::BTreeMap;use std::sync::Arc;use std::time::Duration;use test_case::test_case;@@ -955,6 +960,10 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resul}}))?;let mut builder = test_codex()+ .with_model_info_override("gpt-5.2", |model| {+ model.tool_mode = Some(codex_protocol::openai_models::ToolMode::CodeMode);+ model.experimental_supported_tools = vec!["test_sync_tool".to_string()];+ }).with_model_info_override("gpt-5.4", |model| {model.tool_mode = Some(codex_protocol::openai_models::ToolMode::CodeMode);model.experimental_supported_tools = vec!["test_sync_tool".to_string()];@@ -968,7 +977,16 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resulconfig.approvals_reviewer = ApprovalsReviewer::User;config.mcp_servers.set(mcp_servers).unwrap();});- let test = builder.build_with_auto_env(&server).await?;+ let mut test = builder.build_with_auto_env(&server).await?;+ let metrics = MetricsClient::new(+ MetricsConfig::in_memory("test", "test", "1", Default::default()).with_runtime_reader(),+ )?;+ let mut options = test.start_thread_options().await;+ options.history_mode = Some(codex_protocol::protocol::ThreadHistoryMode::Legacy);+ options.thread_extension_init.insert(metrics.clone());+ let thread = test.thread_manager.start_thread(options).await?;+ test.codex.shutdown_and_wait().await?;+ test.codex = thread.thread;wait_for_mcp_server(&test.codex, "node_repl").await?;let barrier = r#"await tools.test_sync_tool({barrier: {id: "elicitation-origin", participants: 2, timeout_ms: 60000@@ -1043,10 +1061,16 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resul).await;test.codex- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {- text: "Run B and wait for A.".into(),- text_elements: Vec::new(),- }]))+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "Run B and wait for A.".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ model: Some("gpt-5.2".into()),+ ..Default::default()+ }),+ ).await?;let mut invocation_id = None;let mut assessment_target = None;@@ -1081,5 +1105,37 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resul.count(),1);+ test.codex.shutdown_and_wait().await?;+ let mut samples = guardian_blocking_samples(&metrics, "model")?;+ assert_eq!(samples.remove("gpt-5.4"), Some(0.0));+ assert!(samples.remove("gpt-5.2").unwrap() > 0.0);+ assert!(samples.is_empty());Ok(())}++/// Reads per-turn samples shared by command and MCP approval regressions.+pub(super) fn guardian_blocking_samples(+ metrics: &MetricsClient,+ label: &str,+) -> Result<BTreeMap<String, f64>> {+ let snapshot = metrics.snapshot()?;+ let metric = snapshot+ .scope_metrics()+ .flat_map(opentelemetry_sdk::metrics::data::ScopeMetrics::metrics)+ .find(|metric| metric.name() == "codex.guardian.turn.blocking_ms")+ .context("blocking histogram")?;+ let AggregatedMetrics::F64(MetricData::Histogram(histogram)) = metric.data() else {+ panic!("expected blocking histogram");+ };+ histogram+ .data_points()+ .map(|point| {+ let attribute = point+ .attributes()+ .find(|tag| tag.key.as_str() == label)+ .context("blocking metric label")?;+ assert_eq!(point.count(), 1);+ Ok((attribute.value.as_str().to_string(), point.sum()))+ })+ .collect()+}diff --git a/codex-rs/core/tests/suite/guardian_review.rs b/codex-rs/core/tests/suite/guardian_review.rsindex bd31aa799e..a0ef8c25b1 100644--- a/codex-rs/core/tests/suite/guardian_review.rs+++ b/codex-rs/core/tests/suite/guardian_review.rs@@ -26,6 +26,8 @@ use codex_features::Feature;use codex_history::RolloutItem;use codex_login::CodexAuth;use codex_models_manager::manager::RefreshStrategy;+use codex_otel::MetricsClient;+use codex_otel::MetricsConfig;use codex_protocol::ThreadId;use codex_protocol::config_types::ApprovalsReviewer;use codex_protocol::config_types::WindowsSandboxLevel;@@ -95,6 +97,7 @@ use wiremock::http::Method;use wiremock::matchers::method;use wiremock::matchers::path_regex;+use super::guardian_mcp_elicitation::guardian_blocking_samples;use super::network_approval::guardian_parent_catalog;use super::rmcp_client::remote_aware_environment_id;use super::rmcp_client::remote_aware_stdio_server_bin;@@ -2806,7 +2809,16 @@ async fn yielded_code_mode_denials_interrupt_the_servicing_turn() -> Result<()>config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);config.approvals_reviewer = ApprovalsReviewer::AutoReview;});- let test = builder.build_with_auto_env(&server).await?;+ let mut test = builder.build_with_auto_env(&server).await?;+ let metrics = MetricsClient::new(+ MetricsConfig::in_memory("test", "test", "1", Default::default()).with_runtime_reader(),+ )?;+ let mut options = test.start_thread_options().await;+ options.history_mode = Some(codex_protocol::protocol::ThreadHistoryMode::Legacy);+ options.thread_extension_init.insert(metrics.clone());+ let thread = test.thread_manager.start_thread(options).await?;+ test.codex.shutdown_and_wait().await?;+ test.codex = thread.thread;let barrier = r#"await tools.test_sync_tool({barrier: {id: "guardian-origin", participants: 2, timeout_ms: 60000}});"#;@@ -2950,5 +2962,145 @@ for (let index = 0; index < 6; index++) {{1);}+ test.codex.shutdown_and_wait().await?;+ let mut samples = guardian_blocking_samples(&metrics, "outcome")?;+ assert_eq!(samples.remove("completed"), Some(0.0));+ assert!(samples.remove("aborted").unwrap() > 0.0);+ assert!(samples.is_empty());+ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn guardian_blocking_follows_a_pending_review_across_turns() -> Result<()> {+ skip_if_no_network!(Ok(()));+ skip_if_sandbox!(Ok(()));++ let code = r#"// @exec: {"yield_time_ms": 1}+text(await tools.exec_command({+ cmd: "echo spanning-review",+ sandbox_permissions: "require_escalated",+ justification: "Keep a Guardian review pending across turns."+}));"#;+ let (finish_a, a_gate) = tokio::sync::oneshot::channel();+ let (finish_review, review_gate) = tokio::sync::oneshot::channel();+ let chunk = |gate, events| StreamingSseChunk {+ gate,+ body: sse(events),+ };+ let (streaming, _) = start_streaming_sse_server(vec![+ vec![+ chunk(+ /*gate*/ None,+ vec![+ ev_response_created("a"),+ ev_custom_tool_call("cell-a", "exec", code),+ ],+ ),+ chunk(Some(a_gate), vec![ev_completed("a")]),+ ],+ vec![chunk(+ Some(review_gate),+ vec![+ ev_response_created("review"),+ ev_assistant_message("assessment", r#"{"outcome":"deny"}"#),+ ev_completed("review"),+ ],+ )],+ vec![chunk(/*gate*/ None, vec![ev_completed("a-finished")])],+ vec![chunk(+ /*gate*/ None,+ vec![+ ev_function_call("wait-a", "wait", r#"{"cell_id":"1","yield_time_ms":60000}"#),+ ev_completed("b"),+ ],+ )],+ vec![chunk(/*gate*/ None, vec![ev_completed("b-finished")])],+ ])+ .await;+ let server = start_mock_server().await;+ let base_url = format!("{}/v1", streaming.uri());+ let mut builder = test_codex().with_config(move |config| {+ config.features.enable(Feature::CodeMode).unwrap();+ config+ .features+ .disable(Feature::EnableRequestCompression)+ .unwrap();+ config.model_provider.base_url = Some(base_url);+ config.model_provider.supports_websockets = false;+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ });+ for model in ["gpt-5.2", "gpt-5.4"] {+ builder = builder.with_model_info_override(model, |info| {+ info.tool_mode = Some(codex_protocol::openai_models::ToolMode::CodeMode);+ });+ }+ let mut test = builder+ .with_model("gpt-5.4")+ .build_with_auto_env(&server)+ .await?;+ let metrics = MetricsClient::new(+ MetricsConfig::in_memory("test", "test", "1", Default::default()).with_runtime_reader(),+ )?;+ let mut options = test.start_thread_options().await;+ options.history_mode = Some(codex_protocol::protocol::ThreadHistoryMode::Legacy);+ options.thread_extension_init.insert(metrics.clone());+ let thread = test.thread_manager.start_thread(options).await?;+ test.codex.shutdown_and_wait().await?;+ test.codex = thread.thread;++ test.codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "Start A and leave its cell running.".into(),+ text_elements: Vec::new(),+ }]))+ .await?;+ // The review has reached its backend before A is allowed to finish.+ streaming.wait_for_request_count(/*count*/ 2).await;+ finish_a.send(()).unwrap();+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ let requests = streaming.requests().await;+ let yielded: Value = serde_json::from_slice(&requests[2])?;+ let output = yielded["input"]+ .as_array()+ .unwrap()+ .iter()+ .find(|item| item["call_id"] == "cell-a" && item["type"] == "custom_tool_call_output")+ .unwrap();+ assert!(+ output["output"]+ .to_string()+ .contains("Script running with cell ID 1"),+ "{output}"+ );++ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "Wait for A's cell.".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ model: Some("gpt-5.2".into()),+ ..Default::default()+ }),+ )+ .await?;+ // B is active while the same review is still blocked on its response gate.+ streaming.wait_for_request_count(/*count*/ 4).await;+ finish_review.send(()).unwrap();+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ test.codex.shutdown_and_wait().await?;+ let samples = guardian_blocking_samples(&metrics, "model")?;+ assert_eq!(samples.len(), 2);+ assert!(samples["gpt-5.4"] > 0.0);+ assert!(samples["gpt-5.2"] > 0.0);+ streaming.shutdown().await;Ok(())}diff --git a/codex-rs/ext/guardian-reviewer/src/blocking.rs b/codex-rs/ext/guardian-reviewer/src/blocking.rsnew file mode 100644index 0000000000..0daecf7f40--- /dev/null+++ b/codex-rs/ext/guardian-reviewer/src/blocking.rs@@ -0,0 +1,149 @@+//! Splits the union of thread-owned approval waits across active turns.+//! Turn completion exports one sample; pending reviews survive idle gaps and turn changes.+//! Saved durations are removed when their turn finishes or its handle drops.++use std::collections::HashMap;+use std::sync::Arc;+use std::sync::Mutex;+use std::sync::PoisonError;+use std::sync::Weak;+use std::time::Duration;+use std::time::Instant;++/// Tracks pending approvals independently of the turn currently servicing them.+#[derive(Default)]+pub struct ReviewBlocking {+ state: Mutex<State>,+}++#[derive(Default)]+struct State {+ interval: Interval,+ turn: Option<String>,+ completed: HashMap<String, Duration>,+}++/// Identifies a turn's sample and removes it when the turn is released.+pub struct ReviewBlockingTurn {+ id: String,+ tracker: Weak<ReviewBlocking>,+ telemetry: Arc<codex_otel::SessionTelemetry>,+}++impl State {+ fn start_turn(&mut self, turn_id: &str, now: Instant) {+ if let Some(previous) = self.turn.replace(turn_id.to_owned()) {+ self.completed+ .insert(previous, self.interval.finish_turn(now));+ }+ self.interval.start_turn(now);+ }++ fn finish_turn(&mut self, turn_id: &str, now: Instant) -> Option<Duration> {+ if self.turn.as_deref() == Some(turn_id) {+ self.turn = None;+ Some(self.interval.finish_turn(now))+ } else {+ self.completed.remove(turn_id)+ }+ }+}++#[derive(Default)]+struct Interval {+ active: usize,+ since: Option<Instant>,+ elapsed: Duration,+}++impl Interval {+ fn start_turn(&mut self, now: Instant) {+ self.elapsed = Duration::ZERO;+ self.since = (self.active > 0).then_some(now);+ }++ fn finish_turn(&mut self, now: Instant) -> Duration {+ if let Some(since) = self.since.take() {+ self.elapsed += now.saturating_duration_since(since);+ }+ std::mem::take(&mut self.elapsed)+ }++ fn enter(&mut self, now: Instant) {+ if self.active == 0 {+ self.since = Some(now);+ }+ self.active += 1;+ }+ fn leave(&mut self, now: Instant) {+ self.active = self.active.saturating_sub(1);+ if self.active == 0+ && let Some(since) = self.since.take()+ {+ self.elapsed += now.saturating_duration_since(since);+ }+ }+}++impl ReviewBlocking {+ pub fn start_turn(+ self: &Arc<Self>,+ turn_id: &str,+ telemetry: Arc<codex_otel::SessionTelemetry>,+ ) -> ReviewBlockingTurn {+ self.state+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .start_turn(turn_id, Instant::now());+ ReviewBlockingTurn {+ id: turn_id.to_owned(),+ tracker: Arc::downgrade(self),+ telemetry,+ }+ }++ pub fn finish_turn(&self, turn: &ReviewBlockingTurn, outcome: &'static str) {+ let elapsed = self+ .state+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .finish_turn(&turn.id, Instant::now());+ if let Some(elapsed) = elapsed {+ turn.telemetry.record_duration(+ "codex.guardian.turn.blocking_ms",+ elapsed,+ &[("outcome", outcome)],+ );+ }+ }++ pub(crate) fn enter(self: &Arc<Self>) -> BlockingGuard {+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);+ state.interval.enter(Instant::now());+ BlockingGuard(Arc::clone(self))+ }+}++impl Drop for ReviewBlockingTurn {+ fn drop(&mut self) {+ if let Some(tracker) = self.tracker.upgrade() {+ tracker+ .state+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .finish_turn(&self.id, Instant::now());+ }+ }+}++pub(crate) struct BlockingGuard(Arc<ReviewBlocking>);+impl Drop for BlockingGuard {+ fn drop(&mut self) {+ let mut state = self.0.state.lock().unwrap_or_else(PoisonError::into_inner);+ state.interval.leave(Instant::now());+ }+}++#[cfg(test)]+#[path = "blocking_tests.rs"]+mod tests;diff --git a/codex-rs/ext/guardian-reviewer/src/blocking_tests.rs b/codex-rs/ext/guardian-reviewer/src/blocking_tests.rsnew file mode 100644index 0000000000..0d0a6553f4--- /dev/null+++ b/codex-rs/ext/guardian-reviewer/src/blocking_tests.rs@@ -0,0 +1,68 @@+//! Checks overlapping approvals and turn boundaries with an explicit clock.++use super::*;+use pretty_assertions::assert_eq;++#[test]+fn overlapping_reviews_span_turns_without_charging_idle_gaps() {+ let start = Instant::now();+ let mut interval = Interval::default();+ interval.start_turn(start);+ interval.enter(start);+ interval.enter(start + Duration::from_millis(10));+ interval.leave(start + Duration::from_millis(30));+ assert_eq!(interval.elapsed, Duration::ZERO);+ assert_eq!(+ interval.finish_turn(start + Duration::from_millis(40)),+ Duration::from_millis(40)+ );+ interval.start_turn(start + Duration::from_millis(60));+ interval.leave(start + Duration::from_millis(70));+ assert_eq!(+ interval.finish_turn(start + Duration::from_millis(80)),+ Duration::from_millis(10)+ );+ // A review that starts while idle contributes only after the next turn starts.+ interval.enter(start + Duration::from_millis(100));+ interval.start_turn(start + Duration::from_millis(200));+ interval.leave(start + Duration::from_millis(210));+ assert_eq!(+ interval.finish_turn(start + Duration::from_millis(220)),+ Duration::from_millis(10)+ );+ interval.start_turn(start + Duration::from_millis(230));+ interval.enter(start + Duration::from_millis(240));+ interval.leave(start + Duration::from_millis(250));+ interval.enter(start + Duration::from_millis(270));+ interval.leave(start + Duration::from_millis(280));+ assert_eq!(+ interval.finish_turn(start + Duration::from_millis(300)),+ Duration::from_millis(20)+ );+ interval.start_turn(start + Duration::from_millis(310));+ assert_eq!(+ interval.finish_turn(start + Duration::from_millis(320)),+ Duration::ZERO+ );+}++#[test]+fn late_turn_completion_preserves_both_samples_and_ignores_duplicate_stops() {+ let start = Instant::now();+ let mut state = State::default();+ state.start_turn("a", start);+ state.interval.enter(start + Duration::from_millis(10));+ state.start_turn("b", start + Duration::from_millis(30));+ assert_eq!(+ state.finish_turn("a", start + Duration::from_millis(50)),+ Some(Duration::from_millis(20))+ );+ assert_eq!(+ state.finish_turn("a", start + Duration::from_millis(60)),+ None+ );+ assert_eq!(+ state.finish_turn("b", start + Duration::from_millis(70)),+ Some(Duration::from_millis(40))+ );+}diff --git a/codex-rs/ext/guardian-reviewer/src/lib.rs b/codex-rs/ext/guardian-reviewer/src/lib.rsindex 173401024a..94b078f738 100644--- a/codex-rs/ext/guardian-reviewer/src/lib.rs+++ b/codex-rs/ext/guardian-reviewer/src/lib.rs@@ -3,6 +3,9 @@//! The host supplies review attempts and enforces the resulting decision on the bound action.mod assessment;+mod blocking;+pub use blocking::ReviewBlocking;+pub use blocking::ReviewBlockingTurn;mod circuit_breaker;mod completion;mod conversation;diff --git a/codex-rs/ext/guardian-reviewer/src/routing.rs b/codex-rs/ext/guardian-reviewer/src/routing.rsindex c33aa1ae7e..28d97774ba 100644--- a/codex-rs/ext/guardian-reviewer/src/routing.rs+++ b/codex-rs/ext/guardian-reviewer/src/routing.rs@@ -71,6 +71,10 @@ impl<H: ReviewHost> ReviewRequest<'_, H> {.telemetry.start_timer("codex.guardian.decision.duration_ms", &[]).ok();+ let _blocking = self+ .thread_store+ .get::<crate::ReviewBlocking>()+ .map(|blocking| blocking.enter());let runtime = self.thread_store.get::<crate::ReviewerTasks>();let _task = runtime.as_ref().map(|runtime| runtime.tasks.token());if runtimediff --git a/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rs b/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rsindex 0aba3d653b..e6fb25fdca 100644--- a/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rs+++ b/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rs@@ -22,6 +22,8 @@ use codex_extension_api::TurnAbortInput;use codex_extension_api::TurnLifecycleContributor;use codex_extension_api::TurnStartInput;use codex_extension_api::TurnStopInput;+use codex_guardian_reviewer::ReviewBlocking;+use codex_guardian_reviewer::ReviewBlockingTurn;use codex_guardian_reviewer::ReviewDenials;use codex_guardian_reviewer::ReviewerPool;use codex_guardian_reviewer::ReviewerTasks;@@ -58,6 +60,7 @@ impl ThreadLifecycleContributor<Config> for GuardianExtension {let manager = self.thread_manager.clone();let parent_thread_id = input.thread_store.level_id().to_owned();let runtime = input.thread_store.get_or_init(ReviewerTasks::default);+ input.thread_store.get_or_init(ReviewBlocking::default);input.thread_store.get_or_init(|| {ReviewerPool::<GuardianReviewSession>::new(Arc::clone(&runtime),@@ -228,19 +231,39 @@ impl ThreadLifecycleContributor<Config> for GuardianExtension {impl TurnLifecycleContributor for GuardianExtension {fn on_turn_start<'a>(&'a self, input: TurnStartInput<'a>) -> ExtensionFuture<'a, ()> {- Box::pin(ReviewDenials::clear_turn(input.thread_store, input.turn_id))+ Box::pin(async move {+ if input.thread_store.get::<ReviewerTasks>().is_some()+ && let Some(telemetry) = input.turn_store.get()+ {+ let tracker = input.thread_store.get_or_init(ReviewBlocking::default);+ input+ .turn_store+ .get_or_init(|| tracker.start_turn(input.turn_id, telemetry));+ }+ ReviewDenials::clear_turn(input.thread_store, input.turn_id).await;+ })}fn on_turn_stop<'a>(&'a self, input: TurnStopInput<'a>) -> ExtensionFuture<'a, ()> {- Box::pin(ReviewDenials::clear_turn(- input.thread_store,- input.turn_store.level_id(),- ))+ Box::pin(async move {+ if let (Some(tracker), Some(turn)) = (+ input.thread_store.get::<ReviewBlocking>(),+ input.turn_store.get::<ReviewBlockingTurn>(),+ ) {+ tracker.finish_turn(&turn, "completed");+ }+ ReviewDenials::clear_turn(input.thread_store, input.turn_store.level_id()).await;+ })}fn on_turn_abort<'a>(&'a self, input: TurnAbortInput<'a>) -> ExtensionFuture<'a, ()> {- Box::pin(ReviewDenials::clear_turn(- input.thread_store,- input.turn_store.level_id(),- ))+ Box::pin(async move {+ if let (Some(tracker), Some(turn)) = (+ input.thread_store.get::<ReviewBlocking>(),+ input.turn_store.get::<ReviewBlockingTurn>(),+ ) {+ tracker.finish_turn(&turn, "aborted");+ }+ ReviewDenials::clear_turn(input.thread_store, input.turn_store.level_id()).await;+ })}}