@team-agent/installer 0.5.1 → 0.5.3

package/crates/team-agent/src/cli/emit.rs

@@ -112,6 +112,10 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "claim-leader" => cmd_claim_leader(&claim_leader_args(args, cwd)).map(emit_result),
         // Real dispatch: `cmd_attach_leader` writes the `leader_receiver` binding.
         "attach-leader" => cmd_attach_leader(&attach_leader_args(args, cwd)?).map(emit_result),
+        "attach-app-server-leader" => {
+            cmd_attach_app_server_leader(&attach_app_server_leader_args(args, cwd)?)
+                .map(emit_result)
+        }
         "identity" => cmd_identity(&identity_args(args, cwd)).map(emit_result),
         "approvals" => cmd_approvals(&approvals_args(args, cwd)).map(emit_result),
         "inbox" => cmd_inbox(&inbox_args(args, cwd)?).map(emit_result),
@@ -167,6 +171,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "takeover",
     "claim-leader",
     "attach-leader",
+    "attach-app-server-leader",
     "identity",
     "approvals",
     "inbox",
@@ -210,6 +215,23 @@ fn is_known_subcommand(command: &str) -> bool {
     DISPATCH_COMMANDS.contains(&command) || SPEC_ONLY_HELP_COMMANDS.contains(&command)
 }
 
+/// Test-only public accessor for `command_help` — allows integration
+/// tests to grep the help copy without depending on internal parser
+/// machinery.
+pub fn __test_command_help(command: Option<&str>) -> String {
+    command_help(command)
+}
+
+/// Test-only public accessor for `quick_start_args` — allows
+/// integration tests to exercise the parser without going through
+/// stdio + the full `main` entrypoint.
+pub fn __test_quick_start_args(
+    args: &[String],
+    cwd: &std::path::Path,
+) -> Result<crate::cli::types::QuickStartArgs, crate::cli::CliError> {
+    quick_start_args(args, cwd)
+}
+
 fn command_help(command: Option<&str>) -> String {
     match command {
         None => {
@@ -222,7 +244,7 @@ fn command_help(command: Option<&str>) -> String {
             )
         }
         Some("init") => "usage: team-agent init [--workspace WORKSPACE] [--force] [--json]".to_string(),
-        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.".to_string(),
+        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.\n\n--backend selects the worker transport (Phase 1d Batch 2): tmux (default on POSIX; unchanged behavior), conpty (Windows-native ConPTY worker transport; requires the shim binary and Windows host).".to_string(),
         Some("start") => "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]".to_string(),
         Some("compile") => "usage: team-agent compile --team TEAM [--out FILE] [--json]".to_string(),
         Some("send") => "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]\n\nMVP: name-based cross-workspace addressing assumes trusted local caller; no auth gate.".to_string(),
@@ -247,6 +269,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("takeover") => "usage: team-agent takeover [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]".to_string(),
         Some("claim-leader") => "usage: team-agent claim-leader [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]".to_string(),
         Some("attach-leader") => "usage: team-agent attach-leader [--workspace WORKSPACE] [--team TEAM] [--pane PANE] [--provider PROVIDER] [--confirm] [--json]".to_string(),
+        Some("attach-app-server-leader") => "usage: team-agent attach-app-server-leader [--workspace WORKSPACE] [--team TEAM] --socket unix:///path.sock --thread-id THREAD_ID [--json]".to_string(),
         Some("identity") => "usage: team-agent identity [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("approvals") => "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("inbox") => "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]".to_string(),
@@ -670,12 +693,18 @@ struct ParsedArgs {
     pane: Option<String>,
     to_name: Option<String>,
     provider: Option<String>,
+    socket: Option<String>,
+    thread_id: Option<String>,
     message_id: Option<String>,
     content: Option<String>,
     primary_error: Option<String>,
     agent_id: Option<String>,
     task_id: Option<String>,
     result_json: Option<String>,
+    /// 0.5.x Phase 1d Batch 2: quick-start `--backend <tmux|conpty>`.
+    /// Raw string (validated at the quick-start builder); the factory
+    /// enforces literal semantics.
+    backend: Option<String>,
 }
 
 fn parse_args(args: &[String]) -> ParsedArgs {
@@ -717,6 +746,7 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             }
             "--force" => parsed.force = true,
             "--no-display" => parsed.no_display = true,
+            "--backend" => parsed.backend = next_arg(args, &mut i),
             "--discard-session" => parsed.discard_session = true,
             "--role-file" => parsed.role_file = next_arg(args, &mut i),
             "--as" => parsed.as_agent = next_arg(args, &mut i),
@@ -753,6 +783,8 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--pane" => parsed.pane = next_arg(args, &mut i),
             "--to-name" => parsed.to_name = next_arg(args, &mut i),
             "--provider" => parsed.provider = next_arg(args, &mut i),
+            "--socket" => parsed.socket = next_arg(args, &mut i),
+            "--thread-id" => parsed.thread_id = next_arg(args, &mut i),
             "--message-id" => parsed.message_id = next_arg(args, &mut i),
             "--content" => parsed.content = next_arg(args, &mut i),
             "--primary-error" => parsed.primary_error = next_arg(args, &mut i),
@@ -770,6 +802,12 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             other if other.starts_with("--provider=") => {
                 parsed.provider = Some(other.trim_start_matches("--provider=").to_string());
             }
+            other if other.starts_with("--socket=") => {
+                parsed.socket = Some(other.trim_start_matches("--socket=").to_string());
+            }
+            other if other.starts_with("--thread-id=") => {
+                parsed.thread_id = Some(other.trim_start_matches("--thread-id=").to_string());
+            }
             other if other.starts_with('-') => {}
             other => parsed.positionals.push(other.to_string()),
         }
@@ -833,6 +871,20 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
     } else {
         workspace.join(agents_dir)
     };
