Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust
142 KB
Raw Blame
use anyhow::Context;
use anyhow::Result;
use codex_config::types::ApprovalsReviewer;
use codex_core::EnvironmentConfig;
use codex_core::EnvironmentNetworkPolicy;
use codex_core::StartThreadOptions;
use codex_core::TurnInputRequest;
use codex_core::config::Constrained;
use codex_core::config::NetworkProxySpec;
use codex_core::shell::ShellType;
use codex_core::shell::get_shell;
use codex_core::windows_sandbox::WindowsSandboxLevelExt;
use codex_exec_server::CreateDirectoryOptions;
use codex_exec_server::LOCAL_ENVIRONMENT_ID;
use codex_exec_server::REMOTE_ENVIRONMENT_ID;
use codex_exec_server::RemoveOptions;
use codex_extension_api::ExtensionRegistryBuilder;
use codex_extension_api::ToolFinishInput;
use codex_extension_api::ToolLifecycleContributor;
use codex_extension_api::ToolLifecycleFuture;
use codex_features::Feature;
use codex_history::RolloutItem;
#[cfg(unix)]
use codex_network_proxy::CredentialProviderConfig;
#[cfg(unix)]
use codex_network_proxy::MitmHookActionsConfig;
#[cfg(unix)]
use codex_network_proxy::MitmHookConfig;
#[cfg(unix)]
use codex_network_proxy::MitmHookMatchConfig;
use codex_network_proxy::NetworkProxyConfig;
use codex_network_proxy::PROXY_ACTIVE_ENV_KEY;
use codex_protocol::approvals::ExecApprovalKind;
use codex_protocol::approvals::GuardianAssessmentAction;
use codex_protocol::approvals::NetworkApprovalContext;
use codex_protocol::approvals::NetworkApprovalProtocol;
use codex_protocol::approvals::NetworkPolicyAmendment;
use codex_protocol::approvals::NetworkPolicyRuleAction;
use codex_protocol::capabilities::CapabilityRootLocation;
use codex_protocol::capabilities::SelectedCapabilityRoot;
use codex_protocol::config_types::CollaborationMode;
use codex_protocol::config_types::ModeKind;
use codex_protocol::config_types::Settings;
use codex_protocol::config_types::WindowsSandboxLevel;
use codex_protocol::models::NetworkPermissions;
use codex_protocol::models::PermissionProfile;
use codex_protocol::models::PermissionProfileSnapshot;
use codex_protocol::openai_models::AutoReviewMessages;
use codex_protocol::openai_models::ModelVisibility;
use codex_protocol::openai_models::ModelsResponse;
use codex_protocol::permissions::FileSystemAccessMode;
use codex_protocol::permissions::FileSystemPath;
use codex_protocol::permissions::FileSystemSandboxEntry;
use codex_protocol::permissions::FileSystemSandboxPolicy;
use codex_protocol::permissions::NetworkSandboxPolicy;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::EnvironmentConfigState;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ExecApprovalRequestEvent;
use codex_protocol::protocol::GuardianAssessmentStatus;
use codex_protocol::protocol::Op;
use codex_protocol::protocol::ReviewDecision;
use codex_protocol::protocol::ThreadSettingsOverrides;
use codex_protocol::protocol::TurnEnvironmentRequests;
use codex_protocol::protocol::TurnEnvironmentSelection;
use codex_protocol::protocol::TurnEnvironmentSelections;
use codex_protocol::request_permissions::PermissionGrantScope;
use codex_protocol::request_permissions::RequestPermissionProfile;
use codex_protocol::request_permissions::RequestPermissionsResponse;
use codex_protocol::user_input::UserInput;
use codex_thread_store::LoadThreadHistoryParams;
use codex_utils_path_uri::PathUri;
use core_test_support::PathBufExt;
use core_test_support::PathExt;
use core_test_support::managed_network_requirements_loader;
use core_test_support::responses::ResponseMock;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_function_call;
use core_test_support::responses::ev_response_created;
use core_test_support::responses::mount_response_once_match;
use core_test_support::responses::mount_sse_once;
use core_test_support::responses::mount_sse_once_match;
use core_test_support::responses::mount_sse_sequence;
use core_test_support::responses::sse;
use core_test_support::responses::sse_response;
use core_test_support::responses::start_mock_server;
use core_test_support::skip_if_host_windows;
use core_test_support::skip_if_no_network;
use core_test_support::skip_if_no_remote_env;
use core_test_support::skip_if_sandbox;
use core_test_support::skip_if_target_windows;
use core_test_support::test_codex::TestCodex;
use core_test_support::test_codex::TestCodexBuilder;
use core_test_support::test_codex::local;
use core_test_support::test_codex::local_request;
use core_test_support::test_codex::test_codex;
use core_test_support::test_codex::turn_permission_fields;
use core_test_support::wait_for_event;
use core_test_support::wait_for_event_with_timeout;
use pretty_assertions::assert_eq;
use serde_json::Value;
use serde_json::json;
use std::fs;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use std::time::SystemTime;
use std::time::UNIX_EPOCH;
use tempfile::TempDir;
use test_case::test_case;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;

const NETWORK_TEST_HOST: &str = "codex-network-test.invalid";
const NETWORK_TEST_TARGET: &str = "http://codex-network-test.invalid:80";

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn guardian_network_approval_preserves_action_and_outcome_routing() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let first_call_id = "guardian-network-approved";
    let second_call_id = "guardian-network-denied";
    let first_command = network_fetch_args(LOCAL_ENVIRONMENT_ID)["cmd"]
        .as_str()
        .context("expected network command")?
        .to_string();
    let second_command = first_command.clone();
    let expected_command = get_shell(ShellType::Sh)
        .context("expected local sh")?
        .derive_exec_args(&first_command, /*use_login_shell*/ false);
    let denial = "The destination is outside the approved test boundary.";
    let mut actions = Vec::new();
    let mut outputs = Vec::new();
    for (prompt, call_id, outcome, rationale) in [
        (
            "approve the network request",
            first_call_id,
            "allow",
            "The test request is safe.",
        ),
        ("deny the network request", second_call_id, "deny", denial),
    ] {
        mount_sse_once_match(
            &server,
            move |request: &wiremock::Request| {
                !is_guardian_request(request)
                    && request_body_contains(request, prompt)
                    && !request_body_contains(request, call_id)
            },
            sse(vec![
                ev_function_call(
                    call_id,
                    "exec_command",
                    &serde_json::to_string(&network_fetch_args(LOCAL_ENVIRONMENT_ID))?,
                ),
                ev_completed(&format!("{call_id}-start")),
            ]),
        )
        .await;
        let guardian = mount_sse_once_match(
            &server,
            move |request: &wiremock::Request| guardian_request_is_for(request, call_id),
            sse(vec![
                ev_assistant_message(
                    &format!("{call_id}-decision"),
                    &json!({
                        "risk_level": if outcome == "allow" { "low" } else { "high" },
                        "user_authorization": if outcome == "allow" { "high" } else { "low" },
                        "outcome": outcome,
                        "rationale": rationale,
                    })
                    .to_string(),
                ),
                ev_completed(&format!("{call_id}-guardian")),
            ]),
        )
        .await;

        // Process startup can outlast exec_command's first yield. Follow the returned
        // session until its final output instead of consuming Guardian's next response.
        let (output_tx, output_rx) = std::sync::mpsc::channel();
        let parent = wiremock::Mock::given(wiremock::matchers::method("POST"))
            .and(wiremock::matchers::path("/v1/responses"))
            .and(move |request: &wiremock::Request| {
                !is_guardian_request(request) && request_body_contains(request, call_id)
            })
            .respond_with(move |request: &wiremock::Request| {
                let body: Value = serde_json::from_slice(
                    &decoded_request_body(request).expect("decode parent request"),
                )
                .expect("parse parent request");
                let input = body["input"].as_array().expect("parent input");
                let output = input
                    .iter()
                    .rev()
                    .find(|item| item["type"] == "function_call_output")
                    .and_then(|item| item["output"].as_str())
                    .expect("network command or poll output");
                let response_id = format!("{call_id}-{}", input.len());
                let event = if let Some(session_id) = output
                    .lines()
                    .find_map(|line| line.strip_prefix("Process running with session ID "))
                {
                    ev_function_call(
                        &response_id,
                        "write_stdin",
                        &json!({
                            "session_id": session_id.parse::<i32>().expect("session id"),
                            "chars": "",
                            "yield_time_ms": 1_000,
                        })
                        .to_string(),
                    )
                } else {
                    output_tx
                        .send(output.to_string())
                        .expect("save final output");
                    ev_assistant_message(&response_id, "done")
                };
                sse_response(sse(vec![event, ev_completed(&response_id)]))
            })
            .mount_as_scoped(&server)
            .await;
        submit_managed_network_turn(
            &test,
            prompt,
            vec![local(test.config.cwd.clone())],
            ApprovalsReviewer::AutoReview,
            AskForApproval::OnRequest,
        )
        .await?;
        wait_for_completion_without_network_prompt(&test).await;
        outputs.push(
            output_rx
                .try_recv()
                .context("expected final network output")?,
        );
        actions.extend(guardian_network_actions(&guardian)?);
        drop(parent);
    }

    assert_eq!(actions.len(), 2);
    assert_eq!(
        actions[0],
        json!({
            "host": NETWORK_TEST_HOST,
            "port": 80,
            "protocol": "http",
            "target": NETWORK_TEST_TARGET,
            "tool": "network_access",
            "environment_id": LOCAL_ENVIRONMENT_ID,
            "trigger": {
                "callId": first_call_id,
                "command": expected_command,
                "cwd": test.config.cwd,
                "sandboxPermissions": "use_default",
                "toolName": "exec_command",
                "tty": false,
            },
        })
    );
    assert_eq!(
        actions[1]
            .pointer("/trigger/callId")
            .and_then(Value::as_str),
        Some(second_call_id)
    );
    assert_eq!(
        actions[1]
            .pointer("/trigger/command/2")
            .and_then(Value::as_str),
        Some(second_command.as_str())
    );

    assert!(!outputs[0].contains("rejected"));
    assert!(outputs[1].contains(denial));
    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn strict_auto_review_routes_network_approval_to_guardian_when_user_reviewer_is_selected()
-> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test_with_features(
        &server,
        &[Feature::RequestPermissionsTool],
    )
    .await?;
    let permission_call_id = "strict-network-permissions";
    let network_call_id = "strict-network-access";
    let requested_permissions = RequestPermissionProfile {
        network: Some(NetworkPermissions {
            enabled: Some(true),
        }),
        ..Default::default()
    };
    // Guardian and parent requests can arrive in either order after the command yields.
    // Only Guardian requests may consume these decisions.
    let mut guardian_responses = Vec::new();
    for response_id in ["strict-command-guardian", "strict-network-guardian"] {
        guardian_responses.push(
            mount_sse_once_match(
                &server,
                is_guardian_request,
                sse(vec![
                    ev_response_created(response_id),
                    ev_assistant_message(
                        response_id,
                        r#"{"risk_level":"low","user_authorization":"high","outcome":"allow","rationale":"The strict-review request is safe."}"#,
                    ),
                    ev_completed(response_id),
                ]),
            )
            .await,
        );
    }
    let _parent = wiremock::Mock::given(wiremock::matchers::method("POST"))
        .and(wiremock::matchers::path("/v1/responses"))
        .and(|request: &wiremock::Request| !is_guardian_request(request))
        .respond_with(move |request: &wiremock::Request| {
            let body: Value = serde_json::from_slice(
                &decoded_request_body(request).expect("decode parent request"),
            )
            .expect("parse parent request");
            let input = body["input"].as_array().expect("parent input");
            let output = input
                .iter()
                .rev()
                .find(|item| item["type"] == "function_call_output");
            let response_id = format!("strict-parent-{}", input.len());
            let event = match output {
                None => ev_function_call(
                    permission_call_id,
                    "request_permissions",
                    &json!({
                        "reason": "Require automatic review for the rest of this turn",
                        "permissions": requested_permissions,
                    })
                    .to_string(),
                ),
                Some(output) if output["call_id"] == permission_call_id => ev_function_call(
                    network_call_id,
                    "exec_command",
                    &network_fetch_args(LOCAL_ENVIRONMENT_ID).to_string(),
                ),
                Some(output) => {
                    let output = output["output"].as_str().expect("process output");
                    if let Some(session_id) = output
                        .lines()
                        .find_map(|line| line.strip_prefix("Process running with session ID "))
                    {
                        ev_function_call(
                            &response_id,
                            "write_stdin",
                            &json!({
                                "session_id": session_id.parse::<i32>().expect("session id"),
                                "chars": "",
                                "yield_time_ms": 1_000,
                            })
                            .to_string(),
                        )
                    } else {
                        assert!(output.contains("Process exited with code"), "{output}");
                        ev_assistant_message("strict-parent-complete", "reviewed")
                    }
                }
            };
            sse_response(sse(vec![event, ev_completed(&response_id)]))
        })
        .mount_as_scoped(&server)
        .await;

    submit_managed_network_turn(
        &test,
        "grant turn permissions, then automatically review network access",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let EventMsg::RequestPermissions(request) = wait_for_event(&test.codex, |event| {
        matches!(event, EventMsg::RequestPermissions(_))
    })
    .await
    else {
        unreachable!("matched request permissions event")
    };
    assert_eq!(request.call_id, permission_call_id);
    test.codex
        .submit(Op::RequestPermissionsResponse {
            id: permission_call_id.to_string(),
            response: RequestPermissionsResponse {
                permissions: request.permissions,
                scope: PermissionGrantScope::Turn,
                strict_auto_review: true,
            },
        })
        .await?;
    wait_for_completion_without_network_prompt(&test).await;

    assert_eq!(
        guardian_responses
            .iter()
            .flat_map(ResponseMock::requests)
            .filter(|request| {
                request.body_json()["client_metadata"]["x-openai-subagent"] == "guardian"
            })
            .count(),
        2,
        "the command and network request must each receive Guardian review",
    );
    let actions = guardian_responses
        .iter()
        .map(guardian_network_actions)
        .collect::<Result<Vec<_>>>()?
        .into_iter()
        .flatten()
        .collect::<Vec<_>>();
    assert_eq!(actions.len(), 1);
    assert_eq!(
        actions[0]
            .pointer("/trigger/callId")
            .and_then(Value::as_str),
        Some(network_call_id)
    );

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn cancelled_guardian_network_review_fails_closed_without_rewriting_turn_state() -> Result<()>
{
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let call_id = "guardian-network-cancelled";
    let marker = "guardian cancellation must preserve this turn marker";
    mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request) && request_body_contains(request, marker)
        },
        sse(vec![
            ev_response_created("resp-guardian-cancel-parent"),
            ev_function_call(
                call_id,
                "exec_command",
                &serde_json::to_string(&network_fetch_args(LOCAL_ENVIRONMENT_ID))?,
            ),
            ev_completed("resp-guardian-cancel-parent"),
        ]),
    )
    .await;
    let pending_guardian = mount_response_once_match(
        &server,
        is_guardian_request,
        sse_response(sse(vec![
            ev_response_created("resp-guardian-cancelled-review"),
            ev_assistant_message("msg-guardian-cancelled-review", r#"{"outcome":"allow"}"#),
            ev_completed("resp-guardian-cancelled-review"),
        ]))
        .set_delay(Duration::from_secs(30)),
    )
    .await;
    submit_managed_network_turn(
        &test,
        marker,
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::AutoReview,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_guardian_request(&pending_guardian).await;
    test.codex.submit(Op::Interrupt).await?;
    let mut saw_turn_aborted = false;
    let mut saw_guardian_aborted = false;
    while !saw_turn_aborted || !saw_guardian_aborted {
        let event = tokio::time::timeout(Duration::from_secs(5), test.codex.next_event())
            .await
            .context("timed out waiting for parent and Guardian cancellation")?
            .context("event stream ended while waiting for cancellation")?;
        saw_turn_aborted |= matches!(&event.msg, EventMsg::TurnAborted(_));
        saw_guardian_aborted |= matches!(
            &event.msg,
            EventMsg::GuardianAssessment(assessment)
                if assessment.status == GuardianAssessmentStatus::Aborted
        );
    }

    let state_check = mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request)
                && request_body_contains(request, "verify preserved state")
        },
        sse(vec![
            ev_response_created("resp-guardian-cancel-state-check"),
            ev_assistant_message("msg-guardian-cancel-state-check", "state preserved"),
            ev_completed("resp-guardian-cancel-state-check"),
        ]),
    )
    .await;
    submit_managed_network_turn(
        &test,
        "verify preserved state",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_turn_complete(&test).await;
    assert!(state_check.single_request().body_contains_text(marker));

    Ok(())
}

