@team-agent/installer 0.5.21 → 0.5.23

package/Cargo.lock

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

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

@@ -205,6 +205,14 @@ fn coordinator_issue_id(
         }
         crate::coordinator::CoordinatorHealthStatus::Running => {
             if !health.metadata_ok {
+                if health.service_available
+                    && matches!(
+                        health.binary_identity_relation,
+                        crate::coordinator::CoordinatorBinaryIdentityRelation::DaemonNewerThanCaller
+                    )
+                {
+                    return None;
+                }
                 return match health.metadata_mismatch_reason.as_deref() {
                     Some(
                         "binary_identity_missing"
@@ -237,6 +245,11 @@ fn coordinator_issue_value(
         "pid": health.pid.map(|pid| pid.get()),
         "metadata_ok": health.metadata_ok,
         "metadata_mismatch_reason": health.metadata_mismatch_reason.clone(),
+        "process_running": health.process_running,
+        "wire_metadata_ok": health.wire_metadata_ok,
+        "binary_identity_ok": health.binary_identity_ok,
+        "binary_identity_relation": health.binary_identity_relation.as_str(),
+        "service_available": health.service_available,
         "binary_path": health.current_binary_identity.binary_path.clone(),
         "binary_version": health.current_binary_identity.binary_version.clone(),
         "schema_ok": health.schema.ok,
@@ -378,6 +391,15 @@ mod tests {
             pid: Some(crate::coordinator::Pid::new(std::process::id())),
             metadata: None,
             metadata_ok: metadata_mismatch_reason.is_none(),
+            process_running: matches!(status, crate::coordinator::CoordinatorHealthStatus::Running),
+            wire_metadata_ok: metadata_mismatch_reason.is_none(),
+            binary_identity_ok: metadata_mismatch_reason.is_none(),
+            binary_identity_relation: crate::coordinator::CoordinatorBinaryIdentityRelation::Same,
+            service_available: matches!(
+                status,
+                crate::coordinator::CoordinatorHealthStatus::Running
+            ) && metadata_mismatch_reason.is_none()
+                && schema_ok,
             metadata_mismatch_reason: metadata_mismatch_reason.map(ToString::to_string),
             current_binary_identity: crate::coordinator::CoordinatorBinaryIdentity {
                 binary_path: "/current/team-agent".to_string(),

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

@@ -3947,7 +3947,9 @@ pub mod diagnose_port {
     }
 
     fn coordinator_health_value(health: crate::coordinator::HealthReport) -> Value {
-        json!({
+        let expose_binary_drift = health.service_available && !health.metadata_ok;
+        let binary_identity_relation = health.binary_identity_relation.as_str();
+        let mut value = json!({
             "ok": health.ok,
             "status": coordinator_status_wire(health.status),
             "pid": health.pid.map(|p| p.get()),
@@ -3969,7 +3971,19 @@ pub mod diagnose_port {
             "schema": {
                 "message_store_schema_version": health.schema.schema_version,
             },
-        })
+        });
+        if expose_binary_drift {
+            if let Some(obj) = value.as_object_mut() {
+                obj.insert("wire_metadata_ok".to_string(), Value::Bool(true));
+                obj.insert("binary_identity_ok".to_string(), Value::Bool(false));
+                obj.insert(
+                    "binary_identity_relation".to_string(),
+                    Value::String(binary_identity_relation.to_string()),
+                );
+                obj.insert("service_available".to_string(), Value::Bool(true));
+            }
+        }
+        value
     }
 
     fn coordinator_status_wire(

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

@@ -142,11 +142,25 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     {
         return Ok(cmd_send_result(amb, args.json));
     }
+    if let Some(value) = dirty_topology_refusal_value(&selected, args.team.as_deref()) {
+        return Ok(cmd_send_result(value, args.json));
+    }
+    let coordinator_ensure = if target_has_known_worker(&selected.state, &target, &opts.sender) {
+        loud_ensure_coordinator(&selected)?
+    } else {
+        None
+    };
+    if let Some(value) =
+        coordinator_ensure_unavailable_value(coordinator_ensure.as_ref(), &target, &content, &opts)
+    {
+        return Ok(cmd_send_result(value, args.json));
+    }
     let mut outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
     if opts.watch_result {
         outcome = observe_initial_delivery_for_watch(&selected, &target, &outcome, &opts)?;
     }
     let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    append_loud_ensure_fields(&mut value, coordinator_ensure.as_ref());
     if opts.watch_result && initial_delivery_allows_watch(outcome.status) {
         if let Some(obj) = value.as_object_mut() {
             obj.insert("watch".to_string(), watch_notice_json(&target, &opts));
@@ -156,6 +170,202 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     Ok(cmd_send_result(value, args.json))
 }
 
+fn dirty_topology_refusal_value(
+    selected: &crate::state::selector::SelectedTeam,
+    requested_team: Option<&str>,
+) -> Option<Value> {
+    let issue_ids = crate::topology::restart_dirty_topology_issue_ids(&selected.state);
+    if issue_ids.is_empty() {
+        return None;
+    }
+    let session_name = selected
+        .state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .unwrap_or_default()
+        .to_string();
+    let reason = issue_ids
+        .first()
+        .cloned()
+        .unwrap_or_else(|| "dirty_topology".to_string());
+    let repair_team = requested_team
+        .filter(|team| !team.is_empty())
+        .unwrap_or(selected.team_key.as_str());
+    Some(json!({
+        "ok": false,
+        "status": "refused_dirty_topology",
+        "reason": reason,
+        "session_name": session_name,
+        "error": "send refused: tmux endpoint/socket topology is inconsistent; run diagnose from the intended leader socket before sending",
+        "issues": issue_ids
+            .iter()
+            .map(|id| json!({"id": id}))
+            .collect::<Vec<_>>(),
+        "next_actions": [
+            "team-agent diagnose --json",
+            format!("team-agent claim-leader --team {repair_team} --confirm --json"),
+            format!("team-agent takeover --team {repair_team} --confirm --json")
+        ],
+    }))
+}
+
+fn target_has_known_worker(state: &Value, target: &MessageTarget, sender: &str) -> bool {
+    let Some(agents) = state.get("agents").and_then(Value::as_object) else {
+        return false;
+    };
+    match target {
+        MessageTarget::Single(target) => agents.contains_key(target),
+        MessageTarget::Broadcast => agents.keys().any(|agent| agent != sender),
+        MessageTarget::Fanout(recipients) => recipients
+            .iter()
+            .any(|recipient| agents.contains_key(recipient)),
+    }
+}
+
+#[derive(Debug, Clone)]
+struct LoudEnsureResult {
+    previous_status: String,
+    start: crate::coordinator::StartReport,
+}
+
+fn loud_ensure_coordinator(
+    selected: &crate::state::selector::SelectedTeam,
+) -> Result<Option<LoudEnsureResult>, CliError> {
+    if in_process_unit_test() {
+        return Ok(None);
+    }
+    let workspace = crate::coordinator::WorkspacePath::new(selected.run_workspace.clone());
+    let previous = crate::coordinator::coordinator_health(&workspace);
+    if previous.ok {
+        return Ok(None);
+    }
+    if previous.service_available
+        && matches!(
+            previous.binary_identity_relation,
+            crate::coordinator::CoordinatorBinaryIdentityRelation::DaemonNewerThanCaller
+        )
+    {
+        return Ok(None);
+    }
+    let previous_status = coordinator_health_status_wire(previous.status).to_string();
+    let start = crate::coordinator::start_coordinator_with_team(
+        &workspace,
+        Some(selected.team_key.as_str()),
+    )
+    .map_err(|error| CliError::Runtime(error.to_string()))?;
+    if !start.ok {
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    if matches!(
+        start.status,
+        crate::coordinator::StartOutcome::Started
+            | crate::coordinator::StartOutcome::StartedAfterRotation
+    ) {
+        crate::event_log::EventLog::new(&selected.run_workspace)
+            .write(
+                "coordinator.ensure_restarted",
+                json!({
+                    "coordinator_previous_status": previous_status,
+                    "status": start.status,
+                    "pid": start.pid.map(|pid| pid.get()),
+                    "previous_pid": start.previous_pid.map(|pid| pid.get()),
+                    "binary_path": start.binary_path,
+                    "binary_version": start.binary_version,
+                    "rotation_reason": start.rotation_reason,
+                }),
+            )
+            .map_err(|error| CliError::Runtime(error.to_string()))?;
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    Ok(None)
+}
+
+#[cfg(test)]
+fn in_process_unit_test() -> bool {
+    true
+}
+
+#[cfg(not(test))]
+fn in_process_unit_test() -> bool {
+    false
+}
+
+fn coordinator_ensure_unavailable_value(
+    ensure: Option<&LoudEnsureResult>,
+    target: &MessageTarget,
+    content: &str,
+    opts: &SendOptions,
+) -> Option<Value> {
+    let ensure = ensure?;
+    if ensure.start.ok {
+        return None;
+    }
+    let warning = format!(
+        "coordinator is not running; message was not queued for {}. Run `team-agent diagnose` or restart the team before sending again.",
+        first_target(target)
+    );
+    let mut value = json!({
+        "ok": false,
+        "status": "degraded",
+        "delivery_status": "degraded",
+        "delivered": false,
+        "target": target_json(target),
+        "agent_id": first_target(target),
+        "content_length_bytes": content.len(),
+        "sender": opts.sender,
+        "message_id": Value::Null,
+        "message_status": "degraded",
+        "verification": warning,
+        "stage": Value::Null,
+        "reason": "coordinator_unavailable",
+        "channel": "coordinator_unavailable",
+    });
+    append_loud_ensure_fields(&mut value, Some(ensure));
+    Some(value)
+}
+
+fn append_loud_ensure_fields(value: &mut Value, ensure: Option<&LoudEnsureResult>) {
+    let Some(ensure) = ensure else {
+        return;
+    };
+    if !ensure.start.ok {
+        return;
+    }
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("coordinator_auto_restarted".to_string(), json!(true));
+        obj.insert(
+            "coordinator_previous_status".to_string(),
+            json!(ensure.previous_status),
+        );
+        obj.insert(
+            "coordinator".to_string(),
+            coordinator_start_json(&ensure.start),
+        );
+    }
+}
+
+fn coordinator_start_json(report: &crate::coordinator::StartReport) -> Value {
+    let summary = crate::lifecycle::CoordinatorStartSummary::from_start_report(report);
+    crate::lifecycle::coordinator_start_summary_value(&summary)
+}
+
+fn coordinator_health_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",
+    }
+}
+
 /// F1 (0.3.26): direct pane-id send — bypasses agent-name routing + team
 /// membership check. Constructs `Target::Pane`, renders the message with
 /// the standard protocol block (Team Agent message from sender + token),

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

@@ -1143,7 +1143,9 @@ use rusqlite::params;
     }
 
     fn coordinator_health_value(health: crate::coordinator::HealthReport) -> Value {
-        json!({
+        let expose_binary_drift = health.service_available && !health.metadata_ok;
+        let binary_identity_relation = health.binary_identity_relation.as_str();
+        let mut value = json!({
             "ok": health.ok,
             "status": coordinator_status_wire(health.status),
             "pid": health.pid.map(|p| p.get()),
@@ -1165,7 +1167,19 @@ use rusqlite::params;
             "schema": {
                 "message_store_schema_version": health.schema.schema_version,
             },
-        })
+        });
+        if expose_binary_drift {
+            if let Some(obj) = value.as_object_mut() {
+                obj.insert("wire_metadata_ok".to_string(), Value::Bool(true));
+                obj.insert("binary_identity_ok".to_string(), Value::Bool(false));
+                obj.insert(
+                    "binary_identity_relation".to_string(),
+                    Value::String(binary_identity_relation.to_string()),
+                );
+                obj.insert("service_available".to_string(), Value::Bool(true));
+            }
+        }
+        value
     }
 
     fn coordinator_status_wire(status: crate::coordinator::CoordinatorHealthStatus) -> &'static str {

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

@@ -13,10 +13,10 @@ use thiserror::Error;
 use crate::message_store::MessageStore;
 
 use super::types::{
-    CoordinatorBinaryIdentity, CoordinatorHealthStatus, CoordinatorMetadata,
-    CoordinatorMetadataMismatchReason, HealthReport, MetadataSource, Pid, SchemaError,
-    SchemaHealth, StartError, StartOutcome, StartReport, StopError, StopOutcome, StopReport,
-    WatchCursor, WorkspacePath, PROTOCOL_VERSION, ROTATION_MARKER,
+    CoordinatorBinaryIdentity, CoordinatorBinaryIdentityRelation, CoordinatorHealthStatus,
+    CoordinatorMetadata, CoordinatorMetadataMismatchReason, HealthReport, MetadataSource, Pid,
+    SchemaError, SchemaHealth, StartError, StartOutcome, StartReport, StopError, StopOutcome,
+    StopReport, WatchCursor, WorkspacePath, PROTOCOL_VERSION, ROTATION_MARKER,
 };
 
 // ===========================================================================
@@ -40,21 +40,30 @@ pub fn coordinator_health(workspace: &WorkspacePath) -> HealthReport {
         None => CoordinatorHealthStatus::Missing,
     };
     let metadata = read_coordinator_metadata(workspace);
-    let metadata_mismatch = pid
-        .map(|p| coordinator_metadata_mismatch_reason_with_identity(
-            metadata.as_ref(),
-            p,
-            &current_binary_identity,
-        ))
+    let wire_metadata_mismatch = pid
+        .map(|p| coordinator_wire_metadata_mismatch_reason(metadata.as_ref(), p))
         .unwrap_or(Some(CoordinatorMetadataMismatchReason::MetadataMissing));
-    let metadata_ok = metadata_mismatch.is_none();
-    let running = matches!(status, CoordinatorHealthStatus::Running);
+    let binary_identity_mismatch =
+        coordinator_binary_identity_mismatch_reason(metadata.as_ref(), &current_binary_identity);
+    let wire_metadata_ok = wire_metadata_mismatch.is_none();
+    let binary_identity_ok = binary_identity_mismatch.is_none();
+    let metadata_mismatch = wire_metadata_mismatch.or(binary_identity_mismatch);
+    let metadata_ok = wire_metadata_ok && binary_identity_ok;
+    let process_running = matches!(status, CoordinatorHealthStatus::Running);
+    let binary_identity_relation =
+        coordinator_binary_identity_relation(metadata.as_ref(), &current_binary_identity);
+    let service_available = process_running && wire_metadata_ok && schema.ok;
     HealthReport {
-        ok: running && metadata_ok && schema.ok,
+        ok: process_running && metadata_ok && schema.ok,
         status,
         pid,
         metadata,
         metadata_ok,
+        process_running,
+        wire_metadata_ok,
+        binary_identity_ok,
+        binary_identity_relation,
+        service_available,
         metadata_mismatch_reason: metadata_mismatch.map(|reason| reason.as_str().to_string()),
         current_binary_identity,
         schema,
@@ -109,6 +118,62 @@ pub fn start_coordinator_with_team(
             action: health.schema.action,
         });
     }
+    if matches!(health.status, CoordinatorHealthStatus::Running) && !health.wire_metadata_ok {
+        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: health.metadata_mismatch_reason,
+            log: None,
+            schema_error: None,
+            action: Some(
+                "refusing to rotate a coordinator with incompatible protocol or schema metadata"
+                    .to_string(),
+            ),
+        });
+    }
+    if matches!(health.status, CoordinatorHealthStatus::Running)
+        && health.wire_metadata_ok
+        && !health.binary_identity_ok
+        && matches!(
+            health.binary_identity_relation,
+            CoordinatorBinaryIdentityRelation::DaemonNewerThanCaller
+        )
+    {
+        crate::event_log::EventLog::new(workspace.as_path()).write(
+            "coordinator.newer_daemon_preserved",
+            serde_json::json!({
+                "pid": health.pid.map(|pid| pid.get()),
+                "binary_identity_relation": health.binary_identity_relation.as_str(),
+                "reason": "daemon_newer_than_caller",
+                "daemon_binary_path": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_path.clone()),
+                "daemon_binary_version": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_version.clone()),
+                "caller_binary_path": identity.binary_path.clone(),
+                "caller_binary_version": identity.binary_version.clone(),
+            }),
+        )?;
+        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: Some("daemon_newer_than_caller".to_string()),
+            log: Some(coordinator_log_path(workspace)),
+            schema_error: None,
+            action: None,
+        });
+    }
     let rotation_reason = if matches!(health.status, CoordinatorHealthStatus::Running)
         && !health.metadata_ok
     {
@@ -580,6 +645,13 @@ pub fn read_coordinator_metadata(workspace: &WorkspacePath) -> Option<Coordinato
 }
 
 pub fn current_coordinator_binary_identity() -> CoordinatorBinaryIdentity {
+    if let Ok(raw) = std::env::var("TEAM_AGENT_TEST_CALLER_BINARY_IDENTITY") {
+        if let Ok(identity) = serde_json::from_str::<CoordinatorBinaryIdentity>(&raw) {
+            if !identity.binary_path.is_empty() && !identity.binary_version.is_empty() {
+                return identity;
+            }
+        }
+    }
     let binary_path = std::env::current_exe()
         .map(|path| path.canonicalize().unwrap_or(path))
         .map(|path| path.to_string_lossy().into_owned())
@@ -608,6 +680,14 @@ fn coordinator_metadata_mismatch_reason_with_identity(
     metadata: Option<&CoordinatorMetadata>,
     pid: Pid,
     identity: &CoordinatorBinaryIdentity,
+) -> Option<CoordinatorMetadataMismatchReason> {
+    coordinator_wire_metadata_mismatch_reason(metadata, pid)
+        .or_else(|| coordinator_binary_identity_mismatch_reason(metadata, identity))
+}
+
+fn coordinator_wire_metadata_mismatch_reason(
+    metadata: Option<&CoordinatorMetadata>,
+    pid: Pid,
 ) -> Option<CoordinatorMetadataMismatchReason> {
     let Some(metadata) = metadata else {
         return Some(CoordinatorMetadataMismatchReason::MetadataMissing);
@@ -621,6 +701,16 @@ fn coordinator_metadata_mismatch_reason_with_identity(
     if metadata.message_store_schema_version != crate::db::schema::SCHEMA_VERSION {
         return Some(CoordinatorMetadataMismatchReason::MessageStoreSchemaVersionMismatch);
     }
+    None
+}
+
+fn coordinator_binary_identity_mismatch_reason(
+    metadata: Option<&CoordinatorMetadata>,
+    identity: &CoordinatorBinaryIdentity,
+) -> Option<CoordinatorMetadataMismatchReason> {
+    let Some(metadata) = metadata else {
+        return Some(CoordinatorMetadataMismatchReason::MetadataMissing);
+    };
     let Some(binary_version) = metadata.binary_version.as_deref().filter(|value| !value.is_empty())
     else {
         return Some(CoordinatorMetadataMismatchReason::BinaryIdentityMissing);
@@ -632,12 +722,98 @@ fn coordinator_metadata_mismatch_reason_with_identity(
     if binary_version != identity.binary_version {
         return Some(CoordinatorMetadataMismatchReason::BinaryVersionMismatch);
     }
-    if binary_path != identity.binary_path {
+    if !binary_path_matches_current_identity(binary_path, &identity.binary_path) {
         return Some(CoordinatorMetadataMismatchReason::BinaryPathMismatch);
     }
     None
 }
 
+fn coordinator_binary_identity_relation(
+    metadata: Option<&CoordinatorMetadata>,
+    identity: &CoordinatorBinaryIdentity,
+) -> CoordinatorBinaryIdentityRelation {
+    let Some(metadata) = metadata else {
+        return CoordinatorBinaryIdentityRelation::Unknown;
+    };
+    let Some(daemon_version) = metadata
+        .binary_version
+        .as_deref()
+        .filter(|value| !value.is_empty())
+    else {
+        return CoordinatorBinaryIdentityRelation::Unknown;
+    };
+    match compare_version_strings(daemon_version, &identity.binary_version) {
+        Some(std::cmp::Ordering::Greater) => {
+            return CoordinatorBinaryIdentityRelation::DaemonNewerThanCaller;
+        }
+        Some(std::cmp::Ordering::Less) => {
+            return CoordinatorBinaryIdentityRelation::CallerNewerThanDaemon;
+        }
+        Some(std::cmp::Ordering::Equal) => {}
+        None => return CoordinatorBinaryIdentityRelation::Unknown,
+    }
+    let Some(daemon_path) = metadata
+        .binary_path
+        .as_deref()
+        .filter(|value| !value.is_empty())
+    else {
+        return CoordinatorBinaryIdentityRelation::Unknown;
+    };
+    if binary_path_matches_current_identity(daemon_path, &identity.binary_path) {
+        CoordinatorBinaryIdentityRelation::Same
+    } else {
+        CoordinatorBinaryIdentityRelation::SameVersionPathMismatch
+    }
+}
+
+fn compare_version_strings(left: &str, right: &str) -> Option<std::cmp::Ordering> {
+    let left = parse_numeric_version(left)?;
+    let right = parse_numeric_version(right)?;
+    Some(left.cmp(&right))
+}
+
+fn parse_numeric_version(value: &str) -> Option<Vec<u64>> {
+    if value.is_empty() {
+        return None;
+    }
+    value
+        .split('.')
+        .map(|part| part.parse::<u64>().ok())
+        .collect()
+}
+
+fn binary_path_matches_current_identity(metadata_path: &str, identity_path: &str) -> bool {
+    if metadata_path == identity_path {
+        return true;
+    }
+    test_harness_binary_path_matches(metadata_path)
+}
+
+/// Test harness escape hatch for integration tests whose process identity is the
+/// test binary while fixture metadata intentionally points at the built CLI.
+/// Production must not infer this from path shape; callers must set the
+/// `TEAM_AGENT_TEST_HARNESS_BINARY_PATH_MATCH` env explicitly to either the
+/// expected binary path or the target directory containing `team-agent`.
+fn test_harness_binary_path_matches(metadata_path: &str) -> bool {
+    let Ok(path) = std::env::var("TEAM_AGENT_TEST_HARNESS_BINARY_PATH_MATCH") else {
+        return false;
+    };
+    let path = PathBuf::from(path);
+    path_matches(metadata_path, &path)
+        || path_matches(metadata_path, &path.join("team-agent"))
+        || path
+            .parent()
+            .is_some_and(|parent| path_matches(metadata_path, &parent.join("team-agent")))
+}
+
+fn path_matches(metadata_path: &str, path: &Path) -> bool {
+    path.to_string_lossy() == metadata_path
+        || path
+            .canonicalize()
+            .ok()
+            .is_some_and(|path| path.to_string_lossy() == metadata_path)
+}
+
 /// `write_coordinator_metadata`(`metadata.py:46-61`)。写 `coordinator.json`(pretty indent=2),
 /// `updated_at = now(utc).isoformat()`。
 pub fn write_coordinator_metadata(

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

@@ -189,6 +189,29 @@ pub struct CoordinatorBinaryIdentity {
     pub binary_version: String,
 }
 
+/// Caller-relative daemon binary identity relation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CoordinatorBinaryIdentityRelation {
+    Same,
+    CallerNewerThanDaemon,
+    DaemonNewerThanCaller,
+    SameVersionPathMismatch,
+    Unknown,
+}
+
+impl CoordinatorBinaryIdentityRelation {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Same => "same",
+            Self::CallerNewerThanDaemon => "caller_newer_than_daemon",
+            Self::DaemonNewerThanCaller => "daemon_newer_than_caller",
+            Self::SameVersionPathMismatch => "same_version_path_mismatch",
+            Self::Unknown => "unknown",
+        }
+    }
+}
+
 /// Stable machine-readable reason for coordinator metadata rejection.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -285,6 +308,13 @@ pub struct HealthReport {
     pub metadata: Option<CoordinatorMetadata>,
     /// 三元全等(`coordinator_metadata_ok`,`metadata.py:37-43`)。
     pub metadata_ok: bool,
+    pub process_running: bool,
+    /// pid/protocol/schema match; excludes daemon binary identity.
+    pub wire_metadata_ok: bool,
+    pub binary_identity_ok: bool,
+    pub binary_identity_relation: CoordinatorBinaryIdentityRelation,
+    /// A live daemon that can process this workspace's queue.
+    pub service_available: bool,
     pub metadata_mismatch_reason: Option<String>,
     pub current_binary_identity: CoordinatorBinaryIdentity,
     pub schema: SchemaHealth,

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -50,6 +50,7 @@ pub(crate) fn reset_agent(
             })),
         });
     }
