@team-agent/installer 0.5.107 → 0.5.108

package/crates/team-agent/src/cli/status_port/brief.rs

@@ -117,6 +117,14 @@ struct BriefNode {
     tmux_command: Option<String>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct AttachContext {
+    endpoint: String,
+    session: String,
+    window: String,
+    pane: String,
+}
+
 #[derive(Debug)]
 struct ProbeResult {
     nodes: Vec<ProbeNode>,
@@ -150,34 +158,45 @@ pub(crate) fn status_brief_scoped(
     state: &Value,
     agent: Option<&str>,
 ) -> Value {
-    let registered = registered_nodes(state, agent);
-    let probes = probe_registered_endpoints(&registered);
-    let nodes = registered
-        .iter()
-        .map(|node| project_node(node, probes.get(node.endpoint.as_deref().unwrap_or(""))))
-        .collect::<Vec<_>>();
+    let nodes = project_status_nodes(state, agent);
     json!({
-        "nodes": nodes.into_iter().map(BriefNode::into_json).collect::<Vec<_>>()
+        "nodes": nodes
+            .into_iter()
+            .map(|(node, _)| node.into_json())
+            .collect::<Vec<_>>()
     })
 }
 
-/// Human output is the exact same nine-field projection as JSON, rendered in
-/// stable field order. Null values remain explicit rather than becoming a
-/// diagnostic or an inferred value.
+/// Human output keeps the legacy single-node form and groups shared attach
+/// context only when multiple nodes make that repetition useful.
 pub(crate) fn format_status_brief(
-    workspace: &Path,
+    _workspace: &Path,
     state: &Value,
     agent: Option<&str>,
 ) -> String {
-    let value = status_brief_scoped(workspace, state, agent);
-    value
-        .get("nodes")
-        .and_then(Value::as_array)
-        .into_iter()
-        .flatten()
-        .filter_map(format_brief_node)
-        .collect::<Vec<_>>()
-        .join("\n")
+    let nodes = project_status_nodes(state, agent);
+    if nodes.len() <= 1 {
+        return nodes
+            .into_iter()
+            .filter_map(|(node, _)| format_brief_node(&node.into_json()))
+            .collect::<Vec<_>>()
+            .join("\n");
+    }
+    format_multi_node_brief(nodes)
+}
+
+fn project_status_nodes(
+    state: &Value,
+    agent: Option<&str>,
+) -> Vec<(BriefNode, Option<AttachContext>)> {
+    let registered = registered_nodes(state, agent);
+    let probes = probe_registered_endpoints(&registered);
+    registered
+        .iter()
+        .map(|node| {
+            project_node_with_attach(node, probes.get(node.endpoint.as_deref().unwrap_or("")))
+        })
+        .collect()
 }
 
 pub(crate) fn registered_agent_exists(state: &Value, agent: &str) -> bool {
@@ -322,6 +341,86 @@ fn format_brief_node(value: &Value) -> Option<String> {
     ))
 }
 
+fn format_multi_node_brief(nodes: Vec<(BriefNode, Option<AttachContext>)>) -> String {
+    let mut groups = Vec::<(String, String)>::new();
+    for (_, context) in &nodes {
+        let Some(context) = context else { continue };
+        if !groups.iter().any(|(endpoint, session)| {
+            endpoint == &context.endpoint && session == &context.session
+        }) {
+            groups.push((context.endpoint.clone(), context.session.clone()));
+        }
+    }
+
+    let mut lines = groups
+        .iter()
+        .enumerate()
+        .map(|(index, (endpoint, session))| {
+            format_attach_template(index + 1, endpoint, session)
+        })
+        .collect::<Vec<_>>();
+    if !groups.is_empty() {
+        lines.push(
+            "TMUX templates: replace <target> with the window.pane part of the matching ATTACH value."
+                .to_string(),
+        );
+    }
+    lines.push(
+        "NAME\tPROVIDER\tMODEL\tEFFORT\tRUNTIME_STATUS\tACTIVITY\tHEALTH\tSESSION_NAME\tATTACH"
+            .to_string(),
+    );
+    for (node, context) in nodes {
+        let attach = context
+            .as_ref()
+            .and_then(|context| {
+                groups
+                    .iter()
+                    .position(|(endpoint, session)| {
+                        endpoint == &context.endpoint && session == &context.session
+                    })
+                    .map(|index| format!("{}:{}.{}", index + 1, context.window, context.pane))
+            })
+            .unwrap_or_else(|| "null".to_string());
+        lines.push(
+            [
+                escape_human_cell(&node.name),
+                escape_human_cell(&node.provider),
+                escape_human_cell(node.model.as_deref().unwrap_or("null")),
+                escape_human_cell(node.effort.as_deref().unwrap_or("null")),
+                escape_human_cell(&node.runtime_status),
+                escape_human_cell(&node.activity),
+                escape_human_cell(&node.health),
+                escape_human_cell(node.session_name.as_deref().unwrap_or("null")),
+                escape_human_cell(&attach),
+            ]
+            .join("\t"),
+        );
+    }
+    lines.join("\n")
+}
+
+fn format_attach_template(group: usize, endpoint: &str, session: &str) -> String {
+    let flag = if Path::new(endpoint).is_absolute() {
+        "-S"
+    } else {
+        "-L"
+    };
+    let target = format!("{session}:<target>");
+    format!(
+        "TMUX[{group}] tmux {flag} {} attach -t {}",
+        shell_quote(endpoint),
+        shell_quote(&target)
+    )
+}
+
+fn escape_human_cell(value: &str) -> String {
+    value
+        .replace('\\', "\\\\")
+        .replace('\t', "\\t")
+        .replace('\n', "\\n")
+        .replace('\r', "\\r")
+}
+
 fn display_optional(value: &Value) -> String {
     value
         .as_str()
@@ -1051,14 +1150,22 @@ fn non_empty(value: &Value, key: &str) -> Option<String> {
         .map(str::to_string)
 }
 
+#[cfg(test)]
 fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> BriefNode {
+    project_node_with_attach(node, probe).0
+}
+
+fn project_node_with_attach(
+    node: &RegisteredNode,
+    probe: Option<&Option<ProbeResult>>,
+) -> (BriefNode, Option<AttachContext>) {
     let stopped = matches!(
         node.lifecycle.as_deref(),
         Some("stopped" | "done" | "failed" | "error" | "terminated")
     );
     let matched = match_result(node, probe);
     if stopped {
-        return match matched {
+        let projected = match matched {
             MatchResult::Missing => BriefNode {
                 name: node.name.clone(),
                 provider: node.provider.clone(),
@@ -1072,14 +1179,15 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
             },
             MatchResult::Unique(_) | MatchResult::Ambiguous => BriefNode::unknown(node),
         };
+        return (projected, None);
     }
     let MatchResult::Unique(observed) = matched else {
-        return BriefNode::unknown(node);
+        return (BriefNode::unknown(node), None);
     };
     if !node.provider.eq_ignore_ascii_case("unknown")
         && !node.provider.eq_ignore_ascii_case(&observed.provider)
     {
-        return BriefNode::unknown(node);
+        return (BriefNode::unknown(node), None);
     }
     let pi_channel = observed.provider.eq_ignore_ascii_case("pi")
         && observed.evidence_method.as_deref() == Some("pi_activity_channel");
@@ -1097,21 +1205,31 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
     } else {
         valid_health(&observed.health)
     };
-    BriefNode {
-        name: node.name.clone(),
-        provider: if node.provider.eq_ignore_ascii_case("unknown") {
-            observed.provider.clone()
-        } else {
-            node.provider.clone()
+    let tmux_command = tmux_command(node, observed);
+    let attach = tmux_command.as_ref().map(|_| AttachContext {
+        endpoint: observed.socket.clone(),
+        session: observed.session.clone(),
+        window: observed.window.clone(),
+        pane: observed.pane.clone(),
+    });
+    (
+        BriefNode {
+            name: node.name.clone(),
+            provider: if node.provider.eq_ignore_ascii_case("unknown") {
+                observed.provider.clone()
+            } else {
+                node.provider.clone()
+            },
+            model: node.model.clone(),
+            effort: node.effort.clone(),
+            runtime_status: "running".to_string(),
+            activity: activity.to_string(),
+            health: health.to_string(),
+            session_name: observed.session_name.clone(),
+            tmux_command,
         },
-        model: node.model.clone(),
-        effort: node.effort.clone(),
-        runtime_status: "running".to_string(),
-        activity: activity.to_string(),
-        health: health.to_string(),
-        session_name: observed.session_name.clone(),
-        tmux_command: tmux_command(node, observed),
-    }
+        attach,
+    )
 }
 
 fn match_result<'a>(

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

@@ -1930,3 +1930,187 @@ fn unit0_sessions_to_kill_leader_prefixed_session_is_always_spared() {
         ),
     }
 }
+
+const ISSUE_269_ROOT_PID: u32 = 2_147_000_001;
+
+std::thread_local! {
+    static ISSUE_269_LIVENESS_CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    static ISSUE_269_FIRST_ALIVE: std::cell::RefCell<Option<std::time::Instant>> = const { std::cell::RefCell::new(None) };
+    static ISSUE_269_DEATH_DELAY: std::cell::Cell<Option<std::time::Duration>> = const { std::cell::Cell::new(None) };
+}
+
+struct ShutdownWorkspaceCleanup(PathBuf);
+
+impl Drop for ShutdownWorkspaceCleanup {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+
+fn reset_issue_269_probe_state() {
+    ISSUE_269_LIVENESS_CALLS.with(|calls| calls.set(0));
+    ISSUE_269_FIRST_ALIVE.with(|first| *first.borrow_mut() = None);
+    ISSUE_269_DEATH_DELAY.with(|delay| delay.set(None));
+}
+
+fn issue_269_liveness_call_count() -> usize {
+    ISSUE_269_LIVENESS_CALLS.with(std::cell::Cell::get)
+}
+
+fn issue_269_empty_process_table() -> Result<Vec<String>, String> {
+    Ok(Vec::new())
+}
+
+fn issue_269_transient_liveness(pid: u32) -> bool {
+    if pid != ISSUE_269_ROOT_PID {
+        return false;
+    }
+    ISSUE_269_LIVENESS_CALLS.with(|calls| {
+        let call = calls.get();
+        calls.set(call + 1);
+        match call {
+            0 => {
+                ISSUE_269_FIRST_ALIVE.with(|first| *first.borrow_mut() = Some(std::time::Instant::now()));
+                true
+            }
+            1 => {
+                let elapsed = ISSUE_269_FIRST_ALIVE.with(|first| {
+                    first.borrow().as_ref().map(std::time::Instant::elapsed)
+                });
+                ISSUE_269_DEATH_DELAY.with(|delay| delay.set(elapsed));
+                false
+            }
+            _ => false,
+        }
+    })
+}
+
+fn issue_269_persistent_liveness(pid: u32) -> bool {
+    if pid == ISSUE_269_ROOT_PID {
+        ISSUE_269_LIVENESS_CALLS.with(|calls| calls.set(calls.get() + 1));
+        true
+    } else {
+        false
+    }
+}
+
+fn issue_269_already_gone_liveness(pid: u32) -> bool {
+    if pid == ISSUE_269_ROOT_PID {
+        ISSUE_269_LIVENESS_CALLS.with(|calls| calls.set(calls.get() + 1));
+    }
+    false
+}
+
+fn save_issue_269_root_state(workspace: &Path, session: &str) {
+    crate::state::persist::save_runtime_state(
+        workspace,
+        &json!({
+            "session_name": session,
+            "team_key": session,
+            "generation": session,
+            "agents": {
+                "worker": {
+                    "status": "running",
+                    "provider": "fake",
+                    "window": "worker",
+                    "provider_pid": ISSUE_269_ROOT_PID
+                }
+            }
+        }),
+    )
+    .unwrap();
+}
+
+fn shutdown_issue_269_with_probes(
+    workspace: &Path,
+    session: &str,
+    liveness: fn(u32) -> bool,
+) -> serde_json::Value {
+    let transport = CleanShutdownTransport::new().with_owned_session(
+        workspace,
+        session,
+        session,
+        session,
+    );
+    crate::cli::lifecycle_port::with_process_table_test_probe(
+        issue_269_empty_process_table,
+        || {
+            crate::cli::lifecycle_port::with_pid_liveness_test_probe(liveness, || {
+                crate::cli::lifecycle_port::shutdown_with_transport(
+                    workspace,
+                    true,
+                    None,
+                    &transport,
+                )
+                .expect("shutdown should complete")
+            })
+        },
+    )
+}
+
+#[test]
+fn issue269_transient_unmatched_root_converges_inside_grace() {
+    let workspace = tmp_shutdown_workspace("issue269-transient-root");
+    let _workspace_cleanup = ShutdownWorkspaceCleanup(workspace.clone());
+    let session = "team-issue269-transient";
+    save_issue_269_root_state(&workspace, session);
+    reset_issue_269_probe_state();
+
+    let started = std::time::Instant::now();
+    let out = shutdown_issue_269_with_probes(&workspace, session, issue_269_transient_liveness);
+    let elapsed = started.elapsed();
+    let calls = issue_269_liveness_call_count();
+    let death_delay = ISSUE_269_DEATH_DELAY.with(std::cell::Cell::get);
+
+    assert_eq!(
+        out["ok"],
+        json!(true),
+        "an absent final process-table row plus a root that dies during the bounded grace must converge; ppid=0/empty-command is only a conservative placeholder, not a measured identity: {out}"
+    );
+    assert_eq!(out["residuals"]["processes"], json!([]), "{out}");
+    assert!(calls >= 2, "the wait must observe both live and gone states; calls={calls}");
+    assert!(death_delay.is_some_and(|delay| delay <= std::time::Duration::from_millis(500)), "root did not disappear within the bounded grace: {death_delay:?}");
+    assert!(elapsed < std::time::Duration::from_secs(2), "shutdown exceeded the bounded wait: {elapsed:?}");
+}
+
+#[test]
+fn issue269_persistent_unmatched_root_remains_a_residual_after_grace() {
+    let workspace = tmp_shutdown_workspace("issue269-persistent-root");
+    let _workspace_cleanup = ShutdownWorkspaceCleanup(workspace.clone());
+    let session = "team-issue269-persistent";
+    save_issue_269_root_state(&workspace, session);
+    reset_issue_269_probe_state();
+
+    let started = std::time::Instant::now();
+    let out = shutdown_issue_269_with_probes(&workspace, session, issue_269_persistent_liveness);
+    let elapsed = started.elapsed();
+    let calls = issue_269_liveness_call_count();
+    let residuals = out["residuals"]["processes"].as_array().unwrap();
+
+    assert_eq!(out["ok"], json!(false), "a live root must not be filtered by placeholder fields: {out}");
+    assert_eq!(residuals.len(), 1, "{out}");
+    assert_eq!(residuals[0]["pid"], json!(ISSUE_269_ROOT_PID), "{out}");
+    assert_eq!(residuals[0]["ppid"], json!(0), "{out}");
+    assert_eq!(residuals[0]["command"], json!(""), "{out}");
+    assert!((2..=30).contains(&calls), "persistent-root polling must remain bounded; calls={calls}");
+    assert!(elapsed < std::time::Duration::from_secs(2), "shutdown exceeded the bounded wait: {elapsed:?}");
+}
+
+#[test]
+fn issue269_already_gone_root_returns_without_fixed_grace_sleep() {
+    let workspace = tmp_shutdown_workspace("issue269-already-gone-root");
+    let _workspace_cleanup = ShutdownWorkspaceCleanup(workspace.clone());
+    let session = "team-issue269-gone";
+    save_issue_269_root_state(&workspace, session);
+    reset_issue_269_probe_state();
+
+    let started = std::time::Instant::now();
+    let out = shutdown_issue_269_with_probes(&workspace, session, issue_269_already_gone_liveness);
+    let elapsed = started.elapsed();
+    let calls = issue_269_liveness_call_count();
+
+    assert_eq!(out["ok"], json!(true), "{out}");
+    assert_eq!(out["residuals"]["processes"], json!([]), "{out}");
+    assert!(calls >= 2, "the final verification path and wait path must both observe liveness; calls={calls}");
+    assert!(elapsed < std::time::Duration::from_millis(450), "already-gone roots must not incur a fixed grace sleep: {elapsed:?}");
+}