@team-agent/installer 0.5.7 → 0.5.9

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

@@ -38,7 +38,9 @@ use rusqlite::params;
             coordinator_running,
             undelivered_backlog,
         );
-        let agents = enrich_agents(state.get("agents"));
+        let session_name = state.get("session_name").cloned().unwrap_or(Value::Null);
+        let tmux_present = tmux_session_present(workspace, state, session_name.as_str());
+        let agents = enrich_agents(state.get("agents"), tmux_present);
         let tasks = state
             .get("tasks")
             .cloned()
@@ -47,7 +49,6 @@ use rusqlite::params;
             .get("leader_receiver")
             .cloned()
             .unwrap_or_else(|| json!({}));
-        let session_name = state.get("session_name").cloned().unwrap_or(Value::Null);
         let is_external_leader = crate::state::projection::state_is_external_leader(state);
         let leader_topology = if is_external_leader { "external" } else { "managed" };
         let leader_attach_command = if is_external_leader {
@@ -70,7 +71,6 @@ use rusqlite::params;
                 )
             })
         };
-        let tmux_present = tmux_session_present(workspace, state, session_name.as_str());
         let mut readiness_state = state.clone();
         if let Some(obj) = readiness_state.as_object_mut() {
             obj.insert("tmux_session_present".to_string(), serde_json::json!(tmux_present));
@@ -437,7 +437,7 @@ use rusqlite::params;
             .to_string()
     }
 
-    fn enrich_agents(agents: Option<&Value>) -> Value {
+    fn enrich_agents(agents: Option<&Value>, tmux_session_present: bool) -> Value {
         let Some(Value::Object(input)) = agents else {
             return json!({});
         };
@@ -450,6 +450,15 @@ use rusqlite::params;
                         "interacted".to_string(),
                         Value::String(interacted_marker(obj.get("first_send_at"))),
                     );
+                    if let Some(reason) =
+                        stale_reason_for_agent(&Value::Object(obj.clone()), tmux_session_present)
+                    {
+                        enriched.insert("stale".to_string(), Value::Bool(true));
+                        enriched.insert(
+                            "stale_reason".to_string(),
+                            Value::String(reason.to_string()),
+                        );
+                    }
                     out.insert(agent_id.clone(), Value::Object(enriched));
                 }
                 _ => {
@@ -460,6 +469,53 @@ use rusqlite::params;
         Value::Object(out)
     }
 