#[test_case("GET", "http://codex-network-test.invalid/"; "plain_http")]
#[test_case("CONNECT", "codex-network-test.invalid:443"; "connect")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn disconnected_network_request_explains_failure_to_model(
    method: &str,
    target: &str,
) -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    // This tests the controller-local proxy; remote disconnect forwarding is not supported yet.
    let test = managed_network_unified_exec_test(&server).await?;
    let call_id = "network-disconnect";
    let poll_call_id = "network-disconnect-poll";
    let command = format!(
        r#"python3 - <<'PY'
import os, socket, time, urllib.parse
proxy = urllib.parse.urlparse(os.environ['HTTP_PROXY'])
sock = socket.create_connection((proxy.hostname, proxy.port), timeout=10)
sock.sendall(b'{method} {target} HTTP/1.1\r\nHost: codex-network-test.invalid\r\n\r\n')
while not os.path.exists('disconnect-now'):
    time.sleep(0.01)
sock.close()
time.sleep(60)
PY"#
    );
    let mut args = network_exec_args(&command);
    args["environment_id"] = json!(LOCAL_ENVIRONMENT_ID);
    mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request) && !request_body_contains(request, call_id)
        },
        sse(vec![
            ev_function_call(call_id, "exec_command", &serde_json::to_string(&args)?),
            ev_completed("parent-start"),
        ]),
    )
    .await;
    let pending_guardian = mount_response_once_match(
        &server,
        is_guardian_request,
        sse_response(sse(vec![ev_completed("guardian")])).set_delay(Duration::from_secs(60)),
    )
    .await;
    let parent_poll = mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request)
                && request_body_contains(request, call_id)
                && !request_body_contains(request, poll_call_id)
        },
        sse(vec![
            ev_function_call(
                poll_call_id,
                "write_stdin",
                &json!({
                    "session_id": 1000, "chars": "", "yield_time_ms": 10_000,
                })
                .to_string(),
            ),
            ev_completed("parent-poll"),
        ]),
    )
    .await;
    let parent_final = mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request) && request_body_contains(request, poll_call_id)
        },
        sse(vec![
            ev_assistant_message("done", "understood"),
            ev_completed("parent-done"),
        ]),
    )
    .await;
    submit_managed_network_turn(
        &test,
        "explain why the network request fails",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::AutoReview,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_guardian_request(&pending_guardian).await;
    wait_for_response_request(&parent_poll).await;
    fs::write(test.config.cwd.join("disconnect-now"), "close")?;
    wait_for_completion_without_network_prompt(&test).await;

    let output = parent_final
        .single_request()
        .function_call_output_text(poll_call_id)
        .context("expected model-visible disconnect output")?;
    let prefix = "Network request disconnected after ";
    let suffix = " ms, before approval could complete";
    let elapsed = output
        .split_once(prefix)
        .and_then(|(_, rest)| rest.split_once(suffix))
        .map(|(elapsed, _)| elapsed)
        .with_context(|| format!("missing disconnect explanation: {output}"))?;
    assert!(elapsed.parse::<u128>()? > 0);
    let message = &output[output.find(prefix).context("missing disconnect prefix")?..];
    let message = &message[..prefix.len() + elapsed.len() + suffix.len()];
    insta::assert_snapshot!(message.replacen(elapsed, "<elapsed>", 1), @r"
    Network request disconnected after <elapsed> ms, before approval could complete
    ");
    Ok(())
}

#[tokio::test(flavor = "current_thread")]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn timed_out_guardian_network_review_uses_timeout_outcome_without_user_fallback() -> Result<()>
{
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    struct HoldExecResult {
        call_id: &'static str,
        release: tokio::sync::Notify,
    }

    impl ToolLifecycleContributor for HoldExecResult {
        fn on_tool_finish<'a>(&'a self, input: ToolFinishInput<'a>) -> ToolLifecycleFuture<'a> {
            Box::pin(async move {
                if input.call_id == self.call_id {
                    self.release.notified().await;
                }
            })
        }
    }

    let call_id = "guardian-network-timeout";
    let poll_call_id = "guardian-network-timeout-poll";
    let hold_result = Arc::new(HoldExecResult {
        call_id,
        release: tokio::sync::Notify::new(),
    });
    let mut extensions = ExtensionRegistryBuilder::new();
    extensions.tool_lifecycle_contributor(hold_result.clone());
    let server = start_mock_server().await;
    let test = managed_network_unified_exec_builder(&[])?
        .with_extensions(Arc::new(extensions.build()))
        .build_with_remote_and_local_env(&server)
        .await?;
    mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request)
                && request_body_contains(request, "time out the Guardian network review")
        },
        sse(vec![
            ev_response_created("resp-guardian-timeout-parent"),
            ev_function_call(
                call_id,
                "exec_command",
                &serde_json::to_string(&network_fetch_args(LOCAL_ENVIRONMENT_ID))?,
            ),
            ev_completed("resp-guardian-timeout-parent"),
        ]),
    )
    .await;
    let pending_guardian = mount_response_once_match(
        &server,
        is_guardian_request,
        sse_response(sse(vec![
            ev_response_created("resp-guardian-timeout-review"),
            ev_assistant_message("msg-guardian-timeout-review", r#"{"outcome":"allow"}"#),
            ev_completed("resp-guardian-timeout-review"),
        ]))
        .set_delay(Duration::from_secs(300)),
    )
    .await;
    mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request)
                && request_body_contains(request, call_id)
                && request_body_contains(request, "Process running with session ID 1000")
        },
        sse(vec![
            ev_response_created("resp-guardian-timeout-parent-followup"),
            ev_function_call(
                poll_call_id,
                "write_stdin",
                &serde_json::to_string(&json!({
                    "session_id": 1000,
                    "chars": "",
                    "yield_time_ms": 1_000,
                }))?,
            ),
            ev_completed("resp-guardian-timeout-parent-followup"),
        ]),
    )
    .await;
    let parent_final = mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request) && request_body_contains(request, call_id)
        },
        sse(vec![
            ev_response_created("resp-guardian-timeout-parent-final"),
            ev_assistant_message("msg-guardian-timeout-parent-final", "timed out"),
            ev_completed("resp-guardian-timeout-parent-final"),
        ]),
    )
    .await;

    submit_managed_network_turn(
        &test,
        "time out the Guardian network review",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::AutoReview,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_guardian_request(&pending_guardian).await;
    tokio::time::pause();
    tokio::time::advance(Duration::from_secs(91)).await;
    tokio::time::resume();

    // The clock jump expires the review, but cancellation and output drainage
    // still run asynchronously. Hold the tool result until its terminal event
    // so the model cannot poll before the final failure is available.
    let completion = tokio::time::timeout(
        Duration::from_secs(/*secs*/ 10),
        wait_for_event(&test.codex, |event| match event {
            EventMsg::ExecCommandEnd(event) => event.call_id == call_id,
            EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_) => true,
            _ => false,
        }),
    )
    .await;
    // notify_one retains a permit if the tool-finish callback has not run yet.
    hold_result.release.notify_one();
    let completion = completion.context("timed out waiting for the network command to finish")?;
    assert!(
        matches!(completion, EventMsg::ExecCommandEnd(_)),
        "unexpected event before command completion: {completion:?}"
    );
    wait_for_completion_without_network_prompt(&test).await;

    let request = parent_final.single_request();
    // If the initial exec call already returned its final error, no poll is needed.
    let tool_output = request
        .function_call_output_text(poll_call_id)
        .or_else(|| request.function_call_output_text(call_id))
        .context("expected timed-out Guardian tool output")?;
    assert!(
        tool_output.contains(concat!(
            "The automatic permission approval review did not finish before its deadline. ",
            "Do not assume the action is unsafe based on the timeout alone. ",
            "You may retry once, or ask the user for guidance or explicit approval."
        )),
        "unexpected timed-out Guardian tool output: {tool_output}"
    );
    assert!(!tool_output.contains("rejected by user"));

    Ok(())
}

