@team-agent/installer 0.3.15 → 0.3.17

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

@@ -161,6 +161,7 @@ struct CleanShutdownTransport {
     targets: Vec<PaneInfo>,
     kill_server_called: Mutex<bool>,
     probe_timeout_kind: Option<&'static str>,
+    targets_persist_after_kill: bool,
 }
 
 impl CleanShutdownTransport {
@@ -170,6 +171,7 @@ impl CleanShutdownTransport {
             targets: Vec::new(),
             kill_server_called: Mutex::new(false),
             probe_timeout_kind: None,
+            targets_persist_after_kill: false,
         }
     }
 
@@ -186,6 +188,11 @@ impl CleanShutdownTransport {
         self.probe_timeout_kind = Some(probe);
         self
     }
+
+    fn with_targets_persist_after_kill(mut self) -> Self {
+        self.targets_persist_after_kill = true;
+        self
+    }
 }
 
 impl Transport for CleanShutdownTransport {
@@ -249,7 +256,7 @@ impl Transport for CleanShutdownTransport {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        if *self.session_present.lock().unwrap() {
+        if *self.session_present.lock().unwrap() || self.targets_persist_after_kill {
             Ok(self.targets.clone())
         } else {
             Ok(Vec::new())
@@ -375,6 +382,85 @@ fn ps_table_timeout_still_degrades_shutdown_truth() {
     assert_eq!(out["probe_timeout_kind"], json!("ps_table"));
 }
 
+#[test]
+fn bounded_coordinator_stop_returns_grace_window_late_success() {
+    let ws = tmp_shutdown_workspace("late-coordinator-stop-success");
+    let report = crate::cli::lifecycle_port::stop_coordinator_bounded_with(
+        crate::coordinator::WorkspacePath::new(ws),
+        std::time::Duration::from_millis(5),
+        |_workspace| {
+            std::thread::sleep(std::time::Duration::from_millis(25));
+            Ok(crate::coordinator::StopReport {
+                ok: true,
+                status: crate::coordinator::StopOutcome::Stopped,
+                pid: Some(crate::coordinator::Pid::new(12345)),
+            })
+        },
+    )
+    .expect("late result inside grace window must be returned")
+    .expect("stop result should be ok");
+
+    assert!(report.ok, "late success must not be discarded as timeout");
+    assert_eq!(report.status, crate::coordinator::StopOutcome::Stopped);
+}
+
+#[test]
+fn shutdown_outcome_late_or_postcheck_gone_is_ok_with_lsof_diagnostic() {
+    let out = crate::cli::lifecycle_port::classify_shutdown_outcome(
+        crate::cli::lifecycle_port::ShutdownOutcomeInput {
+            kill_error: false,
+            session_residuals: false,
+            process_residuals: false,
+            cleanup_truth_degraded: false,
+            coordinator_timeout: true,
+            coordinator_stop_ok: None,
+            coordinator_post_stop: crate::cli::lifecycle_port::CoordinatorStopObservation::Gone,
+        },
+    );
+
+    assert!(out.ok);
+    assert_eq!(out.status, "ok");
+    assert_eq!(out.phase, None);
+}
+
+#[test]
+fn shutdown_outcome_coordinator_timeout_still_running_is_timeout() {
+    let out = crate::cli::lifecycle_port::classify_shutdown_outcome(
+        crate::cli::lifecycle_port::ShutdownOutcomeInput {
+            kill_error: false,
+            session_residuals: false,
+            process_residuals: false,
+            cleanup_truth_degraded: false,
+            coordinator_timeout: true,
+            coordinator_stop_ok: None,
+            coordinator_post_stop: crate::cli::lifecycle_port::CoordinatorStopObservation::Running,
+        },
+    );
+
+    assert!(!out.ok);
+    assert_eq!(out.status, "timeout");
+    assert_eq!(out.phase, Some("stop_coordinator"));
+}
+
+#[test]
+fn shutdown_outcome_ps_table_degraded_still_partial_after_coordinator_gone() {
+    let out = crate::cli::lifecycle_port::classify_shutdown_outcome(
+        crate::cli::lifecycle_port::ShutdownOutcomeInput {
+            kill_error: false,
+            session_residuals: false,
+            process_residuals: false,
+            cleanup_truth_degraded: true,
+            coordinator_timeout: true,
+            coordinator_stop_ok: None,
+            coordinator_post_stop: crate::cli::lifecycle_port::CoordinatorStopObservation::Gone,
+        },
+    );
+
+    assert!(!out.ok);
+    assert_eq!(out.status, "partial");
+    assert_eq!(out.phase, Some("os_probe"));
+}
+
 #[test]
 fn leader_env_tmux_socket_never_kills_server_even_when_sessions_look_exclusive() {
     let ws = tmp_shutdown_workspace("leader-env-socket-no-kill-server");
@@ -417,3 +503,43 @@ fn leader_env_tmux_socket_never_kills_server_even_when_sessions_look_exclusive()
         "leader-env/shared socket shutdown must kill sessions individually, never kill-server"
     );
 }
+
+#[test]
+fn managed_leader_shutdown_never_kills_server_even_when_socket_looks_exclusive() {
+    let ws = tmp_shutdown_workspace("managed-leader-no-kill-server");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-current",
+            "is_external_leader": false,
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new()
+        .with_targets(vec![PaneInfo {
+            pane_id: PaneId::new("%1"),
+            session: SessionName::new("team-current"),
+            window_index: Some(0),
+            window_name: Some(WindowName::new("leader")),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: None,
+            leader_env: BTreeMap::new(),
+        }])
+        .with_targets_persist_after_kill();
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
+        .expect("shutdown should complete");
+
+    assert_eq!(out["ok"], json!(true));
+    assert_eq!(out["killed_sessions"], json!(["team-current"]));
+    assert_eq!(out["spared_sessions"], json!([]));
+    assert!(
+        !transport.kill_server_called(),
+        "managed topology must clear the team session/window without kill-server"
+    );
+}

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

@@ -36,6 +36,10 @@ use super::*;
         for key in [
             "team",
             "session_name",
+            "leader_topology",
+            "is_external_leader",
+            "leader_attach_command",
+            "leader_client",
             "tmux_session_present",
             "leader_receiver",
             "agents",
@@ -61,6 +65,27 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn status_port_status_reports_managed_leader_topology_and_attach_command() {
+        let ws = seed_status_workspace();
+        let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if let Some(obj) = state.as_object_mut() {
+            obj.insert("is_external_leader".to_string(), json!(false));
+            obj.insert("session_name".to_string(), json!("team-current"));
+        }
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+
+        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+
+        assert_eq!(v["leader_topology"], json!("managed"));
+        assert_eq!(v["is_external_leader"], json!(false));
+        let attach = v["leader_attach_command"]
+            .as_str()
+            .expect("managed status includes attach command");
+        assert!(attach.contains("attach -t team-current:leader"), "{attach}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_status_detail_full_keeps_uncompacted_events() {
         // cmd_status --json --detail -> status_port::status(compact=false): the FULL dict

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

@@ -202,6 +202,8 @@ pub struct LeaderLauncherArgs {
     pub confirm_attach: bool,
     /// `--attach-session <name>` / `--attach-session=<name>`。
     pub attach_session: Option<String>,
+    /// 0.3.16 topology opt-out: keep the old external/current-pane leader launcher path.
+    pub external_leader: bool,
 }
 
 // =============================================================================

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

@@ -1,6 +1,7 @@
 //! leader::lease — attach / claim / autobind 统一 CAS 路径 + claim_lease_no_incident
 //! + 双写 / 分叉检测。
 
+use std::collections::BTreeSet;
 use std::path::Path;
 
 use serde_json::{json, Value};
@@ -25,27 +26,34 @@ use super::{
 /// 整段临界区做 state 变更 + 事件 + 双写 + requeue exhausted watchers。
 pub fn attach_leader(
     workspace: &Path,
+    team: Option<&str>,
     pane: Option<&PaneId>,
     provider: Provider,
 ) -> Result<LeaseResult, LeaderError> {
     let event_log = crate::event_log::EventLog::new(workspace);
-    let mut state = crate::state::persist::load_runtime_state(workspace)?;
-    let targets = crate::tmux_backend::TmuxBackend::for_workspace(workspace)
-        .list_targets()
-        .unwrap_or_default();
+    let scoped_team = team.filter(|value| !value.is_empty());
+    let mut state = if scoped_team.is_some() {
+        crate::state::projection::select_runtime_state(workspace, scoped_team)?
+    } else {
+        crate::state::persist::load_runtime_state(workspace)?
+    };
+    let targets = attach_leader_targets(workspace, &state);
     let pane_id = pane
         .cloned()
         .or_else(|| std::env::var("TMUX_PANE").ok().filter(|p| !p.is_empty()).map(PaneId::new))
         .ok_or_else(|| LeaderError::Validation("tmux pane not found".to_string()))?;
     let non_empty_pane_id = NonEmptyPaneId::try_from_pane(&pane_id)?;
-    let Some(target) = targets.iter().find(|target| target.pane_id == pane_id) else {
+    let Some(target) = targets.iter().find(|target| target.info.pane_id == pane_id) else {
         return Err(LeaderError::Validation(format!("tmux pane not found: {pane_id}")));
     };
-    let mut receiver = receiver_for_attach_target(workspace, &state, target, provider, Discovery::ExplicitPane)?;
-    let validation = validate_attach_target(workspace, &state, target);
+    let mut receiver = receiver_for_attach_target(workspace, &state, &target.info, provider, Discovery::ExplicitPane)?;
+    if let Some(endpoint) = target.endpoint.as_ref() {
+        receiver.tmux_socket = Some(endpoint.clone());
+    }
+    let validation = validate_attach_target(workspace, &state, &target.info);
     if validation.is_err() {
-        let pane_info = pane_info_value(target);
-        let targets_value = Value::Array(targets.iter().map(pane_info_value).collect());
+        let pane_info = pane_info_value(&target.info);
+        let targets_value = Value::Array(targets.iter().map(|target| pane_info_value(&target.info)).collect());
         let owner_record = state_owner(&state);
         if let Some((readopted, validation)) = crate::leader::try_readopt_leader_pane(
             workspace,
@@ -85,7 +93,7 @@ pub fn attach_leader(
     let epoch = current_owner_epoch(&state);
     if state.get("team_owner").is_some() {
         write_receiver_to_state(&mut state, &receiver)?;
-        write_lease_dual_state(workspace, &state)?;
+        write_claim_state(workspace, &state, scoped_team, None)?;
         event_log.write(
             super::LeaderEvent::ReceiverAttached.name(),
             json!({"pane_id": pane_id.as_str(), "owner_epoch": epoch.0}),
@@ -108,7 +116,7 @@ pub fn attach_leader(
     receiver.leader_session_uuid = Some(identity.leader_session_uuid.clone());
     let owner = make_owner(provider, &non_empty_pane_id, &identity, next_epoch);
     write_binding_to_state(&mut state, &receiver, &owner)?;
-    write_lease_dual_state(workspace, &state)?;
+    write_claim_state(workspace, &state, scoped_team, None)?;
     event_log.write(
         super::LeaderEvent::ReceiverAttached.name(),
         json!({"pane_id": pane_id.as_str(), "owner_epoch": next_epoch.0}),
@@ -126,6 +134,80 @@ pub fn attach_leader(
     })
 }
 
+#[derive(Clone)]
+struct AttachLeaderTarget {
+    info: PaneInfo,
+    endpoint: Option<String>,
+}
+
+fn attach_leader_targets(workspace: &Path, state: &Value) -> Vec<AttachLeaderTarget> {
+    let mut targets = Vec::new();
+    for endpoint in state_recorded_tmux_endpoints(state) {
+        let backend = tmux_backend_for_endpoint(&endpoint);
+        targets.extend(
+            backend
+                .list_targets()
+                .unwrap_or_default()
+                .into_iter()
+                .map(|info| AttachLeaderTarget {
+                    info,
+                    endpoint: Some(endpoint.clone()),
+                }),
+        );
+    }
+    targets.extend(
+        crate::tmux_backend::TmuxBackend::for_workspace(workspace)
+            .list_targets()
+            .unwrap_or_default()
+            .into_iter()
+            .map(|info| AttachLeaderTarget { info, endpoint: None }),
+    );
+    targets
+}
+
+fn tmux_backend_for_endpoint(endpoint: &str) -> crate::tmux_backend::TmuxBackend {
+    if endpoint.is_empty() || endpoint == "default" {
+        crate::tmux_backend::TmuxBackend::new()
+    } else if Path::new(endpoint).is_absolute() {
+        crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
+    } else {
+        crate::tmux_backend::TmuxBackend::for_socket_name(endpoint)
+    }
+}
+
+fn state_recorded_tmux_endpoints(state: &Value) -> BTreeSet<String> {
+    let mut out = BTreeSet::new();
+    push_state_tmux_endpoints(state, &mut out);
+    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
+        for team_state in teams.values() {
+            push_state_tmux_endpoints(team_state, &mut out);
+        }
+    }
+    out
+}
+
+fn push_state_tmux_endpoints(state: &Value, out: &mut BTreeSet<String>) {
+    for key in ["tmux_socket", "tmux_endpoint"] {
+        if let Some(endpoint) = state
+            .get(key)
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+        {
+            out.insert(endpoint.to_string());
+        }
+    }
+    for key in ["team_owner", "leader_receiver"] {
+        if let Some(endpoint) = state
+            .get(key)
+            .and_then(|value| value.get("tmux_socket"))
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+        {
+            out.insert(endpoint.to_string());
+        }
+    }
+}
+
 fn requeue_exhausted_watchers_after_attach(
     workspace: &Path,
     state: &Value,