@team-agent/installer 0.5.22 → 0.5.23

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.22"
+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.22"
+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

@@ -239,6 +239,14 @@ fn loud_ensure_coordinator(
     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,

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);
@@ -638,6 +728,60 @@ fn coordinator_metadata_mismatch_reason_with_identity(
     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;

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.22",
+  "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.22",
-    "@team-agent/cli-darwin-x64": "0.5.22",
-    "@team-agent/cli-linux-x64": "0.5.22"
+    "@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",