@team-agent/installer 0.3.14 → 0.3.16

package/Cargo.lock

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

package/Cargo.toml

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

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

@@ -107,6 +107,7 @@ pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
         args.team_id.as_deref(),
         args.yes,
         args.fresh,
+        !args.no_display,
     )?;
     let readiness = value.get("readiness").and_then(Value::as_object);
     let all_resumable_have_session = readiness

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

@@ -77,6 +77,12 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "quick-start" => cmd_quick_start(&quick_start_args(args, cwd)?).map(emit_result),
         "compile" => cmd_compile(&compile_args(args, cwd)?).map(emit_result),
         "send" => cmd_send(&send_args(args, cwd)?).map(emit_result),
+        "fallback-send-leader" => {
+            cmd_fallback_send_leader(&fallback_send_leader_args(args, cwd)?).map(emit_result)
+        }
+        "fallback-report-result" => {
+            cmd_fallback_report_result(&fallback_report_result_args(args, cwd)?).map(emit_result)
+        }
         "allow-peer-talk" => {
             cmd_allow_peer_talk(&allow_peer_talk_args(args, cwd)?).map(emit_result)
         }
@@ -136,6 +142,8 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "quick-start",
     "compile",
     "send",
+    "fallback-send-leader",
+    "fallback-report-result",
     "allow-peer-talk",
     "status",
     "stop",
@@ -202,10 +210,12 @@ 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] [--fresh] [--json]\n\ndefaults: display_backend=none; set display_backend: adaptive in TEAM.md to opt in to adaptive display windows.".to_string(),
+        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--fresh] [--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("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] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]".to_string(),
+        Some("fallback-send-leader") => "usage: team-agent fallback-send-leader --workspace WORKSPACE --team TEAM --sender AGENT --message-id ID --content TEXT --primary-error ERROR [--task TASK] [--json]\n\nEmergency one-shot fallback only after a leader-bound MCP send transport failure; restart-agent after use.".to_string(),
+        Some("fallback-report-result") => "usage: team-agent fallback-report-result --workspace WORKSPACE --team TEAM --agent-id AGENT --task-id TASK --result-json JSON --primary-error ERROR [--json]\n\nEmergency one-shot fallback only after a report_result MCP transport failure; persists the result DB row, then restart-agent after use.".to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
         Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]".to_string(),
         Some("stop") => "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
@@ -347,7 +357,9 @@ fn install_skill_args(args: &[String]) -> Result<InstallSkillArgs, CliError> {
 
 /// 取 `--flag <value>` 的值(用于 install-skill 的 --source/--dest,parse_args 不覆盖的旗标)。
 fn flag_value(args: &[String], flag: &str) -> Option<String> {
-    args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).cloned())
+    args.iter()
+        .position(|a| a == flag)
+        .and_then(|i| args.get(i + 1).cloned())
 }
 
 /// `team-agent install-skill`(RED-1 单源):repo `skills/team-agent` → `~/.codex|.claude|.copilot`。
