@team-agent/installer 0.5.17 → 0.5.19

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.17"
+version = "0.5.19"
 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.17"
+version = "0.5.19"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -732,7 +732,8 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
                 &selected.run_workspace,
             )),
         };
-    let (issues, suggested_repairs) = diagnose_runtime(&state, backend.as_ref());
+    let (issues, suggested_repairs) =
+        diagnose_runtime_for_workspace(&selected.run_workspace, &state, backend.as_ref());
     let ok = issues.as_array().is_some_and(Vec::is_empty);
     Ok(CmdResult::from_json(
         json!({

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

@@ -165,6 +165,125 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
     (Value::Array(issues), Value::Array(repairs))
 }
 
+pub(crate) fn diagnose_runtime_for_workspace(
+    workspace: &std::path::Path,
+    state: &Value,
+    backend: &dyn Transport,
+) -> (Value, Value) {
+    let (mut issues, mut repairs) = diagnose_runtime(state, backend);
+    append_coordinator_health_issue(workspace, state, &mut issues, &mut repairs);
+    (issues, repairs)
+}
+
+fn append_coordinator_health_issue(
+    workspace: &std::path::Path,
+    state: &Value,
+    issues: &mut Value,
+    repairs: &mut Value,
+) {
+    let workspace = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
+    let health = crate::coordinator::coordinator_health(&workspace);
+    let Some(id) = coordinator_issue_id(state, &health) else {
+        return;
+    };
+    if let Some(items) = issues.as_array_mut() {
+        items.push(coordinator_issue_value(id, &health, workspace.as_path()));
+    }
+    if let Some(items) = repairs.as_array_mut() {
+        items.push(coordinator_repair_hint(id, &health));
+    }
+}
+
+fn coordinator_issue_id(
+    state: &Value,
+    health: &crate::coordinator::HealthReport,
+) -> Option<&'static str> {
+    match health.status {
+        crate::coordinator::CoordinatorHealthStatus::Stale
+        | crate::coordinator::CoordinatorHealthStatus::InvalidPid => {
+            Some("coordinator_unavailable")
+        }
+        crate::coordinator::CoordinatorHealthStatus::Running => {
+            if !health.metadata_ok {
+                return match health.metadata_mismatch_reason.as_deref() {
+                    Some(
+                        "binary_identity_missing"
+                        | "binary_version_mismatch"
+                        | "binary_path_mismatch",
+                    ) => Some("coordinator_stale_identity"),
+                    Some(_) | None => Some("coordinator_unavailable"),
+                };
+            }
+            if !health.schema.ok {
+                Some("coordinator_schema_incompatible")
+            } else {
+                None
+            }
+        }
+        crate::coordinator::CoordinatorHealthStatus::Missing => {
+            coordinator_expected(state).then_some("coordinator_unavailable")
+        }
+    }
+}
+
+fn coordinator_issue_value(
+    id: &str,
+    health: &crate::coordinator::HealthReport,
+    workspace: &std::path::Path,
+) -> Value {
+    json!({
+        "id": id,
+        "status": coordinator_status_wire(health.status),
+        "pid": health.pid.map(|pid| pid.get()),
+        "metadata_ok": health.metadata_ok,
+        "metadata_mismatch_reason": health.metadata_mismatch_reason.clone(),
+        "binary_path": health.current_binary_identity.binary_path.clone(),
+        "binary_version": health.current_binary_identity.binary_version.clone(),
+        "schema_ok": health.schema.ok,
+        "coordinator_log": crate::coordinator::coordinator_log_path(
+            &crate::coordinator::WorkspacePath::new(workspace.to_path_buf())
+        )
+        .to_string_lossy()
+        .to_string(),
+    })
+}
+
+fn coordinator_repair_hint(id: &str, _health: &crate::coordinator::HealthReport) -> Value {
+    let hint_action = match id {
+        "coordinator_schema_incompatible" => "team-agent repair-state --schema",
+        _ => "team-agent restart",
+    };
+    json!({
+        "issue": id,
+        "action_required": true,
+        "advisory": true,
+        "broken_class": id,
+        "hint_action": hint_action,
+        "dedupe_key": id,
+        "action": format!("{hint_action} # diagnose only reports coordinator health; it does not start, stop, or rotate the coordinator"),
+    })
+}
+
+fn coordinator_expected(state: &Value) -> bool {
+    state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .is_some_and(|session| !session.is_empty())
+        || state
+            .get("agents")
+            .and_then(Value::as_object)
+            .is_some_and(|agents| !agents.is_empty())
+}
+
+fn coordinator_status_wire(status: crate::coordinator::CoordinatorHealthStatus) -> &'static str {
+    match status {
+        crate::coordinator::CoordinatorHealthStatus::Missing => "missing",
+        crate::coordinator::CoordinatorHealthStatus::InvalidPid => "invalid_pid",
+        crate::coordinator::CoordinatorHealthStatus::Running => "running",
+        crate::coordinator::CoordinatorHealthStatus::Stale => "stale",
+    }
+}
+
 fn topology_repair_hint(issue: &str) -> Value {
     json!({
         "issue": issue,
@@ -246,6 +365,72 @@ mod tests {
         path
     }
 
+    fn coordinator_health_fixture(
+        status: crate::coordinator::CoordinatorHealthStatus,
+        metadata_mismatch_reason: Option<&str>,
+        schema_ok: bool,
+    ) -> crate::coordinator::HealthReport {
+        crate::coordinator::HealthReport {
+            ok: matches!(status, crate::coordinator::CoordinatorHealthStatus::Running)
+                && metadata_mismatch_reason.is_none()
+                && schema_ok,
+            status,
+            pid: Some(crate::coordinator::Pid::new(std::process::id())),
+            metadata: None,
+            metadata_ok: metadata_mismatch_reason.is_none(),
+            metadata_mismatch_reason: metadata_mismatch_reason.map(ToString::to_string),
+            current_binary_identity: crate::coordinator::CoordinatorBinaryIdentity {
+                binary_path: "/current/team-agent".to_string(),
+                binary_version: env!("CARGO_PKG_VERSION").to_string(),
+            },
+            schema: crate::coordinator::SchemaHealth {
+                ok: schema_ok,
+                schema_version: crate::db::schema::SCHEMA_VERSION,
+                error: None,
+                action: None,
+            },
+        }
+    }
+
+    #[test]
+    fn coordinator_issue_id_maps_stale_pid_to_unavailable() {
+        let health = coordinator_health_fixture(
+            crate::coordinator::CoordinatorHealthStatus::Stale,
+            None,
+            true,
+        );
+        assert_eq!(
+            coordinator_issue_id(&json!({"session_name": "team-fixture"}), &health),
+            Some("coordinator_unavailable")
+        );
+    }
+
+    #[test]
+    fn coordinator_issue_id_maps_binary_identity_to_stale_identity() {
+        let health = coordinator_health_fixture(
+            crate::coordinator::CoordinatorHealthStatus::Running,
+            Some("binary_version_mismatch"),
+            true,
+        );
+        assert_eq!(
+            coordinator_issue_id(&json!({"session_name": "team-fixture"}), &health),
+            Some("coordinator_stale_identity")
+        );
+    }
+
+    #[test]
+    fn coordinator_issue_id_maps_schema_failure_to_schema_incompatible() {
+        let health = coordinator_health_fixture(
+            crate::coordinator::CoordinatorHealthStatus::Running,
+            None,
+            false,
+        );
+        assert_eq!(
+            coordinator_issue_id(&json!({"session_name": "team-fixture"}), &health),
+            Some("coordinator_schema_incompatible")
+        );
+    }
+
     #[test]
     fn diagnose_surfaces_codex_session_identity_mismatch() {
         let workspace =

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

@@ -821,7 +821,11 @@ pub mod lifecycle_port {
         let mut coordinator_timeout = false;
         let mut coordinator_post_stop = CoordinatorStopObservation::NotNeeded;
         let mut coordinator_pid_for_report = None;
-        let stopped = if team.is_none() {
+        let coordinator_stop_reason =
+            coordinator_stop_reason_for_shutdown(&run_workspace, team, &state)?;
+        let should_stop_coordinator =
+            matches!(coordinator_stop_reason, "bare_shutdown" | "scoped_last_live_team");
+        let stopped = if should_stop_coordinator {
             let wp = crate::coordinator::WorkspacePath::new(run_workspace.clone());
             let coordinator_pid_before_stop = crate::coordinator::coordinator_health(&wp).pid;
             coordinator_pid_for_report = coordinator_pid_before_stop.map(|pid| pid.get());
@@ -929,6 +933,7 @@ pub mod lifecycle_port {
                     "killed_sessions": killed_sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
                     "spared_sessions": spared_sessions.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
                     "coordinator_status": coordinator_status,
+                    "coordinator_stop_reason": coordinator_stop_reason,
                     "status": status,
                     "phase": phase,
                     "verification_degraded": verification_degraded,
@@ -971,9 +976,11 @@ pub mod lifecycle_port {
                 "owned_files": owned_file_residuals,
             },
             "error": kill_error,
+            "coordinator_stop_reason": coordinator_stop_reason,
             "coordinator": {
                 "status": coordinator_status,
                 "pid": coordinator_pid,
+                "stop_reason": coordinator_stop_reason,
             },
         });
         #[cfg(windows)]
@@ -2921,6 +2928,7 @@ pub mod lifecycle_port {
                 session_name,
                 agents,
                 coordinator_started,
+                coordinator,
                 next_actions,
                 attach_commands,
             } => json!({
@@ -2929,6 +2937,7 @@ pub mod lifecycle_port {
                 "session_name": session_name.as_str(),
                 "agents": agents.iter().map(|a| a.agent_id.as_str()).collect::<Vec<_>>(),
                 "coordinator_started": coordinator_started,
+                "coordinator": crate::lifecycle::coordinator_start_summary_value(&coordinator),
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
                 "reminder": crate::cli::QUICK_START_REMINDER,
@@ -2938,6 +2947,7 @@ pub mod lifecycle_port {
                 agents,
                 failed_agents,
                 coordinator_started,
+                coordinator,
                 next_actions,
                 attach_commands,
             } => json!({
@@ -2964,6 +2974,7 @@ pub mod lifecycle_port {
                     ),
                 })).collect::<Vec<_>>(),
                 "coordinator_started": coordinator_started,
+                "coordinator": crate::lifecycle::coordinator_start_summary_value(&coordinator),
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
                 "reminder": crate::cli::QUICK_START_REMINDER,
@@ -3370,6 +3381,35 @@ pub mod lifecycle_port {
         }
     }
 
+    fn coordinator_stop_reason_for_shutdown(
+        workspace: &Path,
+        team: Option<&str>,
+        selected_state: &Value,
+    ) -> Result<&'static str, CliError> {
+        let Some(requested_team) = team.filter(|team| !team.is_empty()) else {
+            return Ok("bare_shutdown");
+        };
+        let stopped_key = selected_state
+            .get("active_team_key")
+            .and_then(Value::as_str)
+            .filter(|key| !key.is_empty())
+            .unwrap_or(requested_team);
+        let raw = crate::state::persist::load_runtime_state(workspace)?;
+        let live_sibling = raw
+            .get("teams")
+            .and_then(Value::as_object)
+            .is_some_and(|teams| {
+                teams
+                    .iter()
+                    .any(|(key, team)| key.as_str() != stopped_key && team_has_running_agent(team))
+            });
+        if live_sibling {
+            Ok("scoped_live_sibling_present")
+        } else {
+            Ok("scoped_last_live_team")
+        }
+    }
+
     fn mark_matching_session_teams_stopped(
         state: &mut Value,
         session_name: Option<&crate::transport::SessionName>,
@@ -3915,10 +3955,15 @@ pub mod diagnose_port {
                 "pid": m.pid.get(),
                 "protocol_version": m.protocol_version,
                 "message_store_schema_version": m.message_store_schema_version,
+                "binary_path": m.binary_path,
+                "binary_version": m.binary_version,
                 "source": m.source,
                 "updated_at": m.updated_at,
             })),
             "metadata_ok": health.metadata_ok,
+            "metadata_mismatch_reason": health.metadata_mismatch_reason,
+            "binary_path": health.current_binary_identity.binary_path,
+            "binary_version": health.current_binary_identity.binary_version,
             "schema_ok": health.schema.ok,
             "schema_error": health.schema.error.map(|e| format!("{e:?}")),
             "schema": {

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

@@ -1151,10 +1151,15 @@ use rusqlite::params;
                 "pid": m.pid.get(),
                 "protocol_version": m.protocol_version,
                 "message_store_schema_version": m.message_store_schema_version,
+                "binary_path": m.binary_path,
+                "binary_version": m.binary_version,
                 "source": m.source,
                 "updated_at": m.updated_at,
             })),
             "metadata_ok": health.metadata_ok,
+            "metadata_mismatch_reason": health.metadata_mismatch_reason,
+            "binary_path": health.current_binary_identity.binary_path,
+            "binary_version": health.current_binary_identity.binary_version,
             "schema_ok": health.schema.ok,
             "schema_error": health.schema.error.map(|e| format!("{e:?}")),
             "schema": {

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

@@ -57,20 +57,30 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
-    // ── status #3: coordinator = coordinator_health(ws) FULL 8-key shape in golden order ─────────────
-    // GOLDEN coordinator_health: {ok,status,pid,metadata,metadata_ok,schema_ok,schema_error,schema}.
-    // RUST mod.rs:105-112 emits a 6-key subset {status,ok,pid,metadata_ok,schema_ok,schema_version}
-    // (no metadata/schema_error; flat schema_version instead of nested schema). RED on key-order. ──────
+    // ── status #3: coordinator = coordinator_health(ws) FULL shape in golden order ──────────────────
+    // 0.5.18 adds binary identity diagnostics to expose stale coordinator rotation reasons.
     #[test]
-    fn status_coordinator_is_full_health_eight_key_shape() {
+    fn status_coordinator_is_full_health_identity_shape() {
         let ws = tmp_workspace();
         let v = status_port::status(&ws, false, true).expect("status");
         let coord = v["coordinator"].as_object().expect("coordinator dict");
         let order: Vec<&str> = coord.keys().map(String::as_str).collect();
         assert_eq!(
             order,
-            vec!["ok", "status", "pid", "metadata", "metadata_ok", "schema_ok", "schema_error", "schema"],
-            "golden coordinator_health 8-key insertion order; Rust emits a 6-key subset. got {order:?}"
+            vec![
+                "ok",
+                "status",
+                "pid",
+                "metadata",
+                "metadata_ok",
+                "metadata_mismatch_reason",
+                "binary_path",
+                "binary_version",
+                "schema_ok",
+                "schema_error",
+                "schema"
+            ],
+            "golden coordinator_health insertion order with 0.5.18 identity fields; got {order:?}"
         );
         assert!(
             coord.get("schema_version").is_none(),

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

@@ -61,18 +61,14 @@ pub fn run_daemon(args: DaemonArgs) -> Result<(), DaemonError> {
     // seed-state trap where writing active_team_key to state ahead
     // of coord spawn made downstream launch code think "existing
     // runtime, use restart" and skip spec compile.
-    let team_key_from_state = args
-        .team_key
-        .clone()
-        .filter(|s| !s.is_empty())
-        .or_else(|| {
-            state
-                .as_ref()
-                .and_then(|s| s.get("active_team_key"))
-                .and_then(|v| v.as_str())
-                .filter(|s| !s.is_empty())
-                .map(str::to_string)
-        });
+    let team_key_from_state = args.team_key.clone().filter(|s| !s.is_empty()).or_else(|| {
+        state
+            .as_ref()
+            .and_then(|s| s.get("active_team_key"))
+            .and_then(|v| v.as_str())
+            .filter(|s| !s.is_empty())
+            .map(str::to_string)
+    });
     let mut factory_input = crate::transport_factory::TransportFactoryInput::new(
         args.workspace.as_path(),
         crate::transport_factory::TransportPurpose::Coordinator,
@@ -104,7 +100,8 @@ pub fn run_daemon(args: DaemonArgs) -> Result<(), DaemonError> {
                 args.workspace.clone(),
                 Box::new(RealProviderRegistry),
                 Box::new(sel.backend),
-            );
+            )
+            .with_team_key(team_key_from_state.clone());
             return run_daemon_with_coordinator_and_boot_tmux(&args, &coord, Some(metadata));
         }
     };
@@ -120,7 +117,8 @@ pub fn run_daemon(args: DaemonArgs) -> Result<(), DaemonError> {
         args.workspace.clone(),
         Box::new(RealProviderRegistry),
         resolved.backend,
-    );
+    )
+    .with_team_key(team_key_from_state.clone());
     run_daemon_with_coordinator_and_boot_tmux(&args, &coordinator, Some(tmux_metadata))
 }
 
@@ -147,11 +145,14 @@ fn run_daemon_with_coordinator_and_boot_tmux(
     let pid = Pid::new(std::process::id());
     std::fs::write(coordinator_pid_path(&args.workspace), pid.to_string())?;
     write_coordinator_metadata(&args.workspace, pid, MetadataSource::Boot)?;
+    let binary_identity = crate::coordinator::current_coordinator_binary_identity();
 
     let event_log = EventLog::new(args.workspace.as_path());
     let mut boot_event = serde_json::json!({
         "workspace": args.workspace.as_path().to_string_lossy(),
         "once": args.once,
+        "binary_path": binary_identity.binary_path,
+        "binary_version": binary_identity.binary_version,
     });
     if let Some(metadata) = tmux_metadata {
         if let Some(object) = boot_event.as_object_mut() {