exec_argv = argv;  // 默认保持原样：没有 EXEC_WRAPPER 时，zsh 行为和原版完全一致if ((exec_wrapper = getenv("EXEC_WRAPPER")) &&  // 读 Codex 注入的 EXEC_WRAPPER 环境变量——拦截开关就藏在这里    *exec_wrapper && !inblank(*exec_wrapper)) {  // 必须非空且首字符不是空白：防止空字符串/空格把 exec 劫持成"执行空路径"    exec_argv = argv - 2;  // 指针回退两个槽位（zsh 内部缓冲区预留了空间），腾出位置构造新 argv    exec_argv[0] = exec_wrapper;  // 新 argv[0] = wrapper 程序路径，即 codex-execve-wrapper    exec_argv[1] = orig_pth;  // 原本要执行的目标路径，降级成 wrapper 的第一个参数    pth = exec_wrapper;  // execve 的目标从"原命令"换成"wrapper"——劫持完成}winch_unblock();  // 恢复 SIGWINCH 处理（与拦截无关的原有逻辑，保持不动）execve(pth, exec_argv, newenvp);  // 真正执行：设了 EXEC_WRAPPER 时跑的是 wrapper，否则和原版 zsh 一模一样

pub fn start_session(  // 开启一个"升级会话"：不启动 shell，只准备好拦截通道    &self,  // 服务端的策略/路径配置（EscalateServer::new 注入）    parent_cancellation_token: CancellationToken,  // 上层取消令牌：用户一取消，服务端任务立刻退出    command_executor: Arc<dyn ShellCommandExecutor>,  // core 注入的执行器：真正跑"提权命令"的是它（core/src/tools/runtimes/zsh_fork/unix_escalation.rs）) -> anyhow::Result<EscalationSession> {  // 返回会话句柄：env 给 shell，其余字段管理服务端生命周期    let cancellation_token = CancellationToken::new();  // 会话级令牌：单独控制本升级服务的生命周期    let (escalate_server, escalate_client) = AsyncDatagramSocket::pair()?;  // 创建一对 Unix 数据报 socket：服务端留一个，客户端端点要跨 exec 传给 wrapper    let client_socket = escalate_client.into_inner();  // 取出客户端端点的原始 fd（socket2::Socket）    let client_socket_fd = client_socket.as_raw_fd();  // 拿到数字 fd——这个"号码"才是能写进环境变量、跨进程传递的东西    client_socket.set_cloexec(false)?;  // 关键一步：清掉 CLOEXEC，否则 execve 时内核会自动关掉它，wrapper 就找不到了（源码注释：只有客户端端点需要跨 exec）    let client_socket = Arc::new(Mutex::new(Some(client_socket)));  // 持有一份引用：spawn 完成后由生命周期钩子 close_client_socket() 释放父进程侧的 fd    let task = tokio::spawn(escalate_task(escalate_server, Arc::clone(&self.policy), Arc::clone(&command_executor), parent_cancellation_token, cancellation_token.clone()));  // 启动服务端循环：收握手 → 派发给策略决策（见下一节）    let mut env = HashMap::new();  // 组装要注入 shell 环境变量的 overlay    env.insert(ESCALATE_SOCKET_ENV_VAR.to_string(), client_socket_fd.to_string());  // CODEX_ESCALATE_SOCKET=fd号：wrapper 靠它找到升级 socket（escalate_protocol.rs 第 13 行定义）    env.insert(EXEC_WRAPPER_ENV_VAR.to_string(), self.execve_wrapper.to_string_lossy().to_string());  // EXEC_WRAPPER=wrapper路径：zsh 补丁的 zexecve() 读它决定是否劫持 execve    Ok(EscalationSession { env, task, client_socket, cancellation_token })  // 返回会话句柄：env 给 shell，task/socket/token 保证服务端活着且可被取消}

let EscalateRequest { file, argv, workdir, env } = tokio::select! {  // 收 wrapper 的完整请求：目标路径、argv（含 argv[0]）、工作目录、环境快照    request = socket.receive::<EscalateRequest>() => request?,  // serde 反序列化；失败直接报错，不猜    _ = parent_cancellation_token.cancelled() => return Ok(()),  // 等请求期间被取消：安静退出，不留半开连接};let program = AbsolutePathBuf::resolve_path_against_base(file, workdir.as_path());  // 相对路径按 workdir 解析成绝对路径——策略匹配必须用规范化形式（协议注释也强调这一点）let decision = tokio::select! {  // 把裁决权交给 core：execpolicy 规则 + Guardian 审批，可能阻塞等用户点确认    decision = policy.determine_action(&program, &argv, &workdir) => decision.context("failed to determine escalation action")?,  // 把裁决权交给 core：execpolicy + Guardian，可能阻塞等用户确认（见第五节）    _ = parent_cancellation_token.cancelled() => return Ok(()),  // 审批等待期间同样可被取消——用户反悔的窗口一直开着};tracing::debug!("decided {decision:?} for {program:?} {argv:?} {workdir:?}");  // 记录裁决：整条链路里唯一能回答"谁放行了它"的地方match decision {  // 按裁决分三路（Run/Escalate/Deny）——下面只展示 Run 分支    EscalationDecision::Run => {  // 分支一：沙箱内放行        socket.send(EscalateResponse { action: EscalateAction::Run }).await?;  // 回一个 Run，服务端到此无事可做——wrapper 会自己 execv 原命令

EscalationDecision::Escalate(execution) => {  // 分支二：提权执行——命令要出沙箱，但 stdio 必须保持"同一套终端"    socket.send(EscalateResponse { action: EscalateAction::Escalate }).await?;  // 先告知 wrapper "我来代跑"，wrapper 收到后才会把 stdio fd 发过来（顺序不能反）    let (msg, fds) = tokio::select! {  // 收 SuperExecMessage + 附带的文件描述符（SCM_RIGHTS 控制消息传 fd）        message = socket.receive_with_fds::<SuperExecMessage>() => message.context("failed to receive SuperExecMessage")?,  // 收 wrapper 发来的 stdio fd（SCM_RIGHTS）+ 目标号码声明        _ = parent_cancellation_token.cancelled() => return Ok(()),  // 等 stdio 期间被取消：直接退出，fd 随连接关闭自动回收    };    if fds.len() != msg.fds.len() {  // 协议完整性校验：实际收到的 fd 数必须等于消息里声明的目标号码个数        return Err(anyhow::anyhow!("mismatched number of fds in SuperExecMessage: {} in the message, {} from the control message", msg.fds.len(), fds.len()));  // 不一致 = 管道损坏或协议被篡改，宁可报错也不猜着跑    }    let PreparedExec { command, cwd, env, arg0 } = tokio::select! {  // core 按 execution 模式（Unsandboxed/TurnDefault/Permissions）准备"沙箱外执行环境"        prepared = command_executor.prepare_escalated_exec(&program, &argv, &workdir, env, execution) => prepared?,  // 可能重写命令、注入网络代理凭据等（见 unix_escalation.rs prepare_escalated_exec）    };    let (program, args) = command.split_first().ok_or_else(|| anyhow::anyhow!("prepared escalated command must not be empty"))?;  // 拆出程序与参数——prepare 阶段可能已经改写过命令    let mut command = Command::new(program);  // tokio 子进程构建器：下面逐行配置"干净环境 + 精确注入"    command.args(args).arg0(arg0.unwrap_or_else(|| program.clone()))  // arg0 可覆盖：有些程序会检查 argv[0]（如 python -m 场景）        .env_clear().envs(&env)  // 先清空整个环境再注入：Codex 自己的环境变量（含代理凭据、内部 token）一律不泄漏给提权进程        .current_dir(&cwd).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())  // stdio 暂时置空——真正的终端 fd 在下面 pre_exec 里用 dup2 还原        .kill_on_drop(true);  // 本任务被 drop 时立刻杀子进程：提权进程绝不能变成孤儿    scrub_non_inheritable_env_vars(command.as_std_mut());  // 双保险：再剥一遍不可继承的敏感变量（protocol/shell_environment.rs）    unsafe {  // pre_exec 回调在 fork 后、execve 前执行——dup2 必须在这个窗口做        command.pre_exec(move || {  // execve 之前、fork 之后的窗口里做 fd 重映射——这是唯一能安全 dup2 的位置            for (dst_fd, src_fd) in msg.fds.iter().zip(&fds) {  // dst=wrapper 声明的目标号码（0/1/2），src=刚收到的真实 fd                libc::dup2(src_fd.as_raw_fd(), *dst_fd);  // dup2：让子进程的 stdin/out/err 恰好是用户正在用的那套终端            }            Ok(())  // 全部 dup2 成功：execve 后子进程直接继承这套 fd        });  // pre_exec 注册完毕——spawn 的 fork/exec 窗口内自动执行    }    let mut child = command.spawn()?;  // 真正 spawn——这就是"super-exec"：沙箱外、带原终端、环境干净的执行    let exit_status = tokio::select! {  // 等它结束，同时保持可取消        status = child.wait() => status?,  // 正常路径：等待退出        _ = parent_cancellation_token.cancelled() => { let _ = child.start_kill(); child.wait().await? }  // 等待中被取消：先杀再收尸，不留僵尸进程    };    socket.send(SuperExecResult { exit_code: exit_status.code().unwrap_or(127) }).await?;  // 把退出码发回 wrapper——被信号杀死时拿不到 code，用 127 兜底（exec 失败惯例码）

pub async fn run_shell_escalation_execve_wrapper(file: String, argv: Vec<String>) -> anyhow::Result<i32> {  // file=被拦截的原命令路径，argv=原始参数（zsh 补丁把两者都传过来了）    let handshake_client = get_escalate_client()?;  // 读 CODEX_ESCALATE_SOCKET 环境变量拿到继承的 fd，包成数据报 socket（第 19-28 行：fd<0 直接报错）    let (server, client) = AsyncSocket::pair()?;  // 为本次请求新开一对流式 socket：client 端自己留着收发，server 端要交给 EscalateServer    handshake_client.send_with_fds(&[0u8], &[server.into_inner().into()]).await?;  // 握手：1 字节数据报 + SCM_RIGHTS 附带 server fd——服务端据此知道"这次会话走哪条通道"    let env = std::env::vars().filter(|(k, _)| !matches!(k.as_str(), ESCALATE_SOCKET_ENV_VAR | EXEC_WRAPPER_ENV_VAR)).collect();  // 快照当前环境，但剥掉两个协议变量——否则提权进程会递归触发拦截（无限套娃）    client.send(EscalateRequest { file: file.clone().into(), argv: argv.clone(), workdir: AbsolutePathBuf::current_dir()?, env }).await?;  // 发完整请求：目标、argv、cwd、环境——服务端裁决需要全部上下文    let message = client.receive::<EscalateResponse>().await?;  // 阻塞等裁决（Run/Escalate/Deny）    match message.action {  // wrapper 侧按裁决分三路（与上表一一对应）        EscalateAction::Escalate => {  // 分支二：服务端代跑——wrapper 的任务变成"交出终端、等结果"            let destination_fds = [io::stdin().as_raw_fd(), io::stdout().as_raw_fd(), io::stderr().as_raw_fd()];  // 记录自己的 stdio fd 号码——告诉服务端"子进程该用这几个号码"            let fds_to_send = [duplicate_fd_for_transfer(io::stdin(), "stdin")?, duplicate_fd_for_transfer(io::stdout(), "stdout")?, duplicate_fd_for_transfer(io::stderr(), "stderr")?];  // 每个都 dup 一份再发：所有权交给服务端，自己这份继续用（源码注释：wrapper 必须保留自己的 stdio 直到子进程接管）            client.send_with_fds(SuperExecMessage { fds: destination_fds.into_iter().collect() }, &fds_to_send).await?;  // 目标号码 + 真实 fd 一起发过去            let SuperExecResult { exit_code } = client.receive::<SuperExecResult>().await?;  // 等服务端跑完，取回退出码            Ok(exit_code)  // 原样返回：对 shell 来说这就是一条"正常执行、正常退出"的命令——完全透明        }        EscalateAction::Run => {  // 分支一：沙箱内放行——wrapper 退化成一次纯粹的 execv            let file = CString::new(file).context("NUL in file")?;  // 转 C 字符串（execv 要求 NUL 结尾）；路径里带 NUL 直接报错            let argv_cstrs: Vec<CString> = argv.iter().map(|s| CString::new(s.as_str()).context("NUL in argv")).collect::<Result<Vec<_>, _>>()?;  // argv 全部转 C 字符串            let mut argv: Vec<*const libc::c_char> = argv_cstrs.iter().map(|s| s.as_ptr()).collect();  // 取指针数组            argv.push(std::ptr::null());  // execv 约定：argv 以 NULL 结尾            let err = unsafe { libc::execv(file.as_ptr(), argv.as_ptr()); std::io::Error::last_os_error() };  // 直接调 libc::execv——源码注释明说不用 std::process::Command，因为它对信号掩码和 std fd 的 dup2 "做了些奇怪的事"，这里要最大透明            Err(err.into())  // 能走到这行说明 execv 失败了（正常不会返回）：把 errno 转成错误上报        }        EscalateAction::Deny { reason } => {  // 分支三：拒绝——wrapper 只负责"体面地失败"            match reason { Some(reason) => eprintln!("Execution denied: {reason}"), None => eprintln!("Execution denied") }  // 把服务端给的拒绝原因打到 stderr，模型/用户能看到为什么被拒            Ok(1)  // 退出码 1：shell 看到一次普通命令失败，错误信息在 stderr 里        }    }}

async fn determine_action(&self, program: &AbsolutePathBuf, argv: &[String], workdir: &AbsolutePathBuf) -> anyhow::Result<EscalationDecision> {  // EscalationPolicy trait 的实现体：core 注入给 shell-escalation 的"大脑"    let evaluation = {  // 作用域块：读完策略立刻释放锁——规则支持热更新（amend），不能跨 await 持有旧引用        let policy = self.policy.read().await;  // RwLock 读锁：同一会话里多条命令并发裁决时互不阻塞        evaluate_intercepted_exec_policy(&policy, program, argv, InterceptedExecPolicyContext { approval_policy: self.approval_policy, permission_profile: self.permission_profile.clone(), windows_sandbox_level: ..., sandbox_permissions: self.approval_sandbox_permissions, enable_shell_wrapper_parsing: ENABLE_INTERCEPTED_EXEC_POLICY_SHELL_WRAPPER_PARSING })  // execpolicy 匹配：前缀规则优先，未命中走沙箱默认策略兜底（第 490-534 行）    };    let decision_driven_by_policy = Self::decision_driven_by_policy(&evaluation.matched_rules, evaluation.decision);  // 判断裁决是否来自"显式规则"而非启发式/兜底——这决定后面走哪个审批开关（第 225-230 行）    let unsandboxed_allowed = unsandboxed_execution_allowed(&self.permission_profile.file_system_sandbox_policy());  // 当前权限档案是否允许"无沙箱执行"——不允许的话，Escalate 只能退化为 TurnDefault    let needs_escalation = match self.sandbox_permissions {  // 核心判断：这条命令必须出沙箱吗？        SandboxPermissions::UseDefault => unsandboxed_allowed && decision_driven_by_policy,  // 默认模式：只有"规则明确放行 + 档案允许无沙箱"才提权——双条件，fail-closed        SandboxPermissions::RequireEscalated => unsandboxed_allowed,  // 模型显式请求提权（如需要网络）：只要档案允许就提权        SandboxPermissions::WithAdditionalPermissions => true,  // 已授予附加权限（如网络白名单）：必须在带这些权限的环境里跑，必然提权    };    let decision_source = if decision_driven_by_policy { DecisionSource::PrefixRule } else { DecisionSource::UnmatchedCommandFallback };  // 记录裁决来源：显式规则 vs 兜底——两种来源适用的审批开关不同（见下表）    self.process_decision(evaluation.decision, needs_escalation, program, argv, workdir, self.prompt_permissions.clone(), escalation_execution, decision_source).await  // 把 (策略裁决 × 是否需提权) 映射成最终的 EscalationDecision}

let action = match decision {  // 策略裁决 → 协议动作的总映射    Decision::Forbidden => EscalationDecision::deny(Some("Execution forbidden by policy".to_string())),  // 规则明令禁止：直接拒绝，连询问都不发——省得用户反复点"拒绝"    Decision::Prompt => {  // 策略要求人工确认        if execve_prompt_is_rejected_by_policy(self.approval_policy, &decision_source).is_some() {  // 先查用户配置：该来源的审批开关是否被显式关闭（第 204-222 行）            EscalationDecision::deny(Some("Execution forbidden by policy".to_string()))  // 用户配置了"从不询问"：Prompt 等价于 Deny——宁可拒绝也不静默放行（fail loud）        } else {  // 开关未关闭：真正发起审批请求（prompt()，stopwatch 暂停计时）            let decision = self.prompt(program, argv, workdir, &self.stopwatch, prompt_permissions).await?;  // 向用户/Guardian 发审批请求；stopwatch.pause_for() 让超时计时在等待期间暂停——等用户不算"命令执行时间"            match decision {  // ReviewDecision → EscalationDecision 的逐条映射                ReviewDecision::Approved | ReviewDecision::ApprovedForSession | ReviewDecision::ApprovedExecpolicyAmendment { .. } => if needs_escalation { EscalationDecision::escalate(escalation_execution.clone()) } else { EscalationDecision::run() },  // 批准：按 needs_escalation 决定沙箱内跑还是提权跑                ReviewDecision::NetworkPolicyAmendment { network_policy_amendment } => match network_policy_amendment.action { NetworkPolicyRuleAction::Allow => if needs_escalation { EscalationDecision::escalate(escalation_execution.clone()) } else { EscalationDecision::run() },  // 用户批准了"网络策略修订"：视同放行                    NetworkPolicyRuleAction::Deny => EscalationDecision::deny(Some("User denied execution".to_string())) },  // 用户在审批里拒绝了网络访问 = 拒绝执行                ReviewDecision::Denied { rejection } => EscalationDecision::deny(Some(rejection)),  // 用户拒绝：把用户的原话作为 reason 传回 wrapper，最终出现在 stderr                ReviewDecision::TimedOut => EscalationDecision::deny(Some(crate::guardian::guardian_timeout_message(self.review_context.turn().model_info()))),  // 审批超时：按拒绝处理，并生成一条说明超时的消息（含模型信息）                ReviewDecision::Abort => EscalationDecision::deny(Some("User cancelled execution".to_string())),  // 用户主动取消会话/操作            }        }    }    Decision::Allow => if needs_escalation { EscalationDecision::escalate(escalation_execution) } else { EscalationDecision::run() },  // 规则直接放行：同样按 needs_escalation 分流——允许 ≠ 必须出沙箱};

pub(crate) async fn prepare_unified_exec_zsh_fork(req: ..., attempt: &SandboxAttempt<'_>, ctx: &ToolCtx, exec_request: ExecRequest, shell_zsh_path: &std::path::Path, main_execve_wrapper_exe: &std::path::Path) -> Result<Option<PreparedUnifiedExecZshFork>, ToolError> {  // zsh-fork 后端入口：返回 Ok(None) = "不适用，走普通 spawn"    let parsed = match extract_shell_script(&exec_request.command) {  // 先确认这是 zsh -c/-lc 命令——不是就放弃本后端（见下方 extract_shell_script）        Ok(parsed) => parsed,  // 解析成功：拿到 (zsh路径, -c/-lc脚本, login标志)        Err(err) => { tracing::warn!("ZshFork unified exec fallback: {err:?}"); return Ok(None); }  // 注意是 Ok(None) 而不是 Err：不是错误，只是"不适用"——调用方回退普通 spawn    };    if parsed.program != shell_zsh_path.to_string_lossy() {  // 程序必须恰好是 Codex 自带的那个打过补丁的 zsh——系统 zsh 没有 EXEC_WRAPPER 支持，拦截会静默失效        tracing::warn!("ZshFork backend specified, but unified exec command targets `{}` instead of `{}`.", parsed.program, shell_zsh_path.display());  // 留痕：后端被指定但程序不匹配——排查"拦截为何没生效"的关键日志        return Ok(None);  // 不匹配 → 回退普通路径并留警告日志：宁可少一层拦截，也不能假装拦住了    }    let exec_policy = Arc::new(RwLock::new(ctx.session.services.exec_policy.current_for_environment(req.turn_environment.config().exec_policy.as_ref(), ctx.step_context.turn.allow_prefix_rules()).as_ref().clone()));  // 快照当前环境的 execpolicy 规则进 RwLock——会话期间规则可热更新，读锁保证并发裁决安全    let command_executor = CoreShellCommandExecutor { sandbox_manager: attempt.manager.clone(), command: exec_request.command.clone(), cwd, permission_profile: exec_request.permission_profile.clone(), sandbox: exec_request.sandbox, env: exec_request.env.clone(), network: exec_request.network.clone(), ... };  // 构建执行器：Escalate 时由它准备并运行"沙箱外命令"（第 569-827 行）    let escalation_policy = CoreShellActionProvider { policy: Arc::clone(&exec_policy), session: Arc::clone(&ctx.session), review_context: GuardianReviewContext::from(&ctx.step_context), call_id: ctx.call_id.clone(), source: GuardianCommandSource::UnifiedExec, approval_policy: ctx.step_context.settings.approval_policy(), ... };  // 构建决策器：execpolicy + Guardian 审批全部挂在这个结构上    let escalate_server = EscalateServer::new(shell_zsh_path.to_path_buf(), main_execve_wrapper_exe.to_path_buf(), escalation_policy);  // 组装服务端：补丁 zsh 路径 + wrapper 二进制路径 + 策略实现    let escalation_session = escalate_server.start_session(CancellationToken::new(), Arc::new(command_executor)).map_err(|err| ToolError::Rejected(err.to_string()))?;  // 启动会话：socketpair、spawn 服务任务、拿到 env overlay（第二节已拆）    exec_request.env.extend(escalation_session.env().clone());  // 把 CODEX_ESCALATE_SOCKET + EXEC_WRAPPER 注入 shell 环境——从这一刻起，这个 zsh 里的每次 execve 都被拦截    Ok(Some(PreparedUnifiedExecZshFork { exec_request, escalation_session }))  // 返回：改过 env 的请求 + 会话句柄（Drop 时取消服务任务、关 socket——zsh_fork.rs 第 47-60 行的生命周期钩子）}

pub fn set_parent_death_signal(parent_pid: libc::pid_t) -> io::Result<()> {  // Linux 专用：注册"父进程死了就给我 SIGTERM"——防 Codex 本体崩溃后留下孤儿    if unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) } == -1 { return Err(io::Error::last_os_error()); }  // prctl 设置死亡信号；失败是硬错误（在 pre_exec 里调用）    if unsafe { libc::getppid() } != parent_pid {  // 复查父进程 PID：fork 和 exec 之间，原父进程可能恰好退出了（竞态窗口）        unsafe { libc::raise(libc::SIGTERM); }  // 若已"无主"，立刻自杀——源码注释明说这是为了避免 fork/exec 期间的竞态    }    Ok(())  // prctl 成功且父进程仍在：PDEATHSIG 已挂上}pub fn kill_process_group_by_pid(pid: u32) -> io::Result<()> {  // 按 PID 杀掉整个进程组（含子孙），而不是单个进程    let pid = pid as libc::pid_t;  // u32 → i32（libc 接口用 C 的 pid_t）    let pgid = unsafe { libc::getpgid(pid) };  // 先查该进程的组 ID——spawn 时 setpgid(0,0) 让它成为组长，所以 pgid == pid    if pgid == -1 { /* ESRCH/NotFound 视为成功 */ return Ok(()); }  // 进程已不存在：best-effort 语义，清理"没东西可清"不算错误    let result = unsafe { libc::killpg(pgid, libc::SIGKILL) };  // SIGKILL 整组——不给任何成员存活机会（超时/取消的最后一道）    if result == -1 { /* ESRCH 同样视为成功 */ }  // 组已消失：同上，不算错误    Ok(())  // killpg 完成（或组本就不存在）：整组清理结束}

Some(ExecExpirationOutcome::Cancelled) => {  // 用户取消（或会话结束）：两段式清理，源码注释"让懂 TERM 的进程先跑完清理"    let process_group_id = child.id();  // tokio Child 的 PID——spawn 时 setpgid(0,0) 让它成为组长，所以 PGID == 这个 PID    let should_escalate = if let Some(process_group_id) = process_group_id {  // 记录"TERM 是否真的发出去了"——决定宽限期后要不要补 KILL        codex_utils_pty::process_group::terminate_process_group(process_group_id)?  // 第一段：SIGTERM 整组——给进程机会 flush 缓冲、删临时文件（git、npm 都响应 TERM）    } else { false };  // child.id() 为 None（极端情况）：没发过 TERM，后面无需升级杀组    match tokio::time::timeout(CANCELLATION_TERMINATION_GRACE_PERIOD, child.wait()).await {  // 等一个宽限期（常量定义在 exec.rs 顶部）——TERM 之后不是立刻杀        Ok(status) => { status?; if should_escalate && let Some(process_group_id) = process_group_id { codex_utils_pty::process_group::kill_process_group(process_group_id)?; } }  // 宽限期内没退干净：SIGKILL 整组兜底（should_escalate=true 表示 TERM 确实发出去了）        Err(_) => { kill_child_process_group(&mut child)?; child.start_kill()?; }  // wait 本身超时：进程组 + 直接子进程双杀，确保没有漏网之鱼    }    (synthetic_exit_status_for_code(/*code*/ 1), false)  // 合成退出码 1 上报给模型——"被取消"不是"超时"（timed_out=false），两种失败语义严格区分

execve 拦截全链路（zsh-fork 后端）

▼

▼

▼

▼

▼

▼