@team-agent/installer 0.5.2 → 0.5.4

package/crates/team-agent/src/lifecycle/tests/restart.rs

@@ -101,11 +101,8 @@ fn layer2_backing_missing_refusal_carries_checked_paths_and_recovery_hint() {
     use std::sync::atomic::{AtomicU32, Ordering};
     static N: AtomicU32 = AtomicU32::new(0);
     let n = N.fetch_add(1, Ordering::Relaxed);
-    let ws = std::env::temp_dir().join(format!(
-        "ta_rs_l2_backingmiss_{}_{}",
-        std::process::id(),
-        n
-    ));
+    let ws =
+        std::env::temp_dir().join(format!("ta_rs_l2_backingmiss_{}_{}", std::process::id(), n));
     std::fs::create_dir_all(&ws).unwrap();
 
     let missing_rollout = ws.join(".missing-rollout.jsonl");
@@ -168,6 +165,148 @@ fn layer2_backing_missing_refusal_carries_checked_paths_and_recovery_hint() {
     }
 }
 
+fn write_codex_identity_rollout(
+    workspace: &std::path::Path,
+    file_name: &str,
+    session_id: &str,
+    embedded_agent_id: &str,
+) -> std::path::PathBuf {
+    let path = workspace.join(file_name);
+    let text = format!(
+        "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\"}}}}}}\n\
+         {{\"type\":\"turn_context\",\"payload\":{{}}}}\n\
+         {{\"type\":\"response_item\",\"payload\":{{\"content\":[{{\"type\":\"input_text\",\"text\":\"You are Team Agent worker `{embedded_agent_id}` with role `fixture`.\"}}]}}}}\n",
+        workspace.to_string_lossy()
+    );
+    std::fs::write(&path, text).unwrap();
+    path
+}
+
+#[test]
+fn restart_refuses_codex_session_identity_mismatch_without_allow_fresh() {
+    let ws = temp_ws();
+    let rollout = write_codex_identity_rollout(
+        &ws,
+        "rollout-frontend-poison.jsonl",
+        "019f3327-c35a-7023-b3cd-1bea93a7a157",
+        "ios-dev",
+    );
+    let state = json!({
+        "agents": {
+            "frontend": {
+                "provider": "codex",
+                "status": "running",
+                "session_id": "019f3327-c35a-7023-b3cd-1bea93a7a157",
+                "rollout_path": rollout.to_string_lossy(),
+                "captured_at": "2026-07-05T17:04:04Z",
+                "captured_via": "fs_watch",
+                "spawn_cwd": ws.to_string_lossy(),
+                "first_send_at": "2026-07-05T17:10:00Z"
+            }
+        }
+    });
+
+    let plan = crate::lifecycle::restart::classify_restart_plan_with_resume_validation(
+        Some(&ws),
+        &state,
+        false,
+    )
+    .unwrap();
+
+    assert_eq!(plan.decisions.len(), 1);
+    assert_eq!(plan.decisions[0].decision, ResumeDecision::Refuse);
+    assert_eq!(plan.unresumable.len(), 1);
+    let entry = &plan.unresumable[0];
+    assert_eq!(entry.agent_id.as_str(), "frontend");
+    assert_eq!(entry.reason, "session_identity_mismatch");
+    assert_eq!(
+        entry
+            .refusal_reason
+            .as_ref()
+            .map(crate::provider::session::ResumeRefusalReason::wire),
+        Some("session_identity_mismatch")
+    );
+}
+
+#[test]
+fn restart_identity_probe_reports_real_frontend_ios_dev_mismatch_shape() {
+    let ws = temp_ws();
+    let rollout = write_codex_identity_rollout(
+        &ws,
+        "rollout-frontend-poison.jsonl",
+        "019f3327-c35a-7023-b3cd-1bea93a7a157",
+        "ios-dev",
+    );
+    let rollout_path = crate::provider::RolloutPath::new(rollout.clone());
+    let probe = crate::lifecycle::restart::session_identity_probe_for_agent(
+        &aid("frontend"),
+        crate::provider::Provider::Codex,
+        Some(&rollout_path),
+    );
+    assert_eq!(probe.identity_ok, Some(false));
+    assert_eq!(probe.embedded_agent_id.as_deref(), Some("ios-dev"));
+    assert_eq!(probe.rollout_path.as_deref(), Some(rollout.as_path()));
+}
+
+#[test]
+fn restart_allow_fresh_only_fresh_starts_mismatched_codex_worker() {
+    let ws = temp_ws();
+    let frontend_rollout = write_codex_identity_rollout(
+        &ws,
+        "rollout-frontend-poison.jsonl",
+        "019f3327-c35a-7023-b3cd-1bea93a7a157",
+        "ios-dev",
+    );
+    let backend_rollout = write_codex_identity_rollout(
+        &ws,
+        "rollout-backend-valid.jsonl",
+        "019f3327-backend-valid",
+        "backend",
+    );
+    let state = json!({
+        "agents": {
+            "frontend": {
+                "provider": "codex",
+                "status": "running",
+                "session_id": "019f3327-c35a-7023-b3cd-1bea93a7a157",
+                "rollout_path": frontend_rollout.to_string_lossy(),
+                "captured_at": "2026-07-05T17:04:04Z",
+                "captured_via": "fs_watch",
+                "spawn_cwd": ws.to_string_lossy()
+            },
+            "backend": {
+                "provider": "codex",
+                "status": "running",
+                "session_id": "019f3327-backend-valid",
+                "rollout_path": backend_rollout.to_string_lossy(),
+                "captured_at": "2026-07-05T17:04:05Z",
+                "captured_via": "fs_watch",
+                "spawn_cwd": ws.to_string_lossy()
+            }
+        }
+    });
+
+    let plan = crate::lifecycle::restart::classify_restart_plan_with_resume_validation(
+        Some(&ws),
+        &state,
+        true,
+    )
+    .unwrap();
+
+    assert!(
+        plan.unresumable.is_empty(),
+        "allow_fresh should convert the poisoned worker to fresh without refusing; got {:?}",
+        plan.unresumable
+    );
+    let decisions = plan
+        .decisions
+        .iter()
+        .map(|decision| (decision.agent_id.as_str(), decision.decision))
+        .collect::<std::collections::BTreeMap<_, _>>();
+    assert_eq!(decisions.get("frontend"), Some(&ResumeDecision::FreshStart));
+    assert_eq!(decisions.get("backend"), Some(&ResumeDecision::Resume));
+}
+
 #[test]
 fn unit0_restart_corrupt_first_send_at_blocks_before_resume_classification() {
     // The corrupt-first_send_at branch is the hard-refuse gate that fires

package/crates/team-agent/src/lifecycle/types.rs

@@ -440,6 +440,7 @@ pub struct StartedAgent {
     pub agent_id: AgentId,
     pub start_mode: StartMode,
     pub target: String,
+    pub spawned_at: String,
     pub session_id: Option<SessionId>,
     pub rollout_path: Option<RolloutPath>,
     pub pending_session_id: Option<SessionId>,

package/crates/team-agent/src/mcp_server/wire.rs

@@ -314,14 +314,13 @@ fn non_empty_env(key: &str) -> Option<String> {
         .filter(|value| !value.is_empty())
 }
 
-#[cfg(unix)]
+// 0.5.x Windows portability Batch 3: parent-pid probe routes through
+// `crate::platform::process::current_parent_pid`. Unix uses
+// `libc::getppid`; Windows uses Toolhelp32Snapshot. Both return
+// `Option<u32>`; the legacy `0` fallback (which would have silently
+// degraded MCP metadata + orphan detection on Windows) is gone.
 fn parent_pid() -> u32 {
-    u32::try_from(unsafe { libc::getppid() }).unwrap_or(0)
-}
-
-#[cfg(not(unix))]
-fn parent_pid() -> u32 {
-    0
+    crate::platform::process::current_parent_pid().unwrap_or(0)
 }
 
 fn error_response_value(id: RpcId, code: i64, message: String) -> Value {

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1932,6 +1932,9 @@ fn app_server_state(
     })
 }
 
+// 0.5.x Windows portability Batch 5: FakeAppServer uses Unix domain
+// sockets — Unix-only.
+#[cfg(unix)]
 #[test]
 fn app_server_leader_delivery_marks_delivered_without_tmux_transport() {
     let ws = tmp_ws("appdeliver");
@@ -1984,6 +1987,7 @@ fn app_server_leader_delivery_marks_delivered_without_tmux_transport() {
     );
 }
 
+#[cfg(unix)]
 #[test]
 fn app_server_leader_delivery_stale_tuple_fails_closed_with_event() {
     let ws = tmp_ws("appstale");
@@ -2076,6 +2080,7 @@ fn app_server_leader_delivery_fails_closed_on_mode_transport_conflict() {
     );
 }
 
+#[cfg(unix)]
 #[test]
 fn app_server_leader_busy_is_retryable_and_does_not_steer() {
     let ws = tmp_ws("appbusy");

package/crates/team-agent/src/packaging/tests.rs

@@ -222,12 +222,47 @@ fn linux_aarch64_is_native() {
 }
 
 #[test]
-fn windows_x8664_is_native_per_transport_design() {
-    // skeleton:203/211 — Windows 原生一等 (WezTerm/ConPTY,非 tmux)。
-    // 不是 Unsupported,不是 RequiresWslTmux — 是 Native.
-    assert_eq!(
-        platform_support(ReleaseTarget::WindowsX8664),
-        PlatformSupport::Native
+fn windows_x8664_is_preview_compile_only_during_batch_0_to_5() {
+    // 0.5.x Windows portability CR C-1 (P0):
+    // Windows previously claimed `PlatformSupport::Native` but
+    // `cargo check --target x86_64-pc-windows-msvc` was RED — the
+    // Unix-only `std::os::unix` / `libc::pid_t` calls in
+    // tmux_backend/coordinator/lifecycle/packaging never compiled on
+    // Windows. Claiming Native was a MUST-NOT-13 假绿承诺 (user
+    // installs and immediately hits build failures).
+    //
+    // This test locks the honest downgrade in place until Batch 6/7
+    // real-machine gates pass. Promoting Windows back to `Native`
+    // requires:
+    //   1. Batch 6 fake-provider smoke on the SSH host (design §Batch 6)
+    //   2. Batch 7 real-machine subscription serial (CR §C-5)
+    // Both flip this test to `assert PlatformSupport::Native` in a
+    // deliberate PR — no silent regen.
+    //
+    // Truth source: `.team/artifacts/0.5.x-windows-portability-cr-verdict.md` §C-1.
+    match platform_support(ReleaseTarget::WindowsX8664) {
+        PlatformSupport::PreviewCompileOnly { preview_gate, note } => {
+            assert_eq!(preview_gate, "compile_gate");
+            assert!(note.contains("compile_gate") || note.contains("cargo check"));
+        }
+        other => panic!(
+            "Windows must stay `PreviewCompileOnly` while the compile gate is RED; \
+             promoting back to `Native` requires Batch 6 + Batch 7 real-machine gates. \
+             Got {other:?}"
+        ),
+    }
+}
+
+#[test]
+fn windows_x8664_is_not_native_yet_c1_hard_lock() {
+    // Belt-and-braces companion for the above — a distinct assertion
+    // that fires clearly if a future refactor of `PlatformSupport`
+    // changes variant names.
+    let support = platform_support(ReleaseTarget::WindowsX8664);
+    assert_ne!(
+        support,
+        PlatformSupport::Native,
+        "CR C-1: Windows must NOT be Native until Batch 6/7 gates pass"
     );
 }
 

package/crates/team-agent/src/packaging/types.rs

@@ -162,13 +162,27 @@ pub enum ReleaseTarget {
 }
 
 /// 平台支持等级(§8:如实声明,不假装兼容)。
+///
+/// 0.5.x Windows portability CR C-1 (P0) 引入 `PreviewCompileOnly`:
+/// Windows 目前 `cargo check --target x86_64-pc-windows-msvc` **仍红**
+/// (三处 non-Unix fallback + platform 层未接入 + Batch 1-4 未完成);
+/// 保持 `Native` 会构成 MUST-NOT-13 假绿承诺 → 用户装 Windows 二进制
+/// 会真报错。降级为 `PreviewCompileOnly` 明示"当前 Windows 尚未通过
+/// 编译门,Batch 6/7 真机订阅测通过前不承诺 Native"。
+/// Truth source: `.team/artifacts/0.5.x-windows-portability-cr-verdict.md` §C-1。
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case", tag = "level")]
 pub enum PlatformSupport {
-    /// 原生一等(macOS/Linux tmux;Windows WezTerm/ConPTY,见 transport-backend-design.md)。
+    /// 原生一等(macOS/Linux tmux)。
     Native,
     /// 需 WSL + tmux backend(显式标要求,不假装原生)。
     RequiresWslTmux { note: String },
+    /// Windows 移植进行中,`cargo check` 仍红或 Batch 6/7 真机订阅测未过。
+    /// 用户不应期待可运行的 `.exe`;`preview_gate` 字段说明当前挡位
+    /// (`compile_gate` = Batch 0-4 编译门,`fake_provider_smoke` = Batch 6,
+    /// `subscription_realmachine` = Batch 7)。
+    /// 该档位不承诺可用,仅承诺"正在移植 + 每 Batch 有 CI 编译门追踪"。
+    PreviewCompileOnly { preview_gate: String, note: String },
     /// 当前 release 矩阵不覆盖。
     Unsupported { reason: String },
 }
@@ -179,8 +193,22 @@ pub fn platform_support(target: ReleaseTarget) -> PlatformSupport {
         ReleaseTarget::MacosAarch64
         | ReleaseTarget::MacosX8664
         | ReleaseTarget::LinuxX8664
-        | ReleaseTarget::LinuxAarch64
-        | ReleaseTarget::WindowsX8664 => PlatformSupport::Native,
+        | ReleaseTarget::LinuxAarch64 => PlatformSupport::Native,
+        // 0.5.x Windows portability CR C-1 (P0):
+        // `cargo check --target x86_64-pc-windows-msvc` 是当前挡位;
+        // Batch 6 fake-provider smoke + Batch 7 真机订阅测通过后
+        // 才升回 `Native`。历史 tag 期间 Windows 曾声明为 Native 但
+        // 从未通过编译门,构成 MUST-NOT-13 假绿承诺 → 本 batch 降级。
+        ReleaseTarget::WindowsX8664 => PlatformSupport::PreviewCompileOnly {
+            preview_gate: "compile_gate".to_string(),
+            note: "Windows native port in progress; `cargo check --target x86_64-pc-windows-msvc` \
+                   is the current gate. See \
+                   `.team/artifacts/0.5.x-windows-portability-survey-design.md` §Batch 0-6 \
+                   and CR verdict §C-1 for burn-down status. Promote back to `Native` only \
+                   after Batch 6 (fake-provider smoke) + Batch 7 (subscription real-machine) \
+                   pass on the SSH host."
+                .to_string(),
+        },
     }
 }
 

package/crates/team-agent/src/platform/argv.rs

@@ -0,0 +1,324 @@
+//! Process argv / environ probe.
+//!
+//! ## Batch 4 real implementation (leader msg_0689a63a9e40)
+//!
+//! Batch 4 promotes this module from a Batch 0 signature-only
+//! scaffold to a **byte-preserving migration** of the process ancestry
+//! + argv/env probes used by:
+//!
+//! - `lifecycle/launch.rs::process_ancestry_argv` +
+//!   `process_argv_tokens` + `process_parent_pid` — the
+//!   `dangerous_auto_approve` inheritance chain (0.5.0 caller-identity
+//!   钉输入 is exactly this test surface).
+//! - `leader/provider_attribution.rs::process_command_line` +
+//!   `process_environment` — leader provider attribution.
+//!
+//! ## Platform matrix
+//!
+//! - **Linux**: `/proc/<pid>/cmdline` (NUL-separated argv) and
+//!   `/proc/<pid>/environ` (NUL-separated KEY=VALUE).
+//! - **macOS**: `sysctl(KERN_PROCARGS2)` for argv; environ not
+//!   currently probed (matches the pre-batch behavior).
+//! - **non-Linux non-macOS Unix**: `ps -p <pid> -o command=` for argv.
+//! - **Windows**: `NtQueryInformationProcess` + PEB is intrusive; for
+//!   Batch 4 we return `None` for both `argv_tokens` and
+//!   `environ_text` (design §Batch 4 Verification anchor: "unknown
+//!   argv must never infer elevated approval; keep worker permission
+//!   at provider default or require explicit user consent"). This is
+//!   the honest "we don't know" branch — callers already treat
+//!   `None` as "no elevation inherited", so Windows leaders default
+//!   to safe (non-dangerous) approval mode.
+//!
+//! ## CR C-3 anchor
+//!
+//! The `Option::None` return on Windows deliberately keeps worker
+//! permission at provider default. Design §Batch 4 Verification: "the
+//! safe direction is to avoid elevation, not to assume bypass" —
+//! `detect_dangerous_approval` in `lifecycle/launch.rs` already
+//! iterates `process_ancestry_argv(...)` and defaults to
+//! `disabled_dangerous_approval()` when it finds no matching flag,
+//! so a Windows probe returning `None` on every step lands on the
+//! same disabled default. **This is intentional**: leaking a
+//! bypass via unknown argv would be a MUST-NOT-13 假绿 failure.
+
+/// Return the argv tokens for `pid`, or `None` if unavailable on
+/// this platform.
+///
+/// - Linux: `/proc/<pid>/cmdline` NUL-separated (byte-preserving
+///   migration of `lifecycle/launch.rs:3648-3656`).
+/// - macOS: `sysctl(KERN_PROCARGS2)` (migration of
+///   `lifecycle/launch.rs:3659-3711`).
+/// - Other Unix: `ps -p <pid> -o command=` split on whitespace
+///   (migration of `lifecycle/launch.rs:3714-3729`).
+/// - Windows: `None` (design §Batch 4 conservative fallback — never
+///   infer elevated approval from unknown argv).
+pub fn argv_tokens(pid: u32) -> Option<Vec<String>> {
+    #[cfg(target_os = "linux")]
+    {
+        argv_tokens_linux(pid)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        argv_tokens_macos(pid)
+    }
+    #[cfg(all(unix, not(any(target_os = "linux", target_os = "macos"))))]
+    {
+        argv_tokens_ps_fallback(pid)
+    }
+    #[cfg(windows)]
+    {
+        let _ = pid;
+        None
+    }
+}
+
+/// Return the environ text (NUL-joined) for `pid`, or `None`.
+///
+/// - Linux: `/proc/<pid>/environ` verbatim (migration of
+///   `leader/provider_attribution.rs:113-115`).
+/// - Other platforms: `None` (matches the pre-batch
+///   `#[cfg(not(target_os="linux"))]` stub in
+///   `leader/provider_attribution.rs:135-139`).
+pub fn environ_text(pid: u32) -> Option<String> {
+    #[cfg(target_os = "linux")]
+    {
+        environ_text_linux(pid)
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        let _ = pid;
+        None
+    }
+}
+
+/// Return the parent PID of `pid`, or `None` if unavailable.
+///
+/// Byte-preserving migration of `lifecycle/launch.rs::process_parent_pid`:
+/// - Unix: `ps -p <pid> -o ppid=` parsed as u32.
+/// - Windows: Toolhelp32 snapshot walked for the entry matching
+///   `pid`. Same technique as `platform::process::current_parent_pid`.
+pub fn parent_pid(pid: u32) -> Option<u32> {
+    #[cfg(unix)]
+    {
+        parent_pid_unix(pid)
+    }
+    #[cfg(windows)]
+    {
+        parent_pid_windows(pid)
+    }
+    #[cfg(not(any(unix, windows)))]
+    {
+        let _ = pid;
+        None
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// Linux implementation.
+// ─────────────────────────────────────────────────────────────────────
+
+#[cfg(target_os = "linux")]
+fn argv_tokens_linux(pid: u32) -> Option<Vec<String>> {
+    let bytes = std::fs::read(format!("/proc/{pid}/cmdline")).ok()?;
+    let argv_tokens = String::from_utf8_lossy(&bytes)
+        .split('\0')
+        .filter(|token| !token.is_empty())
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    (!argv_tokens.is_empty()).then_some(argv_tokens)
+}
+
+#[cfg(target_os = "linux")]
+fn environ_text_linux(pid: u32) -> Option<String> {
+    String::from_utf8(std::fs::read(format!("/proc/{pid}/environ")).ok()?).ok()
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// macOS implementation.
+// ─────────────────────────────────────────────────────────────────────
+
+#[cfg(target_os = "macos")]
+fn argv_tokens_macos(pid: u32) -> Option<Vec<String>> {
+    use std::mem::size_of;
+    let mut mib = [
+        libc::CTL_KERN,
+        libc::KERN_PROCARGS2,
+        i32::try_from(pid).ok()?,
+    ];
+    let mut size = 0usize;
+    let rc = unsafe {
+        libc::sysctl(
+            mib.as_mut_ptr(),
+            mib.len() as u32,
+            std::ptr::null_mut(),
+            &mut size,
+            std::ptr::null_mut(),
+            0,
+        )
+    };
+    if rc != 0 || size <= size_of::<libc::c_int>() {
+        return None;
+    }
+    let mut buf = vec![0u8; size];
+    let rc = unsafe {
+        libc::sysctl(
+            mib.as_mut_ptr(),
+            mib.len() as u32,
+            buf.as_mut_ptr().cast(),
+            &mut size,
+            std::ptr::null_mut(),
+            0,
+        )
+    };
+    if rc != 0 || size <= size_of::<libc::c_int>() {
+        return None;
+    }
+    let argc = i32::from_ne_bytes(buf.get(..size_of::<libc::c_int>())?.try_into().ok()?) as usize;
+    let mut offset = size_of::<libc::c_int>();
+    while offset < size && buf[offset] != 0 {
+        offset += 1;
+    }
+    while offset < size && buf[offset] == 0 {
+        offset += 1;
+    }
+    let raw = String::from_utf8_lossy(&buf[offset..size]);
+    let argv_tokens = raw
+        .split('\0')
+        .filter(|token| !token.is_empty())
+        .take(argc)
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    (!argv_tokens.is_empty()).then_some(argv_tokens)
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// Generic Unix fallback (`ps -p <pid> -o ...`).
+// ─────────────────────────────────────────────────────────────────────
+
+#[cfg(all(unix, not(any(target_os = "linux", target_os = "macos"))))]
+fn argv_tokens_ps_fallback(pid: u32) -> Option<Vec<String>> {
+    let output = std::process::Command::new("ps")
+        .args(["-p", &pid.to_string(), "-o", "command="])
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let text = String::from_utf8_lossy(&output.stdout);
+    let argv_tokens = text
+        .split_whitespace()
+        .filter(|token| !token.is_empty())
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    (!argv_tokens.is_empty()).then_some(argv_tokens)
+}
+
+#[cfg(unix)]
+fn parent_pid_unix(pid: u32) -> Option<u32> {
+    let output = std::process::Command::new("ps")
+        .args(["-p", &pid.to_string(), "-o", "ppid="])
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    String::from_utf8_lossy(&output.stdout)
+        .trim()
+        .parse::<u32>()
+        .ok()
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// Windows implementation.
+// ─────────────────────────────────────────────────────────────────────
+
+#[cfg(windows)]
+fn parent_pid_windows(pid: u32) -> Option<u32> {
+    use windows::Win32::System::Diagnostics::ToolHelp::{
+        CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W,
+        TH32CS_SNAPPROCESS,
+    };
+    let snapshot = unsafe { CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) }.ok()?;
+    let mut entry = PROCESSENTRY32W {
+        dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32,
+        ..Default::default()
+    };
+    let mut result = unsafe { Process32FirstW(snapshot, &mut entry) };
+    while result.is_ok() {
+        if entry.th32ProcessID == pid {
+            let ppid = entry.th32ParentProcessID;
+            unsafe {
+                let _ = windows::Win32::Foundation::CloseHandle(snapshot);
+            }
+            return Some(ppid);
+        }
+        result = unsafe { Process32NextW(snapshot, &mut entry) };
+    }
+    unsafe {
+        let _ = windows::Win32::Foundation::CloseHandle(snapshot);
+    }
+    None
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// Tests.
+// ─────────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn argv_tokens_returns_some_for_own_pid_on_unix_or_none_on_windows() {
+        // Byte-preserving migration of the ancestry probe. On Unix
+        // this must return a non-empty argv for our own process (test
+        // binary). On Windows the honest `None` return is intentional:
+        // callers see the "no elevation inherited" default branch,
+        // which is safer than reading unknown argv (CR C-3 anchor).
+        let my = std::process::id();
+        let argv = argv_tokens(my);
+        #[cfg(unix)]
+        {
+            let argv = argv.expect("unix must return Some argv for own pid");
+            assert!(!argv.is_empty());
+            // At least argv[0] should look like a test binary path.
+            let argv0 = &argv[0];
+            assert!(!argv0.is_empty());
+        }
+        #[cfg(windows)]
+        {
+            // Windows conservative fallback: None, so
+            // `detect_dangerous_approval` defaults to disabled.
+            assert!(argv.is_none());
+        }
+    }
+
+    #[test]
+    fn parent_pid_returns_some_on_both_platforms() {
+        // Batch 4: parent_pid via `ps -o ppid=` (unix) or Toolhelp32
+        // (windows) — both must resolve our own ppid.
+        let my = std::process::id();
+        let ppid = parent_pid(my);
+        assert!(ppid.is_some(), "parent_pid must resolve own pid on both unix and windows");
+        assert!(ppid.unwrap() > 0);
+    }
+
+    #[test]
+    fn environ_text_linux_only_returns_something_for_own_pid() {
+        // The environ probe is Linux-only by design (matches
+        // `leader/provider_attribution.rs:113-115`). Other platforms
+        // honestly return None; callers already treat that as
+        // "no env-based attribution".
+        let my = std::process::id();
+        let env = environ_text(my);
+        #[cfg(target_os = "linux")]
+        {
+            let env = env.expect("linux must return Some environ");
+            assert!(env.contains('='));
+        }
+        #[cfg(not(target_os = "linux"))]
+        {
+            assert!(env.is_none());
+        }
+    }
+}