@team-agent/installer 0.3.11 → 0.3.13

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.11"
+version = "0.3.13"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.11"
+version = "0.3.13"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -166,6 +166,7 @@ fn quickstart_human(value: &Value) -> String {
 pub fn cmd_compile(args: &CompileArgs) -> Result<CmdResult, CliError> {
     let spec = crate::compiler::compile_team(&args.team)
         .map_err(|e| CliError::Runtime(e.to_string()))?;
+    warn_ignored_owner_team_id(&args.team);
     std::fs::write(&args.out, crate::model::yaml::dumps(&spec))?;
     Ok(CmdResult::from_json(
         json!({
@@ -178,6 +179,28 @@ pub fn cmd_compile(args: &CompileArgs) -> Result<CmdResult, CliError> {
     ))
 }
 
+fn warn_ignored_owner_team_id(team_dir: &std::path::Path) {
+    let Ok(Some(ignored)) = crate::compiler::ignored_owner_team_id_from_team_md(team_dir) else {
+        return;
+    };
+    let workspace = crate::model::paths::team_workspace(team_dir)
+        .unwrap_or_else(|_| team_dir.parent().unwrap_or(team_dir).to_path_buf());
+    eprintln!("Warning: ignored TEAM.md {}={}", ignored.field, ignored.value);
+    eprintln!("Reason: owner identity is the canonical runtime team key, not TEAM.md front matter");
+    eprintln!("Action: remove {} from TEAM.md", ignored.field);
+    let fields = json!({
+        "field": ignored.field,
+        "source": team_dir.join("TEAM.md").to_string_lossy().to_string(),
+        "value": ignored.value,
+        "warning": "ignored user-set owner_team_id",
+        "reason": "owner identity is derived from the canonical runtime team key",
+        "action": "remove owner_team_id from TEAM.md",
+    });
+    if let Err(err) = crate::event_log::EventLog::new(&workspace).write("spec.field_ignored", fields) {
+        eprintln!("Warning: spec.field_ignored event write failed: {err}");
+    }
+}
+
 /// `cmd_status`(`commands.py:90`)。三态:`--summary`(xor json,xor agent)→五行文本;
 /// `--json`→`status_port::status(compact=!detail)`;else→`status_port::format_status(agent)`。
 pub fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {

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

@@ -88,11 +88,8 @@ pub fn cmd_leader_passthrough(
 }
 
 pub(crate) fn leader_passthrough_provider(command: &str) -> crate::model::enums::Provider {
-    match command {
-        "codex" => crate::model::enums::Provider::Codex,
-        "copilot" => crate::model::enums::Provider::Copilot,
-        _ => crate::model::enums::Provider::ClaudeCode,
-    }
+    crate::leader::attribute_command_provider(command)
+        .unwrap_or(crate::model::enums::Provider::ClaudeCode)
 }
 
 // =============================================================================

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

@@ -452,7 +452,9 @@ pub mod lifecycle_port {
         let coordinator_pid = stopped
             .as_ref()
             .and_then(|stopped| stopped.pid.map(|p| p.get()));
-        let ok = stopped.as_ref().map(|stopped| stopped.ok).unwrap_or(true)
+        let coordinator_clean =
+            !coordinator_timeout && stopped.as_ref().map(|stopped| stopped.ok).unwrap_or(true);
+        let ok = coordinator_clean
             && kill_error.is_none()
             && session_residuals.is_empty()
             && process_residuals.is_empty()
@@ -1484,9 +1486,28 @@ pub mod lifecycle_port {
         }
         let agent_id = crate::model::ids::AgentId::new(agent);
         match crate::lifecycle::remove_agent(workspace, &agent_id, from_spec, force, team) {
-            Ok(report) => {
-                Ok(json!({"ok": true, "agent_id": agent, "report": format!("{report:?}")}))
-            }
+            Ok(report @ crate::lifecycle::RemoveAgentOutcome::Removed { .. }) => Ok(json!({
+                "ok": true,
+                "agent_id": agent,
+                "status": "removed",
+                "report": format!("{report:?}"),
+            })),
+            Ok(crate::lifecycle::RemoveAgentOutcome::RefusedFromSpecConfirm { .. }) => Ok(json!({
+                "ok": false,
+                "agent_id": agent,
+                "status": "refused",
+                "reason": "from_spec_confirm_required",
+                "error": "remove-agent requires --from-spec --confirm for spec-defined agents",
+                "action": "rerun with --from-spec --confirm, or omit --from-spec only for dynamic agents",
+            })),
+            Ok(crate::lifecycle::RemoveAgentOutcome::RefusedForceRequired { .. }) => Ok(json!({
+                "ok": false,
+                "agent_id": agent,
+                "status": "refused",
+                "reason": "force_required",
+                "error": "agent is running; remove-agent requires --force",
+                "action": "rerun with --force to stop and remove the running agent",
+            })),
             Err(e) => Ok(error_value(e)),
         }
     }
@@ -1913,6 +1934,71 @@ pub mod lifecycle_port {
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
             }),
+            crate::lifecycle::RestartReport::Partial {
+                session_name,
+                agents,
+                failed_agents,
+                coordinator_started,
+                next_actions,
+                attach_commands,
+            } => json!({
+                "ok": false,
+                "status": "partial",
+                "reason": "restart_agent_failed",
+                "session_name": session_name.as_str(),
+                "agents": agents.iter().map(|a| a.agent_id.as_str()).collect::<Vec<_>>(),
+                "failed_agents": failed_agents.iter().map(|failure| json!({
+                    "agent_id": failure.agent_id.as_str(),
+                    "restart_mode": failure.restart_mode,
+                    "decision": failure.decision,
+                    "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
+                    "phase": failure.phase,
+                    "error": failure.error,
+                    "action": format!(
+                        "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                        failure.agent_id,
+                        failure.agent_id
+                    ),
+                    "log": format!(
+                        ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
+                        failure.agent_id
+                    ),
+                })).collect::<Vec<_>>(),
+                "coordinator_started": coordinator_started,
+                "next_actions": next_actions,
+                "attach_commands": attach_commands,
+            }),
+            crate::lifecycle::RestartReport::Failed {
+                session_name,
+                failed_agents,
+                next_actions,
+                attach_commands,
+            } => json!({
+                "ok": false,
+                "status": "failed",
+                "reason": "restart_all_agents_failed",
+                "session_name": session_name.as_str(),
+                "agents": [],
+                "failed_agents": failed_agents.iter().map(|failure| json!({
+                    "agent_id": failure.agent_id.as_str(),
+                    "restart_mode": failure.restart_mode,
+                    "decision": failure.decision,
+                    "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
+                    "phase": failure.phase,
+                    "error": failure.error,
+                    "action": format!(
+                        "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                        failure.agent_id,
+                        failure.agent_id
+                    ),
+                    "log": format!(
+                        ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
+                        failure.agent_id
+                    ),
+                })).collect::<Vec<_>>(),
+                "next_actions": next_actions,
+                "attach_commands": attach_commands,
+            }),
             crate::lifecycle::RestartReport::RefusedResumeAtomicity {
                 unresumable,
                 allow_fresh,

package/crates/team-agent/src/cli/tests/compile.rs

@@ -16,6 +16,16 @@ fn compile_team_dir(tag: &str) -> std::path::PathBuf {
     team
 }
 
+fn compile_team_dir_with_owner_team_id(tag: &str) -> std::path::PathBuf {
+    let team = compile_team_dir(tag);
+    std::fs::write(
+        team.join("TEAM.md"),
+        "---\nname: compileteam\nobjective: Compile probe.\nprovider: fake\nowner_team_id: user-set-owner\n---\n\nCompile team.\n",
+    )
+    .unwrap();
+    team
+}
+
 #[test]
 fn cmd_compile_json_and_human_match_golden_shape_and_writes_out() {
     let team = compile_team_dir("compile-ok");
@@ -47,6 +57,65 @@ fn cmd_compile_json_and_human_match_golden_shape_and_writes_out() {
     assert_eq!(human_text, expected_human, "golden human output preserves cmd_compile insertion order");
 }
 
+#[test]
+fn cmd_compile_ignores_user_owner_team_id_and_emits_warning_event() {
+    let team = compile_team_dir_with_owner_team_id("compile-ignored-owner");
+    let workspace = team.parent().unwrap().to_path_buf();
+    let out = workspace.join("ignored-owner-out.yaml");
+    let args = CompileArgs { team: team.clone(), out: out.clone(), json: true };
+
+    let result = cmd_compile(&args).expect("compile");
+    assert_eq!(result.exit, ExitCode::Ok);
+    let compiled = std::fs::read_to_string(&out).unwrap();
+    assert!(
+        !compiled.contains("owner_team_id"),
+        "user-set owner_team_id must not be compiled into team.spec.yaml"
+    );
+    let events = crate::event_log::EventLog::new(&workspace).tail(0).unwrap();
+    let event = events
+        .iter()
+        .find(|event| {
+            event
+                .get("event")
+                .and_then(serde_json::Value::as_str)
+                == Some("spec.field_ignored")
+        })
+        .expect("owner_team_id warning event");
+    assert_eq!(
+        event.get("field").and_then(serde_json::Value::as_str),
+        Some("owner_team_id")
+    );
+    assert_eq!(
+        event.get("value").and_then(serde_json::Value::as_str),
+        Some("user-set-owner")
+    );
+    assert_eq!(
+        event.get("action").and_then(serde_json::Value::as_str),
+        Some("remove owner_team_id from TEAM.md")
+    );
+}
+
+#[test]
+fn cmd_compile_without_owner_team_id_emits_no_ignored_field_event() {
+    let team = compile_team_dir("compile-no-ignored-owner");
+    let workspace = team.parent().unwrap().to_path_buf();
+    let out = workspace.join("no-ignored-owner-out.yaml");
+    let args = CompileArgs { team: team.clone(), out, json: true };
+
+    let result = cmd_compile(&args).expect("compile");
+    assert_eq!(result.exit, ExitCode::Ok);
+    let events = crate::event_log::EventLog::new(&workspace).tail(0).unwrap();
+    assert!(
+        events.iter().all(|event| {
+            event
+                .get("event")
+                .and_then(serde_json::Value::as_str)
+                != Some("spec.field_ignored")
+        }),
+        "TEAM.md without owner_team_id must not emit ignored-field warning"
+    );
+}
+
 #[test]
 fn run_dispatches_compile_and_error_path_exits_error() {
     let team = compile_team_dir("compile-dispatch");

package/crates/team-agent/src/cli/tests/main_preserved.rs

@@ -472,6 +472,74 @@ fn seed_team_spec(ws: &std::path::Path) {
             other => panic!("expected JSON output, got {other:?}"),
         }
     }
+    fn seed_remove_agent_workspace(ws: &std::path::Path, status: &str) {
+        seed_team_spec(ws);
+        crate::state::persist::save_runtime_state(
+            ws,
+            &json!({
+                "session_name": "team-agent-fake-e2e",
+                "agents": {
+                    "fake_impl": {
+                        "status": status,
+                        "provider": "fake",
+                        "window": "fake_impl"
+                    }
+                },
+                "spec_path": ws.join("team.spec.yaml").to_string_lossy()
+            }),
+        )
+        .unwrap();
+    }
+    #[test]
+    fn remove_agent_running_refusal_is_not_success_envelope() {
+        let ws = tmp_workspace();
+        seed_remove_agent_workspace(&ws, "running");
+        let out = json_output(
+            cmd_remove_agent(&RemoveAgentArgs {
+                agent: "fake_impl".to_string(),
+                workspace: ws.clone(),
+                team: None,
+                from_spec: true,
+                confirm: true,
+                force: false,
+                json: true,
+            })
+            .unwrap(),
+        );
+        assert_eq!(out["ok"], json!(false));
+        assert_eq!(out["status"], json!("refused"));
+        assert_eq!(out["reason"], json!("force_required"));
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert!(
+            state["agents"].get("fake_impl").is_some(),
+            "refused remove-agent must not delete the running agent"
+        );
+    }
+    #[test]
+    fn remove_agent_from_spec_refusal_is_not_success_envelope() {
+        let ws = tmp_workspace();
+        seed_remove_agent_workspace(&ws, "stopped");
+        let out = json_output(
+            cmd_remove_agent(&RemoveAgentArgs {
+                agent: "fake_impl".to_string(),
+                workspace: ws.clone(),
+                team: None,
+                from_spec: false,
+                confirm: true,
+                force: false,
+                json: true,
+            })
+            .unwrap(),
+        );
+        assert_eq!(out["ok"], json!(false));
+        assert_eq!(out["status"], json!("refused"));
+        assert_eq!(out["reason"], json!("from_spec_confirm_required"));
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert!(
+            state["agents"].get("fake_impl").is_some(),
+            "refused remove-agent must not delete the spec-defined agent"
+        );
+    }
     #[test]
     fn validate_result_file_good_and_inline_garbage_are_distinct() {
         let ws = tmp_workspace();

package/crates/team-agent/src/cli/tests/shutdown_kill_plan.rs

@@ -5,8 +5,15 @@
 //! 集成面由 tests/b5_leader_terminal_kill_red.rs 的真 tmux 契约覆盖,此处锁纯决策 + 4 反向 case。
 
 use crate::cli::lifecycle_port::{sessions_to_kill, KillDecision};
-use crate::transport::SessionName;
-use std::collections::BTreeSet;
+use crate::transport::{
+    AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport,
+    Key, PaneField, PaneId, PaneInfo, SessionName, SetEnvOutcome, SpawnResult, Target, Transport,
+    TransportError, WindowName,
+};
+use serde_json::json;
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
 
 fn names(raw: &[&str]) -> Vec<SessionName> {
     raw.iter().map(|name| SessionName::new(*name)).collect()
@@ -102,3 +109,154 @@ fn union_prefix_and_anchor_no_double_count() {
         KillDecision::KillIndividually { to_kill: vec![], spared: names(&["team-agent-leader-claude-ws-beef"]) }
     );
 }
+
+#[test]
+fn missing_coordinator_is_ok_when_shutdown_cleaned_session() {
+    let ws = tmp_shutdown_workspace("missing-coordinator-clean");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-lane-l1-clean-shutdown",
+            "agents": {
+                "fake_impl": {
+                    "status": "running",
+                    "provider": "fake",
+                    "window": "fake_impl"
+                }
+            }
+        }),
+    )
+    .unwrap();
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(
+        &ws,
+        true,
+        None,
+        &CleanShutdownTransport::new(),
+    )
+    .expect("shutdown should complete");
+    assert_eq!(out["coordinator"]["status"], json!("missing"));
+    assert_eq!(
+        out["ok"], json!(true),
+        "coordinator.status=missing alone must not make a fully cleaned shutdown partial: {out}"
+    );
+    assert_eq!(out["status"], json!("ok"));
+    assert_eq!(out["residuals"]["sessions"], json!([]));
+    assert_eq!(out["residuals"]["processes"], json!([]));
+}
+
+fn tmp_shutdown_workspace(tag: &str) -> PathBuf {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static N: AtomicU64 = AtomicU64::new(0);
+    let dir = std::env::temp_dir().join(format!(
+        "ta-shutdown-{tag}-{}-{}",
+        std::process::id(),
+        N.fetch_add(1, Ordering::Relaxed)
+    ));
+    std::fs::create_dir_all(dir.join(".team").join("runtime")).unwrap();
+    dir
+}
+
+struct CleanShutdownTransport {
+    session_present: Mutex<bool>,
+}
+
+impl CleanShutdownTransport {
+    fn new() -> Self {
+        Self { session_present: Mutex::new(true) }
+    }
+}
+
+impl Transport for CleanShutdownTransport {
+    fn kind(&self) -> BackendKind {
+        BackendKind::Tmux
+    }
+
+    fn spawn_first(
+        &self,
+        _session: &SessionName,
+        _window: &WindowName,
+        _argv: &[String],
+        _cwd: &Path,
+        _env: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
+        unimplemented!("shutdown test does not spawn")
+    }
+
+    fn spawn_into(
+        &self,
+        _session: &SessionName,
+        _window: &WindowName,
+        _argv: &[String],
+        _cwd: &Path,
+        _env: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
+        unimplemented!("shutdown test does not spawn")
+    }
+
+    fn inject(
+        &self,
+        _target: &Target,
+        _payload: &InjectPayload,
+        _submit: Key,
+        _bracketed: bool,
+    ) -> Result<InjectReport, TransportError> {
+        unimplemented!("shutdown test does not inject")
+    }
+
+    fn send_keys(&self, _target: &Target, _keys: &[Key]) -> Result<(), TransportError> {
+        Ok(())
+    }
+
+    fn capture(
+        &self,
+        _target: &Target,
+        range: CaptureRange,
+    ) -> Result<CapturedText, TransportError> {
+        Ok(CapturedText { text: String::new(), range })
+    }
+
+    fn query(&self, _target: &Target, _field: PaneField) -> Result<Option<String>, TransportError> {
+        Ok(None)
+    }
+
+    fn liveness(
+        &self,
+        _pane: &PaneId,
+    ) -> Result<crate::model::enums::PaneLiveness, TransportError> {
+        Ok(crate::model::enums::PaneLiveness::Live)
+    }
+
+    fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
+        Ok(Vec::new())
+    }
+
+    fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
+        Ok(*self.session_present.lock().unwrap())
+    }
+
+    fn list_windows(&self, _session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
+        Ok(Vec::new())
+    }
+
+    fn set_session_env(
+        &self,
+        _session: &SessionName,
+        _key: &str,
+        _value: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
+        Ok(SetEnvOutcome::Applied)
+    }
+
+    fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
+        *self.session_present.lock().unwrap() = false;
+        Ok(())
+    }
+
+    fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
+        Ok(())
+    }
+
+    fn attach_session(&self, _session: &SessionName) -> Result<AttachOutcome, TransportError> {
+        Ok(AttachOutcome::Attached)
+    }
+}

