@team-agent/installer 0.5.16 → 0.5.18

package/Cargo.lock

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

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": {
@@ -4060,79 +4105,15 @@ pub mod leader_port {
         source: &str,
         response: &mut Value,
     ) {
-        let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
-            return;
-        };
-        let team_key = match team.filter(|t| !t.is_empty()) {
-            Some(t) => t.to_string(),
-            None => crate::state::projection::team_state_key(&state),
-        };
-        let receiver = state
-            .get("teams")
-            .and_then(|v| v.as_object())
-            .and_then(|teams| teams.get(&team_key))
-            .and_then(|t| t.get("leader_receiver"))
-            .or_else(|| state.get("leader_receiver"))
-            .cloned();
-        let Some(receiver) = receiver else {
-            return;
-        };
-        let transport_kind = receiver
-            .get("transport_kind")
-            .and_then(Value::as_str)
-            .unwrap_or("direct_tmux")
-            .to_string();
-        let owner_epoch = receiver
-            .get("owner_epoch")
-            .and_then(Value::as_u64)
-            .or_else(|| {
-                state
-                    .get("teams")
-                    .and_then(|v| v.as_object())
-                    .and_then(|teams| teams.get(&team_key))
-                    .and_then(|t| t.get("owner_epoch"))
-                    .and_then(Value::as_u64)
-            })
-            .unwrap_or(0);
-        let entry = crate::leader::registry::build_entry(
+        let Some(outcome) = crate::leader::registry::register_binding_from_state_best_effort(
             workspace,
-            &team_key,
-            &transport_kind,
-            receiver,
-            owner_epoch,
+            team,
             source,
-            chrono::Utc::now().to_rfc3339(),
-        );
-        let event_log = crate::event_log::EventLog::new(workspace);
-        let write_result = crate::leader::registry::write_entry_best_effort(&entry);
-        let registry_status = match &write_result {
-            Some(path) => {
-                let _ = event_log.write(
-                    crate::leader::registry::EVENT_REGISTERED,
-                    json!({
-                        "path": path.display().to_string(),
-                        "team_key": team_key,
-                        "workspace_hash": entry.workspace_hash,
-                        "source": source,
-                        "owner_epoch": entry.owner_epoch,
-                    }),
-                );
-                json!({"status": "registered", "path": path.display().to_string()})
-            }
-            None => {
-                let _ = event_log.write(
-                    crate::leader::registry::EVENT_WRITE_FAILED,
-                    json!({
-                        "team_key": team_key,
-                        "workspace_hash": entry.workspace_hash,
-                        "source": source,
-                    }),
-                );
-                json!({"status": "write_failed"})
-            }
+        ) else {
+            return;
         };
         if let Some(obj) = response.as_object_mut() {
-            obj.insert("leader_registry".to_string(), registry_status);
+            obj.insert("leader_registry".to_string(), outcome.response_json());
         }
     }
 

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() {

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

@@ -13,7 +13,8 @@ use thiserror::Error;
 use crate::message_store::MessageStore;
 
 use super::types::{
-    CoordinatorHealthStatus, CoordinatorMetadata, HealthReport, MetadataSource, Pid, SchemaError,
+    CoordinatorBinaryIdentity, CoordinatorHealthStatus, CoordinatorMetadata,
+    CoordinatorMetadataMismatchReason, HealthReport, MetadataSource, Pid, SchemaError,
     SchemaHealth, StartError, StartOutcome, StartReport, StopError, StopOutcome, StopReport,
     WatchCursor, WorkspacePath, PROTOCOL_VERSION, ROTATION_MARKER,
 };
@@ -27,6 +28,7 @@ use super::types::{
 /// `coordinator_health`(`lifecycle.py:38-46`):`running ∧ metadata_ok ∧ schema_ok` → typed report.
 pub fn coordinator_health(workspace: &WorkspacePath) -> HealthReport {
     let schema = message_store_schema_health(workspace);
+    let current_binary_identity = current_coordinator_binary_identity();
     let pid_path = coordinator_pid_path(workspace);
     let pid = read_pid_file(&pid_path);
     let status = match pid {
@@ -38,7 +40,14 @@ pub fn coordinator_health(workspace: &WorkspacePath) -> HealthReport {
         None => CoordinatorHealthStatus::Missing,
     };
     let metadata = read_coordinator_metadata(workspace);
-    let metadata_ok = pid.is_some_and(|p| coordinator_metadata_ok(metadata.as_ref(), p));
+    let metadata_mismatch = pid
+        .map(|p| coordinator_metadata_mismatch_reason_with_identity(
+            metadata.as_ref(),
+            p,
+            &current_binary_identity,
+        ))
+        .unwrap_or(Some(CoordinatorMetadataMismatchReason::MetadataMissing));
+    let metadata_ok = metadata_mismatch.is_none();
     let running = matches!(status, CoordinatorHealthStatus::Running);
     HealthReport {
         ok: running && metadata_ok && schema.ok,
@@ -46,6 +55,8 @@ pub fn coordinator_health(workspace: &WorkspacePath) -> HealthReport {
         pid,
         metadata,
         metadata_ok,
+        metadata_mismatch_reason: metadata_mismatch.map(|reason| reason.as_str().to_string()),
+        current_binary_identity,
         schema,
     }
 }
@@ -69,11 +80,16 @@ pub fn start_coordinator_with_team(
     team_key: Option<&str>,
 ) -> Result<StartReport, StartError> {
     let health = coordinator_health(workspace);
+    let identity = health.current_binary_identity.clone();
     if health.ok {
         return Ok(StartReport {
             ok: true,
             pid: health.pid,
             status: StartOutcome::AlreadyRunning,
+            previous_pid: None,
+            binary_path: Some(identity.binary_path),
+            binary_version: Some(identity.binary_version),
+            rotation_reason: None,
             log: Some(coordinator_log_path(workspace)),
             schema_error: None,
             action: None,
@@ -84,12 +100,54 @@ pub fn start_coordinator_with_team(
             ok: false,
             pid: health.pid,
             status: StartOutcome::SchemaIncompatible,
+            previous_pid: None,
+            binary_path: Some(identity.binary_path),
+            binary_version: Some(identity.binary_version),
+            rotation_reason: health.metadata_mismatch_reason,
             log: None,
             schema_error: health.schema.error,
             action: health.schema.action,
         });
     }
-    if health.pid.is_some() && !health.metadata_ok && health.metadata.is_some() {
+    let rotation_reason = if matches!(health.status, CoordinatorHealthStatus::Running)
+        && !health.metadata_ok
+    {
+        health.metadata_mismatch_reason.clone()
+    } else {
+        None
+    };
+    if matches!(health.status, CoordinatorHealthStatus::Running) && !health.metadata_ok {
+        crate::event_log::EventLog::new(workspace.as_path()).write(
+            "coordinator.rotation_required",
+            serde_json::json!({
+                "old_pid": health.pid.map(|pid| pid.get()),
+                "reason": rotation_reason.clone(),
+                "old_binary_path": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_path.clone()),
+                "old_binary_version": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_version.clone()),
+                "current_binary_path": identity.binary_path.clone(),
+                "current_binary_version": identity.binary_version.clone(),
+            }),
+        )?;
+        if health.pid.map(|pid| pid.get()) == Some(std::process::id()) {
+            return Ok(StartReport {
+                ok: false,
+                pid: health.pid,
+                status: StartOutcome::RestartIncompatibleStopFailed,
+                previous_pid: health.pid,
+                binary_path: Some(identity.binary_path),
+                binary_version: Some(identity.binary_version),
+                rotation_reason,
+                log: None,
+                schema_error: None,
+                action: Some("refusing to rotate coordinator metadata that points at the caller process".to_string()),
+            });
+        }
         match stop_coordinator(workspace) {
             Ok(stop) if stop.ok => {}
             Ok(_) | Err(_) => {
@@ -97,6 +155,10 @@ pub fn start_coordinator_with_team(
                     ok: false,
                     pid: health.pid,
                     status: StartOutcome::RestartIncompatibleStopFailed,
+                    previous_pid: health.pid,
+                    binary_path: Some(identity.binary_path),
+                    binary_version: Some(identity.binary_version),
+                    rotation_reason,
                     log: None,
                     schema_error: None,
                     action: None,
@@ -131,10 +193,19 @@ pub fn start_coordinator_with_team(
     let pid = Pid::new(child.id());
     std::fs::write(coordinator_pid_path(workspace), pid.to_string())?;
     write_coordinator_metadata(workspace, pid, MetadataSource::Start)?;
+    let status = if rotation_reason.is_some() {
+        StartOutcome::StartedAfterRotation
+    } else {
+        StartOutcome::Started
+    };
     Ok(StartReport {
         ok: true,
         pid: Some(pid),
-        status: StartOutcome::Started,
+        status,
+        previous_pid: health.pid,
+        binary_path: Some(identity.binary_path),
+        binary_version: Some(identity.binary_version),
+        rotation_reason,
         log: Some(log_path),
         schema_error: None,
         action: None,
@@ -206,6 +277,15 @@ pub fn stop_coordinator(workspace: &WorkspacePath) -> Result<StopReport, StopErr
             pid: Some(pid),
         });
     }
+    if pid.get() == std::process::id() {
+        remove_file_if_exists(&pid_path)?;
+        remove_file_if_exists(&coordinator_meta_path(workspace))?;
+        return Ok(StopReport {
+            ok: true,
+            status: StopOutcome::Stopped,
+            pid: Some(pid),
+        });
+    }
     if !terminate_pid(pid) {
         return Ok(StopReport {
             ok: false,
@@ -499,15 +579,63 @@ pub fn read_coordinator_metadata(workspace: &WorkspacePath) -> Option<Coordinato
     serde_json::from_str(&text).ok()
 }
 
-/// `coordinator_metadata_ok`(`metadata.py:37-43`):三元全等
-/// `meta.pid == pid ∧ meta.protocol_version == PROTOCOL_VERSION ∧
-/// meta.message_store_schema_version == SCHEMA_VERSION`。任一不符 → false(不静默继续旧 schema)。
+pub fn current_coordinator_binary_identity() -> CoordinatorBinaryIdentity {
+    let binary_path = std::env::current_exe()
+        .map(|path| path.canonicalize().unwrap_or(path))
+        .map(|path| path.to_string_lossy().into_owned())
+        .unwrap_or_else(|_| "<unknown>".to_string());
+    CoordinatorBinaryIdentity {
+        binary_path,
+        binary_version: crate::packaging::Version::current().as_str().to_string(),
+    }
+}
+
+/// `coordinator_metadata_ok` now includes daemon binary identity in addition
+/// to the original pid/protocol/schema tuple.
 pub fn coordinator_metadata_ok(metadata: Option<&CoordinatorMetadata>, pid: Pid) -> bool {
-    metadata.is_some_and(|m| {
-        m.pid == pid
-            && m.protocol_version == PROTOCOL_VERSION
-            && m.message_store_schema_version == crate::db::schema::SCHEMA_VERSION
-    })
+    coordinator_metadata_mismatch_reason(metadata, pid).is_none()
+}
+
+pub fn coordinator_metadata_mismatch_reason(
+    metadata: Option<&CoordinatorMetadata>,
+    pid: Pid,
+) -> Option<CoordinatorMetadataMismatchReason> {
+    let identity = current_coordinator_binary_identity();
+    coordinator_metadata_mismatch_reason_with_identity(metadata, pid, &identity)
+}
+
+fn coordinator_metadata_mismatch_reason_with_identity(
+    metadata: Option<&CoordinatorMetadata>,
+    pid: Pid,
+    identity: &CoordinatorBinaryIdentity,
+) -> Option<CoordinatorMetadataMismatchReason> {
+    let Some(metadata) = metadata else {
+        return Some(CoordinatorMetadataMismatchReason::MetadataMissing);
+    };
+    if metadata.pid != pid {
+        return Some(CoordinatorMetadataMismatchReason::PidMismatch);
+    }
+    if metadata.protocol_version != PROTOCOL_VERSION {
+        return Some(CoordinatorMetadataMismatchReason::ProtocolVersionMismatch);
+    }
+    if metadata.message_store_schema_version != crate::db::schema::SCHEMA_VERSION {
+        return Some(CoordinatorMetadataMismatchReason::MessageStoreSchemaVersionMismatch);
+    }
+    let Some(binary_version) = metadata.binary_version.as_deref().filter(|value| !value.is_empty())
+    else {
+        return Some(CoordinatorMetadataMismatchReason::BinaryIdentityMissing);
+    };
+    let Some(binary_path) = metadata.binary_path.as_deref().filter(|value| !value.is_empty())
+    else {
+        return Some(CoordinatorMetadataMismatchReason::BinaryIdentityMissing);
+    };
+    if binary_version != identity.binary_version {
+        return Some(CoordinatorMetadataMismatchReason::BinaryVersionMismatch);
+    }
+    if binary_path != identity.binary_path {
+        return Some(CoordinatorMetadataMismatchReason::BinaryPathMismatch);
+    }
+    None
 }
 
 /// `write_coordinator_metadata`(`metadata.py:46-61`)。写 `coordinator.json`(pretty indent=2),
@@ -525,6 +653,8 @@ pub fn write_coordinator_metadata(
         pid,
         protocol_version: PROTOCOL_VERSION,
         message_store_schema_version: crate::db::schema::SCHEMA_VERSION,
+        binary_path: Some(current_coordinator_binary_identity().binary_path),
+        binary_version: Some(crate::packaging::Version::current().as_str().to_string()),
         source,
         updated_at: chrono::Utc::now().to_rfc3339(),
     };

package/crates/team-agent/src/coordinator/tests/basics.rs

@@ -38,6 +38,7 @@ fn status_enums_serialize_to_exact_python_strings() {
         (serde_json::to_string(&StartOutcome::RestartIncompatibleStopFailed).unwrap(), "\"restart_incompatible_stop_failed\""),
         (serde_json::to_string(&StartOutcome::SchemaIncompatible).unwrap(), "\"schema_incompatible\""),
         (serde_json::to_string(&StartOutcome::Started).unwrap(), "\"started\""),
+        (serde_json::to_string(&StartOutcome::StartedAfterRotation).unwrap(), "\"started_after_rotation\""),
         (serde_json::to_string(&StopOutcome::Missing).unwrap(), "\"missing\""),
         (serde_json::to_string(&StopOutcome::InvalidPidRemoved).unwrap(), "\"invalid_pid_removed\""),
         (serde_json::to_string(&StopOutcome::KillFailed).unwrap(), "\"kill_failed\""),
@@ -173,6 +174,9 @@ fn coordinator_metadata_json_field_names_are_stable() {
     assert_eq!(json["pid"], 123);
     assert_eq!(json["protocol_version"], 2);
     assert_eq!(json["message_store_schema_version"], 3);
+    let identity = current_coordinator_binary_identity();
+    assert_eq!(json["binary_path"], identity.binary_path);
+    assert_eq!(json["binary_version"], identity.binary_version);
     assert_eq!(json["source"], "boot");
     assert_eq!(json["updated_at"], "2026-06-02T00:00:00+00:00");
 }

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

@@ -13,10 +13,13 @@ fn ws() -> WorkspacePath {
 }
 
 fn meta(pid: u32, proto: u32, schema: i64) -> CoordinatorMetadata {
+    let identity = current_coordinator_binary_identity();
     CoordinatorMetadata {
         pid: Pid(pid),
         protocol_version: proto,
         message_store_schema_version: schema,
+        binary_path: Some(identity.binary_path),
+        binary_version: Some(identity.binary_version),
         source: MetadataSource::Boot,
         updated_at: "2026-06-02T00:00:00+00:00".to_string(),
     }