#[test_case(true; "same_turn")]
#[test_case(false; "later_turn")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn background_network_approval_uses_current_review_settings_and_original_execution(
    same_turn: bool,
) -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_builder(&[
        Feature::RequestPermissionsTool,
        Feature::StepModelSwitching,
    ])?
    .with_model("guardian-parent-a")
    .with_config(|config| {
        config.model_catalog = Some(guardian_parent_catalog());
    })
    .build_with_remote_and_local_env(&server)
    .await?;
    let start_call_id = "cross-turn-network-start";
    let permission_call_id = "cross-turn-network-permissions";
    let stdin_call_id = "cross-turn-network-stdin";
    let requested_permissions = RequestPermissionProfile {
        network: Some(NetworkPermissions {
            enabled: Some(true),
        }),
        ..Default::default()
    };
    let command = format!(
        "read _; {}; echo CROSS-TURN-NETWORK-COMPLETE; read _",
        remote_network_proxy_request_command("NETWORK-RESULT")
    );
    let mut start_args = network_exec_args(&command);
    start_args["environment_id"] = json!(LOCAL_ENVIRONMENT_ID);
    start_args["tty"] = json!(true);
    start_args["yield_time_ms"] = json!(250);
    let mut events = vec![
        sse(vec![
            ev_response_created("resp-cross-turn-network-start"),
            ev_function_call(
                start_call_id,
                "exec_command",
                &serde_json::to_string(&start_args)?,
            ),
            ev_completed("resp-cross-turn-network-start"),
        ]),
        sse(vec![
            ev_response_created("resp-cross-turn-network-first-complete"),
            ev_assistant_message("msg-cross-turn-network-first-complete", "terminal started"),
            ev_completed("resp-cross-turn-network-first-complete"),
        ]),
        sse(vec![
            ev_response_created("resp-cross-turn-network-permissions"),
            ev_function_call(
                permission_call_id,
                "request_permissions",
                &serde_json::to_string(&json!({
                    "reason": "Automatically review the existing terminal's network access",
                    "permissions": requested_permissions,
                }))?,
            ),
            ev_completed("resp-cross-turn-network-permissions"),
        ]),
        sse(vec![
            ev_response_created("resp-cross-turn-network-stdin"),
            ev_function_call(
                stdin_call_id,
                "write_stdin",
                &serde_json::to_string(&json!({
                    "session_id": 1000,
                    "chars": "continue\n",
                    "yield_time_ms": 10_000,
                }))?,
            ),
            ev_completed("resp-cross-turn-network-stdin"),
        ]),
        // Strict review approves terminal input before the process can request network access.
        sse(vec![
            ev_response_created("resp-cross-turn-stdin-guardian"),
            ev_assistant_message(
                "msg-cross-turn-stdin-guardian",
                r#"{"risk_level":"low","user_authorization":"high","outcome":"allow","rationale":"Continue the existing terminal."}"#,
            ),
            ev_completed("resp-cross-turn-stdin-guardian"),
        ]),
        sse(vec![
            ev_response_created("resp-network-guardian-environment"),
            ev_function_call(
                "guardian-pwd",
                "exec_command",
                &network_exec_args("pwd").to_string(),
            ),
            ev_completed("resp-network-guardian-environment"),
        ]),
        sse(vec![
            ev_response_created("resp-cross-turn-network-guardian"),
            ev_assistant_message(
                "msg-cross-turn-network-guardian",
                r#"{"risk_level":"low","user_authorization":"high","outcome":"allow","rationale":"The existing terminal's network request is safe."}"#,
            ),
            ev_completed("resp-cross-turn-network-guardian"),
        ]),
        sse(vec![
            ev_response_created("resp-cross-turn-network-second-complete"),
            ev_assistant_message(
                "msg-cross-turn-network-second-complete",
                "network request approved",
            ),
            ev_completed("resp-cross-turn-network-second-complete"),
        ]),
    ];
    if same_turn {
        // Omit the first completion so the original turn stays active.
        events.remove(/*index*/ 1);
    }
    let responses = mount_sse_sequence(&server, events).await;

    submit_managed_network_turn(
        &test,
        "start a background terminal that waits before requesting network access",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let EventMsg::TurnStarted(first_turn) = wait_for_event(&test.codex, |event| {
        matches!(event, EventMsg::TurnStarted(_))
    })
    .await
    else {
        unreachable!("matched first turn start")
    };
    let current_cwd = test.cwd.path().join("later-turn");
    fs::create_dir(&current_cwd)?;
    let active_turn_id = if same_turn {
        first_turn.turn_id.clone()
    } else {
        wait_for_turn_complete(&test).await;
        assert_eq!(test.codex.list_background_terminals().await.len(), 1);
        test.codex
            .start_or_steer_turn(
                TurnInputRequest::user_input(vec![UserInput::Text {
                    text: "review the existing terminal under B".to_string(),
                    text_elements: Vec::new(),
                }])
                .with_thread_settings(ThreadSettingsOverrides {
                    environments: Some(TurnEnvironmentRequests::new(
                        current_cwd.abs(),
                        vec![local_request(current_cwd.abs())],
                    )),
                    collaboration_mode: Some(CollaborationMode {
                        mode: ModeKind::Default,
                        settings: Settings {
                            model: "guardian-parent-b".to_string(),
                            reasoning_effort: Some(
                                codex_protocol::openai_models::ReasoningEffort::Medium,
                            ),
                            developer_instructions: None,
                        },
                    }),
                    ..Default::default()
                }),
            )
            .await?;
        let EventMsg::TurnStarted(active_turn) = wait_for_event(&test.codex, |event| {
            matches!(event, EventMsg::TurnStarted(_))
        })
        .await
        else {
            unreachable!("matched second turn start")
        };
        assert_ne!(active_turn.turn_id, first_turn.turn_id);
        active_turn.turn_id
    };
    let EventMsg::RequestPermissions(request) = wait_for_event(&test.codex, |event| {
        matches!(event, EventMsg::RequestPermissions(_))
    })
    .await
    else {
        unreachable!("matched request permissions event")
    };
    assert_eq!(request.call_id, permission_call_id);
    if same_turn {
        let (reply, outcome) = tokio::sync::oneshot::channel();
        test.codex
            .submit(Op::TurnSettings {
                turn_id: active_turn_id.clone(),
                update: codex_protocol::protocol::TurnSettingsUpdate {
                    model: Some("guardian-parent-b".to_string()),
                    effort: Some(Some(codex_protocol::openai_models::ReasoningEffort::Medium)),
                    ..Default::default()
                },
                reply,
            })
            .await?;
        assert_eq!(
            tokio::time::timeout(Duration::from_secs(10), outcome).await??,
            codex_protocol::protocol::TurnSettingsUpdateOutcome::Applied,
        );
    }
    test.codex
        .submit(Op::RequestPermissionsResponse {
            id: permission_call_id.to_string(),
            response: RequestPermissionsResponse {
                permissions: request.permissions,
                scope: PermissionGrantScope::Turn,
                strict_auto_review: true,
            },
        })
        .await?;
    let assessment = wait_for_event(&test.codex, |event| {
        matches!(
            event,
            EventMsg::GuardianAssessment(assessment)
                if assessment.status == GuardianAssessmentStatus::Approved
                    && matches!(assessment.action, GuardianAssessmentAction::NetworkAccess { .. })
        ) || matches!(
            event,
            EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)
        )
    })
    .await;
    let EventMsg::GuardianAssessment(assessment) = assessment else {
        panic!("expected Guardian approval, got {assessment:?}");
    };
    assert_eq!(assessment.turn_id, active_turn_id);
    wait_for_turn_complete(&test).await;

    let actions = guardian_network_actions(&responses)?;
    assert_eq!(actions.len(), 2);
    assert_eq!(actions[0], actions[1]);
    let original_command = get_shell(ShellType::Sh)
        .context("expected local sh")?
        .derive_exec_args(&command, /*use_login_shell*/ false);
    assert_eq!(
        actions[0]["trigger"],
        json!({
            "callId": start_call_id,
            "toolName": "exec_command",
            "command": original_command,
            "cwd": test.config.cwd,
            "sandboxPermissions": "use_default",
            "tty": true,
        })
    );
    let requests = responses.requests();
    let reviews = requests
        .iter()
        .filter(|request| request.body_json()["client_metadata"]["x-openai-subagent"] == "guardian")
        .collect::<Vec<_>>();
    assert_eq!(reviews.len(), 3);
    for review in &reviews {
        assert_eq!(review.body_json()["model"], "guardian-parent-b");
        assert_eq!(review.body_json()["reasoning"]["effort"], "medium");
    }
    let parent_requests = requests
        .iter()
        .filter(|request| request.body_json()["client_metadata"]["x-openai-subagent"] != "guardian")
        .collect::<Vec<_>>();
    assert_eq!(parent_requests[0].body_json()["model"], "guardian-parent-a");
    let final_parent = parent_requests
        .last()
        .context("parent completion request")?;
    assert_eq!(final_parent.body_json()["model"], "guardian-parent-b");
    let metadata: Value = serde_json::from_str(
        final_parent.body_json()["client_metadata"]["x-codex-turn-metadata"]
            .as_str()
            .context("Responses turn metadata")?,
    )?;
    // Strict review does not change this field's policy-routing meaning.
    assert_eq!(metadata["auto_review_enabled"], false);
    let pwd_output = reviews[2]
        .function_call_output_text("guardian-pwd")
        .context("Guardian pwd output")?;
    let original_cwd = test
        .config
        .cwd
        .as_path()
        .to_str()
        .context("UTF-8 original cwd")?;
    let current_cwd = current_cwd.to_str().context("UTF-8 current cwd")?;
    assert!(pwd_output.contains(original_cwd));
    assert!(!pwd_output.contains(current_cwd));
    let stdin_output = responses
        .requests()
        .iter()
        .find_map(|request| request.function_call_output_text(stdin_call_id))
        .context("expected background terminal network request output")?;
    assert!(!stdin_output.contains("blocked by policy"));
    assert!(
        stdin_output.contains("NETWORK-RESULT:HTTP/1.1 502")
            || stdin_output.contains("NETWORK-RESULT:HTTP/1.1 200")
    );
    assert!(stdin_output.contains("CROSS-TURN-NETWORK-COMPLETE"));
    assert_eq!(
        test.codex.list_background_terminals().await.len(),
        1,
        "approved network access must not terminate the background process"
    );
    test.codex.submit(Op::CleanBackgroundTerminals).await?;

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn user_network_approval_once_session_and_denial_semantics() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let environments = vec![local(test.config.cwd.clone())];

    mount_exec_network_turn(
        &server,
        "resp-user-network-once-1",
        "user-network-once-1",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "approve this network request once",
        environments.clone(),
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    assert!(
        approval
            .call_id
            .starts_with("network#local#http#codex-network-test.invalid#80#")
    );
    assert_eq!(approval.approval_id.as_deref(), None);
    let first_approval_call_id = approval.call_id.clone();
    assert!(!approval.turn_id.is_empty());
    assert_eq!(approval.cwd, test.config.cwd.clone().into());
    assert_eq!(
        approval.reason.as_deref(),
        Some("Network access to codex-network-test.invalid requires approval")
    );
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::Approved,
        })
        .await?;
    wait_for_turn_complete(&test).await;

    mount_exec_network_turn(
        &server,
        "resp-user-network-once-2",
        "user-network-once-2",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "the once decision must prompt again",
        environments.clone(),
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    assert_eq!(approval.approval_id.as_deref(), None);
    assert_ne!(approval.call_id, first_approval_call_id);
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::ApprovedForSession,
        })
        .await?;
    wait_for_turn_complete(&test).await;

    mount_exec_network_turn(
        &server,
        "resp-user-network-session",
        "user-network-session",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "the session decision must bypass another prompt",
        environments.clone(),
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_completion_without_network_prompt(&test).await;

    let different_port_target = format!("http://{NETWORK_TEST_HOST}:81");
    let different_port_command = format!(
        "python3 -c \"import urllib.request; urllib.request.build_opener(urllib.request.ProxyHandler()).open('{different_port_target}', timeout=2).read()\""
    );
    let denied_responses = mount_exec_network_turn(
        &server,
        "resp-user-network-port",
        "user-network-port",
        network_exec_args(&different_port_command),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "a different port must prompt",
        environments,
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval_target(
        &test,
        LOCAL_ENVIRONMENT_ID,
        &different_port_target,
        NetworkApprovalProtocol::Http,
    )
    .await?;
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::denied("rejected by user"),
        })
        .await?;
    wait_for_turn_complete(&test).await;
    let denied_output = denied_responses
        .requests()
        .iter()
        .find_map(|request| request.function_call_output_text("user-network-port"))
        .context("expected user-denied network output")?;
    assert!(denied_output.contains("rejected by user"));
    assert!(!denied_output.contains("blocked by policy"));

    let socks_target = format!("socks5-tcp://{NETWORK_TEST_HOST}:443");
    let socks_command = format!(
        r#"python3 -c "import os,socket,urllib.parse; proxy=urllib.parse.urlparse(os.environ['ALL_PROXY']); host='{NETWORK_TEST_HOST}'.encode(); sock=socket.create_connection((proxy.hostname, proxy.port)); sock.sendall(b'\x05\x01\x00'); assert sock.recv(2) == b'\x05\x00'; sock.sendall(b'\x05\x01\x00\x03' + bytes([len(host)]) + host + (443).to_bytes(2, 'big')); print(sock.recv(10))""#
    );
    let abort_response = mount_sse_once(
        &server,
        sse(vec![
            ev_response_created("resp-user-network-abort"),
            ev_function_call(
                "user-network-abort",
                "exec_command",
                &serde_json::to_string(&network_exec_args(&socks_command))?,
            ),
            ev_completed("resp-user-network-abort"),
        ]),
    )
    .await;
    submit_managed_network_turn(
        &test,
        "a different protocol must prompt and the user abort must stay a user outcome",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval_target(
        &test,
        LOCAL_ENVIRONMENT_ID,
        &socks_target,
        NetworkApprovalProtocol::Socks5Tcp,
    )
    .await?;
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::Abort,
        })
        .await?;
    wait_for_event(&test.codex, |event| {
        matches!(event, EventMsg::TurnAborted(_))
    })
    .await;
    abort_response.single_request();

    Ok(())
}

#[derive(Clone, Copy)]
enum OtherNetworkReview {
    Denied,
    Pending,
    ApprovedForSession,
}

