@team-agent/installer 0.5.75 → 0.5.78

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

@@ -60,19 +60,23 @@ pub(super) fn compact_not_ready(full: &Value) -> Value {
         })
         .unwrap_or_default();
     let mut obj = Map::new();
-    let channel_unbound = reasons
-        .iter()
-        .any(|reason| reason == "leader_receiver_unbound");
     obj.insert(
         "reasons".to_string(),
         Value::Array(reasons.into_iter().map(Value::String).collect()),
     );
     obj.insert("agents".to_string(), Value::Array(agents));
-    if channel_unbound {
-        obj.insert(
-            "next_action".to_string(),
-            Value::String("claim-leader".to_string()),
-        );
+    if let Some(next_action) = full
+        .pointer("/readiness/next_action")
+        .and_then(Value::as_str)
+    {
+        let truly_unbound = full.pointer("/readiness/state").and_then(Value::as_str)
+            == Some("leader_receiver_unbound");
+        if !next_action.contains("claim-leader") || truly_unbound {
+            obj.insert(
+                "next_action".to_string(),
+                Value::String(next_action.to_string()),
+            );
+        }
     }
     Value::Object(obj)
 }

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

@@ -95,18 +95,21 @@ impl RuntimeSnapshot {
             .filter(|team| !team.is_empty())
             .map(str::to_string)
             .unwrap_or_else(|| crate::state::projection::team_state_key(state));
-        if !team_key.is_empty()
-            && !crate::lifecycle::launch::launched_team_receiver_is_attached(workspace, &team_key)
-        {
-            if let Some(object) = readiness.as_object_mut() {
-                object.insert("all_attached_receiver".to_string(), json!(false));
-                object.insert("ready".to_string(), json!(false));
-                object.insert("state".to_string(), json!("leader_receiver_unbound"));
-                object.insert("next_action".to_string(), json!("claim-leader"));
-                object.insert(
-                    "reason".to_string(),
-                    json!("leader registry does not authorize this workspace"),
-                );
+        if !team_key.is_empty() {
+            let class = crate::lifecycle::launch::classify_leader_binding(workspace, &team_key);
+            if class != crate::lifecycle::launch::LeaderBindingClass::Attached {
+                if let Some(object) = readiness.as_object_mut() {
+                    object.insert("all_attached_receiver".to_string(), json!(false));
+                    object.insert("ready".to_string(), json!(false));
+                    object.insert("state".to_string(), json!(class.issue_id()));
+                    object.insert("reason".to_string(), json!(class.issue_id()));
+                    if class == crate::lifecycle::launch::LeaderBindingClass::Unbound {
+                        object.insert(
+                            "next_action".to_string(),
+                            json!(class.repair()),
+                        );
+                    }
+                }
             }
         }
         let grok_slot = crate::cli::grok_slot_report(workspace, state).to_json();

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

@@ -230,7 +230,7 @@ pub(super) fn pending_leader_notifications(
             "created_at": row.get::<_, Option<String>>(4)?,
             "delivery_attempts": row.get::<_, i64>(5)?,
             "channel": channel,
-            "action": "run team-agent attach-leader or team-agent takeover",
+            "action": "historical leader mailbox debt; not proof of current unbound owner",
         }))
     };
     let rows = match owner_team_id {

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

@@ -34,6 +34,14 @@ use store::{
 mod compact;
 pub(super) use compact::*;
 
+mod brief;
+pub(crate) use brief::{format_status_brief, registered_agent_exists, status_brief_scoped};
+#[cfg(test)]
+pub(crate) use brief::{
+    with_test_nodeprobe, with_test_nodeprobe_candidates, with_test_nodeprobe_resolver_delay,
+    with_test_nodeprobe_unbound, ResolverDelaySignal,
+};
+
 mod runtime;
 pub(super) use runtime::*;
 

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

@@ -90,6 +90,44 @@ fn seed_self_signed_attached_leader(ws: &std::path::Path) {
     .unwrap();
 }
 
+fn seed_canonical_healthy_leader(ws: &std::path::Path, endpoint: &str) {
+    crate::state::persist::save_runtime_state(
+        ws,
+        &json!({
+            "team_key": "current",
+            "workspace": ws,
+            "teams": {
+                "current": {
+                    "team_owner": {
+                        "pane_id": "%1",
+                        "owner_epoch": 1,
+                        "provider": "codex"
+                    },
+                    "leader_receiver": {
+                        "mode": "direct_tmux",
+                        "status": "attached",
+                        "pane_id": "%1",
+                        "owner_epoch": 1,
+                        "provider": "codex",
+                        "tmux_socket": endpoint
+                    }
+                }
+            }
+        }),
+    )
+    .unwrap();
+    assert_eq!(
+        crate::leader::registry::register_binding_from_state_best_effort(
+            ws,
+            Some("current"),
+            "diagnose-healthy-fixture",
+        )
+        .as_ref()
+        .map(|outcome| outcome.status),
+        Some("registered")
+    );
+}
+
 fn seed_leader_registry_entry(ws: &std::path::Path) {
     let entry = crate::leader::registry::build_entry(
         ws,
@@ -345,17 +383,33 @@ fn dispatch_routes_diagnose_healthy_leader() {
     ]);
     let _home = IsolatedHome::enter("diagnose-healthy");
     let ws = tmp_workspace();
-    seed_self_signed_attached_leader(&ws);
-    seed_leader_registry_entry(&ws);
-    let code = run(
-        &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
+    let endpoint = "/tmp/ta-diagnose-healthy.sock";
+    seed_canonical_healthy_leader(&ws, endpoint);
+    let transport = crate::transport::test_support::OfflineTransport::default()
+        .with_tmux_endpoint(endpoint)
+        .with_targets(vec![crate::transport::PaneInfo {
+            pane_id: crate::transport::PaneId::new("%1"),
+            session: crate::transport::SessionName::new("s"),
+            window_index: None,
+            window_name: None,
+            pane_index: None,
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: Some(ws.clone()),
+            active: true,
+            pane_pid: None,
+            leader_env: Default::default(),
+        }]);
+    let code = crate::transport_factory::with_leader_endpoint_transport(endpoint, transport, || {
+        run(
+            &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
+            &ws,
+        )
+    });
     assert_eq!(
         code,
         ExitCode::Ok,
-        "`diagnose` must be Ok when state.json looks attached AND ~/.team-agent/leaders/ \
-         has a matching attached row; got {code:?}"
+        "`diagnose` must be Ok when canonical owner/receiver, production registry, and live align; got {code:?}"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

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

@@ -133,6 +133,7 @@ mod named_address;
 mod peer_allow;
 mod run_delegation;
 mod shutdown_kill_plan;
+mod status_brief;
 mod status_send;
 mod verb_install_skill;
 mod verb_profile;

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

@@ -234,6 +234,76 @@ fn resolve_name_team_disambiguated() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn resolve_qualified_name_prefers_unique_state_pane_over_same_window_idle_pane() {
+    let ws = named_ws("qualified-state-pane-disambiguation");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "team-a": worker_team("team-a", "qa", "%worker", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new().with_targets(vec![
+        pane("team-a", "qa", "%worker"),
+        pane("team-a", "qa", "%idle"),
+    ]);
+
+    let resolved = resolve_name_with_transport(
+        &ws,
+        &format!("{}::team-a/qa", ws.display()),
+        &transport,
+    )
+    .expect("a qualified worker address should use its unique state pane");
+    assert_eq!(resolved.pane_id, "%worker");
+    assert_eq!(resolved.state_pane_id.as_deref(), Some("%worker"));
+    assert!(!resolved.state_pane_stale);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_qualified_name_state_pane_must_uniquely_match_scoped_candidates() {
+    for scenario in ["missing", "stale", "cross-session", "duplicate"] {
+        let ws = named_ws(&format!("qualified-state-pane-{scenario}"));
+        let mut team = worker_team("team-a", "qa", "%worker", "qa");
+        let targets = match scenario {
+            "missing" => {
+                team["agents"]["qa"]
+                    .as_object_mut()
+                    .unwrap()
+                    .remove("pane_id");
+                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+            }
+            "stale" => {
+                team["agents"]["qa"]["pane_id"] = json!("%stale");
+                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+            }
+            "cross-session" => vec![
+                pane("old-team-a", "qa", "%worker"),
+                pane("team-a", "qa", "%current-one"),
+                pane("team-a", "qa", "%current-two"),
+            ],
+            "duplicate" => {
+                team["agents"]["qa"]["pane_id"] = json!("%duplicate");
+                vec![
+                    pane("team-a", "qa", "%duplicate"),
+                    pane("team-a", "qa", "%duplicate"),
+                ]
+            }
+            _ => unreachable!(),
+        };
+        seed_state(&ws, state_with_teams(json!({"team-a": team})));
+        let transport = OfflineTransport::new().with_targets(targets);
+        let err = resolve_name_with_transport(
+            &ws,
+            &format!("{}::team-a/qa", ws.display()),
+            &transport,
+        )
+        .expect_err("non-unique state pane evidence must remain fail-closed");
+        assert_eq!(err.kind, NamedAddressErrorKind::NameAmbiguous, "{scenario}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+}
+
 #[test]
 fn resolve_qualified_name_canonicalizes_legacy_session_alias() {
     let ws = named_ws("legacy-session-alias");

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

@@ -335,13 +335,12 @@ fn cli_add_agent_duplicate_id_surfaces_real_error() {
         );
 }
 
-// 5 [P1] — cmd_status --json reflects the REAL coordinator_health + real DB message/result counts.
-// The placeholder status_port::status hardcodes coordinator={status:stopped, schema_ok:false} and
-// messages/results={count:0}. Seed: state.json + a real team.db (2 messages + 1 result) + a healthy
-// coordinator (this pid + metadata) -> the real path must surface running-coordinator + non-zero
-// counts. OS-safe (all reads/seeds, no spawn).
+// 5 [P1] — cmd_status --json emits the concise seven-field node projection.
+// Status must not leak coordinator/db/history diagnostics; missing exact nodeprobe evidence remains
+// an explicit unknown projection. The fixture still seeds a real store to ensure the status path
+// does not accidentally depend on coordinator or mailbox reads.
 #[test]
-fn cli_status_reflects_real_coordinator_health_and_db_counts() {
+fn cli_status_emits_seven_field_brief_without_diagnostics() {
     let ws = seed_status_workspace(); // writes .team/runtime/state.json
     let store = crate::message_store::MessageStore::open(&ws).unwrap();
     let _ = store
@@ -386,25 +385,31 @@ fn cli_status_reflects_real_coordinator_health_and_db_counts() {
         CmdOutput::Json(v) => v,
         other => panic!("status --json must yield a Json CmdOutput; got {other:?}"),
     };
-    assert_ne!(
-        value["coordinator"],
-        json!({"status": "stopped", "schema_ok": false}),
-        "status `coordinator` must reflect the REAL coordinator_health (seeded running), not the \
-             placeholder's hardcoded {{status:stopped, schema_ok:false}}; got {}",
-        value["coordinator"]
+    let nodes = value
+        .get("nodes")
+        .and_then(serde_json::Value::as_array)
+        .expect("status brief must expose a nodes array");
+    assert_eq!(nodes.len(), 1);
+    let fields: std::collections::BTreeSet<&str> = nodes[0]
+        .as_object()
+        .expect("status brief node must be an object")
+        .keys()
+        .map(String::as_str)
+        .collect();
+    assert_eq!(
+        fields,
+        [
+            "name",
+            "provider",
+            "runtime_status",
+            "activity",
+            "health",
+            "session_name",
+            "tmux_command",
+        ]
+        .into_iter()
+        .collect()
     );
-    assert_ne!(
-            value["messages"],
-            json!({"count": 0}),
-            "status `messages` must reflect the REAL DB rows (2 seeded), not the placeholder's {{count:0}}; got {}",
-            value["messages"]
-        );
-    assert_ne!(
-            value["results"],
-            json!({"count": 0}),
-            "status `results` must reflect the REAL DB result row, not the placeholder's {{count:0}}; got {}",
-            value["results"]
-        );
 }
 
 // 6 [P1] — cmd_shutdown delegates to the REAL crate::coordinator::stop_coordinator (+ tmux