package/crates/team-agent/src/compiler.rs

@@ -29,6 +29,14 @@ use std::path::Path;
 use crate::model::yaml::Value;
 use crate::model::{paths, spec, yaml, ModelError};
 
+pub const IGNORED_OWNER_TEAM_ID_FIELD: &str = "owner_team_id";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IgnoredTeamField {
+    pub field: &'static str,
+    pub value: String,
+}
+
 /// `compiler._read_front_matter` (compiler.py:173-185).
 ///
 /// Reads `path` (UTF-8). If the text does not start with `"---\n"`, returns
@@ -76,6 +84,21 @@ pub fn read_front_matter(path: &Path) -> Result<(Value, String), ModelError> {
     Ok((meta, after_marker.trim_start_matches('\n').to_string()))
 }
 
+pub fn ignored_owner_team_id_from_team_md(team_dir: &Path) -> Result<Option<IgnoredTeamField>, ModelError> {
+    let team_md = team_dir.join("TEAM.md");
+    if !team_md.exists() {
+        return Ok(None);
+    }
+    let (team_meta, _) = read_front_matter(&team_md)?;
+    let Some(value) = team_meta.get(IGNORED_OWNER_TEAM_ID_FIELD) else {
+        return Ok(None);
+    };
+    Ok(Some(IgnoredTeamField {
+        field: IGNORED_OWNER_TEAM_ID_FIELD,
+        value: front_matter_value_label(value),
+    }))
+}
+
 /// `compiler.compile_team` (compiler.py:23-135) — returns the compiled spec dict.
 ///
 /// `TEAM.md` + sorted `agents/*.md` → the canonical spec `Value::Map` with the