#[test_case(OtherNetworkReview::Denied; "latest_rejection")]
#[test_case(OtherNetworkReview::Pending; "pending_review")]
#[test_case(OtherNetworkReview::ApprovedForSession; "accepted_review")]
#[tokio::test(flavor = "current_thread")]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn network_rejection_preserves_execution_and_review_outcomes(
    other_review: OtherNetworkReview,
) -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let local_cwd = test.cwd.path().abs();
    let call_id = "network-multiple-reviews";
    let poll_call_id = "network-multiple-reviews-poll";
    let second_target = format!("http://{NETWORK_TEST_HOST}:81");
    let command = format!(
        r#"read _; python3 - <<'PY'
import fcntl, os, pathlib, socket, threading, urllib.parse
process_lock = open('network-process-lock', 'w')
fcntl.flock(process_lock, fcntl.LOCK_EX)
proxy = urllib.parse.urlparse(os.environ['HTTP_PROXY'])
def fetch(port):
    with socket.create_connection((proxy.hostname, proxy.port), timeout=30) as sock:
        sock.sendall(f'GET http://{NETWORK_TEST_HOST}:{{port}}/ HTTP/1.1\r\nHost: {NETWORK_TEST_HOST}:{{port}}\r\nConnection: close\r\n\r\n'.encode())
        status = sock.makefile('rb').readline().decode().strip()
        result = pathlib.Path(f'network-result-{{port}}')
        result.with_suffix('.tmp').write_text(status)
        result.with_suffix('.tmp').replace(result)
threads = [threading.Thread(target=fetch, args=(port,)) for port in (80, 81)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()
threading.Event().wait()
PY"#
    );
    let mut args = network_exec_args(&command);
    args["yield_time_ms"] = json!(250);
    args["tty"] = json!(true);
    let responses = mount_sse_sequence(
        &server,
        vec![
            sse(vec![
                ev_function_call(call_id, "exec_command", &args.to_string()),
                ev_completed("network-start"),
            ]),
            sse(vec![
                ev_function_call(
                    poll_call_id,
                    "write_stdin",
                    &json!({"session_id": 1000, "chars": "start\n", "yield_time_ms": 10_000})
                        .to_string(),
                ),
                ev_completed("network-poll"),
            ]),
            sse(vec![
                ev_assistant_message("network-done", "done"),
                ev_completed("network-done"),
            ]),
        ],
    )
    .await;

    submit_managed_network_turn(
        &test,
        "review both network requests from one execution",
        vec![local(local_cwd.clone())],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;

    let mut approvals = Vec::new();
    for _ in 0..2 {
        let event = wait_for_event_with_timeout(
            &test.codex,
            |event| {
                matches!(
                    event,
                    EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)
                )
            },
            Duration::from_secs(30),
        )
        .await;
        let EventMsg::ExecApprovalRequest(approval) = event else {
            anyhow::bail!("execution completed before both network approvals were requested");
        };
        approvals.push(approval);
    }
    assert_eq!(test.codex.list_background_terminals().await.len(), 1);
    // The child holds this lock until exit, including across the sandbox's PID namespace.
    let process_lock = fs::File::open(local_cwd.join("network-process-lock"))?;
    assert!(matches!(
        process_lock.try_lock(),
        Err(fs::TryLockError::WouldBlock)
    ));
    assert_eq!(approvals[0].turn_id, approvals[1].turn_id);
    approvals.sort_by_key(|approval| approval.command[1].clone());
    let actual_targets = approvals
        .iter()
        .map(|approval| approval.command[1].clone())
        .collect::<Vec<_>>();
    let mut expected_targets = vec![NETWORK_TEST_TARGET.to_string(), second_target];
    expected_targets.sort();
    assert_eq!(actual_targets, expected_targets);

    let first_rejection = "first network approval was rejected";
    let latest_rejection = "latest network approval was rejected";
    let first_approval = &approvals[0];
    let first_decision = match other_review {
        OtherNetworkReview::Denied => Some(ReviewDecision::denied(first_rejection)),
        OtherNetworkReview::Pending => None,
        OtherNetworkReview::ApprovedForSession => Some(ReviewDecision::ApprovedForSession),
    };
    if let Some(decision) = first_decision {
        test.codex
            .submit(Op::ExecApproval {
                id: first_approval.effective_approval_id(),
                turn_id: Some(first_approval.turn_id.clone()),
                decision,
            })
            .await?;
    }
    if matches!(other_review, OtherNetworkReview::ApprovedForSession) {
        // Wait for the process to observe the proxy response before cancelling its execution.
        let result_path = local_cwd.join("network-result-80");
        wait_for_paths(&[&result_path]).await?;
        let result = fs::read_to_string(result_path)?;
        assert!(result.starts_with("HTTP/1.1 200") || result.starts_with("HTTP/1.1 502"));
    }
    let final_approval = &approvals[1];
    test.codex
        .submit(Op::ExecApproval {
            id: final_approval.effective_approval_id(),
            turn_id: Some(final_approval.turn_id.clone()),
            decision: ReviewDecision::denied(latest_rejection),
        })
        .await?;
    wait_for_completion_without_network_prompt(&test).await;
    tokio::time::timeout(Duration::from_secs(5), async {
        loop {
            match process_lock.try_lock() {
                Ok(()) => return Ok(()),
                Err(fs::TryLockError::WouldBlock) => {
                    tokio::time::sleep(Duration::from_millis(10)).await;
                }
                Err(fs::TryLockError::Error(error)) => return Err(error),
            }
        }
    })
    .await
    .context("background process remained alive after network rejection")??;
    assert!(test.codex.list_background_terminals().await.is_empty());

    let output = responses
        .requests()
        .iter()
        .find_map(|request| request.function_call_output_text(poll_call_id))
        .context("expected output from the execution with multiple network reviews")?;
    assert!(output.contains(latest_rejection), "{output}");
    assert!(!output.contains(first_rejection), "{output}");

    if matches!(other_review, OtherNetworkReview::ApprovedForSession) {
        let probe_call_id = "network-session-grant-probe";
        let probe = mount_exec_network_turn(
            &server,
            "network-session-grant-probe",
            probe_call_id,
            network_exec_args(&remote_network_proxy_request_command("REUSED-GRANT")),
        )
        .await?;
        submit_managed_network_turn(
            &test,
            "reuse the accepted host grant after the original execution was cancelled",
            vec![local(local_cwd.clone())],
            ApprovalsReviewer::User,
            AskForApproval::OnRequest,
        )
        .await?;
        wait_for_completion_without_network_prompt(&test).await;
        let output = probe
            .function_call_output_text(probe_call_id)
            .context("expected network output from the new execution")?;
        assert!(
            output.contains("REUSED-GRANT:HTTP/1.1 200")
                || output.contains("REUSED-GRANT:HTTP/1.1 502"),
            "{output}",
        );
    }

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn allowing_network_policy_amendment_persists_context_and_bypasses_prompt() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let environments = vec![local(test.config.cwd.clone())];
    let first_responses = mount_exec_network_turn(
        &server,
        "resp-network-amendment-1",
        "network-amendment-1",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "persist an allow rule for this host",
        environments.clone(),
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    let amendments = approval
        .proposed_network_policy_amendments
        .clone()
        .context("expected network policy amendments")?;
    assert_eq!(
        amendments,
        vec![
            NetworkPolicyAmendment {
                host: NETWORK_TEST_HOST.to_string(),
                action: NetworkPolicyRuleAction::Allow,
            },
            NetworkPolicyAmendment {
                host: NETWORK_TEST_HOST.to_string(),
                action: NetworkPolicyRuleAction::Deny,
            },
        ]
    );
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::NetworkPolicyAmendment {
                network_policy_amendment: amendments[0].clone(),
            },
        })
        .await?;
    wait_for_turn_complete(&test).await;

    let policy = fs::read_to_string(test.home.path().join("rules/default.rules"))?;
    assert!(policy.contains(
        r#"network_rule(host="codex-network-test.invalid", protocol="http", decision="allow""#
    ));
    assert!(first_responses.requests().iter().any(|request| {
        request.body_contains_text(
            "Allowed network rule saved in execpolicy (allowlist): codex-network-test.invalid",
        )
    }));
    mount_exec_network_turn(
        &server,
        "resp-network-amendment-2",
        "network-amendment-2",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "reuse the persisted allow rule",
        environments,
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_completion_without_network_prompt(&test).await;

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn denying_network_policy_amendment_persists_and_blocks_request() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let responses = mount_exec_network_turn(
        &server,
        "resp-network-deny-amendment",
        "network-deny-amendment",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "persist a deny rule for this host",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::NetworkPolicyAmendment {
                network_policy_amendment: NetworkPolicyAmendment {
                    host: NETWORK_TEST_HOST.to_string(),
                    action: NetworkPolicyRuleAction::Deny,
                },
            },
        })
        .await?;
    wait_for_turn_complete(&test).await;

    let policy = fs::read_to_string(test.home.path().join("rules/default.rules"))?;
    assert!(policy.contains(
        r#"network_rule(host="codex-network-test.invalid", protocol="http", decision="deny""#
    ));
    let output = responses
        .requests()
        .iter()
        .find_map(|request| request.function_call_output_text("network-deny-amendment"))
        .context("expected denied network tool output")?;
    assert!(output.contains("rejected by user"));
    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn failed_network_policy_amendment_denies_request_and_does_not_approve_host() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let environments = vec![local(test.config.cwd.clone())];
    let first_responses = mount_exec_network_turn(
        &server,
        "resp-network-failed-amendment-1",
        "network-failed-amendment-1",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "reject an invalid network policy amendment",
        environments.clone(),
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::NetworkPolicyAmendment {
                network_policy_amendment: NetworkPolicyAmendment {
                    host: "not-the-approved-host.invalid".to_string(),
                    action: NetworkPolicyRuleAction::Allow,
                },
            },
        })
        .await?;
    wait_for_turn_complete(&test).await;

    let denied_output = first_responses
        .requests()
        .iter()
        .find_map(|request| request.function_call_output_text("network-failed-amendment-1"))
        .context("expected the failed policy amendment to reject the network request")?;
    assert!(denied_output.contains("blocked by policy"));
    mount_exec_network_turn(
        &server,
        "resp-network-failed-amendment-2",
        "network-failed-amendment-2",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "a failed policy amendment must not approve the host for the session",
        environments,
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::denied("reject the retried network request"),
        })
        .await?;
    wait_for_turn_complete(&test).await;

    Ok(())
}

