@team-agent/installer 0.5.7 → 0.5.8

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.7"
+version = "0.5.8"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.7"
+version = "0.5.8"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -18,28 +18,34 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
             Ok(true) => {}
             Ok(false) => {
                 issues.push(json!("tmux_session_missing"));
-                repairs.push(json!({
-                    "issue": "tmux_session_missing",
-                    "action": format!("restart or relaunch tmux session `{session_name}`"),
-                }));
+                repairs.push(recovery_hint(
+                    session_name,
+                    "tmux_session_missing",
+                    "team-agent restart",
+                ));
             }
             Err(error) => {
                 issues.push(json!("tmux_session_missing"));
-                repairs.push(json!({
-                    "issue": "tmux_session_missing",
-                    "action": format!("restart or relaunch tmux session `{session_name}`"),
-                    "reason": error.to_string(),
-                }));
+                let mut hint =
+                    recovery_hint(session_name, "tmux_session_missing", "team-agent restart");
+                if let Some(obj) = hint.as_object_mut() {
+                    obj.insert("reason".to_string(), Value::String(error.to_string()));
+                }
+                repairs.push(hint);
             }
         }
     }
 
     if !leader_receiver_attached(state) {
         issues.push(json!("leader_not_attached"));
-        repairs.push(json!({
-            "issue": "leader_not_attached",
-            "action": "attach or claim a leader receiver before sending work",
-        }));
+        repairs.push(recovery_hint(
+            state
+                .get("session_name")
+                .and_then(Value::as_str)
+                .unwrap_or("unknown"),
+            "leader_not_attached",
+            "team-agent attach-leader",
+        ));
     } else {
         // 0.4.x (CR R2 P0): leader provider health reconciliation. The
         // leader_receiver may be marked `attached` (pane addressable) but the
@@ -57,6 +63,11 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
                     issues.push(json!("leader_provider_exited"));
                     repairs.push(json!({
                         "issue": "leader_provider_exited",
+                        "action_required": true,
+                        "advisory": true,
+                        "broken_class": "leader_provider_exited",
+                        "hint_action": "team-agent restart",
+                        "dedupe_key": "leader_provider_exited",
                         "action": format!(
                             "leader pane fell back to shell — provider `{provider_label}` exited; \
                              relaunch with `team-agent {provider_label}` to restart the provider"
@@ -65,10 +76,14 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
                 }
                 crate::leader::LeaderProviderHealth::Unreachable => {
                     issues.push(json!("leader_provider_unreachable"));
-                    repairs.push(json!({
-                        "issue": "leader_provider_unreachable",
-                        "action": "leader pane is dead — relaunch the leader",
-                    }));
+                    repairs.push(recovery_hint(
+                        state
+                            .get("session_name")
+                            .and_then(Value::as_str)
+                            .unwrap_or("unknown"),
+                        "leader_provider_unreachable",
+                        "team-agent claim-leader",
+                    ));
                 }
                 crate::leader::LeaderProviderHealth::Alive => {}
             }
@@ -179,6 +194,20 @@ fn leader_receiver_attached(state: &Value) -> bool {
     mode_direct && status_attached && pane_present
 }
 
+fn recovery_hint(team: &str, broken_class: &str, hint_action: &str) -> Value {
+    json!({
+        "issue": broken_class,
+        "action_required": true,
+        "advisory": true,
+        "broken_class": broken_class,
+        "hint_action": hint_action,
+        "dedupe_key": format!("{team}:{broken_class}"),
+        "action": format!(
+            "{hint_action} # alternatives: team-agent restart; team-agent claim-leader; team-agent quick-start; team-agent attach-leader"
+        ),
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -531,6 +531,55 @@ fn resolve_bare_agent(
     }
 }
 
+/// Phase-DX E3 (plan §4 / CR supplements A/B/C, P0 red lines #1 & #6):
+/// build advisory diagnostic candidates for a failed `--to-name leader`
+/// resolution. The candidate list is deliberately shaped to be **read by
+/// humans**, not consumed as route authority: every entry carries
+/// `advisory: true` and a `source` tag identifying where it was observed.
+///
+/// Candidate source rules:
+/// - The transport passed in is already scoped by [`transport_for_cli_target`]
+///   to the team's recorded `leader_receiver.tmux_socket` (or the workspace
+///   default when no socket was recorded), so `transport.list_targets()`
+///   enumerates only that endpoint. We do NOT scan other tmux sockets or
+///   fall back to reverse-authority tmux-session discovery.
+/// - `pane_id` fields are copied verbatim from `list_targets`. `session` is
+///   the tmux session, and `socket` records the tmux endpoint the candidate
+///   was seen on (whichever the scoped transport reports).
+///
+/// Callers must never treat any candidate as authoritative; MUST-NOT-12 stays
+/// intact — resolver refusal is still the outcome even when candidates fire.
+fn leader_advisory_candidates(
+    state: &Value,
+    team: &str,
+    transport: &dyn Transport,
+    source: &str,
+) -> Vec<Value> {
+    let socket = team_entry(state, team)
+        .and_then(|entry| entry.get("leader_receiver"))
+        .or_else(|| state.get("leader_receiver"))
+        .and_then(|receiver| string_field(receiver, "tmux_socket"))
+        .map(str::to_string)
+        .or_else(|| transport.tmux_endpoint());
+    let targets = match transport.list_targets() {
+        Ok(targets) => targets,
+        Err(_) => return Vec::new(),
+    };
+    targets
+        .into_iter()
+        .map(|pane| {
+            json!({
+                "pane_id": pane.pane_id.as_str(),
+                "session": pane.session.as_str(),
+                "window": pane.window_name.as_ref().map(|w| w.as_str()),
+                "socket": socket,
+                "source": source,
+                "advisory": json!(true),
+            })
+        })
+        .collect()
+}
+
 fn resolve_leader(
     sender_workspace: &Path,
     target_workspace: &Path,
@@ -544,7 +593,12 @@ fn resolve_leader(
     } else {
         state.get("leader_receiver")
     }
-    .ok_or_else(|| name_not_live_leader(team, None, None, None, transport.tmux_endpoint()))?;
+    .ok_or_else(|| {
+        let mut err = name_not_live_leader(team, None, None, None, transport.tmux_endpoint());
+        err.candidates =
+            leader_advisory_candidates(state, team, transport, "state_recorded_socket");
+        err
+    })?;
     if let Some((mode, transport_kind)) = receiver_transport_conflict(receiver) {
         let mut err = NamedAddressError::new(
             NamedAddressErrorKind::NameNotLive,
@@ -569,7 +623,13 @@ fn resolve_leader(
     }
     let pane_id = string_field(receiver, "pane_id")
         .filter(|pane| !pane.is_empty())
-        .ok_or_else(|| name_not_live_leader(team, None, None, None, transport.tmux_endpoint()))?;
+        .ok_or_else(|| {
+            let mut err =
+                name_not_live_leader(team, None, None, None, transport.tmux_endpoint());
+            err.candidates =
+                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
+            err
+        })?;
     let session = string_field(receiver, "session_name");
     let window = string_field(receiver, "window_name");
     let socket = string_field(receiver, "tmux_socket")
@@ -599,13 +659,13 @@ fn resolve_leader(
             agent_status: None,
             warning: None,
         }),
-        0 => Err(name_not_live_leader(
-            team,
-            Some(pane_id),
-            session,
-            window,
-            socket,
-        )),
+        0 => {
+            let mut err =
+                name_not_live_leader(team, Some(pane_id), session, window, socket);
+            err.candidates =
+                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
+            Err(err)
+        }
         _ => Err(name_ambiguous(
             "multiple live panes matched leader_receiver pane id",
             matches

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();
@@ -846,7 +902,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 +1028,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/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/lifecycle/restart/remove.rs

@@ -670,78 +670,30 @@ fn delete_agent_health(workspace: &Path, agent_id: &AgentId) -> Result<bool, Lif
     Ok(changed > 0)
 }
 
-/// 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 health columns, or None if absent.
+// Phase-DX E2: `select_agent_health` / `restore_agent_health` / `CapturedHealth` moved to
+// `db::agent_health_capture` so the SQL column references (agent_health backup columns)
+// live in the persistence layer (whitelisted by the E2 grep guard) rather than lifecycle
+// policy code. The wrappers below preserve the existing `LifecycleError` surface.
+use crate::db::agent_health_capture::{
+    restore_agent_health as capture_restore_agent_health,
+    select_agent_health as capture_select_agent_health, CapturedHealth,
+};
+
 fn select_agent_health(
     workspace: &Path,
     agent_id: &AgentId,
 ) -> Result<Option<CapturedHealth>, LifecycleError> {
-    let store = crate::message_store::MessageStore::open(workspace)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let conn = crate::db::schema::open_db(store.db_path())
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    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)
+    capture_select_agent_health(workspace, agent_id)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
-/// 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.
 fn restore_agent_health(
     workspace: &Path,
     agent_id: &AgentId,
     row: &Option<CapturedHealth>,
 ) -> Result<(), LifecycleError> {
-    let Some(row) = row else {
-        delete_agent_health(workspace, agent_id)?;
-        return Ok(());
-    };
-    let store = crate::message_store::MessageStore::open(workspace)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let conn = crate::db::schema::open_db(store.db_path())
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    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();
-    // The restore always follows a delete of this row, so a plain insert re-materializes the captured
-    // health (golden _restore_agent_health re-upserts status||"IDLE" + the captured columns).
-    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,
-        ],
-    )
-    .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    Ok(())
-}
-
-#[derive(Clone)]
-struct CapturedHealth {
-    owner_team_id: Option<String>,
-    status: Option<String>,
-    last_output_at: Option<String>,
-    context_usage_pct: Option<i64>,
-    current_task_id: Option<String>,
+    capture_restore_agent_health(workspace, agent_id, row)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
 fn maybe_fail_remove_after_agent_health_delete() -> Result<(), LifecycleError> {

package/crates/team-agent/src/mcp_server/helpers.rs

@@ -336,10 +336,27 @@ fn current_turn_id_from_state(state: &Value, agent_id: &str) -> Option<String> {
             }
         }
     }
+    // Phase-DX E2: read the renamed `current_turn_message_id` (leader→worker turn
+    // proxy from `delivery::arm_turn_open`). Legacy state written by 0.5.x may
+    // still carry the pre-rename JSON key; the fallback keeps current-turn
+    // attribution stable during the transition. Neither field is treated as
+    // authoritative task state — that stays A1 territory (task FSM).
+    //
+    // The next line reads the pre-rename JSON key verbatim; that is deliberate
+    // and marked so the E2 grep guard admits it as a documented exception. The
+    // marker distinguishes a legitimate read-only backwards-compat bridge from
+    // an authority-consuming read (which the guard still forbids). Delete this
+    // fallback and its marker when the A1 task FSM lands (task attribution
+    // becomes authoritative and legacy state layouts are no longer produced).
+    let legacy_field = "current_task_id"; // ALLOWED-LEGACY-READ: backward-compat bridge for pre-rename key
     state
         .get("agents")
         .and_then(|agents| agents.get(agent_id))
-        .and_then(|agent| agent.get("current_task_id"))
+        .and_then(|agent| {
+            agent
+                .get("current_turn_message_id")
+                .or_else(|| agent.get(legacy_field))
+        })
         .and_then(Value::as_str)
         .and_then(non_empty_string)
         .map(ToString::to_string)

package/crates/team-agent/src/mcp_server/tests/send.rs

@@ -112,29 +112,43 @@ fn send_outcome_direct_renders_compact_body() {
 // ════════════════════════════════════════════════════════════════════════
 // CONTROL-PLANE: send_message worker recipient → WorkerAccepted (tools.py:135-183)
 // ════════════════════════════════════════════════════════════════════════
-#[test]
-fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
-    // A worker recipient w/ a delivered message_id → async accepted carrying the
-    // byte-stable poll hint. Identity anchored on injected env (no candidate scan).
-    // golden: a leader WITH owner_team_id on an unseeded ws would hit the C23 cross-team
-    // refusal first (worker-1 not in visible peers) -> PeerNotInScope. owner_team_id=None
-    // (legacy single-team) bypasses that, isolating the worker-recipient accepted path.
-    // The cross-team refusal has its own tests (refuse_cross_team_peer_* / send_message_cross_team_*).
-    // A-7: the accepted path needs a REAL stored message_id (tools.py:175-181 —
-    // fabricated ids are gone), so the workspace seeds a running worker-1 the
-    // delivery layer can actually queue for.
-    let ws = unique_ws("send-worker");
+fn seed_current_worker_state(tag: &str) -> std::path::PathBuf {
+    let ws = unique_ws(tag);
     crate::state::persist::save_runtime_state(
         &ws,
         &serde_json::json!({
             "session_name": "team-x",
+            "active_team_key": "current",
             "agents": {
                 "worker-1": {"status": "running", "agent_id": "worker-1", "window": "worker-1"},
             },
+            "teams": {
+                "current": {
+                    "status": "alive",
+                    "agents": {
+                        "worker-1": {"status": "running", "agent_id": "worker-1", "window": "worker-1"},
+                    },
+                },
+            },
         }),
     )
     .unwrap();
-    let tools = TeamOrchestratorTools::with_identity(&ws, Some(AgentId::new("leader")), None);
+    ws
+}
+
+#[test]
+fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
+    // A worker recipient w/ a delivered message_id → async accepted carrying the
+    // byte-stable poll hint. Identity anchored on injected env (no candidate scan).
+    // A-7: the accepted path needs a REAL stored message_id (tools.py:175-181 —
+    // fabricated ids are gone), so the workspace seeds a running worker-1 the
+    // delivery layer can actually queue for.
+    let ws = seed_current_worker_state("send-worker");
+    let tools = TeamOrchestratorTools::with_identity(
+        &ws,
+        Some(AgentId::new("leader")),
+        Some(TeamKey::new("current")),
+    );
     let outcome = tools.send_message(
         &MessageTarget::Single("worker-1".to_string()),
         "do the thing",
@@ -155,6 +169,104 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
     }
 }
 
+#[test]
+fn ordinary_send_assign_shape_has_no_recovery_marker() {
+    let ws = seed_current_worker_state("ordinary-no-recovery");
+    let tools = TeamOrchestratorTools::with_identity(
+        &ws,
+        Some(AgentId::new("leader")),
+        Some(TeamKey::new("current")),
+    );
+
+    let sent = tools
+        .send_message(
+            &MessageTarget::Single("worker-1".to_string()),
+            "ordinary send",
+            None,
+            None,
+            None,
+            None,
+        )
+        .expect("ordinary send ok")
+        .to_value();
+    assert!(
+        !sent.as_object().unwrap().contains_key("recovery"),
+        "ordinary send must not carry recovery marker: {sent}"
+    );
+    assert!(
+        sent.get("acceptance_marker").is_none(),
+        "ordinary send must not carry acceptance marker: {sent}"
+    );
+
+    let assigned = tools
+        .assign_task(
+            &json!({"id": "ordinary-task", "assignee": "worker-1", "title": "ordinary"}),
+            None,
+        )
+        .expect("ordinary assign ok");
+    let assigned_value = serde_json::to_value(&assigned).expect("serialize ordinary assign");
+    assert!(
+        !assigned_value.as_object().unwrap().contains_key("recovery"),
+        "ordinary assign must not carry recovery marker: {assigned_value}"
+    );
+    assert!(
+        assigned_value.get("acceptance_marker").is_none(),
+        "ordinary assign must not carry acceptance marker: {assigned_value}"
+    );
+
+    let recovery_false_assigned = tools
+        .assign_task(
+            &json!({
+                "id": "ordinary-recovery-false-task",
+                "assignee": "worker-1",
+                "title": "ordinary recovery false",
+                "recovery": false,
+            }),
+            None,
+        )
+        .expect("recovery=false assign ok");
+    let recovery_false_value =
+        serde_json::to_value(&recovery_false_assigned).expect("serialize recovery=false assign");
+    assert!(
+        !recovery_false_value
+            .as_object()
+            .unwrap()
+            .contains_key("recovery"),
+        "recovery=false assign must not carry recovery marker: {recovery_false_value}"
+    );
+    assert!(
+        recovery_false_value.get("acceptance_marker").is_none(),
+        "recovery=false assign must not carry acceptance marker: {recovery_false_value}"
+    );
+}
+
+#[test]
+fn recovery_assign_shape_has_structured_marker() {
+    let ws = seed_current_worker_state("recovery-marker");
+    let tools = TeamOrchestratorTools::with_identity(
+        &ws,
+        Some(AgentId::new("leader")),
+        Some(TeamKey::new("current")),
+    );
+
+    let assigned = tools
+        .assign_task(
+            &json!({
+                "id": "recovery-task",
+                "assignee": "worker-1",
+                "title": "recover",
+                "recovery": true,
+            }),
+            None,
+        )
+        .expect("recovery assign ok");
+    assert_eq!(assigned.fields.get("recovery"), Some(&json!(true)));
+    assert_eq!(
+        assigned.fields.get("acceptance_marker"),
+        Some(&json!("recovery"))
+    );
+}
+
 #[test]
 fn send_message_worker_recipient_surfaces_dead_coordinator_warning() {
     let ws = unique_ws("send-worker-dead-coord");

package/crates/team-agent/src/mcp_server/tools.rs

@@ -116,6 +116,7 @@ impl TeamOrchestratorTools {
         };
 
         let task_value = Value::Object(task_obj.clone());
+        let recovery = task_recovery_marker(&task_value);
         let mut state = load_runtime_state(&self.workspace).map_err(tool_runtime_error)?;
         ensure_object(&mut state);
         let team_key = self
@@ -139,7 +140,16 @@ impl TeamOrchestratorTools {
             None,
             None,
         )?;
-        compact_tool_result(&out.to_value())
+        let mut ok = compact_tool_result(&out.to_value())?;
+        if recovery {
+            ok.fields
+                .insert("recovery".to_string(), serde_json::json!(true));
+            ok.fields.insert(
+                "acceptance_marker".to_string(),
+                Value::String("recovery".to_string()),
+            );
+        }
+        Ok(ok)
     }
 
     /// `send_message` (`tools.py:135-183`): C14/C15/C17 scope resolution.
@@ -989,6 +999,11 @@ fn assignment_message(task: &Value, explicit: Option<&str>) -> String {
     json_dumps_default(task)
 }
 
+fn task_recovery_marker(task: &Value) -> bool {
+    task.get("recovery").and_then(Value::as_bool) == Some(true)
+        || task.get("acceptance_marker").and_then(Value::as_str) == Some("recovery")
+}
+
 fn scope_override_name(scope: Scope) -> Option<&'static str> {
     match scope {
         Scope::Team => Some("team"),

package/crates/team-agent/src/messaging/delivery.rs

@@ -1981,12 +1981,19 @@ fn arm_turn_open(state: &mut serde_json::Value, recipient: &str, message_id: &Op
         .and_then(|agents| agents.get_mut(recipient))
         .and_then(serde_json::Value::as_object_mut)
     {
-        agent.insert(
-            "current_task_id".to_string(),
-            message_id.as_ref().map_or(serde_json::Value::Null, |id| {
+        // Phase-DX E2 (CR P0 red line #5): the leader→worker turn message id.
+        // Renamed from a misleading legacy field name (which was never a task
+        // FSM id — task FSM is A1) to `current_turn_message_id`, matching its
+        // actual semantic. Reader compatibility lives in `coordinator/tick.rs`
+        // (whitelisted for the transition) and `mcp_server/helpers.rs`; other
+        // messaging/lifecycle/mcp_server code MUST NOT treat this as
+        // authoritative task state.
+        let field = message_id
+            .as_ref()
+            .map_or(serde_json::Value::Null, |id| {
                 serde_json::Value::String(id.clone())
-            }),
-        );
+            });
+        agent.insert("current_turn_message_id".to_string(), field);
     }
 }
 

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1581,10 +1581,15 @@ fn deliver_pending_submit_unverified_is_not_saved_by_readback() {
         Some(&serde_json::json!(message_id)),
         "current-turn fact is armed immediately after physical inject succeeds"
     );
+    // Phase-DX E2 rename: the leader→worker turn message id lives under
+    // `current_turn_message_id` (the previous name misleadingly implied a task
+    // FSM id — that is A1 territory). Same value written by
+    // `delivery::arm_turn_open`; the invariant of arming-without-delivered is
+    // unchanged.
     assert_eq!(
-        updated.pointer("/agents/w1/current_task_id"),
+        updated.pointer("/agents/w1/current_turn_message_id"),
         Some(&serde_json::json!(message_id)),
-        "agent current_task_id is armed without marking the message delivered"
+        "agent current-turn message id is armed without marking the message delivered"
     );
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.7",
-    "@team-agent/cli-darwin-x64": "0.5.7",
-    "@team-agent/cli-linux-x64": "0.5.7"
+    "@team-agent/cli-darwin-arm64": "0.5.8",
+    "@team-agent/cli-darwin-x64": "0.5.8",
+    "@team-agent/cli-linux-x64": "0.5.8"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",