@@ -518,5 +541,12 @@ fn max_active_agents(count: usize) -> i64 {
     }
 }
 
+fn front_matter_value_label(value: &Value) -> String {
+    value
+        .as_str()
+        .map(ToString::to_string)
+        .unwrap_or_else(|| yaml::dumps(value).trim().to_string())
+}
+
 #[cfg(test)]
 mod tests;

package/crates/team-agent/src/coordinator/health.rs

@@ -1,6 +1,8 @@
 //! coordinator 健康/身份 & 只读可观测面:metadata 身份原语 + coordinator 路径 + watch 实时流。
 
 use std::io::{Read, Seek, SeekFrom};
+#[cfg(unix)]
+use std::os::unix::process::CommandExt;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::time::Duration;
@@ -96,13 +98,15 @@ pub fn start_coordinator(workspace: &WorkspacePath) -> Result<StartReport, Start
         .append(true)
         .open(&log_path)?;
     let log_err = log.try_clone()?;
-    let child = Command::new(std::env::current_exe()?)
+    let mut command = Command::new(std::env::current_exe()?);
+    command
         .args(["coordinator", "--workspace"])
         .arg(workspace.as_path())
         .stdin(Stdio::null())
         .stdout(Stdio::from(log))
-        .stderr(Stdio::from(log_err))
-        .spawn()?;
+        .stderr(Stdio::from(log_err));
+    detach_daemon_child(&mut command);
+    let child = command.spawn()?;
     let pid = Pid::new(child.id());
     std::fs::write(coordinator_pid_path(workspace), pid.to_string())?;
     write_coordinator_metadata(workspace, pid, MetadataSource::Start)?;