#[test_case(ApprovalsReviewer::User; "user_approval")]
#[test_case(ApprovalsReviewer::AutoReview; "shutdown_during_guardian_retry")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn unattributed_network_request_uses_active_turn_environment_fallback(
    approvals_reviewer: ApprovalsReviewer,
) -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses a raw TCP proxy fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let features = if approvals_reviewer == ApprovalsReviewer::User {
        &[Feature::DeferredExecutor][..]
    } else {
        &[]
    };
    let test = managed_network_unified_exec_test_with_features(&server, features).await?;
    let mut selection = local(test.config.cwd.clone());
    if approvals_reviewer == ApprovalsReviewer::User {
        let cwd = test.config.cwd.join("late-environment");
        fs::create_dir(&cwd)?;
        selection = local(cwd);
        selection.config = EnvironmentConfigState::Pending;
    }
    let pending_model = mount_response_once_match(
        &server,
        |request: &wiremock::Request| request_body_contains(request, "hold the active turn"),
        sse_response(sse(vec![
            ev_response_created("resp-unattributed-network"),
            ev_assistant_message("msg-unattributed-network", "done"),
            ev_completed("resp-unattributed-network"),
        ]))
        .set_delay(Duration::from_secs(30)),
    )
    .await;
    submit_managed_network_turn(
        &test,
        "hold the active turn",
        vec![selection.clone()],
        approvals_reviewer,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_response_request(&pending_model).await;

    if approvals_reviewer == ApprovalsReviewer::User {
        let root = SelectedCapabilityRoot {
            id: "late-environment".into(),
            location: CapabilityRootLocation::Environment {
                environment_id: selection.environment_id.clone(),
                path: selection.cwd.clone(),
            },
        };
        test.codex
            .environment_ready(
                &selection,
                EnvironmentConfig {
                    environment_hooks: Default::default(),
                    allow_login_shell: test.config.permissions.allow_login_shell,
                    workspace_roots: selection.workspace_roots.clone(),
                    permission_profile: PermissionProfileSnapshot::legacy(
                        test.config.permissions.permission_profile().clone(),
                    ),
                    shell_environment_policy: test
                        .config
                        .permissions
                        .shell_environment_policy
                        .clone(),
                    windows_sandbox_level: WindowsSandboxLevel::from_config(&test.config),
                    windows_sandbox_type: test.config.permissions.windows_sandbox_type,
                    use_legacy_landlock: test.config.features.use_legacy_landlock(),
                    exec_policy: None,
                    mcp_policy: None,
                    network_policy: None,
                    selected_capability_roots: vec![root.clone()],
                },
            )
            .await?;
        tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {
            while !test
                .codex
                .inspect_selected_capability_roots()
                .ready_roots
                .contains(&root)
            {
                tokio::task::yield_now().await;
            }
        })
        .await?;
    }

    let proxy_addr = test
        .session_configured
        .network_proxy
        .as_ref()
        .context("expected managed network proxy")?
        .http_addr
        .clone();
    if approvals_reviewer == ApprovalsReviewer::AutoReview {
        mount_sse_once_match(
            &server,
            is_guardian_request,
            core_test_support::responses::sse_failed(
                "guardian-first-failure",
                "rate_limit_exceeded",
                "Rate limit exceeded. Please try again in 0s.",
            ),
        )
        .await;
        let retrying = mount_sse_once_match(
            &server,
            is_guardian_request,
            core_test_support::responses::sse_failed(
                "guardian-rate-limited",
                "rate_limit_exceeded",
                "Rate limit exceeded. Please try again in 60s.",
            ),
        )
        .await;
        let proxy_request = tokio::spawn(raw_http_proxy_request(proxy_addr, NETWORK_TEST_HOST));
        wait_for_response_request(&retrying).await;
        let request = retrying.single_request().body_json();
        let thread_id = request["client_metadata"]["thread_id"]
            .as_str()
            .context("Guardian thread id")?;
        let thread_id = codex_protocol::ThreadId::from_string(thread_id)?;
        // Internal reviewers are hidden from get_thread. Their persisted terminal event
        // confirms the reviewer's own retries finished before testing Guardian's retry wait.
        tokio::time::timeout(Duration::from_secs(5), async {
            loop {
                test.thread_store.flush_thread(thread_id).await?;
                let history = test
                    .thread_store
                    .load_latest_model_context(LoadThreadHistoryParams {
                        thread_id,
                        include_archived: false,
                    })
                    .await?;
                if history.items.iter().any(|item| {
                    matches!(item, RolloutItem::EventMsg(EventMsg::TurnComplete(event)) if event.error.is_some())
                }) {
                    return Ok::<(), anyhow::Error>(());
                }
                tokio::time::sleep(Duration::from_millis(10)).await;
            }
        })
        .await
        .context("Guardian reviewer did not finish its rate-limited turn")??;
        tokio::time::timeout(Duration::from_secs(5), test.codex.shutdown_and_wait())
            .await
            .context("parent shutdown waited for Guardian's 60-second retry")??;
        let response = tokio::time::timeout(Duration::from_secs(5), proxy_request).await???;
        assert!(response.starts_with("HTTP/1.1 403"), "{response}");
        assert_eq!(retrying.requests().len(), 1);
        return Ok(());
    }
    let proxy_request = tokio::spawn(raw_http_proxy_request(proxy_addr, NETWORK_TEST_HOST));
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    assert_eq!(approval.command, ["network-access", NETWORK_TEST_TARGET]);
    assert_eq!(approval.cwd, selection.cwd.into());
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: Some(approval.turn_id),
            decision: ReviewDecision::Approved,
        })
        .await?;
    let response = tokio::time::timeout(Duration::from_secs(10), proxy_request)
        .await
        .context("unattributed proxy request did not finish")???;
    assert!(response.starts_with("HTTP/1.1 200") || response.starts_with("HTTP/1.1 502"));

    test.codex.submit(Op::Interrupt).await?;
    wait_for_event(&test.codex, |event| {
        matches!(event, EventMsg::TurnAborted(_))
    })
    .await;

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn ambiguous_unattributed_network_request_is_not_assigned_to_active_calls() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses POSIX shell and raw TCP fixtures");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let first_marker = test.cwd.path().join("ambiguous-network-first");
    let second_marker = test.cwd.path().join("ambiguous-network-second");
    let wait_command = |marker: &std::path::Path| {
        format!(
            "touch '{}' && while true; do sleep 1; done",
            marker.display()
        )
    };
    mount_sse_once_match(
        &server,
        |request: &wiremock::Request| request_body_contains(request, "start two active commands"),
        sse(vec![
            ev_response_created("resp-ambiguous-network"),
            ev_function_call(
                "ambiguous-network-first",
                "exec_command",
                &serde_json::to_string(&network_exec_args(&wait_command(&first_marker)))?,
            ),
            ev_function_call(
                "ambiguous-network-second",
                "exec_command",
                &serde_json::to_string(&network_exec_args(&wait_command(&second_marker)))?,
            ),
            ev_completed("resp-ambiguous-network"),
        ]),
    )
    .await;
    submit_managed_network_turn(
        &test,
        "start two active commands",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    wait_for_paths(&[&first_marker, &second_marker]).await?;

    let proxy_addr = test
        .session_configured
        .network_proxy
        .as_ref()
        .context("expected managed network proxy")?
        .http_addr
        .clone();
    let response = tokio::time::timeout(
        Duration::from_secs(10),
        raw_http_proxy_request(proxy_addr, NETWORK_TEST_HOST),
    )
    .await
    .context("ambiguous proxy request did not finish")??;
    assert!(response.starts_with("HTTP/1.1 403"));
    assert!(
        tokio::time::timeout(
            Duration::from_secs(1),
            wait_for_event(&test.codex, |event| matches!(
                event,
                EventMsg::ExecApprovalRequest(_)
            ))
        )
        .await
        .is_err(),
        "ambiguous request was incorrectly assigned to an active call"
    );

    test.codex.submit(Op::Interrupt).await?;
    wait_for_event(&test.codex, |event| {
        matches!(event, EventMsg::TurnAborted(_))
    })
    .await;
    test.codex.submit(Op::CleanBackgroundTerminals).await?;
    tokio::time::timeout(Duration::from_secs(10), async {
        loop {
            if test.codex.list_background_terminals().await.is_empty() {
                break;
            }
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .context("timed out waiting for background terminal cleanup")?;

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn thread_turnover_closes_managed_proxy_tunnels() -> Result<()> {
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let mut config = test.config.clone();
    let mut network = NetworkProxyConfig {
        enabled: true,
        mode: codex_network_proxy::NetworkMode::Full,
        allow_local_binding: Some(true),
        allow_upstream_proxy: false,
        ..NetworkProxyConfig::default()
    };
    network.set_allowed_domains(vec!["127.0.0.1".to_string()]);
    config.permissions.network = Some(NetworkProxySpec::from_config_and_constraints(
        network,
        /*requirements*/ None,
        config.permissions.permission_profile(),
    )?);
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
    let target = listener.local_addr()?;

    for cycle in 0..3 {
        let started = test
            .thread_manager
            .start_thread(StartThreadOptions::new(config.clone()))
            .await?;
        let proxy = started
            .session_configured
            .network_proxy
            .as_ref()
            .context("expected managed network proxy for new thread")?;
        let (mut client, upstream) = tokio::time::timeout(Duration::from_secs(5), async {
            let mut client = tokio::net::TcpStream::connect(&proxy.http_addr).await?;
            client
                .write_all(
                    format!("CONNECT {target} HTTP/1.1\r\nHost: {target}\r\n\r\n").as_bytes(),
                )
                .await?;
            let (mut upstream, _) = listener.accept().await?;
            let mut headers = Vec::new();
            while !headers.ends_with(b"\r\n\r\n") {
                headers.push(client.read_u8().await?);
            }
            let headers = String::from_utf8(headers)?;
            assert!(headers.starts_with("HTTP/1.1 200 "), "{headers:?}");
            client.write_all(b"request").await?;
            client.shutdown().await?;
            let mut request = Vec::new();
            upstream.read_to_end(&mut request).await?;
            assert_eq!(request, b"request");
            // Preserve valid half-close behavior while the thread is alive; its
            // upstream peer deliberately keeps the write half open through unload.
            upstream.write_all(b"response").await?;
            let mut response = [0_u8; 8];
            client.read_exact(&mut response).await?;
            assert_eq!(&response, b"response");
            Ok::<_, anyhow::Error>((client, upstream))
        })
        .await
        .with_context(|| {
            format!("thread cycle {cycle} did not establish a half-closed tunnel")
        })??;

        tokio::time::timeout(Duration::from_secs(5), started.thread.shutdown_and_wait())
            .await
            .with_context(|| format!("thread cycle {cycle} did not shut down"))??;
        // Unloading releases both the manager's and caller's strong session owners.
        drop(
            test.thread_manager
                .remove_thread(&started.thread_id)
                .await
                .context("expected stopped thread in manager")?,
        );
        drop(started);

        let result = tokio::time::timeout(Duration::from_secs(2), client.read(&mut [0_u8; 1]))
            .await
            .with_context(|| format!("thread cycle {cycle} retained its tunnel after unload"))?;
        match result {
            Ok(bytes) => assert_eq!(bytes, 0),
            Err(error) => assert!(
                matches!(
                    error.kind(),
                    std::io::ErrorKind::ConnectionReset | std::io::ErrorKind::ConnectionAborted
                ),
                "unexpected tunnel error after thread unload: {error}"
            ),
        }
        drop(upstream);
    }
    test.codex.shutdown_and_wait().await?;
    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn guardian_receives_exact_triggers_for_concurrent_network_requests() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let barrier_dir = TempDir::new_in(test.cwd.path())?;
    let first_marker = barrier_dir.path().join("first");
    let second_marker = barrier_dir.path().join("second");
    let network_command = |marker: &PathBuf, peer_marker: &PathBuf, host: &str| {
        format!(
            "touch '{}' && while [ ! -e '{}' ]; do sleep 0.01; done && python3 -c \"import urllib.request; urllib.request.build_opener(urllib.request.ProxyHandler()).open('http://{host}', timeout=10).read()\"",
            marker.display(),
            peer_marker.display(),
        )
    };
    let first_command = network_command(&first_marker, &second_marker, "1.1.1.1");
    let second_command = network_command(&second_marker, &first_marker, "8.8.8.8");
    let mut first_args = network_exec_args(&first_command);
    first_args["yield_time_ms"] = json!(10_000);
    let mut second_args = network_exec_args(&second_command);
    second_args["yield_time_ms"] = json!(10_000);
    let first_denial = "first concurrent network request denied";
    let second_denial = "second concurrent network request denied";
    mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request)
                && request_body_contains(request, "run both network requests")
                && !request_body_contains(request, "exec-network-first")
        },
        sse(vec![
            ev_response_created("resp-network-concurrent"),
            ev_function_call(
                "exec-network-first",
                "exec_command",
                &serde_json::to_string(&first_args)?,
            ),
            ev_function_call(
                "exec-network-second",
                "exec_command",
                &serde_json::to_string(&second_args)?,
            ),
            ev_completed("resp-network-concurrent"),
        ]),
    )
    .await;
    let first_guardian = mount_sse_once_match(
        &server,
        |request: &wiremock::Request| guardian_request_is_for(request, "exec-network-first"),
        sse(vec![
            ev_response_created("resp-network-guardian-1"),
            ev_assistant_message(
                "msg-network-guardian-1",
                &json!({
                    "risk_level": "high",
                    "user_authorization": "low",
                    "outcome": "deny",
                    "rationale": first_denial,
                })
                .to_string(),
            ),
            ev_completed("resp-network-guardian-1"),
        ]),
    )
    .await;
    let second_guardian = mount_sse_once_match(
        &server,
        |request: &wiremock::Request| guardian_request_is_for(request, "exec-network-second"),
        sse(vec![
            ev_response_created("resp-network-guardian-2"),
            ev_assistant_message(
                "msg-network-guardian-2",
                &json!({
                    "risk_level": "high",
                    "user_authorization": "low",
                    "outcome": "deny",
                    "rationale": second_denial,
                })
                .to_string(),
            ),
            ev_completed("resp-network-guardian-2"),
        ]),
    )
    .await;
    let final_response = mount_sse_once_match(
        &server,
        |request: &wiremock::Request| {
            !is_guardian_request(request)
                && request_body_contains(request, "exec-network-first")
                && request_body_contains(request, "exec-network-second")
        },
        sse(vec![
            ev_response_created("resp-network-done"),
            ev_assistant_message("msg-network-done", "done"),
            ev_completed("resp-network-done"),
        ]),
    )
    .await;

    submit_managed_network_turn(
        &test,
        "run both network requests",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::AutoReview,
        AskForApproval::OnRequest,
    )
    .await?;
    let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
    let actual_triggers = loop {
        let mut actual_triggers = guardian_network_triggers(&[&first_guardian, &second_guardian])?;
        actual_triggers.sort_unstable();
        actual_triggers.dedup();
        if actual_triggers.len() == 2 {
            break actual_triggers;
        }
        if tokio::time::Instant::now() >= deadline {
            anyhow::bail!("timed out waiting for both Guardian network reviews");
        }
        tokio::time::sleep(Duration::from_millis(10)).await;
    };
    wait_for_turn_complete(&test).await;

    assert_eq!(
        actual_triggers,
        vec![
            ("exec-network-first".to_string(), first_command),
            ("exec-network-second".to_string(), second_command),
        ]
    );
    let requests = final_response.requests();
    let first_output = requests
        .iter()
        .find_map(|request| request.function_call_output_text("exec-network-first"))
        .context("expected first concurrent tool output")?;
    let second_output = requests
        .iter()
        .find_map(|request| request.function_call_output_text("exec-network-second"))
        .context("expected second concurrent tool output")?;
    assert!(first_output.contains(first_denial));
    assert!(!first_output.contains(second_denial));
    assert!(second_output.contains(second_denial));
    assert!(!second_output.contains(first_denial));

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[cfg_attr(
    not(target_os = "linux"),
    ignore = "requires the trusted Linux proxy bridge"
)]
async fn guardian_receives_exact_trigger_for_single_network_request() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let command = "python3 -c \"import urllib.request; opener = urllib.request.build_opener(urllib.request.ProxyHandler()); print('OK:' + opener.open('http://1.1.1.1', timeout=10).read().decode(errors='replace'))\"".to_string();
    let call_id = "exec-network-single";
    mount_sse_once_match(
        &server,
        move |request: &wiremock::Request| {
            !is_guardian_request(request) && !request_body_contains(request, call_id)
        },
        sse(vec![
            ev_response_created("resp-network-single"),
            ev_function_call(
                call_id,
                "exec_command",
                &serde_json::to_string(&network_exec_args(&command))?,
            ),
            ev_completed("resp-network-single"),
        ]),
    )
    .await;
    let guardian = mount_sse_once_match(
        &server,
        is_guardian_request,
        sse(vec![
            ev_response_created("resp-network-guardian"),
            ev_assistant_message("msg-network-guardian", r#"{"outcome":"deny"}"#),
            ev_completed("resp-network-guardian"),
        ]),
    )
    .await;

    // The command can yield before its network request reaches Guardian. Keep the
    // parent on that process until it exits, without consuming Guardian's reply.
    let _parent = wiremock::Mock::given(wiremock::matchers::method("POST"))
        .and(wiremock::matchers::path("/v1/responses"))
        .and(move |request: &wiremock::Request| {
            !is_guardian_request(request) && request_body_contains(request, call_id)
        })
        .respond_with(move |request: &wiremock::Request| {
            let body: Value = serde_json::from_slice(
                &decoded_request_body(request).expect("decode parent request"),
            )
            .expect("parse parent request");
            let input = body["input"].as_array().expect("parent input");
            let output = input
                .iter()
                .rev()
                .find(|item| item["type"] == "function_call_output")
                .and_then(|item| item["output"].as_str())
                .expect("network command or poll output");
            let response_id = format!("{call_id}-{}", input.len());
            let event = if let Some(session_id) = output
                .lines()
                .find_map(|line| line.strip_prefix("Process running with session ID "))
            {
                ev_function_call(
                    &response_id,
                    "write_stdin",
                    &json!({
                        "session_id": session_id.parse::<i32>().expect("session id"),
                        "chars": "",
                        "yield_time_ms": 1_000,
                    })
                    .to_string(),
                )
            } else {
                ev_assistant_message(&response_id, "done")
            };
            sse_response(sse(vec![event, ev_completed(&response_id)]))
        })
        .mount_as_scoped(&server)
        .await;

    submit_managed_network_turn(
        &test,
        "run one network request",
        vec![local(test.config.cwd.clone())],
        ApprovalsReviewer::AutoReview,
        AskForApproval::OnRequest,
    )
    .await?;
    tokio::time::timeout(Duration::from_secs(30), wait_for_turn_complete(&test))
        .await
        .context("timed out waiting for the network process and Guardian review to finish")?;

    assert_eq!(
        guardian_network_triggers(&[&guardian])?,
        vec![(call_id.to_string(), command)]
    );

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn remote_guardian_network_decisions_are_scoped_to_each_request_and_environment() -> Result<()>
{
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));
    skip_if_no_remote_env!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let remote = test.executor_environment().selection().clone();
    assert_eq!(remote.environment_id, REMOTE_ENVIRONMENT_ID);
    let session_call_id = "remote-guardian-session-approval";
    let session_command = remote_network_proxy_request_command("REMOTE_GUARDIAN_SESSION");
    let session_probe_call_id = "remote-guardian-session-probe";
    let session_probe_command =
        remote_network_proxy_request_command("REMOTE_GUARDIAN_SESSION_PROBE");

    let cases = [
        (
            "remote-guardian-deny",
            remote_network_proxy_request_command("REMOTE_GUARDIAN_DENY"),
            remote.clone(),
            "The first remote request must be denied.",
            false,
        ),
        (
            "remote-guardian-allow",
            remote_network_proxy_request_command("REMOTE_GUARDIAN_ALLOW"),
            remote.clone(),
            "This remote request is safe to allow once.",
            true,
        ),
        (
            "remote-guardian-deny-again",
            remote_network_proxy_request_command("REMOTE_GUARDIAN_DENY_AGAIN"),
            remote.clone(),
            "A previous remote approval must not approve a later request.",
            false,
        ),
        (
            "local-guardian-deny",
            remote_network_proxy_request_command("LOCAL_GUARDIAN_DENY"),
            local(test.cwd.path().abs()),
            "A remote approval must not approve the local environment.",
            false,
        ),
    ];

    let mut scripted_responses = Vec::with_capacity(cases.len() * 3 + 4);
    for (call_id, command, _, rationale, approved) in &cases {
        if *call_id == "local-guardian-deny" {
            scripted_responses.push(sse(vec![
                ev_response_created("resp-remote-guardian-session-approval-parent"),
                ev_function_call(
                    session_call_id,
                    "exec_command",
                    &serde_json::to_string(&network_exec_args(&session_command))?,
                ),
                ev_completed("resp-remote-guardian-session-approval-parent"),
            ]));
            scripted_responses.push(sse(vec![
                ev_response_created("resp-remote-guardian-session-approval-done"),
                ev_assistant_message("msg-remote-guardian-session-approval-done", "done"),
                ev_completed("resp-remote-guardian-session-approval-done"),
            ]));
        }
        scripted_responses.push(sse(vec![
            ev_response_created(&format!("resp-{call_id}-parent")),
            ev_function_call(
                call_id,
                "exec_command",
                &serde_json::to_string(&network_exec_args(command))?,
            ),
            ev_completed(&format!("resp-{call_id}-parent")),
        ]));
        let assessment = json!({
            "risk_level": if *approved { "low" } else { "high" },
            "user_authorization": if *approved { "high" } else { "low" },
            "outcome": if *approved { "allow" } else { "deny" },
            "rationale": rationale,
        });
        scripted_responses.push(sse(vec![
            ev_response_created(&format!("resp-{call_id}-guardian")),
            ev_assistant_message(&format!("msg-{call_id}-guardian"), &assessment.to_string()),
            ev_completed(&format!("resp-{call_id}-guardian")),
        ]));
        scripted_responses.push(sse(vec![
            ev_response_created(&format!("resp-{call_id}-done")),
            ev_assistant_message(&format!("msg-{call_id}-done"), "done"),
            ev_completed(&format!("resp-{call_id}-done")),
        ]));
    }
    scripted_responses.push(sse(vec![
        ev_response_created("resp-remote-guardian-session-probe-parent"),
        ev_function_call(
            session_probe_call_id,
            "exec_command",
            &serde_json::to_string(&network_exec_args(&session_probe_command))?,
        ),
        ev_completed("resp-remote-guardian-session-probe-parent"),
    ]));
    scripted_responses.push(sse(vec![
        ev_response_created("resp-remote-guardian-session-probe-done"),
        ev_assistant_message("msg-remote-guardian-session-probe-done", "done"),
        ev_completed("resp-remote-guardian-session-probe-done"),
    ]));
    let responses = mount_sse_sequence(&server, scripted_responses).await;

    for (call_id, _, environment, _, _) in &cases {
        if *call_id == "local-guardian-deny" {
            submit_managed_network_turn(
                &test,
                "approve the remote destination for this session",
                vec![remote.clone()],
                ApprovalsReviewer::User,
                AskForApproval::OnRequest,
            )
            .await?;
            let approval = expect_network_approval(&test, REMOTE_ENVIRONMENT_ID).await?;
            test.codex
                .submit(Op::ExecApproval {
                    id: approval.effective_approval_id(),
                    turn_id: Some(approval.turn_id),
                    decision: ReviewDecision::ApprovedForSession,
                })
                .await?;
            tokio::time::timeout(Duration::from_secs(15), wait_for_turn_complete(&test))
                .await
                .context("remote session approval should complete")?;
        }
        let prompt = format!("review network request {call_id}");
        submit_managed_network_turn(
            &test,
            &prompt,
            vec![environment.clone()],
            ApprovalsReviewer::AutoReview,
            AskForApproval::OnRequest,
        )
        .await?;
        tokio::time::timeout(
            Duration::from_secs(15),
            wait_for_completion_without_network_prompt(&test),
        )
        .await
        .with_context(|| format!("Guardian review for {call_id} should complete"))?;
    }
    submit_managed_network_turn(
        &test,
        "verify the remote session approval remains active",
        vec![remote],
        ApprovalsReviewer::User,
        AskForApproval::OnRequest,
    )
    .await?;
    tokio::time::timeout(
        Duration::from_secs(15),
        wait_for_completion_without_network_prompt(&test),
    )
    .await
    .context("remote session approval should bypass another network prompt")?;

    let local_shell = get_shell(ShellType::Sh).context("expected local sh")?;
    let mut expected_actions = Vec::with_capacity(cases.len());
    for (call_id, command, environment, _, _) in &cases {
        let cwd = environment
            .cwd
            .to_abs_path()
            .with_context(|| format!("resolve the environment cwd for {call_id}"))?;
        let command = if environment.environment_id == LOCAL_ENVIRONMENT_ID {
            local_shell.derive_exec_args(command, /*use_login_shell*/ false)
        } else {
            vec!["/bin/sh".to_string(), "-c".to_string(), command.clone()]
        };
        expected_actions.push(json!({
            "host": NETWORK_TEST_HOST,
            "port": 80,
            "protocol": "http",
            "target": NETWORK_TEST_TARGET,
            "tool": "network_access",
            "environment_id": environment.environment_id,
            "trigger": {
                "callId": call_id,
                "command": command,
                "cwd": cwd,
                "sandboxPermissions": "use_default",
                "toolName": "exec_command",
                "tty": false,
            },
        }));
    }
    assert_eq!(guardian_network_actions(&responses)?, expected_actions);

    let requests = responses.requests();
    for (call_id, marker) in [
        (session_call_id, "REMOTE_GUARDIAN_SESSION:HTTP/1.1 502"),
        (
            session_probe_call_id,
            "REMOTE_GUARDIAN_SESSION_PROBE:HTTP/1.1 502",
        ),
    ] {
        let output = requests
            .iter()
            .find_map(|request| request.function_call_output_text(call_id))
            .with_context(|| format!("expected remote session network output for {call_id}"))?;
        assert!(output.contains(marker));
        assert!(!output.contains("rejected"));
    }
    for (call_id, _, _, rationale, approved) in &cases {
        let output = requests
            .iter()
            .find_map(|request| request.function_call_output_text(call_id))
            .with_context(|| format!("expected network tool output for {call_id}"))?;
        if *approved {
            assert!(output.contains("REMOTE_GUARDIAN_ALLOW:HTTP/1.1 502"));
            assert!(!output.contains("rejected"));
        } else {
            assert!(output.contains(rationale));
            assert!(!output.contains("HTTP/1.1 502"));
        }
    }

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn owner_network_policy_follows_the_selected_remote_command() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));
    skip_if_no_remote_env!(Ok(()));

    let server = start_mock_server().await;
    let mut scenarios = vec![(
        "ROOTED",
        managed_network_unified_exec_test(&server).await?,
        Some(true),
    )];
    for (scenario, configured_controller, allow_local_binding) in [
        ("ROOTLESS", false, None),
        ("USER_ROOTED", true, Some(true)),
        ("USER_UNSET", true, None),
        ("USER_DENIED", true, Some(false)),
    ] {
        let mut builder = test_codex().with_config(move |config| {
            config
                .features
                .disable(Feature::NetworkProxy)
                .expect("test config should allow feature update");
            for feature in [Feature::UnifiedExec, Feature::ExecPermissionApprovals] {
                config
                    .features
                    .enable(feature)
                    .expect("test config should allow feature update");
            }
            config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);
            config
                .permissions
                .set_permission_profile(PermissionProfile::workspace_write_with(
                    &[],
                    NetworkSandboxPolicy::Enabled,
                    /*exclude_tmpdir_env_var*/ false,
                    /*exclude_slash_tmp*/ false,
                ))
                .expect("set permission profile");
            config.permissions.network = configured_controller.then(|| {
                NetworkProxySpec::from_config_and_constraints(
                    NetworkProxyConfig {
                        enabled: true,
                        allow_local_binding,
                        ..NetworkProxyConfig::default()
                    },
                    /*requirements*/ None,
                    config.permissions.permission_profile(),
                )
                .expect("build user-configured controller proxy")
            });
        });
        let test = builder.build_with_remote_and_local_env(&server).await?;
        assert!(!test.config.managed_network_requirements_enabled());
        assert!(!test.config.features.enabled(Feature::NetworkProxy));
        assert_eq!(
            test.session_configured.network_proxy.is_some(),
            configured_controller
        );
        scenarios.push((scenario, test, allow_local_binding));
    }

    for (scenario, test, controller_local_binding) in scenarios {
        let mut remote = test.executor_environment().selection().clone();
        let remote_private_path = remote.cwd.join("secondary-environment-private")?;
        let permissions = test.config.permissions.permission_profile();
        let mut filesystem = permissions.file_system_sandbox_policy();
        filesystem.entries.push(FileSystemSandboxEntry {
            path: FileSystemPath::Path {
                path: remote_private_path.clone(),
            },
            access: FileSystemAccessMode::Deny,
            missing_path_behavior: None,
        });
        filesystem.entries.push(FileSystemSandboxEntry::new(
            FileSystemPath::GlobPattern {
                pattern: "*.guardian-secret".into(),
            },
            FileSystemAccessMode::Deny,
        ));
        let remote_review_permissions = PermissionProfile::from_runtime_permissions(
            &filesystem,
            permissions.network_sandbox_policy(),
        );

        for (suffix, allowed_domain, expected) in [
            (
                "ESCALATION_DENIED",
                NETWORK_TEST_HOST,
                "test escalation denied",
            ),
            ("ESCALATED", NETWORK_TEST_HOST, "OWNER_ESCALATED:unproxied"),
            ("ESCALATED_DENY_READ", "owner-only.invalid", "HTTP/1.1 403"),
            ("ALLOWED", NETWORK_TEST_HOST, "HTTP/1.1 502"),
            ("DENIED", "owner-only.invalid", "HTTP/1.1 403"),
            ("REVIEWED", "owner-only.invalid", "HTTP/1.1 502"),
            ("OFFLINE", "owner-only.invalid", "ROOTLESS_OWNER_OFFLINE"),
            ("REQUIRED_ALLOWED", NETWORK_TEST_HOST, "HTTP/1.1 502"),
            ("REQUIRED_DENIED", "owner-only.invalid", "HTTP/1.1 403"),
            ("GRANTED_DENIED", "owner-only.invalid", "HTTP/1.1 403"),
            (
                "LOCAL_GRANTED",
                "127.0.0.?",
                if controller_local_binding == Some(false) {
                    "HTTP/1.1 403"
                } else {
                    "HTTP/1.1 502"
                },
            ),
            ("LOCAL_DENIED", "127.0.0.?", "HTTP/1.1 403"),
            (
                "LOCAL_OMITTED",
                "127.0.0.?",
                if controller_local_binding == Some(true) {
                    "HTTP/1.1 502"
                } else {
                    "HTTP/1.1 403"
                },
            ),
        ] {
            let local_binding_probe =
                matches!(suffix, "LOCAL_GRANTED" | "LOCAL_DENIED" | "LOCAL_OMITTED");
            if matches!(scenario, "USER_UNSET" | "USER_DENIED") && !local_binding_probe {
                continue;
            }
            let escalated = matches!(
                suffix,
                "ESCALATED" | "ESCALATION_DENIED" | "ESCALATED_DENY_READ"
            );
            let requires_proxy = matches!(suffix, "REQUIRED_ALLOWED" | "REQUIRED_DENIED");
            let restricted = requires_proxy || matches!(suffix, "OFFLINE" | "GRANTED_DENIED");
            if scenario != "ROOTLESS" && restricted {
                continue;
            }
            let marker = format!("{scenario}_OWNER_{suffix}");
            let mut proxy_config = NetworkProxyConfig {
                enabled: requires_proxy,
                allow_local_binding: match suffix {
                    "LOCAL_DENIED" => Some(false),
                    "LOCAL_OMITTED" => None,
                    _ => Some(true),
                },
                ..NetworkProxyConfig::default()
            };
            proxy_config.set_allowed_domains(vec![allowed_domain.to_string()]);
            let mut permission_profile = if restricted {
                PermissionProfile::workspace_write()
            } else if suffix == "REVIEWED" {
                remote_review_permissions.clone()
            } else {
                test.config.permissions.permission_profile().clone()
            };
            const SECRET: &str = "owner-escalation-secret";
            if suffix == "ESCALATED_DENY_READ" {
                test.fs()
                    .write_file(
                        &remote.cwd.join("secret.env")?,
                        SECRET.as_bytes().to_vec(),
                        Default::default(),
                        /*sandbox*/ None,
                    )
                    .await?;
                let (mut filesystem, network) = permission_profile.to_runtime_permissions();
                filesystem.entries.push(FileSystemSandboxEntry::new(
                    FileSystemPath::GlobPattern {
                        pattern: "**/secret.env".into(),
                    },
                    FileSystemAccessMode::Deny,
                ));
                permission_profile =
                    PermissionProfile::from_runtime_permissions(&filesystem, network);
            }
            let owner_config = EnvironmentConfig {
                environment_hooks: Default::default(),
                allow_login_shell: test.config.permissions.allow_login_shell,
                workspace_roots: remote.workspace_roots.clone(),
                permission_profile: PermissionProfileSnapshot::legacy(permission_profile),
                shell_environment_policy: test.config.permissions.shell_environment_policy.clone(),
                windows_sandbox_level: WindowsSandboxLevel::from_config(&test.config),
                windows_sandbox_type: test.config.permissions.windows_sandbox_type,
                use_legacy_landlock: test.config.features.use_legacy_landlock(),
                exec_policy: None,
                mcp_policy: None,
                network_policy: Some(EnvironmentNetworkPolicy::from_config(
                    &proxy_config,
                    /*managed_allowed_domains_only*/ suffix != "REVIEWED",
                )),
                selected_capability_roots: Vec::new(),
            };
            let mut primary = local(test.cwd.path().abs());
            primary.config = EnvironmentConfigState::Ready(EnvironmentConfig {
                environment_hooks: Default::default(),
                workspace_roots: primary.workspace_roots.clone(),
                permission_profile: PermissionProfileSnapshot::legacy(PermissionProfile::Disabled),
                network_policy: None,
                ..owner_config.clone()
            });
            remote.config = EnvironmentConfigState::Ready(owner_config);

            // Traffic policy alone leaves restricted owners offline. Required proxies and
            // approved network grants activate the filtered route without a controller proxy.
            let command = if suffix == "OFFLINE" {
                format!(
                    "python3 -c \"import socket; sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); sock.connect(('198.51.100.1', 9))\" 2>/dev/null || printf {marker}"
                )
            } else if requires_proxy {
                let direct_probe = r#"python3 - <<'PYTHON'
import errno, socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
    sock.connect(('198.51.100.1', 9))
except OSError as error:
    assert error.errno in (errno.ENETUNREACH, errno.EACCES, errno.EPERM), error
    print('OWNER_DIRECT_NETWORK_BLOCKED')
else:
    raise AssertionError('direct network unexpectedly allowed')
PYTHON"#;
                format!(
                    "{direct_probe}\n{}",
                    remote_network_proxy_request_command(&marker)
                )
            } else if suffix == "ESCALATED_DENY_READ" {
                let read_probe = r#"python3 - <<'PYTHON'
try:
    with open('secret.env') as secret:
        print(secret.read())
except PermissionError:
    print('READ_BLOCKED')
PYTHON"#;
                format!(
                    "{read_probe}\n{}",
                    remote_network_proxy_request_command(&marker)
                )
            } else if local_binding_probe {
                // A wildcard allowlist does not explicitly authorize private destinations.
                // Port zero has no listener: 502 proves the request passed policy enforcement,
                // while 403 proves the controller/owner composition denied the loopback target.
                remote_network_proxy_request_command(&marker)
                    .replace(NETWORK_TEST_HOST, "127.0.0.1:0")
            } else if escalated {
                // Direct sockets and an unproxied environment exercise the actual remote launch.
                format!(
                    "python3 -c \"import os,socket; assert '{PROXY_ACTIVE_ENV_KEY}' not in os.environ; sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); sock.connect(('198.51.100.1', 9)); print('{marker}:unproxied')\""
                )
            } else {
                remote_network_proxy_request_command(&marker)
            };
            let mut args = network_exec_args(&command);
            args.as_object_mut().unwrap().remove("shell");
            args["environment_id"] = json!(REMOTE_ENVIRONMENT_ID);
            if escalated {
                args["sandbox_permissions"] = json!("require_escalated");
                args["justification"] = json!("exercise approved full sandbox escalation");
            } else if suffix == "GRANTED_DENIED" {
                args["sandbox_permissions"] = json!("with_additional_permissions");
                args["additional_permissions"] = json!({"network": {"enabled": true}});
                args["justification"] = json!("exercise attachment-scoped network access");
            }
            let guardian = if suffix == "REVIEWED" {
                Some(
                    mount_sse_once_match(
                        &server,
                        is_guardian_request,
                        sse(vec![
                            ev_response_created("resp-owner-network-guardian"),
                            ev_assistant_message(
                                "msg-owner-network-guardian",
                                r#"{"outcome":"allow"}"#,
                            ),
                            ev_completed("resp-owner-network-guardian"),
                        ]),
                    )
                    .await,
                )
            } else {
                None
            };
            let responses = mount_exec_network_turn(&server, &marker, &marker, args).await?;
            submit_managed_network_turn(
                &test,
                "exercise the selected environment's network policy",
                vec![primary, remote.clone()],
                if suffix == "REVIEWED" {
                    ApprovalsReviewer::AutoReview
                } else {
                    ApprovalsReviewer::User
                },
                if escalated || matches!(suffix, "REVIEWED" | "GRANTED_DENIED") {
                    AskForApproval::OnRequest
                } else {
                    AskForApproval::Never
                },
            )
            .await?;
            if escalated || suffix == "GRANTED_DENIED" {
                let event = wait_for_event(&test.codex, |event| {
                    matches!(
                        event,
                        EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)
                    )
                })
                .await;
                let EventMsg::ExecApprovalRequest(approval) = event else {
                    anyhow::bail!("expected command approval before completion")
                };
                test.codex
                    .submit(Op::ExecApproval {
                        id: approval.effective_approval_id(),
                        turn_id: Some(approval.turn_id),
                        decision: if suffix == "ESCALATION_DENIED" {
                            ReviewDecision::denied(expected)
                        } else {
                            ReviewDecision::Approved
                        },
                    })
                    .await?;
            }
            wait_for_completion_without_network_prompt(&test).await;
            if let Some(guardian) = guardian {
                assert_eq!(
                    guardian_network_triggers(&[&guardian])?,
                    vec![(marker.clone(), command)]
                );
                let prompt = guardian
                    .single_request()
                    .message_input_texts("user")
                    .join("");
                let permissions = prompt
                    .split_once("PARENT TURN PERMISSION CONTEXT START")
                    .and_then(|(_, text)| text.split_once("PARENT TURN PERMISSION CONTEXT END"))
                    .map(|(permissions, _)| permissions)
                    .context("network Guardian permissions")?;
                assert!(permissions.contains(&remote_private_path.inferred_native_path_string()));
                let remote_glob = remote
                    .cwd
                    .join("*.guardian-secret")?
                    .inferred_native_path_string();
                assert!(permissions.contains(&format!("glob `{remote_glob}`")));
            }
            let output = responses
                .function_call_output_text(&marker)
                .context("expected remote network output")?;
            assert!(
                output.contains(expected),
                "unexpected network output for {marker}: {output}"
            );
            if requires_proxy {
                assert!(output.contains("OWNER_DIRECT_NETWORK_BLOCKED"), "{output}");
            }
            if suffix == "ESCALATION_DENIED" {
                assert!(!output.contains(":unproxied"));
            } else if suffix == "ESCALATED_DENY_READ" {
                assert!(output.contains("READ_BLOCKED"), "{output}");
                assert!(!output.contains(SECRET), "{output}");
            }
        }
    }

    Ok(())
}

