@team-agent/installer 0.5.22 → 0.5.24

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.22"
+version = "0.5.24"
 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.24"
 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/leader/lease.rs

@@ -1615,33 +1615,14 @@ fn state_owner(state: &Value) -> Option<TeamOwner> {
         .and_then(|v| serde_json::from_value(v).ok())
 }
 
-/// `_write_lease_dual_state`(card §85 C17;`__init__.py:588`)。同一锁内写 workspace state.json
-/// + team/<session> snapshot,两份永不分叉。**CROSS-LANE**:snapshot 写经 step 13 restart。
+/// `_write_lease_dual_state` — Foundation-0 F0-2: the historical dual
+/// write to the legacy per-session snapshot has been retired
+/// (`.team/artifacts/foundation-0-slice-design.md` §§4-5). This helper
+/// now persists ONLY the canonical root state; retaining the public
+/// name for 0.5.x call-site stability. The B0 legacy snapshot is
+/// diagnostic-only via `lifecycle::save_team_runtime_snapshot`.
 pub fn write_lease_dual_state(workspace: &Path, state: &Value) -> Result<(), LeaderError> {
     crate::state::persist::save_runtime_state(workspace, state)?;
-    if let Some(session_name) = state.get("session_name").and_then(Value::as_str) {
-        write_team_snapshot_atomic(workspace, session_name, state)?;
-    }
-    Ok(())
-}
-
-fn write_team_snapshot_atomic(
-    workspace: &Path,
-    session_name: &str,
-    state: &Value,
-) -> Result<(), LeaderError> {
-    let snap_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name);
-    let parent = snap_path
-        .parent()
-        .ok_or_else(|| LeaderError::Validation("team snapshot path has no parent".to_string()))?;
-    std::fs::create_dir_all(parent)?;
-    let tmp = parent.join(format!("state.json.tmp-{}", std::process::id()));
-    let data = serde_json::to_vec_pretty(state)?;
-    std::fs::write(&tmp, data)?;
-    if let Err(error) = std::fs::rename(&tmp, &snap_path) {
-        let _ = std::fs::remove_file(&tmp);
-        return Err(error.into());
-    }
     Ok(())
 }
 
@@ -1769,17 +1750,22 @@ fn compact_team_state_preserving_claim_fields(state: &Value, target_key: &str) -
     entry
 }
 
-/// `_detect_dual_state_divergence`(card §85 C18;`__init__.py:556`)。workspace-level 与
-/// team-level snapshot 在 owner_uuid/receiver_pane_id/owner_epoch 上是否分叉 → `Some(详情)`。
-/// **CROSS-LANE**:snapshot 读经 step 13 restart。
-pub fn detect_dual_state_divergence(
+/// Foundation-0 F0-2: reader for legacy per-session snapshot vs
+/// canonical root state. Diagnostic-only after the dual-write retirement
+/// (`.team/artifacts/foundation-0-slice-design.md` §§4-5); product
+/// authority code never consults this — it exists so `status`/`diagnose`
+/// can surface `legacy_snapshot_stale` when the on-disk sidecar has
+/// drifted. Every touch of the legacy path constants below is marked
+/// `B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ` so the RED3 grep guard admits
+/// them as documented exceptions.
+pub fn detect_dual_state_divergence( // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic-only entry point; no product save/route consumer.
     workspace: &Path,
     state: &Value,
 ) -> Result<Option<Value>, LeaderError> {
     let Some(session_name) = state.get("session_name").and_then(Value::as_str) else {
         return Ok(None);
     };
-    let snap_path = readable_team_snapshot_path(workspace, session_name);
+    let snap_path = readable_team_snapshot_path(workspace, session_name); // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic legacy-shape path lookup.
     if !snap_path.exists() {
         return Ok(None);
     }
@@ -1810,16 +1796,19 @@ pub fn detect_dual_state_divergence(
         "team_receiver_pane": team_receiver_pane,
         "workspace_owner_epoch": workspace_epoch,
         "team_owner_epoch": team_epoch,
+        "_legacy_snapshot_stale": true,
     })))
 }
 