+    emit_newer_daemon_preserved_if_present(workspace)?;
     let lifecycle_workspace = lifecycle_workspace(workspace, owner_team, true)?;
     match crate::lifecycle::reset_agent(
         &lifecycle_workspace,
@@ -97,6 +98,7 @@ pub(crate) fn fork_agent(
     as_agent_id: &str,
     label: Option<&str>,
 ) -> ToolResult {
+    emit_newer_daemon_preserved_if_present(workspace)?;
     let lifecycle_workspace = lifecycle_workspace(workspace, owner_team, false)?;
     // operations.py:315 — the label becomes the forked agent's role.
     let report = crate::lifecycle::launch::fork_agent(
@@ -128,6 +130,41 @@ fn reset_refusal_reason(reason: ResetRefusal) -> Value {
     }
 }
 
+fn emit_newer_daemon_preserved_if_present(workspace: &Path) -> Result<(), super::super::ToolError> {
+    let workspace_path = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
+    let health = crate::coordinator::coordinator_health(&workspace_path);
+    if !(health.service_available
+        && !health.binary_identity_ok
+        && matches!(
+            health.binary_identity_relation,
+            crate::coordinator::CoordinatorBinaryIdentityRelation::DaemonNewerThanCaller
+        ))
+    {
+        return Ok(());
+    }
+    crate::event_log::EventLog::new(workspace)
+        .write(
+            "coordinator.newer_daemon_preserved",
+            serde_json::json!({
+                "pid": health.pid.map(|pid| pid.get()),
+                "binary_identity_relation": health.binary_identity_relation.as_str(),
+                "reason": "daemon_newer_than_caller",
+                "daemon_binary_path": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_path.clone()),
+                "daemon_binary_version": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_version.clone()),
+                "caller_binary_path": health.current_binary_identity.binary_path,
+                "caller_binary_version": health.current_binary_identity.binary_version,
+            }),
+        )
+        .map(|_| ())
+        .map_err(tool_runtime_error)
+}
+
 fn lifecycle_workspace(
     workspace: &Path,
     owner_team: Option<&TeamKey>,

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

@@ -319,6 +319,30 @@ fn coordinator_unavailable_outcome(
     if health.ok || matches!(health.status, CoordinatorHealthStatus::Missing) {
         return Ok(None);
     }
+    if health.service_available {
+        event_log.write(
+            "send.coordinator_binary_identity_drift_ignored",
+            serde_json::json!({
+                "recipient": recipient,
+                "sender": opts.sender,
+                "coordinator_status": health.status,
+                "coordinator_pid": health.pid.map(|pid| pid.get()),
+                "message_queued": true,
+                "binary_identity_relation": health.binary_identity_relation.as_str(),
+                "daemon_binary_path": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_path.clone()),
+                "daemon_binary_version": health
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.binary_version.clone()),
+                "caller_binary_path": health.current_binary_identity.binary_path,
+                "caller_binary_version": health.current_binary_identity.binary_version,
+            }),
+        )?;
+        return Ok(None);
+    }
     let warning = format!(
         "coordinator is not running; message was not queued for {recipient}. Run `team-agent diagnose` or restart the team before sending again."
     );
@@ -329,6 +353,7 @@ fn coordinator_unavailable_outcome(
             "sender": opts.sender,
             "coordinator_status": health.status,
             "coordinator_pid": health.pid.map(|pid| pid.get()),
+            "metadata_mismatch_reason": health.metadata_mismatch_reason,
             "message_queued": false,
             "warning": warning,
             "coordinator_log": crate::coordinator::coordinator_log_path(&coordinator_workspace)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.21",
+  "version": "0.5.23",
   "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.21",
-    "@team-agent/cli-darwin-x64": "0.5.21",
-    "@team-agent/cli-linux-x64": "0.5.21"
+    "@team-agent/cli-darwin-arm64": "0.5.23",
+    "@team-agent/cli-darwin-x64": "0.5.23",
+    "@team-agent/cli-linux-x64": "0.5.23"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",