#[test_case(FileSystemSandboxPolicy::read_only(); "restricted_filesystem")]
#[test_case(FileSystemSandboxPolicy::unrestricted(); "unrestricted_filesystem")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn escalated_owner_network_terminal_requires_stdin_approval(
    filesystem: FileSystemSandboxPolicy,
) -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python interactive fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));
    skip_if_no_remote_env!(Ok(()));

    let server = start_mock_server().await;
    let profile =
        PermissionProfile::from_runtime_permissions(&filesystem, NetworkSandboxPolicy::Enabled);
    let test = test_codex()
        .with_config(move |config| {
            for feature in [Feature::UnifiedExec, Feature::WriteStdinApproval] {
                config
                    .features
                    .enable(feature)
                    .expect("enable test feature");
            }
            config.permissions.network = None;
            config
                .permissions
                .set_permission_profile(profile)
                .expect("set permission profile");
        })
        .build_with_auto_env(&server)
        .await?;
    assert!(test.session_configured.network_proxy.is_none());
    let mut remote = test.executor_environment().selection().clone();
    let mut proxy = NetworkProxyConfig::default();
    proxy.set_allowed_domains(vec!["owner-only.invalid".to_string()]);
    remote.config = EnvironmentConfigState::Ready(EnvironmentConfig {
        environment_hooks: Default::default(),
        allow_login_shell: test.config.permissions.allow_login_shell,
        workspace_roots: remote.workspace_roots.clone(),
        permission_profile: PermissionProfileSnapshot::legacy(
            test.config.permissions.permission_profile().clone(),
        ),
        shell_environment_policy: test.config.permissions.shell_environment_policy.clone(),
        windows_sandbox_level: WindowsSandboxLevel::from_config(&test.config),
        windows_sandbox_type: test.config.permissions.windows_sandbox_type,
        use_legacy_landlock: test.config.features.use_legacy_landlock(),
        exec_policy: None,
        mcp_policy: None,
        network_policy: Some(EnvironmentNetworkPolicy::from_config(
            &proxy, /*managed_allowed_domains_only*/ true,
        )),
        selected_capability_roots: Vec::new(),
    });

    let command = format!(
        "python3 -c \"import os; assert '{PROXY_ACTIVE_ENV_KEY}' not in os.environ; print('INPUT:' + input())\""
    );
    let mut args = network_exec_args(&command);
    args["environment_id"] = json!(REMOTE_ENVIRONMENT_ID);
    args["tty"] = json!(true);
    args["sandbox_permissions"] = json!("require_escalated");
    args["justification"] = json!("exercise approved interactive escalation");
    let launch_call = "owner-terminal-launch";
    let stdin_call = "owner-terminal-stdin";
    let responses = mount_sse_sequence(
        &server,
        vec![
            sse(vec![
                ev_function_call(launch_call, "exec_command", &args.to_string()),
                ev_completed("owner-terminal-started"),
            ]),
            sse(vec![
                ev_function_call(
                    stdin_call,
                    "write_stdin",
                    &json!({"session_id": 1000, "chars": "hello\n", "yield_time_ms": 1_000})
                        .to_string(),
                ),
                ev_completed("owner-terminal-input"),
            ]),
            sse(vec![
                ev_assistant_message("owner-terminal-done", "done"),
                ev_completed("owner-terminal-done"),
            ]),
        ],
    )
    .await;
    submit_managed_network_turn(
        &test,
        "launch a terminal and send input",
        vec![remote],
        ApprovalsReviewer::User,
        AskForApproval::UnlessTrusted,
    )
    .await?;
    let mut approvals = Vec::new();
    loop {
        match wait_for_event(&test.codex, |_| true).await {
            EventMsg::ExecApprovalRequest(approval) => {
                test.codex
                    .submit(Op::ExecApproval {
                        id: approval.effective_approval_id(),
                        turn_id: Some(approval.turn_id),
                        decision: ReviewDecision::Approved,
                    })
                    .await?;
                approvals.push((approval.kind, approval.call_id, approval.approval_id));
            }
            EventMsg::TurnComplete(_) => break,
            _ => {}
        }
    }
    assert_eq!(
        approvals,
        vec![
            (ExecApprovalKind::Command, launch_call.to_string(), None),
            (
                ExecApprovalKind::WriteStdin,
                launch_call.to_string(),
                Some(stdin_call.to_string()),
            ),
        ]
    );
    let output = responses
        .function_call_output_text(stdin_call)
        .context("expected terminal input output")?;
    assert!(output.contains("INPUT:hello"), "{output}");
    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn approved_network_host_for_one_environment_still_prompts_in_another() -> Result<()> {
    skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");
    skip_if_host_windows!(Ok(()));
    skip_if_no_network!(Ok(()));
    skip_if_sandbox!(Ok(()));
    skip_if_no_remote_env!(Ok(()));

    let server = start_mock_server().await;
    let test = managed_network_unified_exec_test(&server).await?;
    let local_cwd = TempDir::new()?;
    let remote_cwd = PathBuf::from(format!(
        "/tmp/codex-network-approval-{}",
        SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis()
    ))
    .abs();
    let remote_cwd_uri = PathUri::from_host_native_path(&remote_cwd)?;
    test.fs()
        .create_directory(
            &remote_cwd_uri,
            CreateDirectoryOptions {
                recursive: true,
                follow_symlinks: true,
            },
            /*sandbox*/ None,
        )
        .await?;
    let environments = vec![
        local(local_cwd.path().abs()),
        TurnEnvironmentSelection {
            selected_capability_roots: Default::default(),
            environment_id: REMOTE_ENVIRONMENT_ID.to_string(),
            cwd: PathUri::from_abs_path(&remote_cwd),
            workspace_roots: vec![PathUri::from_abs_path(&remote_cwd)],
            config: EnvironmentConfigState::FromThread,
        },
    ];

    mount_exec_network_turn(
        &server,
        "resp-network-local",
        "exec-network-local",
        network_fetch_args(LOCAL_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "fetch from the local environment",
        environments.clone(),
        ApprovalsReviewer::User,
        AskForApproval::UnlessTrusted,
    )
    .await?;
    let approval = expect_network_approval(&test, LOCAL_ENVIRONMENT_ID).await?;
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: None,
            decision: ReviewDecision::ApprovedForSession,
        })
        .await?;
    wait_for_turn_complete(&test).await;

    let remote_responses = mount_exec_network_turn(
        &server,
        "resp-network-remote",
        "exec-network-remote",
        network_fetch_args(REMOTE_ENVIRONMENT_ID),
    )
    .await?;
    submit_managed_network_turn(
        &test,
        "fetch from the remote environment",
        environments.clone(),
        ApprovalsReviewer::User,
        AskForApproval::UnlessTrusted,
    )
    .await?;
    let approval = expect_network_approval(&test, REMOTE_ENVIRONMENT_ID).await?;
    let rejection = "approval request failed because the client disconnected";
    test.codex
        .submit(Op::ExecApproval {
            id: approval.effective_approval_id(),
            turn_id: None,
            decision: ReviewDecision::denied(rejection),
        })
        .await?;
    wait_for_turn_complete(&test).await;
    assert_eq!(
        remote_responses.function_call_output_text("exec-network-remote"),
        Some(rejection.to_string())
    );

    test.fs()
        .remove(
            &remote_cwd_uri,
            RemoveOptions {
                recursive: true,
                force: true,
                follow_symlinks: true,
            },
            /*sandbox*/ None,
        )
        .await?;

    Ok(())
}

