From 19c984961bb30c22603d970dca340daa39d6e109 Mon Sep 17 00:00:00 2001
From: Dylan Hurd <dylan.hurd@openai.com>
Date: Mon, 27 Apr 2026 22:18:42 -0700
Subject: [PATCH] simplify

---
 codex-rs/core/src/guardian/review_session.rs | 96 +++++++++-----------
 1 file changed, 45 insertions(+), 51 deletions(-)

diff --git a/codex-rs/core/src/guardian/review_session.rs b/codex-rs/core/src/guardian/review_session.rs
index 2496a9038d..aa479d3508 100644
--- a/codex-rs/core/src/guardian/review_session.rs
+++ b/codex-rs/core/src/guardian/review_session.rs
@@ -318,21 +318,47 @@ impl GuardianReviewSessionManager {
             Some(trunk) => trunk,
             None => {
                 let spawn_cancel_token = CancellationToken::new();
-                let spawned_review_session = match run_before_review_deadline_with_cancel(
+                let cold_start = run_before_review_deadline_with_cancel(
                     deadline,
                     params.external_cancel.as_ref(),
                     &spawn_cancel_token,
-                    Box::pin(spawn_guardian_review_session(
-                        &params,
-                        params.spawn_config.clone(),
-                        next_reuse_key.clone(),
-                        spawn_cancel_token.clone(),
-                        /*fork_snapshot*/ None,
-                    )),
+                    Box::pin(async {
+                        let spawned_review_session = Arc::new(
+                            spawn_guardian_review_session(
+                                &params,
+                                params.spawn_config.clone(),
+                                next_reuse_key.clone(),
+                                spawn_cancel_token.clone(),
+                                /*fork_snapshot*/ None,
+                            )
+                            .await?,
+                        );
+
+                        let mut state = self.state.lock().await;
+                        if state.is_shutdown {
+                            spawned_review_session.shutdown_in_background();
+                            Ok(None)
+                        } else if let Some(current_trunk) = state.trunk.as_ref().cloned() {
+                            if current_trunk.reuse_key != next_reuse_key
+                                && current_trunk.review_lock.try_acquire().is_ok()
+                            {
+                                stale_trunk_to_shutdown =
+                                    state.trunk.replace(Arc::clone(&spawned_review_session));
+                                Ok(Some((spawned_review_session, true)))
+                            } else {
+                                spawned_review_session.shutdown_in_background();
+                                Ok(Some((current_trunk, false)))
+                            }
+                        } else {
+                            state.trunk = Some(Arc::clone(&spawned_review_session));
+                            Ok(Some((spawned_review_session, true)))
+                        }
+                    }),
                 )
-                .await
-                {
-                    Ok(Ok(review_session)) => Arc::new(review_session),
+                .await;
+
+                let Some((trunk, installed_spawned_trunk)) = (match cold_start {
+                    Ok(Ok(cold_start)) => cold_start,
                     Ok(Err(err)) => {
                         return (
                             GuardianReviewSessionOutcome::PromptBuildFailed(err),
@@ -342,50 +368,18 @@ impl GuardianReviewSessionManager {
                     Err(outcome) => {
                         return (outcome, GuardianReviewAnalyticsResult::without_session());
                     }
+                }) else {
+                    return (
+                        GuardianReviewSessionOutcome::Aborted,
+                        GuardianReviewAnalyticsResult::without_session(),
+                    );
                 };
-
-                let trunk = match run_before_review_deadline(
-                    deadline,
-                    params.external_cancel.as_ref(),
-                    self.state.lock(),
-                )
-                .await
+                spawned_trunk = installed_spawned_trunk;
+                if installed_spawned_trunk
+                    && let Some(review_session) = stale_trunk_to_shutdown.take()
                 {
-                    Ok(mut state) => {
-                        if state.is_shutdown {
-                            spawned_review_session.shutdown_in_background();
-                            return (
-                                GuardianReviewSessionOutcome::Aborted,
-                                GuardianReviewAnalyticsResult::without_session(),
-                            );
-                        } else if let Some(current_trunk) = state.trunk.as_ref().cloned() {
-                            if current_trunk.reuse_key != next_reuse_key
-                                && current_trunk.review_lock.try_acquire().is_ok()
-                            {
-                                stale_trunk_to_shutdown =
-                                    state.trunk.replace(Arc::clone(&spawned_review_session));
-                                spawned_trunk = true;
-                                Arc::clone(&spawned_review_session)
-                            } else {
-                                spawned_review_session.shutdown_in_background();
-                                current_trunk
-                            }
-                        } else {
-                            state.trunk = Some(Arc::clone(&spawned_review_session));
-                            spawned_trunk = true;
-                            Arc::clone(&spawned_review_session)
-                        }
-                    }
-                    Err(outcome) => {
-                        spawned_review_session.shutdown_in_background();
-                        return (outcome, GuardianReviewAnalyticsResult::without_session());
-                    }
-                };
-
-                if let Some(review_session) = stale_trunk_to_shutdown.take() {
                     review_session.shutdown_in_background();
                 }
-
                 trunk
             }
         };