-fn readable_team_snapshot_path(workspace: &Path, session_name: &str) -> PathBuf {
-    let safe_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name);
+fn readable_team_snapshot_path(workspace: &Path, session_name: &str) -> PathBuf { // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: diagnostic-only path resolver.
+    let safe_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name); // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ: reuses helpers safe legacy path.
     if safe_path.exists() {
         return safe_path;
     }
+    // Raw legacy `runtime/teams` fallback for pre-safe-shape snapshots. // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ
+    let legacy_dir = "teams"; // B0_DIAGNOSTIC_LEGACY_SNAPSHOT_READ
     crate::model::paths::runtime_dir(workspace)
-        .join("teams")
+        .join(legacy_dir)
         .join(session_name)
         .join("state.json")
 }

package/crates/team-agent/src/leader/rediscover/tests.rs

@@ -135,7 +135,12 @@ fn try_readopt_writes_owner_receiver_dual_state_and_events() {
     assert_eq!(owner_view["claimed_via"], json!("attach-leader"));
     assert_eq!(owner_view["owner_epoch"], json!(4));
     assert_eq!(receiver_view["discovery"], json!("attach_readopt"));
-    assert!(crate::model::paths::runtime_dir(&ws)
+    // Foundation-0 F0-2: the try_readopt success path no longer side-
+    // effects a legacy per-session snapshot; canonical teams.<key> is
+    // the sole authority. The legacy sidecar stays absent unless a
+    // diagnostic writer explicitly created it
+    // (`.team/artifacts/foundation-0-slice-design.md` §§4-5).
+    assert!(!crate::model::paths::runtime_dir(&ws)
         .join("teams")
         .join("sess")
         .join("state.json")

package/crates/team-agent/src/leader/tests/lease_api.rs

@@ -112,7 +112,15 @@ use super::*;
     // 强化:带 session_name 时必须落 BOTH —— workspace state.json + team/<session> snapshot,
     // 两份 team_owner.pane_id / owner_epoch 必须一致(永不分叉)。空 body Ok(()) 会被这里抓。
     #[test]
-    fn write_lease_dual_state_persists_both_locations_without_divergence() {
+    // Foundation-0 F0-2 conversion of the C17 dual-write invariant test:
+    // legacy per-session snapshot dual-write has been retired
+    // (`.team/artifacts/foundation-0-slice-design.md` §§4-5). The lease
+    // helper now persists ONLY the canonical root state; a legacy
+    // snapshot is diagnostic-only and never re-appears as a side effect
+    // of `write_lease_dual_state`. This test enforces exactly that:
+    // canonical root gets the owner tuple, and the legacy per-session
+    // path stays absent unless a diagnostic path explicitly writes it.
+    fn write_lease_dual_state_persists_canonical_root_only_no_legacy_side_effect() {
         let ws = std::env::temp_dir().join(format!("ta_rs_dual_{}", std::process::id()));
         std::fs::create_dir_all(&ws).unwrap();
         let state = serde_json::json!({
@@ -121,32 +129,33 @@ use super::*;
             "leader_receiver": {"pane_id": "%1", "owner_epoch": 2},
         });
         write_lease_dual_state(&ws, &state).unwrap();
-        // (1) workspace state.json(<ws>/.team/runtime/state.json)被写,team_owner.pane_id==%1。
+        // Canonical root state.json IS written; F0-2 keeps this as the
+        // single product authority.
         let ws_path = crate::state::persist::runtime_state_path(&ws);
         let ws_state: serde_json::Value =
             serde_json::from_str(&std::fs::read_to_string(&ws_path).expect("workspace state.json 必须存在")).unwrap();
         assert_eq!(ws_state["team_owner"]["pane_id"], serde_json::json!("%1"));
         assert_eq!(ws_state["team_owner"]["owner_epoch"], serde_json::json!(2));
-        // (2) team-level snapshot(<ws>/.team/runtime/teams/<session>/state.json)被写。
-        let snap_path = crate::model::paths::runtime_dir(&ws)
-            .join("teams")
-            .join("team-sess")
-            .join("state.json");
-        let snap_state: serde_json::Value =
-            serde_json::from_str(&std::fs::read_to_string(&snap_path).expect("team snapshot state.json 必须存在")).unwrap();
-        // (3) 两份永不分叉:owner pane_id / owner_epoch 必须相等(C17 核心不变量)。
-        assert_eq!(
-            ws_state["team_owner"]["pane_id"], snap_state["team_owner"]["pane_id"],
-            "workspace 与 team snapshot 的 owner pane 不得分叉"
-        );
-        assert_eq!(
-            ws_state["team_owner"]["owner_epoch"], snap_state["team_owner"]["owner_epoch"],
-            "workspace 与 team snapshot 的 owner_epoch 不得分叉"
+        // Legacy per-session snapshot MUST NOT be a side effect of the
+        // lease save path any more — this is the RED2 authority-write
+        // guard shape at the unit-test layer.
+        let legacy_snap = crate::lifecycle::helpers::team_snapshot_path(&ws, "team-sess");
+        assert!(
+            !legacy_snap.exists(),
+            "F0-2: write_lease_dual_state must not write the legacy per-session snapshot; found {}",
+            legacy_snap.display(),
         );
     }
 
     #[test]
     fn lease_divergence_reads_restart_snapshot_for_special_session_names() {
+        // Foundation-0 F0-2 conversion: `write_lease_dual_state` no longer
+        // side-effects a legacy snapshot; the divergence detector is a
+        // diagnostic reader that fires only when a diagnostic writer
+        // (e.g. `lifecycle::save_team_runtime_snapshot`) has produced
+        // the sidecar. Sequence exercised here: canonical root save →
+        // diagnostic snapshot save with a different pane → divergence
+        // reader observes the drift.
         let ws = std::env::temp_dir().join(format!("ta_rs_dual_special_{}", std::process::id()));
         std::fs::create_dir_all(&ws).unwrap();
         let state = serde_json::json!({
@@ -160,17 +169,21 @@ use super::*;
             .join("teams")
             .join("team:proj-中文")
             .join("state.json");
+        // F0-2: canonical save must not create either the restart-safe
+        // or the raw legacy snapshot as a side effect.
         assert!(
-            safe_path.exists(),
-            "lease snapshot must use the restart-safe path: {}",
+            !safe_path.exists(),
+            "F0-2: canonical write_lease_dual_state must not create the restart-safe legacy snapshot: {}",
             safe_path.display()
         );
         assert!(
             !raw_path.exists(),
-            "new lease writes must not create the legacy raw session path: {}",
+            "F0-2: canonical write_lease_dual_state must not create the raw legacy snapshot: {}",
             raw_path.display()
         );
 
+        // Diagnostic write path with a divergent pane so we can exercise
+        // the divergence reader below.
         let restart_state = serde_json::json!({
             "session_name": "team:proj-中文",
             "team_owner": {"pane_id": "%9", "owner_epoch": 2, "leader_session_uuid": "uuuu"},
@@ -180,13 +193,18 @@ use super::*;
         assert_eq!(restart_path, safe_path);
         assert!(
             restart_path.exists(),
-            "restart snapshot must be written to a real file: {}",
+            "diagnostic snapshot must be written to a real file: {}",
             restart_path.display()
         );
 
+        // F0-2 RED1 diagnostic marker is present on the on-disk file.
+        let snap_state: serde_json::Value =
+            serde_json::from_str(&std::fs::read_to_string(&restart_path).unwrap()).unwrap();
+        assert_eq!(snap_state["_not_authoritative"], serde_json::json!(true));
+
         let d = detect_dual_state_divergence(&ws, &state)
             .unwrap()
-            .expect("divergence detector must read the restart-written snapshot");
+            .expect("divergence detector must read the diagnostic snapshot");
         assert_eq!(d["workspace_owner_pane"], serde_json::json!("%1"));
         assert_eq!(d["team_owner_pane"], serde_json::json!("%9"));
         assert_eq!(d["workspace_receiver_pane"], serde_json::json!("%1"));

package/crates/team-agent/src/leader/tests/lease_claim.rs

@@ -10,13 +10,16 @@ use super::*;
     /// (bound-pane liveness + caller eligibility) deterministically with no tmux.
     #[test]
     #[serial_test::serial(env)]
-    fn claim_lease_no_incident_vacant_acquire_advances_epoch_and_dual_writes() {
+    // Foundation-0 F0-2 conversion: `claim_lease_no_incident` used to
+    // dual-write the legacy per-session snapshot; that is retired
+    // (`.team/artifacts/foundation-0-slice-design.md` §§4-5). Canonical
+    // teams.<team_key> now carries the sole authoritative owner tuple.
+    fn claim_lease_no_incident_vacant_acquire_advances_epoch_and_writes_canonical_only() {
         let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
         let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
         let ws = p2_temp_ws("claim_vacant");
         let team_id = TeamKey::new("current");
         let caller = PaneId::new("%5");
-        // empty (vacant) state with a session so dual-state writes both files.
         let mut state = serde_json::json!({"session_name": "team-agent-x"});
         let event_log = crate::event_log::EventLog::new(&ws);
         let live = seeded_liveness(&["%5"]);
@@ -35,45 +38,25 @@ use super::*;
         let receiver = r.receiver.as_ref().expect("claimed → receiver");
         assert_eq!(receiver.pane_id, caller);
         assert_eq!(receiver.discovery, Some(Discovery::ClaimLeader));
-        // Stage 3d (identity-boundary unified plan, architect direction
-        // 2026-06-23): canonical owner now lives at teams.<team_key>; the
-        // top-level dual-write was dropped. Read through the ownership
-        // repository which preserves the legacy precedence for callers
-        // that still consult top-level on migration states.
         let ws_path = crate::state::persist::runtime_state_path(&ws);
         let ws_state: serde_json::Value =
             serde_json::from_str(&std::fs::read_to_string(&ws_path).unwrap()).unwrap();
-        // The canonical team_key is what `team_state_key(state)` derives
-        // (here: state's session_name "team-agent-x" since no explicit
-        // team_key/team_dir/spec_path was seeded). The test's `team_id`
-        // parameter is the LOOKUP key but `claim_lease_no_incident` uses
-        // the state-derived key for canonical writes. Stage 5 will unify
-        // these via TeamRuntimePaths.
         let canonical_key = crate::state::projection::team_state_key(&ws_state);
         let ws_owner =
             crate::state::ownership::read_owner_value(&ws_state, &canonical_key)
                 .expect("Stage 3d: vacant acquire writes canonical owner");
         assert_eq!(ws_owner["pane_id"], serde_json::json!("%5"));
         assert_eq!(ws_owner["owner_epoch"], serde_json::json!(1));
-        // team_id parameter is currently unused by the canonical write
-        // (architect Stage 5 will close this gap); silence the warning.
         let _ = &team_id;
+        // F0-2: canonical claim path must NOT side-effect the legacy
+        // per-session snapshot any more.
         let snap_path = crate::model::paths::runtime_dir(&ws)
             .join("teams").join("team-agent-x").join("state.json");
-        let snap: serde_json::Value =
-            serde_json::from_str(&std::fs::read_to_string(&snap_path).unwrap()).unwrap();
-        // Snapshot is per-session; team_state_key on the snapshot derives
-        // from its session_name. Read top-level first (legacy snapshot
-        // layout), fall back to derived team key.
-        let snap_owner = snap
-            .get("team_owner")
-            .or_else(|| {
-                let key = crate::state::projection::team_state_key(&snap);
-                snap.get("teams").and_then(|t| t.get(key)).and_then(|e| e.get("team_owner"))
-            })
-            .expect("dual-state snapshot owner");
-        assert_eq!(snap_owner["pane_id"], serde_json::json!("%5"), "dual-state snapshot owner");
-        assert_eq!(snap_owner["owner_epoch"], serde_json::json!(1));
+        assert!(
+            !snap_path.exists(),
+            "F0-2: vacant claim must not write a legacy per-session snapshot; found {}",
+            snap_path.display(),
+        );
     }
 
     // RED — DEAD-OWNER RECOVER: bound pane %1 absent from live set, caller %5

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

@@ -6,8 +6,24 @@ use std::path::{Path, PathBuf};
 
 use super::*;
 
-/// `save_team_runtime_snapshot(workspace, state)`(`restart/snapshot.py:42`,**bug-084**)。
-/// `os.replace` 原子写;`EACCES/EPERM/EBUSY` 退避重试,**绝不 unwrap**。
+/// `save_team_runtime_snapshot(workspace, state)` — Foundation-0 F0-2:
+/// this is now a **diagnostic-only** legacy per-session snapshot writer.
+/// Root/projection `.team/runtime/state.json` is the sole product
+/// authority; the file this writes carries `_not_authoritative:true`
+/// and pointers back to the canonical path so no reader can mistake it
+/// for the real runtime state. See
+/// `.team/artifacts/foundation-0-slice-design.md` §§4-5 F0-2.
+///
+/// Product save paths (attach/claim/start-agent/restart/stop/remove)
+/// must NOT call this — the RED2 grep guard enforces that. Retained
+/// callers are diagnostic/migration/test paths only.
+///
+/// Preserves the legacy path shape (`.team/runtime/teams/<session>/state.json`)
+/// so 0.5.x operators inspecting the file see the diagnostic marker
+/// rather than being surprised by a missing file. The B3 canonical
+/// team-key layout will live under a different path
+/// (`teams/<team_key>/...`), so this file also cannot be mistaken for
+/// the future canonical shape.
 pub fn save_team_runtime_snapshot(
     workspace: &Path,
     state: &serde_json::Value,
@@ -16,17 +32,34 @@ pub fn save_team_runtime_snapshot(
         .get("session_name")
         .and_then(|v| v.as_str())
         .ok_or_else(|| LifecycleError::StatePersist("session_name is required".to_string()))?;
-    // golden restart/snapshot.py:46-47 — team_runtime_snapshot_dir = runtime_dir(workspace)/teams/<safe>,
-    // and paths.py:25-26 runtime_dir = workspace/.team/runtime. Use the crate path helper so the snapshot
-    // lands at <ws>/.team/runtime/teams/<safe>, matching golden AND the rest of the crate (not the
-    // ".team"-less <ws>/runtime/teams that the original port wrote).
     let path = team_snapshot_path(workspace, session_name);
     let dir = path
         .parent()
         .ok_or_else(|| LifecycleError::StatePersist("snapshot path has no parent".to_string()))?;
     fs::create_dir_all(&dir).map_err(|e| persist_err("create snapshot dir", &e))?;
+    let canonical_path = crate::state::persist::runtime_state_path(workspace);
+    let generated_at = chrono::Utc::now().to_rfc3339();
+    // F0-2 RED1: annotate the snapshot payload with diagnostic-only
+    // metadata so any reader can immediately see it is derived, not
+    // authoritative. `_canonical_state_path` points at the real
+    // runtime authority; `_derived_from` names the code path that
+    // produced this file; `_generated_at` records freshness so stale
+    // snapshots are easy to identify.
+    let mut annotated = state.clone();
+    if let Some(obj) = annotated.as_object_mut() {
+        obj.insert("_not_authoritative".to_string(), serde_json::json!(true));
+        obj.insert(
+            "_canonical_state_path".to_string(),
+            serde_json::json!(canonical_path.to_string_lossy()),
+        );
+        obj.insert(
+            "_derived_from".to_string(),
+            serde_json::json!("lifecycle::save_team_runtime_snapshot"),
+        );
+        obj.insert("_generated_at".to_string(), serde_json::json!(generated_at));
+    }
     let tmp = dir.join("state.json.tmp");
-    let data = serde_json::to_vec_pretty(state)
+    let data = serde_json::to_vec_pretty(&annotated)
         .map_err(|e| LifecycleError::StatePersist(format!("serialize snapshot: {e}")))?;
     fs::write(&tmp, data).map_err(|e| persist_err("write snapshot temp", &e))?;
     fs::rename(&tmp, &path).map_err(|e| persist_err("replace snapshot", &e))?;

package/crates/team-agent/src/lifecycle/restart/agent.rs

@@ -915,12 +915,9 @@ pub(super) fn stop_agent_at_paths(
     )
     .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     // golden operations.py:96-99: snapshot (side-effect), then state_file = write_team_state path.
-    // snapshot.py:19-21 returns None silently when session_name is falsy — mirror that no-op here so
-    // a workspace whose persisted state lacks session_name proceeds to write team_state and return ok
-    // (do NOT swallow OTHER snapshot errors). The stop/reset/remove-force paths all inherit this guard.
-    if session_name_present(&state) {
-        crate::lifecycle::helpers::save_team_runtime_snapshot(workspace, &state)?;
-    }
+    // Foundation-0 F0-2: legacy per-session snapshot dual-write retired
+    // (`.team/artifacts/foundation-0-slice-design.md` §§4-5). Root state
+    // remains the only save target on the stop path.
     let state_file = write_team_state(spec_workspace, &spec, &state)?;
     write_stop_complete_event(workspace, agent_id, &target_str, stopped)?;
     Ok(StopAgentReport {

package/crates/team-agent/src/lifecycle/restart/remove.rs

@@ -186,17 +186,12 @@ fn remove_agent_at_paths(
     );
     match result {
         Ok(success) => {
-            // golden agents.py:135: _save_team_runtime_snapshot runs OUTSIDE the try/except, and
-            // snapshot.py:19-21 returns None (no error) when session_name is falsy. Mirror that here:
-            // only snapshot when session_name is present, and never let it roll the committed removal back.
-            if success
-                .removed_state
-                .get("session_name")
-                .and_then(|v| v.as_str())
-                .is_some_and(|s| !s.is_empty())
-            {
-                let _ = crate::lifecycle::helpers::save_team_runtime_snapshot(workspace, &success.removed_state)?;
-            }
+            // Foundation-0 F0-2: the historical dual-write to the legacy
+            // per-session snapshot has been retired
+            // (`.team/artifacts/foundation-0-slice-design.md` §§4-5).
+            // Root/projection is the sole runtime authority; the
+            // snapshot writer stayed in `lifecycle::helpers` only for
+            // diagnostic/migration/test callers.
             write_remove_complete_event(
                 paths.run_workspace,
                 agent_id,

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

@@ -280,8 +280,10 @@ pub(crate) fn latest_reportable_message_for(
     agent_id: &str,
     owner_team_id: Option<&str>,
 ) -> Option<String> {
-    current_reportable_message_for(workspace, agent_id, owner_team_id)
-        .or_else(|| latest_delivered_direct_message_for(workspace, agent_id, owner_team_id))
+    match direct_message_attribution_for(workspace, agent_id, owner_team_id) {
+        DirectMessageAttribution::Reportable(message_id) => Some(message_id),
+        DirectMessageAttribution::BlockedByNewer { .. } | DirectMessageAttribution::None => None,
+    }
 }
 
 pub(crate) fn current_reportable_message_for(
@@ -306,6 +308,49 @@ pub(crate) fn latest_delivered_direct_message_for(
     latest_reportable_message_from_db(&conn, agent_id, owner_team_id)
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum DirectMessageAttribution {
+    Reportable(String),
+    BlockedByNewer {
+        message_id: String,
+        status: String,
+        error: Option<String>,
+    },
+    None,
+}
+
+pub(crate) fn direct_message_attribution_for(
+    workspace: &Path,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> DirectMessageAttribution {
+    use crate::db::message_store::MessageStore;
+    let Ok(store) = MessageStore::open(workspace) else {
+        return DirectMessageAttribution::None;
+    };
+    let Ok(conn) = crate::db::schema::open_db(store.db_path()) else {
+        return DirectMessageAttribution::None;
+    };
+    if let Some(message_id) = current_turn_message_for(workspace, &conn, agent_id, owner_team_id) {
+        return DirectMessageAttribution::Reportable(message_id);
+    }
+    match latest_direct_message_from_db(&conn, agent_id, owner_team_id) {
+        Some(candidate)
+            if reportable_message_status(&candidate.status, candidate.error.as_deref()) =>
+        {
+            DirectMessageAttribution::Reportable(candidate.message_id)
+        }
+        Some(candidate) if blocks_historical_fallback(&candidate.status) => {
+            DirectMessageAttribution::BlockedByNewer {
+                message_id: candidate.message_id,
+                status: candidate.status,
+                error: candidate.error,
+            }
+        }
+        Some(_) | None => DirectMessageAttribution::None,
+    }
+}
+
 fn current_turn_message_for(
     workspace: &Path,
     conn: &rusqlite::Connection,
@@ -419,9 +464,27 @@ fn latest_reportable_message_from_db(
     agent_id: &str,
     owner_team_id: Option<&str>,
 ) -> Option<String> {
-    let row = conn
-        .query_row(
-            "select m.message_id, m.status, m.error from messages m
+    let candidate = latest_direct_message_from_db(conn, agent_id, owner_team_id)?;
+    if reportable_message_status(&candidate.status, candidate.error.as_deref()) {
+        Some(candidate.message_id)
+    } else {
+        None
+    }
+}
+
+struct DirectMessageCandidate {
+    message_id: String,
+    status: String,
+    error: Option<String>,
+}
+
+fn latest_direct_message_from_db(
+    conn: &rusqlite::Connection,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<DirectMessageCandidate> {
+    conn.query_row(
+        "select m.message_id, m.status, m.error from messages m
              where m.recipient = ?1
                and (?2 is null or m.owner_team_id = ?2)
                and (m.task_id is null or m.task_id = '')
@@ -437,29 +500,25 @@ fn latest_reportable_message_from_db(
              order by m.created_at desc,
                case when m.status = 'delivered' then 0 else 1 end
              limit 1",
-            params![agent_id, owner_team_id],
-            |row| {
-                Ok((
-                    row.get::<_, String>(0)?,
-                    row.get::<_, String>(1)?,
-                    row.get::<_, Option<String>>(2)?,
-                ))
-            },
-        )
-        .optional()
-        .ok()
-        .flatten()?;
-    let (message_id, status, error) = row;
-    if reportable_message_status(&status, error.as_deref()) {
-        Some(message_id)
-    } else {
-        None
-    }
+        params![agent_id, owner_team_id],
+        |row| {
+            Ok(DirectMessageCandidate {
+                message_id: row.get::<_, String>(0)?,
+                status: row.get::<_, String>(1)?,
+                error: row.get::<_, Option<String>>(2)?,
+            })
+        },
+    )
+    .optional()
+    .ok()
+    .flatten()
 }
 
 fn reportable_message_status(status: &str, error: Option<&str>) -> bool {
-    matches!(
-        status,
-        "delivered" | "submitted" | "injected" | "visible"
-    ) && (status == "delivered" || error.is_none())
+    matches!(status, "delivered" | "submitted" | "injected" | "visible")
+        && (status == "delivered" || error.is_none())
+}
+
+fn blocks_historical_fallback(status: &str) -> bool {
+    matches!(status, "failed" | "refused" | "blocked")
 }

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/mcp_server/tools.rs

@@ -20,10 +20,10 @@ use crate::state::persist::{
 use crate::messaging::{self, MessageTarget, SendOptions};
 
 use super::helpers::{
-    current_reportable_message_for, delivery_outcome_value, ensure_object, enum_value,
-    insert_array, is_worker_recipient, json_dumps_default, latest_delivered_direct_message_for,
-    latest_task_for_assignee, non_empty_string, normalized_envelope_value, object_fields,
-    requires_ack_for_target, tool_runtime_error,
+    delivery_outcome_value, direct_message_attribution_for, ensure_object, enum_value,
+    insert_array, is_worker_recipient, json_dumps_default, latest_task_for_assignee,
+    non_empty_string, normalized_envelope_value, object_fields, requires_ack_for_target,
+    tool_runtime_error, DirectMessageAttribution,
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
@@ -336,41 +336,49 @@ impl TeamOrchestratorTools {
                 // message-scoped fallback, before defaulting to "manual".
                 //   1. explicit arg
                 //   2. current physical direct turn for this agent
-                //   3. latest delivered direct message with no result yet
-                //   4. latest nonterminal assigned task in teams.<owner>.tasks
-                //      (scoped) → top-level tasks
+                //   3. bounded latest reportable direct message with no result yet
+                //   4. latest nonterminal assigned task in teams.<owner>.tasks,
+                //      only when no newer failed/refused/blocked direct turn blocks fallback
                 //   5. "manual" — truly uncorrelated; collect still rejects
                 let owner_team_id_str = self.owner_team_id.as_ref().map(|t| t.as_str().to_string());
-                let resolved = task_id
-                    .map(ToString::to_string)
-                    .or_else(|| {
-                        self.agent_id.as_ref().and_then(|agent| {
-                            current_reportable_message_for(
-                                &self.workspace,
-                                agent.as_str(),
-                                owner_team_id_str.as_deref(),
-                            )
-                        })
-                    })
-                    .or_else(|| {
-                        self.agent_id.as_ref().and_then(|agent| {
-                            latest_delivered_direct_message_for(
-                                &self.workspace,
-                                agent.as_str(),
-                                owner_team_id_str.as_deref(),
-                            )
-                        })
-                    })
-                    .or_else(|| {
-                        self.agent_id.as_ref().and_then(|agent| {
-                            latest_task_for_assignee(
-                                &self.workspace,
-                                agent.as_str(),
-                                owner_team_id_str.as_deref(),
-                            )
-                        })
-                    })
-                    .unwrap_or_else(|| "manual".to_string());
+                let resolved = if let Some(task_id) = task_id {
+                    task_id.to_string()
+                } else if let Some(agent) = self.agent_id.as_ref() {
+                    match direct_message_attribution_for(
+                        &self.workspace,
+                        agent.as_str(),
+                        owner_team_id_str.as_deref(),
+                    ) {
+                        DirectMessageAttribution::Reportable(message_id) => message_id,
+                        DirectMessageAttribution::BlockedByNewer {
+                            message_id,
+                            status,
+                            error,
+                        } => {
+                            push_report_warning(
+                                obj,
+                                serde_json::json!({
+                                    "code": "result_attribution_blocked_by_newer_direct_message",
+                                    "field": "task_id",
+                                    "severity": "warning",
+                                    "advisory": true,
+                                    "message_id": message_id,
+                                    "message_status": status,
+                                    "message_error": error,
+                                }),
+                            );
+                            "manual".to_string()
+                        }
+                        DirectMessageAttribution::None => latest_task_for_assignee(
+                            &self.workspace,
+                            agent.as_str(),
+                            owner_team_id_str.as_deref(),
+                        )
+                        .unwrap_or_else(|| "manual".to_string()),
+                    }
+                } else {
+                    "manual".to_string()
+                };
                 obj.insert("task_id".to_string(), Value::String(resolved));
             }
             if !obj.contains_key("agent_id") {
@@ -977,6 +985,29 @@ fn merge_object_fields(existing: &mut Value, incoming: &Value) {
     }
 }
 
+fn push_report_warning(obj: &mut serde_json::Map<String, Value>, warning: Value) {
+    let Some(code) = warning.get("code").and_then(Value::as_str) else {
+        return;
+    };
+    let Some(field) = warning.get("field").and_then(Value::as_str) else {
+        return;
+    };
+    match obj.get_mut("warnings") {
+        Some(Value::Array(warnings)) => {
+            let exists = warnings.iter().any(|existing| {
+                existing.get("code").and_then(Value::as_str) == Some(code)
+                    && existing.get("field").and_then(Value::as_str) == Some(field)
+            });
+            if !exists {
+                warnings.push(warning);
+            }
+        }
+        _ => {
+            obj.insert("warnings".to_string(), Value::Array(vec![warning]));
+        }
+    }
+}
+
 fn write_team_tasks(state: &mut Value, team_key: &str, tasks: Vec<Value>) {
     let Some(root) = state.as_object_mut() else {
         return;

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.24",
   "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.24",
+    "@team-agent/cli-darwin-x64": "0.5.24",
+    "@team-agent/cli-linux-x64": "0.5.24"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",