+    fn stale_reason_for_agent(agent: &Value, tmux_session_present: bool) -> Option<&'static str> {
+        let pane_dead = !tmux_session_present && agent_has_pane_fact(agent);
+        let process_dead =
+            agent_process_dead(agent) || (!tmux_session_present && agent_has_process_fact(agent));
+        match (pane_dead, process_dead) {
+            (true, true) => Some("both"),
+            (false, true) => Some("process_dead"),
+            (true, false) => Some("pane_dead"),
+            (false, false) => None,
+        }
+    }
+
+    fn agent_has_pane_fact(agent: &Value) -> bool {
+        ["pane_id", "window", "window_name"].iter().any(|key| {
+            agent
+                .get(*key)
+                .and_then(Value::as_str)
+                .is_some_and(|value| !value.is_empty())
+        })
+    }
+
+    fn agent_has_process_fact(agent: &Value) -> bool {
+        agent.get("pid").and_then(Value::as_i64).is_some()
+            || agent.get("process_started").and_then(Value::as_bool) == Some(true)
+            || agent.get("provider_process_dead").and_then(Value::as_bool).is_some()
+            || agent.get("process_liveness").and_then(Value::as_str).is_some()
+    }
+
+    fn agent_process_dead(agent: &Value) -> bool {
+        if agent.get("provider_process_dead").and_then(Value::as_bool) == Some(true) {
+            return true;
+        }
+        ["process_liveness", "worker_state"].iter().any(|key| {
+            agent
+                .get(*key)
+                .and_then(Value::as_str)
+                .is_some_and(is_dead_process_state)
+        })
+    }
+
+    fn is_dead_process_state(value: &str) -> bool {
+        matches!(
+            value,
+            "dead" | "missing" | "stopped" | "exited" | "terminated"
+        )
+    }
+
     fn interacted_marker(value: Option<&Value>) -> String {
         let Some(raw) = value.and_then(Value::as_str) else {
             return "never".to_string();
@@ -654,14 +710,20 @@ use rusqlite::params;
         limit: usize,
     ) -> Result<Value, CliError> {
         let limit = i64::try_from(limit).unwrap_or(i64::MAX);
+        // E6 (0.5.9 offline-mailbox §6.6): also surface `queued_until_leader_attach`
+        // rows (third-party sends into the leader mailbox) so the target owner can
+        // see them alongside the rebind-required failures. Channel wire label
+        // distinguishes the two so the operator can tell the two shapes apart.
         let sql = match owner_team_id {
             Some(_) => {
                 "select message_id, sender, status, error, created_at, delivery_attempts
                  from messages
                  where recipient = 'leader'
-                   and status = 'failed'
-                   and error = 'leader_not_attached'
                    and owner_team_id = ?1
+                   and (
+                     (status = 'failed' and error = 'leader_not_attached')
+                     or status = 'queued_until_leader_attach'
+                   )
                  order by created_at desc
                  limit ?2"
             }
@@ -669,8 +731,10 @@ use rusqlite::params;
                 "select message_id, sender, status, error, created_at, delivery_attempts
                  from messages
                  where recipient = 'leader'
-                   and status = 'failed'
-                   and error = 'leader_not_attached'
+                   and (
+                     (status = 'failed' and error = 'leader_not_attached')
+                     or status = 'queued_until_leader_attach'
+                   )
                  order by created_at desc
                  limit ?1"
             }
@@ -679,14 +743,20 @@ use rusqlite::params;
             .prepare(sql)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let map_row = |row: &rusqlite::Row<'_>| {
+            let status: String = row.get(2)?;
+            let channel = if status == "queued_until_leader_attach" {
+                "leader_mailbox"
+            } else {
+                "rebind_required"
+            };
             Ok(json!({
                 "message_id": row.get::<_, String>(0)?,
                 "sender": row.get::<_, Option<String>>(1)?,
-                "status": row.get::<_, String>(2)?,
+                "status": status,
                 "error": row.get::<_, Option<String>>(3)?,
                 "created_at": row.get::<_, Option<String>>(4)?,
                 "delivery_attempts": row.get::<_, i64>(5)?,
-                "channel": "rebind_required",
+                "channel": channel,
                 "action": "run team-agent attach-leader or team-agent takeover",
             }))
         };
@@ -846,7 +916,15 @@ use rusqlite::params;
         // 0.4.x Phase 1: add `worker_state` (canonical 5-state product
         // surface). `activity` is preserved alongside as the deprecated
         // legacy classifier output (CR R3 same-source contract).
-        for key in ["status", "provider", "worker_state", "activity", "last_output_at"] {
+        for key in [
+            "status",
+            "provider",
+            "worker_state",
+            "activity",
+            "last_output_at",
+            "stale",
+            "stale_reason",
+        ] {
             if let Some(value) = input.get(key) {
                 out.insert(key.to_string(), value.clone());
             }
@@ -964,10 +1042,35 @@ use rusqlite::params;
             );
             insert_optional_string(&mut item, "last_output_at", row.get(2).map_err(|e| CliError::Runtime(e.to_string()))?);
             insert_optional_i64(&mut item, "context_usage_pct", row.get(3).map_err(|e| CliError::Runtime(e.to_string()))?);
-            insert_optional_string(&mut item, "current_task_id", row.get(4).map_err(|e| CliError::Runtime(e.to_string()))?);
+            let current_task_id: Option<String> =
+                row.get(4).map_err(|e| CliError::Runtime(e.to_string()))?;
+            let has_current_task = current_task_id.is_some();
+            insert_optional_string(&mut item, "current_task_id", current_task_id);
+            let updated_at: String =
+                row.get(5).map_err(|e| CliError::Runtime(e.to_string()))?;
+            // Phase-DX E2 (plan §4 / CR supplement A): expose the last agent_health
+            // observation timestamp as `health_updated_at` alongside the legacy
+            // `updated_at` alias. Two names for one column keep old scrapers working
+            // while surfacing the semantic (heartbeat, not row bookkeeping).
+            item.insert("updated_at".to_string(), json!(updated_at.clone()));
+            item.insert("health_updated_at".to_string(), json!(updated_at));
+            // Phase-DX E2 (CR P0 red line #6, supplements A/B): current_task is a
+            // best-effort *display* field until A1 makes task FSM authoritative.
+            // The structured source/confidence markers stop downstream code from
+            // treating agent_health.current_task_id as authority. `current_task_source`
+            // records where the display value came from (only "health" today —
+            // Phase-DX never merges state tasks into this projection); the
+            // `current_task_confidence` enum stays "best_effort" for the whole
+            // Phase-DX slice (A1 will later flip it to "authoritative" when the
+            // task FSM lands). Field is written unconditionally so consumers can
+            // switch on it even when `current_task_id` is null.
+            item.insert(
+                "current_task_source".to_string(),
+                json!(if has_current_task { "health" } else { "none" }),
+            );
             item.insert(
-                "updated_at".to_string(),
-                json!(row.get::<_, String>(5).map_err(|e| CliError::Runtime(e.to_string()))?),
+                "current_task_confidence".to_string(),
+                json!("best_effort"),
             );
             insert_optional_string(&mut item, "owner_team_id", row.get(6).map_err(|e| CliError::Runtime(e.to_string()))?);
             out.insert(agent_id, Value::Object(item));

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

@@ -51,6 +51,7 @@ use super::*;
             message_id: None,
             pane: None,
             to_name: None,
+        to_leader: None,
         };
         let _ = cmd_send(&args);
 

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

@@ -159,6 +159,7 @@ fn named_send_args(
         message_id: None,
         pane: pane.map(str::to_string),
         to_name: to_name.map(str::to_string),
+        to_leader: None,
     }
 }
 
