@team-agent/installer 0.3.13 → 0.3.15

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)),
@@ -168,48 +175,12 @@ pub mod lifecycle_port {
         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 state_for_kill = state.clone();
         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)
         };
-        let result =
-            shutdown_with_transport_and_state(workspace, keep_logs, team, &transport, Some(state));
-        if team.is_none() {
-            // E12 (P0): the leader terminal lives on this socket by design. A bare shutdown must
-            // NOT `kill-server` it away. spare = state-anchor sessions ∪ `team-agent-leader-*`
-            // prefix sessions (union; cr E12 ①). kill_server only when the socket is exclusively
-            // ours (no spare + no foreign session); shared socket → kill our sessions individually
-            // (cr E12 ②). All spare derivation comes from ONE snapshot (list_targets + the state
-            // already loaded) — no independent ps/tmux re-derivation (N39).
-            let transport_dyn: &dyn crate::transport::Transport = &transport;
-            let pane_targets = transport_dyn.list_targets().unwrap_or_default();
-            let sessions = socket_session_names(transport_dyn);
-            let event_log = crate::event_log::EventLog::new(&run_ws);
-            let anchor_sessions =
-                anchor_sessions_from_state(&state_for_kill, &pane_targets, &event_log);
-            let decision = sessions_to_kill(&sessions, &anchor_sessions);
-            match decision {
-                KillDecision::KillServerExclusive => transport.kill_server(),
-                KillDecision::KillIndividually { to_kill, spared } => {
-                    if !spared.is_empty() || to_kill.len() != sessions.len() {
-                        // shared socket / leader spared → never whole-server teardown.
-                        let _ = event_log.write(
-                            "shutdown.kill_server_skipped_shared_socket",
-                            json!({
-                                "spared_sessions": spared.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
-                                "killed_sessions": to_kill.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
-                            }),
-                        );
-                    }
-                    for session in &to_kill {
-                        let _ = transport_dyn.kill_session(session);
-                    }
-                }
-            }
-        }
-        result
+        shutdown_with_transport_and_state(workspace, keep_logs, team, &transport, Some(state))
     }
 
     /// E12 ①:从 state 锚 pane_id(leader_receiver/team_owner,top+teams)映射到其所在 session
@@ -235,15 +206,13 @@ pub mod lifecycle_port {
             .collect()
     }
 
-    fn socket_session_names(
-        transport: &dyn crate::transport::Transport,
+    fn socket_session_names_from_targets(
+        pane_targets: &[crate::transport::PaneInfo],
     ) -> Vec<crate::transport::SessionName> {
         let mut seen = std::collections::BTreeSet::new();
-        transport
-            .list_targets()
-            .unwrap_or_default()
-            .into_iter()
-            .map(|pane| pane.session)
+        pane_targets
+            .iter()
+            .map(|pane| pane.session.clone())
             .filter(|session| seen.insert(session.as_str().to_string()))
             .collect()
     }
@@ -281,6 +250,103 @@ pub mod lifecycle_port {
         }
     }
 