@@ -116,6 +120,24 @@ pub fn start_coordinator(workspace: &WorkspacePath) -> Result<StartReport, Start
     })
 }
 
+#[cfg(unix)]
+fn detach_daemon_child(command: &mut Command) {
+    // The coordinator is a daemon: it must not remain in the launcher's process
+    // group, otherwise bare SSH command teardown can SIGHUP it after quick-start exits.
+    unsafe {
+        command.pre_exec(|| {
+            if libc::setsid() == -1 {
+                Err(std::io::Error::last_os_error())
+            } else {
+                Ok(())
+            }
+        });
+    }
+}
+
+#[cfg(not(unix))]
+fn detach_daemon_child(_command: &mut Command) {}
+
 /// `stop_coordinator`(`lifecycle.py:228-247`):SIGTERM pid + 清 pid/meta → typed report。
 pub fn stop_coordinator(workspace: &WorkspacePath) -> Result<StopReport, StopError> {
     let pid_path = coordinator_pid_path(workspace);
@@ -696,3 +718,41 @@ fn clean_text(text: &str) -> String {
 fn prefix_chars(text: &str, max: usize) -> String {
     text.chars().take(max).collect()
 }
+
+#[cfg(all(test, unix))]
+mod tests {
+    use super::*;
+
+    struct ChildGuard(std::process::Child);
+
+    impl Drop for ChildGuard {
+        fn drop(&mut self) {
+            unsafe {
+                libc::kill(self.0.id() as libc::pid_t, libc::SIGTERM);
+            }
+            let _ = self.0.wait();
+        }
+    }
+
+    #[test]
+    fn coordinator_daemon_spawn_helper_detaches_session() {
+        let mut command = Command::new("/bin/sleep");
+        command
+            .arg("30")
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        detach_daemon_child(&mut command);
+
+        let child = command.spawn().expect("spawn detached child");
+        let guard = ChildGuard(child);
+        let pid = guard.0.id() as libc::pid_t;
+        let sid = unsafe { libc::getsid(pid) };
+
+        assert_ne!(sid, -1, "getsid({pid}) failed");
+        assert_eq!(
+            sid, pid,
+            "detached coordinator children must become session leaders so launcher SIGHUP does not reach them"
+        );
+    }
+}