+    // 0.5.x Phase 1d Batch 2: validate the `--backend` literal up-front
+    // so users get a fast, actionable error instead of a downstream
+    // factory refusal. Accept the same literals as the factory
+    // `RequestedTransportBackend::parse_literal`.
+    if let Some(literal) = parsed.backend.as_deref() {
+        let normalized = literal.trim().to_ascii_lowercase();
+        if normalized != "tmux" && normalized != "conpty" {
+            return Err(CliError::Usage(format!(
+                "--backend must be `tmux` or `conpty`, got {literal:?}. \
+                 `pty` is not a supported literal in Phase 1d (design \
+                 §Non-Goals + CR C-1 ②)."
+            )));
+        }
+    }
     Ok(QuickStartArgs {
         workspace,
         agents_dir,
@@ -841,6 +893,7 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
         yes: parsed.yes,
         no_display: parsed.no_display,
         json: parsed.json,
+        backend: parsed.backend,
     })
 }
 
@@ -1079,6 +1132,26 @@ fn attach_leader_args(args: &[String], cwd: &Path) -> Result<AttachLeaderArgs, C
     })
 }
 
+fn attach_app_server_leader_args(
+    args: &[String],
+    cwd: &Path,
+) -> Result<AttachAppServerLeaderArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(AttachAppServerLeaderArgs {
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        socket: parsed
+            .socket
+            .filter(|socket| !socket.is_empty())
+            .ok_or_else(|| CliError::Usage("missing --socket".to_string()))?,
+        thread_id: parsed
+            .thread_id
+            .filter(|thread_id| !thread_id.is_empty())
+            .ok_or_else(|| CliError::Usage("missing --thread-id".to_string()))?,
+        json: parsed.json,
+    })
+}
+
 fn identity_args(args: &[String], cwd: &Path) -> IdentityArgs {
     let parsed = parse_args(args);
     IdentityArgs {
@@ -1444,10 +1517,15 @@ fn peek_args(args: &[String], cwd: &Path) -> Result<PeekArgs, CliError> {
 fn run_coordinator(args: &[String], cwd: &Path) -> Result<ExitCode, CliError> {
     let parsed = parse_args(args);
     let workspace = crate::coordinator::WorkspacePath::new(workspace(&parsed, cwd));
+    // 0.5.x Windows portability Batch 9 F8: pass `--team` through
+    // to the daemon so it doesn't have to derive from state at
+    // boot time. `parse_args` already recognizes `--team`; we just
+    // thread the value into `DaemonArgs::team_key`.
     crate::coordinator::run_daemon(crate::coordinator::DaemonArgs {
         workspace,
         once: parsed.once,
         tick_interval_sec: parsed.tick_interval,
+        team_key: parsed.team.clone(),
     })
     .map(|()| ExitCode::Ok)
     .map_err(|e| CliError::Runtime(e.to_string()))

package/crates/team-agent/src/cli/mod.rs

@@ -53,6 +53,7 @@ pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker t
 pub(crate) const STATUS_REMINDER: &str = "To wait for results use --watch-result or team-agent collect. Do not capture-pane worker terminals.";
 
 pub mod adapters;
+pub mod attach_app_server_leader;
 pub mod diagnose;
 pub mod emit;
 pub mod helpers;
@@ -64,6 +65,7 @@ pub mod status;
 pub mod types;
 
 pub use adapters::*;
+pub use attach_app_server_leader::*;
 pub use diagnose::*;
 pub use emit::*;
 pub use leader::*;
@@ -120,14 +122,16 @@ pub mod lifecycle_port {
         team_id: Option<&str>,
         yes: bool,
         open_display: bool,
+        backend: Option<&str>,
     ) -> Result<Value, CliError> {
-        match crate::lifecycle::quick_start_in_workspace_with_display(
+        match crate::lifecycle::quick_start_in_workspace_with_display_and_backend(
             workspace,
             agents_dir,
             name,
             yes,
             team_id,
             open_display,
+            backend,
         ) {
             Ok(report) => Ok(quick_start_value(report)),
             Err(e) => Ok(error_value(e)),
@@ -192,16 +196,40 @@ pub mod lifecycle_port {
         crate::tmux_backend::attach_command_for_workspace(cwd, session, window.as_str())
     }
     /// `runtime.shutdown`(`cmd_shutdown`)。
+    ///
+    /// 0.5.x Phase 1d Batch 5: the workspace-transport branch now routes
+    /// through `transport_factory::resolve_read_only_transport` so a
+    /// conpty team's shutdown reaches the shim rather than a
+    /// no-op tmux backend. Legacy tmux endpoint literal in state still
+    /// takes the `shutdown_transport_for_endpoint` tmux channel helper
+    /// path (intentional — this is the "attached explicit tmux
+    /// endpoint" branch and stays tmux-typed).
+    ///
+    /// `shutdown_with_transport_and_state` is generic over `&dyn
+    /// Transport`, so we hand the boxed factory backend down as
+    /// `&*box`. Factory refusal falls back to the workspace tmux
+    /// backend byte-equivalent to today so daemon liveness paths
+    /// don't crash.
     pub fn shutdown(workspace: &Path, keep_logs: bool, team: Option<&str>) -> Result<Value, CliError> {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let state = shutdown_state_for_team(&run_ws, team)?;
-        let transport = if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
-            shutdown_transport_for_endpoint(endpoint)
-        } else {
-            shutdown_workspace_transport(&run_ws)
-        };
-        shutdown_with_transport_and_state(workspace, keep_logs, team, &transport, Some(state))
+        if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
+            let transport = shutdown_transport_for_endpoint(endpoint);
+            return shutdown_with_transport_and_state(
+                workspace, keep_logs, team, &transport, Some(state),
+            );
+        }
+        let boxed: Box<dyn crate::transport::Transport> =
+            match crate::transport_factory::resolve_read_only_transport(
+                &run_ws,
+                Some(&state),
+                crate::transport_factory::TransportPurpose::Shutdown,
+            ) {
+                Ok(r) => r.backend,
+                Err(_) => Box::new(shutdown_workspace_transport(&run_ws)),
+            };
+        shutdown_with_transport_and_state(workspace, keep_logs, team, boxed.as_ref(), Some(state))
     }
 
     /// E12 ①:从 state 锚 pane_id(leader_receiver/team_owner,top+teams)映射到其所在 session
@@ -915,7 +943,17 @@ pub mod lifecycle_port {
                 }),
             )
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        Ok(json!({
+        // 0.5.x Windows portability Batch 6 Option A (leader
+        // constraint 3): if a ConPTY shim was recorded in
+        // `state.transport.shim.pid`, terminate it explicitly via
+        // `platform::process::terminate_pid`.
+        //
+        // Batch 7 refinement: the field is emitted into the shutdown
+        // JSON only on Windows so Unix golden fixtures stay
+        // byte-preserving. The Unix behavior is a no-op (no shim
+        // concept there); adding a placeholder key would just noise
+        // up the fixtures.
+        let mut response = json!({
             "ok": ok,
             "status": status,
             "phase": phase,
@@ -938,8 +976,59 @@ pub mod lifecycle_port {
             "coordinator": {
                 "status": coordinator_status,
                 "pid": coordinator_pid,
+            },
+        });
+        #[cfg(windows)]
+        {
+            if let Some(obj) = response.as_object_mut() {
+                obj.insert(
+                    "conpty_shim".to_string(),
+                    shutdown_conpty_shim(&run_workspace),
+                );
             }
-        }))
+        }
+        #[cfg(not(windows))]
+        {
+            let _ = &run_workspace;
+        }
+        Ok(response)
+    }
+
+    /// 0.5.x Windows portability Batch 6 Option A: locate and
+    /// terminate the ConPTY shim if `state.transport.shim.pid` is
+    /// recorded. Returns a JSON blob for the shutdown response so
+    /// operators can distinguish "no shim was ever launched" from
+    /// "shim terminated cleanly" from "shim already gone".
+    ///
+    /// Windows-only; caller (`shutdown_with_transport_and_state`)
+    /// only invokes on Windows. Unix has no shim concept.
+    #[cfg(windows)]
+    fn shutdown_conpty_shim(workspace: &Path) -> serde_json::Value {
+        let Some(pid) = crate::coordinator::conpty_shim::recorded_shim_pid(workspace) else {
+            return json!({ "action": "no_shim_recorded" });
+        };
+        // Prefer graceful termination — Windows maps this to
+        // `TerminationOutcome::ForceOnly` (Batch 3 anchor: no
+        // SIGTERM equivalent for non-console child), which
+        // surfaces the honest audit signal in the JSON.
+        let outcome = crate::platform::process::terminate_pid(
+            pid,
+            crate::platform::process::SignalKind::TerminateForce,
+        );
+        match outcome {
+            Ok(crate::platform::process::TerminationOutcome::Requested) => {
+                json!({ "pid": pid, "action": "terminated" })
+            }
+            Ok(crate::platform::process::TerminationOutcome::AlreadyGone) => {
+                json!({ "pid": pid, "action": "already_gone" })
+            }
+            Ok(crate::platform::process::TerminationOutcome::ForceOnly { reason }) => {
+                json!({ "pid": pid, "action": "terminated_force_only", "reason": reason })
+            }
+            Err(e) => {
+                json!({ "pid": pid, "action": "terminate_failed", "reason": e.to_string() })
+            }
+        }
     }
 
     /// T5 (harvest §1 / A2): the bounded stop RETAINS the JoinHandle and reclaims the
@@ -1191,24 +1280,41 @@ pub mod lifecycle_port {
                 }
             }
         }
-        let workspace_transport = shutdown_workspace_transport(workspace);
-        match crate::transport::Transport::has_session(&workspace_transport, session) {
-            Ok(true) => residual = true,
-            Ok(false) => {}
-            Err(err) if tmux_absent_error(&err.to_string()) => {}
-            Err(err) => {
-                error.get_or_insert_with(|| err.to_string());
-                residual = true;
+        // 0.5.x Phase 1d Batch 5 (design §Batch 5 point 4): a ConPTY
+        // team's residual check MUST NOT read the workspace tmux socket
+        // + shared default tmux socket as evidence for/against ConPTY
+        // residual. Those probes are meaningless for a shim-owned pane
+        // universe: they will always return `has_session=false` (no
+        // tmux session exists) which would look like "no residual" but
+        // gives zero honest information about whether the shim / child
+        // panes have actually been reaped. Skip the tmux fallback
+        // probes when the primary transport is ConPTY; the primary
+        // transport check above already covered the honest question
+        // ("does the shim still have this session?").
+        let primary_is_conpty = matches!(
+            transport.kind(),
+            crate::transport::BackendKind::ConPty
+        );
+        if !primary_is_conpty {
+            let workspace_transport = shutdown_workspace_transport(workspace);
+            match crate::transport::Transport::has_session(&workspace_transport, session) {
+                Ok(true) => residual = true,
+                Ok(false) => {}
+                Err(err) if tmux_absent_error(&err.to_string()) => {}
+                Err(err) => {
+                    error.get_or_insert_with(|| err.to_string());
+                    residual = true;
+                }
             }
-        }
-        let default_transport = crate::tmux_backend::TmuxBackend::new();
-        match crate::transport::Transport::has_session(&default_transport, session) {
-            Ok(true) => residual = true,
-            Ok(false) => {}
-            Err(err) if tmux_absent_error(&err.to_string()) => {}
-            Err(err) => {
-                error.get_or_insert_with(|| err.to_string());
-                residual = true;
+            let default_transport = crate::tmux_backend::TmuxBackend::new();
+            match crate::transport::Transport::has_session(&default_transport, session) {
+                Ok(true) => residual = true,
+                Ok(false) => {}
+                Err(err) if tmux_absent_error(&err.to_string()) => {}
+                Err(err) => {
+                    error.get_or_insert_with(|| err.to_string());
+                    residual = true;
+                }
             }
         }
         let sessions = if residual {
@@ -1308,34 +1414,48 @@ pub mod lifecycle_port {
             return;
         }
         for pid in pids.iter().rev() {
-            send_process_signal(*pid, libc::SIGTERM);
+            let _ = crate::platform::process::terminate_pid(
+                *pid,
+                crate::platform::process::SignalKind::TerminateGraceful,
+            );
         }
         std::thread::sleep(std::time::Duration::from_millis(150));
         for pid in pids.iter().rev() {
-            send_process_signal(*pid, libc::SIGKILL);
+            let _ = crate::platform::process::terminate_pid(
+                *pid,
+                crate::platform::process::SignalKind::TerminateForce,
+            );
         }
         wait_for_processes_gone(&pids, std::time::Duration::from_secs(1));
     }
 
     fn reap_process_groups(pgids: &[u32], protected: &ShutdownProtection) {
+        // 0.5.x Windows portability Batch 3: routes group termination
+        // through `platform::process::terminate_group`. Unix keeps
+        // `kill(-pgid, SIGTERM|SIGKILL)` semantics byte-for-byte;
+        // Windows returns AlreadyGone (no pgid concept — Job Object
+        // teardown is the shim-side concern per design §Route B).
+        // The `pgid_t <= 1 || protected.contains_pgid(...)` filter
+        // stays in place so pgid 0/1 (kernel/init) and the caller's
+        // own group are never targeted.
         for pgid in pgids {
-            let Ok(pgid_t) = libc::pid_t::try_from(*pgid) else {
-                continue;
-            };
-            if pgid_t <= 1 || protected.contains_pgid(*pgid) {
+            if *pgid <= 1 || protected.contains_pgid(*pgid) {
                 continue;
             }
-            send_process_signal_group(pgid_t, libc::SIGTERM);
+            let _ = crate::platform::process::terminate_group(
+                *pgid,
+                crate::platform::process::SignalKind::TerminateGraceful,
+            );
         }
         std::thread::sleep(std::time::Duration::from_millis(150));
         for pgid in pgids {
-            let Ok(pgid_t) = libc::pid_t::try_from(*pgid) else {
-                continue;
-            };
-            if pgid_t <= 1 || protected.contains_pgid(*pgid) {
+            if *pgid <= 1 || protected.contains_pgid(*pgid) {
                 continue;
             }
-            send_process_signal_group(pgid_t, libc::SIGKILL);
+            let _ = crate::platform::process::terminate_group(
+                *pgid,
+                crate::platform::process::SignalKind::TerminateForce,
+            );
         }
     }
 
@@ -1660,7 +1780,10 @@ pub mod lifecycle_port {
         let mut protected = ShutdownProtection::default();
         let current = std::process::id();
         protected.pids.insert(current);
-        if let Ok(pgid) = u32::try_from(unsafe { libc::getpgrp() }) {
+        // 0.5.x Windows portability Batch 3: use platform primitive.
+        // Windows returns None (no pgid concept) and the branch is
+        // skipped honestly.
+        if let Some(pgid) = crate::platform::process::current_process_group() {
             protected.pgids.insert(pgid);
         }
         let mut cursor = current;
@@ -1795,56 +1918,33 @@ pub mod lifecycle_port {
         }
     }
 
-    fn send_process_signal(pid: u32, signal: libc::c_int) {
-        let Ok(pid_t) = libc::pid_t::try_from(pid) else {
-            return;
-        };
-        unsafe {
-            libc::kill(pid_t, signal);
-        }
-    }
-
-    fn send_process_signal_group(pgid: libc::pid_t, signal: libc::c_int) {
-        unsafe {
-            libc::kill(-pgid, signal);
-        }
-    }
+    // 0.5.x Windows portability Batch 3: the four inline helpers
+    // (send_process_signal, send_process_signal_group,
+    // reap_child_if_possible, process_is_live) have been replaced
+    // by direct calls through `crate::platform::process::*` at the
+    // shutdown callsites above. The private helpers are removed so
+    // there's a single source of truth for signal/waitpid/liveness
+    // semantics; Unix behavior is byte-preserving (SignalKind maps
+    // 1:1 to SIGTERM/SIGKILL, ProcessLiveness::Live == the previous
+    // `kill(pid, 0) == 0 || EPERM` branch).
 
     fn wait_for_processes_gone(pids: &[u32], timeout: std::time::Duration) {
         let start = std::time::Instant::now();
         loop {
             for pid in pids {
-                reap_child_if_possible(*pid);
+                crate::platform::process::reap_child_if_possible(*pid);
             }
-            if !pids.iter().any(|pid| process_is_live(*pid)) || start.elapsed() >= timeout {
+            if !pids
+                .iter()
+                .any(|pid| crate::platform::process::pid_is_alive(*pid))
+                || start.elapsed() >= timeout
+            {
                 return;
             }
             std::thread::sleep(std::time::Duration::from_millis(25));
         }
     }
 
-    fn reap_child_if_possible(pid: u32) {
-        let Ok(pid_t) = libc::pid_t::try_from(pid) else {
-            return;
-        };
-        let mut status = 0;
-        unsafe {
-            libc::waitpid(pid_t, &mut status, libc::WNOHANG);
-        }
-    }
-
-    fn process_is_live(pid: u32) -> bool {
-        let Ok(pid_t) = libc::pid_t::try_from(pid) else {
-            return false;
-        };
-        let rc = unsafe { libc::kill(pid_t, 0) };
-        if rc == 0 {
-            return true;
-        }
-        let err = std::io::Error::last_os_error();
-        err.raw_os_error() == Some(libc::EPERM)
-    }
-
     fn process_pgids(
         pids: &[u32],
         protected: &ShutdownProtection,
@@ -1855,8 +1955,15 @@ pub mod lifecycle_port {
             .filter_map(|pid| table.iter().find(|process| process.pid == *pid))
             .filter_map(|process| process.pgid)
             .filter(|pgid| {
-                libc::pid_t::try_from(*pgid)
-                    .map(|pgid_t| pgid_t > 1 && !protected.contains_pgid(*pgid))
+                // 0.5.x Windows portability Batch 4: `libc::pid_t` was
+                // used here as a signed-integer conversion gate to
+                // reject values > INT_MAX. Replace with the equivalent
+                // `i32::try_from` (pgid_t is `c_int` on every Unix we
+                // support). Windows has no pgid concept so `pgids`
+                // is empty in practice — the filter is dead code on
+                // Windows but must still compile.
+                i32::try_from(*pgid)
+                    .map(|pgid_int| pgid_int > 1 && !protected.contains_pgid(*pgid))
                     .unwrap_or(false)
             })
             .collect::<Vec<_>>();
@@ -1882,7 +1989,10 @@ pub mod lifecycle_port {
             .map(|process| process.pid)
             .collect::<std::collections::BTreeSet<_>>();
         for pid in root_pids {
-            if !protected.contains_pid(*pid) && process_is_live(*pid) && seen.insert(*pid) {
+            if !protected.contains_pid(*pid)
+                && crate::platform::process::pid_is_alive(*pid)
+                && seen.insert(*pid)
+            {
                 residuals.push(ProcessInfo {
                     pid: *pid,
                     ppid: 0,