#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn agent_started_proxy_denies_brokered_provider_alias() -> Result<()> {
    const REAL_CREDENTIAL: &str = "alias_aaaaaaaaaaaaaaaaaaaaaaaa";
    let upstream = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
    let port = upstream.local_addr()?.port();
    let mut network = NetworkProxyConfig {
        enabled: true,
        proxy_url: "http://127.0.0.1:0".to_string(),
        socks_url: "http://127.0.0.1:0".to_string(),
        // Local requests must stay behind the proxy for their credentials to be masked.
        allow_local_binding: Some(false),
        allow_upstream_proxy: false,
        mitm_hooks: vec![MitmHookConfig {
            host: "localhost".to_string(),
            matcher: MitmHookMatchConfig {
                methods: vec!["GET".to_string()],
                path_prefixes: vec!["/v1".to_string()],
                ..MitmHookMatchConfig::default()
            },
            actions: MitmHookActionsConfig::default(),
        }],
        ..NetworkProxyConfig::default()
    };
    network.set_credential_broker_enabled(/*enabled*/ true);
    network.set_allowed_domains(vec!["localhost".to_string(), "127.0.0.1".to_string()]);
    network.credential_providers.insert(
        "alias_test".to_string(),
        CredentialProviderConfig {
            env: vec!["ALIAS_TEST_TOKEN".to_string()],
            patterns: vec!["alias_[a-z]{24}".to_string()],
            url_prefixes: vec![
                format!("http://localhost:{port}/v1"),
                format!("http://127.0.0.1:{port}/v2"),
            ],
            ..CredentialProviderConfig::default()
        },
    );
    let permission_profile = PermissionProfile::workspace_write_with(
        &[],
        NetworkSandboxPolicy::Enabled,
        /*exclude_tmpdir_env_var*/ false,
        /*exclude_slash_tmp*/ false,
    );
    let server = start_mock_server().await;
    let test = test_codex()
        .with_config(move |config| {
            for feature in [
                Feature::UnifiedExec,
                Feature::ShellSnapshot,
                Feature::NetworkProxy,
            ] {
                config
                    .features
                    .enable(feature)
                    .expect("enable test feature");
            }
            config.permissions.approval_policy = Constrained::allow_any(AskForApproval::Never);
            config
                .permissions
                .set_permission_profile(permission_profile.clone())
                .expect("set permission profile");
            config
                .permissions
                .shell_environment_policy
                .r#set
                .insert("ALIAS_TEST_TOKEN".to_string(), REAL_CREDENTIAL.to_string());
            config.permissions.network = Some(
                NetworkProxySpec::from_config_and_constraints(
                    network,
                    /*requirements*/ None,
                    &permission_profile,
                )
                .expect("build brokered managed network proxy"),
            );
        })
        // Credential brokerage currently runs only in the local environment.
        .build(&server)
        .await?;
    let proxy = test
        .session_configured
        .network_proxy
        .as_ref()
        .context("agent did not start its managed network proxy")?;
    let command = r#"printf 'BROKERED:%s\nACTIVE:%s\n' "$ALIAS_TEST_TOKEN" "$CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE""#;
    let call_id = "exec-brokered-provider-alias";
    let mut args = network_exec_args(command);
    args["yield_time_ms"] = json!(30_000);
    let responses =
        mount_exec_network_turn(&server, "resp-brokered-provider-alias", call_id, args).await?;
    test.submit_text_turn("read the brokered credential")
        .await?;
    let output = responses
        .function_call_output_text(call_id)
        .context("agent did not return command output")?;
    assert!(output.contains("ACTIVE:1"), "{output}");
    assert!(!output.contains(REAL_CREDENTIAL));
    let token = output
        .lines()
        .find_map(|line| line.strip_prefix("BROKERED:"))
        .context("agent did not expose its brokered dummy")?;
    assert!(token.starts_with("alias_"));

    // Probe after the command exits so the denial cannot interrupt the tool call.
    let response = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {
        let mut connection = tokio::net::TcpStream::connect(&proxy.http_addr).await?;
        connection
            .write_all(
                format!(
                    "GET http://127.0.0.1:{port}/v2/resource HTTP/1.1\r\n\
                     Host: 127.0.0.1:{port}\r\nAuthorization: Bearer {token}\r\n\
                     Connection: close\r\n\r\n"
                )
                .as_bytes(),
            )
            .await?;
        let mut response = String::new();
        connection.read_to_string(&mut response).await?;
        Ok::<_, std::io::Error>(response)
    })
    .await
    .context("alias denial did not finish")??;
    assert!(response.starts_with("HTTP/1.1 403"), "{response}");
    assert!(response.contains("blocked-by-mitm-hook"), "{response}");
    assert!(!response.contains(REAL_CREDENTIAL));
    Ok(())
}