@@ -328,11 +329,16 @@ fn resolve_leader_name_not_live() {
         .with_targets(vec![pane("other", "codex", "%other")]);
 
     let err = resolve_name_with_transport(&ws, "alpha/leader", &transport).unwrap_err();
-    assert_eq!(err.kind, NamedAddressErrorKind::NameNotLive);
+    // 0.5.9 E6 taxonomy split: `--to-name <team>/leader` when the team
+    // exists but the leader receiver's pane is missing is now
+    // `leader_not_attached` (not the coarser `name_not_live`), so a
+    // third-party sender can be told what to do without being pushed
+    // toward `claim-leader`/`takeover` (owner-only actions).
+    assert_eq!(err.kind, NamedAddressErrorKind::LeaderNotAttached);
     let n38 = err.n38_message();
-    assert!(n38.contains("claim-leader"), "{n38}");
     assert!(n38.contains("attach-leader"), "{n38}");
-    assert!(n38.contains("takeover"), "{n38}");
+    assert!(!n38.contains("claim-leader"), "third-party copy must not suggest claim-leader: {n38}");
+    assert!(!n38.contains("takeover"), "third-party copy must not suggest takeover: {n38}");
     let _ = std::fs::remove_dir_all(&ws);
 }
 

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

@@ -448,6 +448,7 @@ use super::*;
             message_id: None,
             pane: None,
             to_name: None,
+        to_leader: None,
         }
     }
 

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

@@ -334,6 +334,11 @@ pub struct SendArgs {
     /// `target` / `targets` / `--pane`; resolves workspace/team/agent or leader
     /// name to the current live pane before using direct pane injection.
     pub to_name: Option<String>,
+    /// E7 (0.5.9 host-leader-registry-design): `--to-leader NAME` resolves
+    /// NAME through `~/.team-agent/leaders`, canonical-validates, and then
+    /// delegates to the E6 leader delivery path (live inject or offline
+    /// mailbox with `queued_until_leader_attach`).
+    pub to_leader: Option<String>,
 }
 
 /// E23 worker-side emergency fallback for `team_orchestrator.send_message`
@@ -617,6 +622,15 @@ pub struct SessionsArgs {
     pub team: Option<String>,
 }
 
+/// E7 (0.5.9 host-leader-registry-design §4.1): `team-agent leaders`
+/// enumerates the host discovery index and classifies each entry as
+/// LIVE, STALE, or AMBIGUOUS after re-validating against canonical
+/// workspace state.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LeadersArgs {
+    pub json: bool,
+}
+
 /// `validate [spec=team.spec.yaml] --json`(`parser.py:120`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ValidateArgs {

package/crates/team-agent/src/coordinator/tick.rs