+    #[derive(Debug, Default)]
+    struct ShutdownSocketCleanup {
+        killed_sessions: Vec<crate::transport::SessionName>,
+        spared_sessions: Vec<crate::transport::SessionName>,
+        error: Option<String>,
+    }
+
+    fn push_unique_session(
+        sessions: &mut Vec<crate::transport::SessionName>,
+        session: crate::transport::SessionName,
+    ) {
+        if !sessions
+            .iter()
+            .any(|existing| existing.as_str() == session.as_str())
+        {
+            sessions.push(session);
+        }
+    }
+
+    fn bare_shutdown_socket_cleanup(
+        transport: &dyn crate::transport::Transport,
+        state: &Value,
+        event_log: &crate::event_log::EventLog,
+    ) -> ShutdownSocketCleanup {
+        // E12 (P0): the leader terminal lives on this socket by design. A bare shutdown must
+        // NOT `kill-server` it away. spare = state-anchor sessions ∪ `team-agent-leader-*`
+        // prefix sessions (union; cr E12 ①). kill_server only when the socket is exclusively
+        // ours (no spare + no foreign session); shared socket → kill our sessions individually
+        // (cr E12 ②). All spare derivation comes from ONE snapshot (list_targets + state) —
+        // 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);
+        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,
+                    spared_sessions: Vec::new(),
+                    error,
+                }
+            }
+            KillDecision::KillIndividually { to_kill, spared } => {
+                if !spared.is_empty() || to_kill.len() != sessions.len() {
+                    // shared socket / leader spared → never whole-server teardown.
+                    let _ = event_log.write(
+                        "shutdown.kill_server_skipped_shared_socket",
+                        json!({
+                            "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,
@@ -358,8 +424,11 @@ pub mod lifecycle_port {
         reap_process_tree(&root_pids, &protected, &entry_table);
         reap_process_groups(&root_pgids, &protected);
         let mut kill_error: Option<String> = None;
+        let mut killed_sessions = Vec::new();
+        let mut spared_sessions = Vec::new();
         deadline.check("kill_session")?;
         if let Some(session) = session_name.as_ref() {
+            push_unique_session(&mut killed_sessions, session.clone());
             if let Err(error) = transport.kill_session(session) {
                 if !tmux_absent_error(&error.to_string()) {
                     kill_error = Some(error.to_string());
@@ -376,21 +445,28 @@ pub mod lifecycle_port {
             reap_scope,
             &mut probe_degraded,
         );
-        deadline.check("session_residuals")?;
-        let session_residuals = if let Some(session) = session_name.as_ref() {
-            let (residuals, error) = session_residuals_after_reap(
-                transport,
-                &run_workspace,
-                session,
-                !captured_missing_sessions,
-            );
-            if let Some(error) = error {
+        if team.is_none() {
+            deadline.check("shared_socket_cleanup")?;
+            let event_log = crate::event_log::EventLog::new(&run_workspace);
+            let cleanup = bare_shutdown_socket_cleanup(transport, &state, &event_log);
+            for session in cleanup.killed_sessions {
+                push_unique_session(&mut killed_sessions, session);
+            }
+            spared_sessions = cleanup.spared_sessions;
+            if let Some(error) = cleanup.error {
                 kill_error.get_or_insert(error);
             }
-            residuals
-        } else {
-            Vec::new()
-        };
+        }
+        deadline.check("session_residuals")?;
+        let (session_residuals, session_residual_error) = session_residuals_after_reap_many(
+            transport,
+            &run_workspace,
+            &killed_sessions,
+            !captured_missing_sessions,
+        );
+        if let Some(error) = session_residual_error {
+            kill_error.get_or_insert(error);
+        }
         deadline.check("process_residuals")?;
         // C-①: the post-verify gets ONE fresh verification snapshot (reaps changed
         // the world; #248 post-verify facts must be current, not the entry view).
@@ -424,10 +500,18 @@ pub mod lifecycle_port {
             None
         };
         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 session_killed = session_name.is_some()
+        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()
             && process_residuals.is_empty();
@@ -458,13 +542,13 @@ pub mod lifecycle_port {
             && kill_error.is_none()
             && session_residuals.is_empty()
             && process_residuals.is_empty()
-            && !verification_degraded
+            && !cleanup_truth_degraded
             && !coordinator_timeout;
         let status = if ok {
             "ok"
         } else if coordinator_timeout {
             "timeout"
-        } else if verification_degraded {
+        } else if cleanup_truth_degraded {
             "partial"
         } else if kill_error.is_some() {
             "failed"
@@ -473,12 +557,11 @@ pub mod lifecycle_port {
         };
         let phase = if coordinator_timeout {
             Some("stop_coordinator")
-        } else if verification_degraded {
+        } else if cleanup_truth_degraded {
             Some("os_probe")
         } else {
             None
         };
-        let probe_timeout_kind = probe_timeout.as_ref().map(|timeout| timeout.probe);
         let probe_timeout_value = probe_timeout.as_ref().map(|timeout| {
             json!({
                 "probe": timeout.probe,
@@ -494,6 +577,8 @@ pub mod lifecycle_port {
                     "team": team,
                     "session_name": session_name.as_ref().map(|s| s.as_str().to_string()),
                     "session_killed": session_killed,
+                    "killed_sessions": killed_sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                    "spared_sessions": spared_sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
                     "coordinator_status": coordinator_status,
                     "status": status,
                     "phase": phase,
@@ -515,6 +600,8 @@ pub mod lifecycle_port {
             "team": team,
             "session_name": session_name.map(|s| s.as_str().to_string()),
             "session_killed": session_killed,
+            "killed_sessions": killed_sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+            "spared_sessions": spared_sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
             "residuals": {
                 "sessions": session_residuals,
                 "processes": process_residuals,
@@ -606,10 +693,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())
     }
 
@@ -673,6 +769,33 @@ pub mod lifecycle_port {
         (sessions, error)
     }
 
+    fn session_residuals_after_reap_many(
+        transport: &dyn crate::transport::Transport,
+        workspace: &Path,
+        sessions: &[crate::transport::SessionName],
+        check_primary_transport: bool,
+    ) -> (Vec<String>, Option<String>) {
+        let mut residuals = Vec::new();
+        let mut error = None;
+        for session in sessions {
+            let (session_residuals, session_error) = session_residuals_after_reap(
+                transport,
+                workspace,
+                session,
+                check_primary_transport,
+            );
+            for residual in session_residuals {
+                if !residuals.iter().any(|seen| seen == &residual) {
+                    residuals.push(residual);
+                }
+            }
+            if let Some(session_error) = session_error {
+                error.get_or_insert(session_error);
+            }
+        }
+        (residuals, error)
+    }
+
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     enum ShutdownReapScope {
         Workspace,
@@ -721,11 +844,7 @@ pub mod lifecycle_port {
     /// pids; Gap 37 escalation order TERM -> grace -> KILL preserved), then a single
     /// bounded wait for the whole union. kill/wait sets derive from the SAME snapshot
     /// as the protected set (N39).
-    fn reap_process_tree(
-        root_pids: &[u32],
-        protected: &ShutdownProtection,
-        table: &[ProcessInfo],
-    ) {
+    fn reap_process_tree(root_pids: &[u32], protected: &ShutdownProtection, table: &[ProcessInfo]) {
         let mut pids = Vec::new();
         let mut seen = std::collections::BTreeSet::new();
         for root in root_pids {
@@ -787,12 +906,21 @@ pub mod lifecycle_port {
             let mut protected = shutdown_protection_set(&round_table);
             extend_protection_with_leader_panes(&mut protected, transport, state, &round_table);
             let residuals = matched_processes(
-                workspace, state, root_pids, root_pgids, &protected, scope, &round_table,
+                workspace,
+                state,
+                root_pids,
+                root_pgids,
+                &protected,
+                scope,
+                &round_table,
             );
             if residuals.is_empty() {
                 return;
             }
-            let residual_pids = residuals.iter().map(|process| process.pid).collect::<Vec<_>>();
+            let residual_pids = residuals
+                .iter()
+                .map(|process| process.pid)
+                .collect::<Vec<_>>();
             reap_process_tree(&residual_pids, &protected, &round_table);
             let pgids = residuals
                 .iter()
@@ -906,7 +1034,9 @@ pub mod lifecycle_port {
     /// - E4b team-in-team:子 team state 的 team_owner.pane_id 指父 team worker pane;
     ///   父 team state 的 teams.<child>.team_owner.pane_id 同义(若有该字段)
     ///   → 任一 team 的 shutdown 都不杀任何 team 的 leader 锚 pane
-    pub fn collect_state_leader_anchor_pane_ids(state: &Value) -> std::collections::BTreeSet<String> {
+    pub fn collect_state_leader_anchor_pane_ids(
+        state: &Value,
+    ) -> std::collections::BTreeSet<String> {
         let mut out = std::collections::BTreeSet::new();
         push_anchor_pane_id(state, &mut out);
         if let Some(teams) = state.get("teams").and_then(Value::as_object) {
@@ -1042,7 +1172,10 @@ pub mod lifecycle_port {
         for socket_endpoint in collect_state_recorded_tmux_sockets(state) {
             let cross_backend =
                 crate::tmux_backend::TmuxBackend::for_tmux_endpoint(&socket_endpoint);
-            let cross_panes = <crate::tmux_backend::TmuxBackend as crate::transport::Transport>::list_targets(&cross_backend)
+            let cross_panes =
+                <crate::tmux_backend::TmuxBackend as crate::transport::Transport>::list_targets(
+                    &cross_backend,
+                )
                 .unwrap_or_default();
             leader_pane_pids.extend(
                 cross_panes
@@ -1167,8 +1300,9 @@ pub mod lifecycle_port {
         scope: ShutdownReapScope,
         table: &[ProcessInfo],
     ) -> Vec<Value> {
-        let mut residuals =
-            matched_processes(workspace, state, root_pids, root_pgids, protected, scope, table);
+        let mut residuals = matched_processes(
+            workspace, state, root_pids, root_pgids, protected, scope, table,
+        );
         let mut seen = residuals
             .iter()
             .map(|process| process.pid)
@@ -1891,7 +2025,7 @@ pub mod lifecycle_port {
                 state_path: Some(PathBuf::from("/tmp/state.json")),
                 next_actions: vec!["restart".to_string()],
                 attach_commands: vec![
-                    "tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker".to_string(),
+                    "tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker".to_string()
                 ],
             });
             assert_eq!(
@@ -2157,7 +2291,10 @@ pub mod lifecycle_port {
             let msg = "agent start requirement unmet: agent foo not found";
             let na = error_next_action(msg).expect("not-found must carry next_action");
             assert!(na.contains("add-agent"), "must steer to add-agent: {na}");
-            assert!(na.contains("--role-file"), "must show the role-file flag: {na}");
+            assert!(
+                na.contains("--role-file"),
+                "must show the role-file flag: {na}"
+            );
         }
 
         #[test]
@@ -2176,7 +2313,10 @@ pub mod lifecycle_port {
 
         #[test]
         fn unrelated_error_has_no_next_action() {
-            assert_eq!(error_next_action("state persistence failed: disk full"), None);
+            assert_eq!(
+                error_next_action("state persistence failed: disk full"),
+                None
+            );
         }
 
         #[test]
@@ -2187,7 +2327,10 @@ pub mod lifecycle_port {
             let v = error_value(err);
             assert_eq!(v["ok"], serde_json::json!(false));
             assert!(
-                v["next_action"].as_str().unwrap_or("").contains("add-agent"),
+                v["next_action"]
+                    .as_str()
+                    .unwrap_or("")
+                    .contains("add-agent"),
                 "error_value must attach the add-agent guidance: {v}"
             );
         }
@@ -2242,8 +2385,8 @@ pub mod diagnose_port {
             .unwrap_or(true);
         // legacy 降级面(legacy_team_invalid)不下拉整体 ok —— 用户没显式让我们
         // 体检这个 team,失败是降级诊断信息,不是 install 自检失败。
-        let legacy_only_failure =
-            !profile_smoke_ok && profile_smoke_value.get("status").and_then(Value::as_str)
+        let legacy_only_failure = !profile_smoke_ok
+            && profile_smoke_value.get("status").and_then(Value::as_str)
                 == Some("legacy_team_invalid");
         let effective_smoke_ok = profile_smoke_ok || legacy_only_failure;
         let ok = workspace_valid && (team_context || workspace_has_entries) && effective_smoke_ok;