@@ -355,7 +367,9 @@ fn flag_value(args: &[String], flag: &str) -> Option<String> {
 fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
     // 卸载分支(单源:走同一 SkillTarget 表的 dest_dir;all → SINGLE_TARGETS 全集)。
     if args.uninstall {
-        let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("."));
+        let home = std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| PathBuf::from("."));
         let targets: Vec<crate::packaging::SkillTarget> = match args.target {
             crate::packaging::SkillTarget::All => {
                 crate::packaging::SkillTarget::SINGLE_TARGETS.to_vec()
@@ -367,7 +381,8 @@ fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
             if let Some(dest) = t.dest_dir(&home) {
                 let existed = dest.0.exists();
                 if existed && !args.dry_run {
-                    std::fs::remove_dir_all(&dest.0).map_err(|e| CliError::Runtime(e.to_string()))?;
+                    std::fs::remove_dir_all(&dest.0)
+                        .map_err(|e| CliError::Runtime(e.to_string()))?;
                 }
                 removed.push(serde_json::json!({
                     "target": t,
@@ -386,13 +401,14 @@ fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
         .source
         .clone()
         .ok_or_else(|| CliError::Usage("missing --source <skill dir>".to_string()))?;
-    let outcomes = crate::packaging::install::install_skill(&crate::packaging::SkillInstallOptions {
-        target: args.target,
-        dest: args.dest.clone(),
-        dry_run: args.dry_run,
-        source,
-    })
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let outcomes =
+        crate::packaging::install::install_skill(&crate::packaging::SkillInstallOptions {
+            target: args.target,
+            dest: args.dest.clone(),
+            dry_run: args.dry_run,
+            source,
+        })
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
     let installed: Vec<serde_json::Value> = outcomes
         .iter()
         .map(|o| {
@@ -643,6 +659,11 @@ struct ParsedArgs {
     pane: Option<String>,
     provider: 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>,
 }
 
 fn parse_args(args: &[String]) -> ParsedArgs {
@@ -664,7 +685,9 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--team-id" => parsed.team_id = next_arg(args, &mut i),
             "--targets" | "--target" | "--to" => parsed.targets = next_arg(args, &mut i),
             "--task" => parsed.task = next_arg(args, &mut i),
+            "--task-id" => parsed.task_id = next_arg(args, &mut i),
             "--sender" => parsed.sender = next_arg(args, &mut i),
+            "--agent-id" => parsed.agent_id = next_arg(args, &mut i),
             "--watch-result" => parsed.watch_result = true,
             "--requires-ack" => parsed.requires_ack = true,
             "--no-ack" => parsed.no_ack = true,
@@ -719,6 +742,9 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--pane" => parsed.pane = next_arg(args, &mut i),
             "--provider" => parsed.provider = 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),
+            "--result-json" => parsed.result_json = next_arg(args, &mut i),
             "-h" | "--help" => {}
             other if other.starts_with("--team=") => {
                 parsed.team = Some(other.trim_start_matches("--team=").to_string());
@@ -792,6 +818,7 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
         team_id: parsed.team_id.or(parsed.team),
         yes: parsed.yes,
         fresh: parsed.fresh,
+        no_display: parsed.no_display,
         json: parsed.json,
     })
 }
@@ -862,6 +889,60 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
     })
 }
 
+fn fallback_send_leader_args(
+    args: &[String],
+    cwd: &Path,
+) -> Result<FallbackSendLeaderArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(FallbackSendLeaderArgs {
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        sender: parsed
+            .sender
+            .or(parsed.agent_id)
+            .ok_or_else(|| CliError::Usage("missing --sender <agent>".to_string()))?,
+        task: parsed.task.or(parsed.task_id),
+        message_id: parsed
+            .message_id
+            .ok_or_else(|| CliError::Usage("missing --message-id <id>".to_string()))?,
+        content: parsed
+            .content
+            .or_else(|| (!parsed.positionals.is_empty()).then(|| parsed.positionals.join(" ")))
+            .ok_or_else(|| CliError::Usage("missing --content <text>".to_string()))?,
+        primary_error: parsed
+            .primary_error
+            .ok_or_else(|| CliError::Usage("missing --primary-error <error>".to_string()))?,
+        json: parsed.json,
+    })
+}
+
+fn fallback_report_result_args(
+    args: &[String],
+    cwd: &Path,
+) -> Result<FallbackReportResultArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(FallbackReportResultArgs {
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        agent_id: parsed
+            .agent_id
+            .or(parsed.sender)
+            .ok_or_else(|| CliError::Usage("missing --agent-id <agent>".to_string()))?,
+        task_id: parsed
+            .task_id
+            .or(parsed.task)
+            .ok_or_else(|| CliError::Usage("missing --task-id <task>".to_string()))?,
+        result_json: parsed
+            .result_json
+            .or_else(|| parsed.result)
+            .ok_or_else(|| CliError::Usage("missing --result-json <json>".to_string()))?,
+        primary_error: parsed
+            .primary_error
+            .ok_or_else(|| CliError::Usage("missing --primary-error <error>".to_string()))?,
+        json: parsed.json,
+    })
+}
+
 fn allow_peer_talk_args(args: &[String], cwd: &Path) -> Result<AllowPeerTalkArgs, CliError> {
     let parsed = parse_args(args);
     Ok(AllowPeerTalkArgs {

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

@@ -29,6 +29,8 @@ pub fn leader_launcher_args(values: &[String]) -> Result<LeaderLauncherArgs, Cli
             out.attach_existing = true;
         } else if token == "--confirm" {
             out.confirm_attach = true;
+        } else if token == "--external-leader" {
+            out.external_leader = true;
         } else if token == "--attach-session" {
             let Some(value) = values.get(idx + 1) else {
                 return Err(CliError::Runtime(

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

@@ -115,9 +115,16 @@ pub mod lifecycle_port {
         team_id: Option<&str>,
         yes: bool,
         fresh: bool,
+        open_display: bool,
     ) -> Result<Value, CliError> {
-        match crate::lifecycle::quick_start_in_workspace(
-            workspace, agents_dir, name, yes, fresh, team_id,
+        match crate::lifecycle::quick_start_in_workspace_with_display(
+            workspace,
+            agents_dir,
+            name,
+            yes,
+            fresh,
+            team_id,
+            open_display,
         ) {
             Ok(report) => Ok(quick_start_value(report)),
             Err(e) => Ok(error_value(e)),
@@ -141,6 +148,7 @@ pub mod lifecycle_port {
             attach.attach_existing,
             attach.confirm_attach,
             attach_session.as_ref(),
+            attach.external_leader,
         )
         .map_err(|e| CliError::Runtime(e.to_string()))?;
         let outcome = crate::leader::start::execute_leader_plan(&plan, cwd)
@@ -150,10 +158,21 @@ pub mod lifecycle_port {
             crate::leader::LeaderLaunchStatus::Detached => true,
             crate::leader::LeaderLaunchStatus::NotStarted => false,
         };
+        let leader_attach_command = if plan.is_external_leader {
+            None
+        } else {
+            plan.session_name.as_ref().and_then(|session| {
+                crate::tmux_backend::attach_command_for_workspace(cwd, session, "leader")
+            })
+        };
         Ok(json!({
             "ok": ok,
             "provider": provider,
             "mode": plan.mode,
+            "leader_topology": if plan.is_external_leader { "external" } else { "managed" },
+            "is_external_leader": plan.is_external_leader,
+            "leader_window": plan.leader_window.as_ref().map(|window| window.as_str().to_string()),
+            "leader_attach_command": leader_attach_command,
             "status": outcome.status,
             "exit_code": outcome.exit_code,
             "reason": outcome.reason,
@@ -169,7 +188,7 @@ pub mod lifecycle_port {
             .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) {
-            crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
+            shutdown_transport_for_endpoint(endpoint)
         } else {
             shutdown_workspace_transport(&run_ws)
         };
@@ -275,9 +294,39 @@ pub mod lifecycle_port {
         // no independent ps/tmux re-derivation (N39).
         let pane_targets = transport.list_targets().unwrap_or_default();
         let sessions = socket_session_names_from_targets(&pane_targets);
+        if !state_uses_external_leader(state) {
+            return managed_leader_socket_cleanup(transport, state, &sessions, event_log);
+        }
         let anchor_sessions = anchor_sessions_from_state(state, &pane_targets, event_log);
         match sessions_to_kill(&sessions, &anchor_sessions) {
             KillDecision::KillServerExclusive => {
+                if state
+                    .get("tmux_socket_source")
+                    .and_then(Value::as_str)
+                    == Some("leader_env")
+                {
+                    let _ = event_log.write(
+                        "shutdown.kill_server_skipped_shared_socket",
+                        json!({
+                            "reason": "leader_env_tmux_socket",
+                            "spared_sessions": [],
+                            "killed_sessions": sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                        }),
+                    );
+                    let mut error = None;
+                    for session in &sessions {
+                        if let Err(err) = transport.kill_session(session) {
+                            if !tmux_absent_error(&err.to_string()) {
+                                error.get_or_insert_with(|| err.to_string());
+                            }
+                        }
+                    }
+                    return ShutdownSocketCleanup {
+                        killed_sessions: sessions,
+                        spared_sessions: Vec::new(),
+                        error,
+                    };
+                }
                 let error = transport.kill_server().err().map(|error| error.to_string());
                 ShutdownSocketCleanup {
                     killed_sessions: sessions,
@@ -313,6 +362,66 @@ pub mod lifecycle_port {
         }
     }
 
+    fn state_uses_external_leader(state: &Value) -> bool {
+        state
+            .get("is_external_leader")
+            .and_then(Value::as_bool)
+            .unwrap_or(true)
+    }
+
+    fn managed_leader_socket_cleanup(
+        transport: &dyn crate::transport::Transport,
+        state: &Value,
+        sessions: &[crate::transport::SessionName],
+        event_log: &crate::event_log::EventLog,
+    ) -> ShutdownSocketCleanup {
+        let target = state
+            .get("session_name")
+            .and_then(Value::as_str)
+            .filter(|session| !session.is_empty())
+            .map(crate::transport::SessionName::new);
+        let mut to_kill = Vec::new();
+        if let Some(target) = target {
+            if sessions.is_empty()
+                || sessions
+                    .iter()
+                    .any(|session| session.as_str() == target.as_str())
+            {
+                to_kill.push(target);
+            }
+        }
+        let spared = sessions
+            .iter()
+            .filter(|session| {
+                !to_kill
+                    .iter()
+                    .any(|target| target.as_str() == session.as_str())
+            })
+            .cloned()
+            .collect::<Vec<_>>();
+        let _ = event_log.write(
+            "shutdown.kill_server_skipped_managed_leader",
+            json!({
+                "reason": "managed_leader_topology",
+                "spared_sessions": spared.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                "killed_sessions": to_kill.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+            }),
+        );
+        let mut error = None;
+        for session in &to_kill {
+            if let Err(err) = transport.kill_session(session) {
+                if !tmux_absent_error(&err.to_string()) {
+                    error.get_or_insert_with(|| err.to_string());
+                }
+            }
+        }
+        ShutdownSocketCleanup {
+            killed_sessions: to_kill,
+            spared_sessions: spared,
+            error,
+        }
+    }
+
     pub fn shutdown_with_transport(
         workspace: &Path,
         keep_logs: bool,
@@ -449,8 +558,12 @@ pub mod lifecycle_port {
         );
         deadline.check("stop_coordinator")?;
         let mut coordinator_timeout = false;
+        let mut coordinator_post_stop = CoordinatorStopObservation::NotNeeded;
+        let mut coordinator_pid_for_report = None;
         let stopped = if team.is_none() {
             let wp = crate::coordinator::WorkspacePath::new(run_workspace.clone());
+            let coordinator_pid_before_stop = crate::coordinator::coordinator_health(&wp).pid;
+            coordinator_pid_for_report = coordinator_pid_before_stop.map(|pid| pid.get());
             match stop_coordinator_bounded(wp, std::time::Duration::from_millis(900)) {
                 Some(Ok(report)) => Some(report),
                 Some(Err(error)) => {
@@ -459,16 +572,31 @@ pub mod lifecycle_port {
                 }
                 None => {
                     coordinator_timeout = true;
+                    let wp = crate::coordinator::WorkspacePath::new(run_workspace.clone());
+                    coordinator_post_stop =
+                        coordinator_post_stop_observation(&wp, coordinator_pid_before_stop);
                     None
                 }
             }
         } else {
             None
         };
+        if let Some(stopped) = stopped.as_ref().filter(|stopped| !stopped.ok) {
+            let wp = crate::coordinator::WorkspacePath::new(run_workspace.clone());
+            coordinator_post_stop = coordinator_post_stop_observation(&wp, stopped.pid);
+        }
         let probe_timeout = crate::os_probe::probe_timeout();
-        // swallow batch 1: a failed ps probe degrades verification truthfully — the
-        // empty table must never read as a clean "no residual processes".
-        let verification_degraded = probe_timeout.is_some() || probe_degraded;
+        let probe_timeout_kind = probe_timeout.as_ref().map(|timeout| timeout.probe);
+        // swallow batch 1: a failed ps probe degrades cleanup truthfully — the
+        // empty table must never read as a clean "no residual processes". A slow
+        // per-process cwd probe is diagnostic only once session/process residuals
+        // are otherwise clean.
+        let cleanup_truth_degraded = probe_degraded || probe_timeout_kind == Some("ps_table");
+        let diagnostic_probe_degraded = probe_timeout_kind == Some("lsof_cwd");
+        let other_probe_timeout_degraded =
+            probe_timeout.is_some() && !cleanup_truth_degraded && !diagnostic_probe_degraded;
+        let verification_degraded =
+            cleanup_truth_degraded || diagnostic_probe_degraded || other_probe_timeout_degraded;
         let session_killed = !killed_sessions.is_empty()
             && kill_error.is_none()
             && session_residuals.is_empty()
@@ -494,33 +622,19 @@ pub mod lifecycle_port {
         let coordinator_pid = stopped
             .as_ref()
             .and_then(|stopped| stopped.pid.map(|p| p.get()));
-        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()
-            && !verification_degraded
-            && !coordinator_timeout;
-        let status = if ok {
-            "ok"
-        } else if coordinator_timeout {
-            "timeout"
-        } else if verification_degraded {
-            "partial"
-        } else if kill_error.is_some() {
-            "failed"
-        } else {
-            "partial"
-        };
-        let phase = if coordinator_timeout {
-            Some("stop_coordinator")
-        } else if verification_degraded {
-            Some("os_probe")
-        } else {
-            None
-        };
-        let probe_timeout_kind = probe_timeout.as_ref().map(|timeout| timeout.probe);
+        let coordinator_pid = coordinator_pid.or(coordinator_pid_for_report);
+        let outcome = classify_shutdown_outcome(ShutdownOutcomeInput {
+            kill_error: kill_error.is_some(),
+            session_residuals: !session_residuals.is_empty(),
+            process_residuals: !process_residuals.is_empty(),
+            cleanup_truth_degraded,
+            coordinator_timeout,
+            coordinator_stop_ok: stopped.as_ref().map(|stopped| stopped.ok),
+            coordinator_post_stop,
+        });
+        let ok = outcome.ok;
+        let status = outcome.status;
+        let phase = outcome.phase;
         let probe_timeout_value = probe_timeout.as_ref().map(|timeout| {
             json!({
                 "probe": timeout.probe,
@@ -577,14 +691,110 @@ pub mod lifecycle_port {
     /// worker thread — on a timely result it joins immediately; on timeout it gives the
     /// thread one short grace join window instead of dropping it detached (repeated
     /// shutdowns no longer accumulate leaked threads racing the same workspace).
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub(crate) enum CoordinatorStopObservation {
+        NotNeeded,
+        Gone,
+        Running,
+        Unknown,
+    }
+
+    pub(crate) struct ShutdownOutcome {
+        pub(crate) ok: bool,
+        pub(crate) status: &'static str,
+        pub(crate) phase: Option<&'static str>,
+    }
+
+    pub(crate) struct ShutdownOutcomeInput {
+        pub(crate) kill_error: bool,
+        pub(crate) session_residuals: bool,
+        pub(crate) process_residuals: bool,
+        pub(crate) cleanup_truth_degraded: bool,
+        pub(crate) coordinator_timeout: bool,
+        pub(crate) coordinator_stop_ok: Option<bool>,
+        pub(crate) coordinator_post_stop: CoordinatorStopObservation,
+    }
+
+    pub(crate) fn classify_shutdown_outcome(input: ShutdownOutcomeInput) -> ShutdownOutcome {
+        let coordinator_clean = match input.coordinator_post_stop {
+            CoordinatorStopObservation::Gone => true,
+            CoordinatorStopObservation::Running | CoordinatorStopObservation::Unknown => false,
+            CoordinatorStopObservation::NotNeeded => {
+                !input.coordinator_timeout && input.coordinator_stop_ok.unwrap_or(true)
+            }
+        };
+        let ok = coordinator_clean
+            && !input.kill_error
+            && !input.session_residuals
+            && !input.process_residuals
+            && !input.cleanup_truth_degraded;
+        if ok {
+            return ShutdownOutcome {
+                ok,
+                status: "ok",
+                phase: None,
+            };
+        }
+        let (status, phase) = if input.coordinator_timeout && !coordinator_clean {
+            ("timeout", Some("stop_coordinator"))
+        } else if input.cleanup_truth_degraded {
+            ("partial", Some("os_probe"))
+        } else if input.kill_error {
+            ("failed", None)
+        } else {
+            ("partial", None)
+        };
+        ShutdownOutcome { ok, status, phase }
+    }
+
+    fn coordinator_post_stop_observation(
+        workspace: &crate::coordinator::WorkspacePath,
+        pid: Option<crate::coordinator::Pid>,
+    ) -> CoordinatorStopObservation {
+        if let Some(pid) = pid {
+            match crate::coordinator::pid_is_running(pid) {
+                Ok(true) => return CoordinatorStopObservation::Running,
+                Ok(false) => return CoordinatorStopObservation::Gone,
+                Err(_) => {}
+            }
+        }
+        let health = crate::coordinator::coordinator_health(workspace);
+        match health.status {
+            crate::coordinator::CoordinatorHealthStatus::Running => {
+                CoordinatorStopObservation::Running
+            }
+            crate::coordinator::CoordinatorHealthStatus::Missing
+            | crate::coordinator::CoordinatorHealthStatus::InvalidPid
+            | crate::coordinator::CoordinatorHealthStatus::Stale => {
+                CoordinatorStopObservation::Gone
+            }
+        }
+    }
+
     fn stop_coordinator_bounded(
         workspace: crate::coordinator::WorkspacePath,
         timeout: std::time::Duration,
     ) -> Option<Result<crate::coordinator::types::StopReport, String>> {
+        stop_coordinator_bounded_with(workspace, timeout, |workspace| {
+            crate::coordinator::stop_coordinator(workspace).map_err(|error| error.to_string())
+        })
+    }
+
+    pub(crate) fn stop_coordinator_bounded_with<F>(
+        workspace: crate::coordinator::WorkspacePath,
+        timeout: std::time::Duration,
+        stop: F,
+    ) -> Option<Result<crate::coordinator::types::StopReport, String>>
+    where
+        F: FnOnce(
+                &crate::coordinator::WorkspacePath,
+            ) -> Result<crate::coordinator::types::StopReport, String>
+            + Send
+            + 'static,
+    {
         let (tx, rx) = std::sync::mpsc::channel();
         let handle = std::thread::spawn(move || {
-            let result =
-                crate::coordinator::stop_coordinator(&workspace).map_err(|error| error.to_string());
+            let result = stop(&workspace);
             let _ = tx.send(result);
         });
         let outcome = rx.recv_timeout(timeout).ok();
@@ -599,8 +809,7 @@ pub mod lifecycle_port {
         match rx.recv_timeout(std::time::Duration::from_millis(250)) {
             Ok(late) => {
                 let _ = handle.join();
-                let _ = late; // result arrived after the deadline: still a timeout to the caller
-                None
+                Some(late)
             }
             Err(_) => {
                 if handle.is_finished() {
@@ -652,10 +861,19 @@ pub mod lifecycle_port {
         crate::tmux_backend::TmuxBackend::for_workspace(workspace)
     }
 
+    fn shutdown_transport_for_endpoint(endpoint: &str) -> crate::tmux_backend::TmuxBackend {
+        if Path::new(endpoint).is_absolute() {
+            crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
+        } else {
+            crate::tmux_backend::TmuxBackend::for_socket_name(endpoint)
+        }
+    }
+
     fn legacy_worker_tmux_endpoint(state: &Value) -> Option<&str> {
         state
             .get("tmux_endpoint")
             .and_then(Value::as_str)
+            .or_else(|| state.get("tmux_socket").and_then(Value::as_str))
             .filter(|endpoint| !endpoint.is_empty())
     }