@@ -2366,8 +2366,14 @@ fn write_agent_health(
         .get("context_usage_pct")
         .or_else(|| agent.get("context_usage_percent"))
         .and_then(Value::as_i64);
+    // Phase-DX E2: read the renamed `current_turn_message_id` (leader→worker turn
+    // proxy, written by delivery::arm_turn_open) with fallbacks to the legacy field
+    // names for backwards state compatibility. The SQL column stays `current_task_id`
+    // (agent_health schema) — a rename would require a DB migration, which Phase-DX
+    // forbids.
     let current_task_id = agent
-        .get("current_task_id")
+        .get("current_turn_message_id")
+        .or_else(|| agent.get("current_task_id"))
         .or_else(|| agent.get("task_id"))
         .and_then(Value::as_str);
     conn.execute(

package/crates/team-agent/src/db/agent_health_capture.rs

@@ -0,0 +1,96 @@
+//! Phase-DX E2: `agent_health` row capture/restore for the remove-agent flow.
+//!
+//! Extracted from `lifecycle/restart/remove.rs` so the SQL column reference to
+//! `current_task_id` sits in the persistence layer (whitelisted by the E2 grep
+//! guard) rather than in lifecycle policy code. Semantics are the golden Python
+//! `_capture_agent_health` / `_restore_agent_health` — a plain
+//! backup-across-delete that never treats the stored column as authoritative
+//! task state.
+
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+use std::path::Path;
+
+use crate::model::ids::AgentId;
+
+#[derive(Clone, Debug)]
+pub struct CapturedHealth {
+    pub owner_team_id: Option<String>,
+    pub status: Option<String>,
+    pub last_output_at: Option<String>,
+    pub context_usage_pct: Option<i64>,
+    pub current_task_id: Option<String>,
+}
+
+/// golden agents.py:185 `copy.deepcopy(store.agent_health().get(agent_id))` — read the row BEFORE
+/// delete so the rollback can re-upsert it. Returns the captured columns, or `None` if the row is
+/// absent.
+pub fn select_agent_health(
+    workspace: &Path,
+    agent_id: &AgentId,
+) -> Result<Option<CapturedHealth>, crate::db::DbError> {
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| crate::db::DbError::Schema(e.to_string()))?;
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    let row = conn
+        .query_row(
+            "select owner_team_id, status, last_output_at, context_usage_pct, current_task_id \
+             from agent_health where agent_id = ?1",
+            [agent_id.as_str()],
+            |r| {
+                Ok(CapturedHealth {
+                    owner_team_id: r.get::<_, Option<String>>(0)?,
+                    status: r.get::<_, Option<String>>(1)?,
+                    last_output_at: r.get::<_, Option<String>>(2)?,
+                    context_usage_pct: r.get::<_, Option<i64>>(3)?,
+                    current_task_id: r.get::<_, Option<String>>(4)?,
+                })
+            },
+        )
+        .ok();
+    Ok(row)
+}
+
+/// golden agents.py:268-278 `_restore_agent_health`: re-upsert the captured row (status||"IDLE"),
+/// or delete the row when there was nothing to restore.
+pub fn restore_agent_health(
+    workspace: &Path,
+    agent_id: &AgentId,
+    row: &Option<CapturedHealth>,
+) -> Result<(), crate::db::DbError> {
+    let Some(row) = row else {
+        return delete_agent_health(workspace, agent_id);
+    };
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| crate::db::DbError::Schema(e.to_string()))?;
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    let status = row.status.clone().unwrap_or_else(|| "IDLE".to_string());
+    let now = chrono::Utc::now()
+        .format("%Y-%m-%dT%H:%M:%S%.6f+00:00")
+        .to_string();
+    conn.execute(
+        "insert into agent_health (owner_team_id, agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at) \
+         values (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+        rusqlite::params![
+            row.owner_team_id,
+            agent_id.as_str(),
+            status,
+            row.last_output_at,
+            row.context_usage_pct,
+            row.current_task_id,
+            now,
+        ],
+    )?;
+    Ok(())
+}
+
+fn delete_agent_health(workspace: &Path, agent_id: &AgentId) -> Result<(), crate::db::DbError> {
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| crate::db::DbError::Schema(e.to_string()))?;
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    conn.execute(
+        "delete from agent_health where agent_id = ?1",
+        [agent_id.as_str()],
+    )?;
+    Ok(())
+}

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

@@ -9,6 +9,7 @@
 //! §10:db 层无 unwrap/expect/panic;rusqlite 错误经 [`DbError`] 传播。
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
+pub mod agent_health_capture;
 pub mod message_store;
 pub mod migration;
 pub mod schema;

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

@@ -81,6 +81,7 @@ pub mod lease;
 pub mod owner_bind;
 pub mod provider_attribution;
 pub mod rediscover;
+pub mod registry;
 pub mod start;
 pub mod takeover;
 pub mod types;