pub(super) fn guardian_parent_catalog() -> ModelsResponse {
    let template = codex_models_manager::bundled_models_response()
        .expect("bundled model catalog")
        .models
        .into_iter()
        .find(|model| model.slug == "gpt-5.5")
        .expect("gpt-5.5 in bundled catalog");
    // Keep safety settings compatible so active publication can switch A to B.
    ModelsResponse {
        models: ["guardian-parent-a", "guardian-parent-b"]
            .into_iter()
            .map(|slug| {
                let mut model = template.clone();
                model.slug = slug.to_string();
                model.visibility = ModelVisibility::List;
                model.auto_review_model_override = None;
                model.supported_reasoning_levels.retain(|level| {
                    level.effort != codex_protocol::openai_models::ReasoningEffort::Low
                });
                model
                    .model_messages
                    .as_mut()
                    .expect("model messages")
                    .auto_review = Some(AutoReviewMessages {
                    policy: Some("captured policy".to_string()),
                    policy_template: Some(
                        "captured template: {{ tenant_policy_config }}".to_string(),
                    ),
                    node_repl_policy: None,
                    rejection_instructions: None,
                    timeout_instructions: None,
                });
                model
            })
            .collect(),
    }
}

async fn managed_network_unified_exec_test(server: &wiremock::MockServer) -> Result<TestCodex> {
    managed_network_unified_exec_test_with_features(server, &[]).await
}

async fn managed_network_unified_exec_test_with_features(
    server: &wiremock::MockServer,
    features: &[Feature],
) -> Result<TestCodex> {
    let test = managed_network_unified_exec_builder(features)?
        .build_with_remote_and_local_env(server)
        .await?;
    assert!(test.config.managed_network_requirements_enabled());
    assert!(test.config.permissions.network.is_some());
    assert!(test.session_configured.network_proxy.is_some());
    Ok(test)
}

fn managed_network_unified_exec_builder(features: &[Feature]) -> Result<TestCodexBuilder> {
    let home = Arc::new(TempDir::new()?);
    fs::write(
        home.path().join("config.toml"),
        r#"default_permissions = "workspace"

[permissions.workspace.filesystem]
":minimal" = "read"

[permissions.workspace.network]
enabled = true
mode = "limited"
allow_local_binding = true
"#,
    )?;
    let approval_policy = AskForApproval::OnRequest;
    let permission_profile = PermissionProfile::workspace_write_with(
        &[],
        NetworkSandboxPolicy::Enabled,
        /*exclude_tmpdir_env_var*/ false,
        /*exclude_slash_tmp*/ false,
    );
    let permission_profile_for_config = permission_profile;
    let features = features.to_vec();
    Ok(test_codex()
        .with_home(home)
        .with_cloud_config_bundle(managed_network_requirements_loader())
        .with_config(move |config| {
            for feature in &features {
                config
                    .features
                    .enable(*feature)
                    .expect("test config should allow feature update");
            }
            config.permissions.approval_policy = Constrained::allow_any(approval_policy);
            config
                .permissions
                .set_permission_profile(permission_profile_for_config)
                .expect("set permission profile");
        }))
}

async fn mount_exec_network_turn(
    server: &wiremock::MockServer,
    response_prefix: &str,
    call_id: &str,
    args: Value,
) -> Result<ResponseMock> {
    let responses = vec![
        sse(vec![
            ev_response_created(&format!("{response_prefix}-1")),
            ev_function_call(call_id, "exec_command", &serde_json::to_string(&args)?),
            ev_completed(&format!("{response_prefix}-1")),
        ]),
        sse(vec![
            ev_response_created(&format!("{response_prefix}-2")),
            ev_assistant_message(&format!("{response_prefix}-msg"), "done"),
            ev_completed(&format!("{response_prefix}-2")),
        ]),
    ];
    Ok(mount_sse_sequence(server, responses).await)
}

fn network_fetch_args(environment_id: &str) -> Value {
    let command = format!(
        "python3 -c \"import urllib.request; opener = urllib.request.build_opener(urllib.request.ProxyHandler()); print('OK:' + opener.open('http://{NETWORK_TEST_HOST}', timeout=2).read().decode(errors='replace'))\""
    );
    let mut args = network_exec_args(&command);
    args["environment_id"] = json!(environment_id);
    args
}

fn network_exec_args(command: &str) -> Value {
    json!({
        "shell": "/bin/sh",
        "cmd": command,
        "login": false,
        "yield_time_ms": 1_000,
    })
}

fn remote_network_proxy_request_command(marker: &str) -> String {
    let host = NETWORK_TEST_HOST;
    format!(
        "python3 -c \"import os,socket,urllib.parse; proxy = urllib.parse.urlparse(os.environ['HTTP_PROXY']); sock = socket.create_connection((proxy.hostname, proxy.port), timeout=10); sock.sendall(b'GET http://{host} HTTP/1.1\\r\\nHost: {host}\\r\\nConnection: close\\r\\n\\r\\n'); print('{marker}:' + sock.makefile('rb').readline().decode(errors='replace'))\""
    )
}

async fn submit_managed_network_turn(
    test: &TestCodex,
    prompt: &str,
    environments: Vec<TurnEnvironmentSelection>,
    approvals_reviewer: ApprovalsReviewer,
    approval_policy: AskForApproval,
) -> Result<()> {
    let permission_profile = PermissionProfile::workspace_write_with(
        &[],
        NetworkSandboxPolicy::Enabled,
        /*exclude_tmpdir_env_var*/ false,
        /*exclude_slash_tmp*/ false,
    );
    let (sandbox_policy, permission_profile) =
        turn_permission_fields(permission_profile, test.config.cwd.as_path());
    let turn_environment_selections =
        TurnEnvironmentSelections::new(test.config.cwd.clone(), environments);

    test.codex
        .start_or_steer_turn(
            TurnInputRequest::user_input(vec![UserInput::Text {
                text: prompt.into(),
                text_elements: Vec::new(),
            }])
            .with_thread_settings(ThreadSettingsOverrides {
                environments: Some(turn_environment_selections.into_requests()),
                approval_policy: Some(approval_policy),
                approvals_reviewer: Some(approvals_reviewer),
                sandbox_policy: Some(sandbox_policy),
                permission_profile,
                collaboration_mode: Some(CollaborationMode {
                    mode: ModeKind::Default,
                    settings: Settings {
                        model: test.session_configured.model.clone(),
                        reasoning_effort: None,
                        developer_instructions: None,
                    },
                }),
                ..Default::default()
            }),
        )
        .await?;

    Ok(())
}

fn decoded_request_body(request: &wiremock::Request) -> Option<Vec<u8>> {
    let is_zstd = request
        .headers
        .get("content-encoding")
        .and_then(|value| value.to_str().ok())
        .is_some_and(|value| {
            value
                .split(',')
                .any(|entry| entry.trim().eq_ignore_ascii_case("zstd"))
        });
    if is_zstd {
        zstd::stream::decode_all(std::io::Cursor::new(&request.body)).ok()
    } else {
        Some(request.body.clone())
    }
}

fn request_body_contains(request: &wiremock::Request, text: &str) -> bool {
    decoded_request_body(request)
        .and_then(|body| String::from_utf8(body).ok())
        .is_some_and(|body| body.contains(text))
}

fn is_guardian_request(request: &wiremock::Request) -> bool {
    decoded_request_body(request)
        .and_then(|body| serde_json::from_slice::<Value>(&body).ok())
        .is_some_and(|body| {
            body.pointer("/client_metadata/x-openai-subagent")
                .and_then(Value::as_str)
                == Some("guardian")
        })
}

fn guardian_request_is_for(request: &wiremock::Request, call_id: &str) -> bool {
    decoded_request_body(request)
        .and_then(|body| serde_json::from_slice::<Value>(&body).ok())
        .filter(|body| {
            body.pointer("/client_metadata/x-openai-subagent")
                .and_then(Value::as_str)
                == Some("guardian")
        })
        .and_then(|body| {
            body.get("input")
                .and_then(Value::as_array)
                .and_then(|input| {
                    input
                        .iter()
                        .rev()
                        .find(|item| item.get("role").and_then(Value::as_str) == Some("user"))
                })
                .cloned()
        })
        .is_some_and(|latest_user_message| latest_user_message.to_string().contains(call_id))
}

fn guardian_network_triggers(responses: &[&ResponseMock]) -> Result<Vec<(String, String)>> {
    responses
        .iter()
        .flat_map(|responses| responses.requests())
        .filter(|request| {
            request.body_json()["client_metadata"]["x-openai-subagent"].as_str() == Some("guardian")
        })
        .map(|request| {
            let user_texts = request.message_input_texts("user");
            let action: Value = serde_json::from_str(
                user_texts
                    .iter()
                    .rev()
                    .find(|text| text.contains("\"tool\": \"network_access\""))
                    .context("expected network access JSON in Guardian request")?
                    .trim(),
            )?;
            Ok((
                action
                    .pointer("/trigger/callId")
                    .and_then(Value::as_str)
                    .context("expected exact trigger call id")?
                    .to_string(),
                action
                    .pointer("/trigger/command/2")
                    .and_then(Value::as_str)
                    .context("expected exact trigger command")?
                    .to_string(),
            ))
        })
        .collect()
}

fn guardian_network_actions(responses: &ResponseMock) -> Result<Vec<Value>> {
    responses
        .requests()
        .into_iter()
        .filter(|request| {
            request.body_json()["client_metadata"]["x-openai-subagent"].as_str() == Some("guardian")
                && request
                    .message_input_texts("user")
                    .iter()
                    .any(|text| text.contains("\"tool\": \"network_access\""))
        })
        .map(|request| {
            let user_texts = request.message_input_texts("user");
            serde_json::from_str(
                user_texts
                    .iter()
                    .rev()
                    .find(|text| text.contains("\"tool\": \"network_access\""))
                    .context("expected network access JSON in Guardian request")?
                    .trim(),
            )
            .context("parse Guardian network action")
        })
        .collect()
}

async fn expect_network_approval(
    test: &TestCodex,
    expected_environment_id: &str,
) -> Result<ExecApprovalRequestEvent> {
    expect_network_approval_target(
        test,
        expected_environment_id,
        NETWORK_TEST_TARGET,
        NetworkApprovalProtocol::Http,
    )
    .await
}

async fn expect_network_approval_target(
    test: &TestCodex,
    expected_environment_id: &str,
    expected_target: &str,
    expected_protocol: NetworkApprovalProtocol,
) -> Result<ExecApprovalRequestEvent> {
    let deadline = std::time::Instant::now() + Duration::from_secs(30);
    let remaining = deadline
        .checked_duration_since(std::time::Instant::now())
        .context("timed out waiting for network approval request")?;
    let event = wait_for_event_with_timeout(
        &test.codex,
        |event| {
            matches!(
                event,
                EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)
            )
        },
        remaining,
    )
    .await;
    match event {
        EventMsg::ExecApprovalRequest(approval) => {
            assert_eq!(
                approval.command,
                vec!["network-access".to_string(), expected_target.to_string()]
            );
            assert_eq!(
                approval.network_approval_context,
                Some(NetworkApprovalContext {
                    host: NETWORK_TEST_HOST.to_string(),
                    protocol: expected_protocol,
                })
            );
            assert_eq!(
                approval.environment_id.as_deref(),
                Some(expected_environment_id)
            );
            Ok(approval)
        }
        EventMsg::TurnComplete(_) => {
            panic!("expected network approval request before completion");
        }
        other => panic!("unexpected event: {other:?}"),
    }
}

async fn wait_for_completion_without_network_prompt(test: &TestCodex) {
    let event = wait_for_event(&test.codex, |event| {
        matches!(
            event,
            EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)
        )
    })
    .await;
    match event {
        EventMsg::TurnComplete(_) => {}
        EventMsg::ExecApprovalRequest(approval) => {
            panic!(
                "unexpected network approval request: {:?}",
                approval.command
            )
        }
        other => panic!("unexpected event: {other:?}"),
    }
}

async fn wait_for_guardian_request(responses: &ResponseMock) {
    tokio::time::timeout(Duration::from_secs(10), async {
        loop {
            if responses.requests().iter().any(|request| {
                request.body_json()["client_metadata"]["x-openai-subagent"] == "guardian"
            }) {
                return;
            }
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .expect("timed out waiting for Guardian request");
}

async fn wait_for_response_request(responses: &ResponseMock) {
    tokio::time::timeout(Duration::from_secs(10), async {
        loop {
            if !responses.requests().is_empty() {
                return;
            }
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .expect("timed out waiting for Responses API request");
}

async fn raw_http_proxy_request(proxy_addr: String, host: &str) -> std::io::Result<String> {
    let mut stream = tokio::net::TcpStream::connect(proxy_addr).await?;
    stream
        .write_all(
            format!("GET http://{host}/ HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\n\r\n")
                .as_bytes(),
        )
        .await?;
    let mut response = Vec::new();
    stream.read_to_end(&mut response).await?;
    Ok(String::from_utf8_lossy(&response).into_owned())
}

async fn wait_for_paths(paths: &[&std::path::Path]) -> Result<()> {
    tokio::time::timeout(Duration::from_secs(10), async {
        loop {
            if paths.iter().all(|path| path.exists()) {
                return;
            }
            tokio::time::sleep(Duration::from_millis(10)).await;
        }
    })
    .await
    .context("timed out waiting for commands to start")?;
    Ok(())
}

async fn wait_for_turn_complete(test: &TestCodex) {
    wait_for_event(&test.codex, |event| {
        matches!(event, EventMsg::TurnComplete(_))
    })
    .await;
}