@team-agent/installer 0.5.15 → 0.5.17

package/Cargo.lock

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

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

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

package/crates/team-agent/src/leader/lease.rs

@@ -634,10 +634,28 @@ fn claim_lease_no_incident_with_target(
     let bound_endpoint_matches_caller = bound_endpoint_matches_current_process(state);
     if bound_pane_id.as_deref() == Some(caller_pane.as_str()) && bound_endpoint_matches_caller {
         let current_endpoint = crate::tmux_backend::socket_name_from_tmux_env();
-        let (topology_convergence, converged) =
+        let (mut topology_convergence, converged) =
             apply_endpoint_convergence(state, team_id, current_endpoint.as_deref(), pre_epoch);
         if converged {
             write_claim_state(workspace, state, scoped_team, team)?;
+            topology_convergence = verify_persisted_topology_convergence(
+                workspace,
+                team_id.as_str(),
+                topology_convergence,
+                pre_epoch,
+            )?;
+            if topology_convergence
+                .as_ref()
+                .and_then(|metadata| metadata.get("status"))
+                .and_then(Value::as_str)
+                != Some("converged")
+            {
+                return Ok(convergence_persistence_refusal(
+                    topology_convergence,
+                    pre_epoch,
+                    Some(caller_pane.clone()),
+                ));
+            }
         }
         return Ok(LeaseResult {
             ok: true,
@@ -788,9 +806,29 @@ fn claim_lease_no_incident_with_target(
     );
     let owner = make_owner(provider, &non_empty_caller_pane, &identity, next_epoch);
     write_binding_to_state(state, &receiver, &owner)?;
-    let (topology_convergence, _) =
+    let (mut topology_convergence, converged) =
         apply_endpoint_convergence(state, team_id, receiver.tmux_socket.as_deref(), next_epoch);
     write_claim_state(workspace, state, scoped_team, team)?;
+    if converged {
+        topology_convergence = verify_persisted_topology_convergence(
+            workspace,
+            team_id.as_str(),
+            topology_convergence,
+            next_epoch,
+        )?;
+        if topology_convergence
+            .as_ref()
+            .and_then(|metadata| metadata.get("status"))
+            .and_then(Value::as_str)
+            != Some("converged")
+        {
+            return Ok(convergence_persistence_refusal(
+                topology_convergence,
+                next_epoch,
+                Some(caller_pane.clone()),
+            ));
+        }
+    }
     let uuid_prefix = identity.leader_session_uuid.as_str().chars().take(8).collect::<String>();
     if reason == LeaseReason::PreviousOwnerPaneDead {
         event_log.write(
@@ -962,6 +1000,124 @@ fn write_convergence_marker(state: &mut Value, team_id: &str, metadata: &Value)
     }
 }
 
+fn verify_persisted_topology_convergence(
+    workspace: &Path,
+    team_id: &str,
+    metadata: Option<Value>,
+    owner_epoch: OwnerEpoch,
+) -> Result<Option<Value>, LeaderError> {
+    let Some(mut metadata) = metadata else {
+        return Ok(None);
+    };
+    if metadata.get("status").and_then(Value::as_str) != Some("converged") {
+        return Ok(Some(metadata));
+    }
+    let Some(new_endpoint) = metadata
+        .get("new_tmux_endpoint")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+    else {
+        mark_convergence_persistence_conflict(&mut metadata, team_id);
+        return Ok(Some(metadata));
+    };
+    let state = crate::state::persist::load_runtime_state(workspace)?;
+    if endpoint_convergence_persisted(&state, team_id, &new_endpoint, owner_epoch.0) {
+        mark_convergence_persisted(&mut metadata, team_id);
+    } else {
+        mark_convergence_persistence_conflict(&mut metadata, team_id);
+    }
+    Ok(Some(metadata))
+}
+
+fn endpoint_convergence_persisted(
+    state: &Value,
+    team_id: &str,
+    endpoint: &str,
+    owner_epoch: u64,
+) -> bool {
+    if !endpoint_convergence_node_matches(state, endpoint, owner_epoch) {
+        return false;
+    }
+    state
+        .get("teams")
+        .and_then(Value::as_object)
+        .and_then(|teams| teams.get(team_id))
+        .is_some_and(|team| endpoint_convergence_node_matches(team, endpoint, owner_epoch))
+}
+
+fn endpoint_convergence_node_matches(node: &Value, endpoint: &str, owner_epoch: u64) -> bool {
+    node.get("tmux_endpoint").and_then(Value::as_str) == Some(endpoint)
+        && node.get("tmux_socket").and_then(Value::as_str) == Some(endpoint)
+        && node.get("tmux_socket_source").and_then(Value::as_str) == Some("leader_env")
+        && node
+            .get("topology_convergence")
+            .and_then(|marker| marker.get("status"))
+            .and_then(Value::as_str)
+            == Some("converged")
+        && node
+            .get("topology_convergence")
+            .and_then(|marker| marker.get("owner_epoch"))
+            .and_then(Value::as_u64)
+            == Some(owner_epoch)
+}
+
+fn mark_convergence_persisted(metadata: &mut Value, team_id: &str) {
+    let Some(obj) = metadata.as_object_mut() else {
+        return;
+    };
+    obj.insert("persisted".to_string(), json!(true));
+    obj.insert("checked_paths".to_string(), json!(convergence_checked_paths(team_id)));
+}
+
+fn mark_convergence_persistence_conflict(metadata: &mut Value, team_id: &str) {
+    let Some(obj) = metadata.as_object_mut() else {
+        return;
+    };
+    obj.insert("status".to_string(), json!("persistence_conflict"));
+    obj.insert("persisted".to_string(), json!(false));
+    obj.insert("checked_paths".to_string(), json!(convergence_checked_paths(team_id)));
+    obj.insert(
+        "action".to_string(),
+        json!("endpoint convergence was not durably persisted; retry claim-leader or takeover"),
+    );
+}
+
+fn convergence_checked_paths(team_id: &str) -> Vec<String> {
+    [
+        "/tmux_endpoint".to_string(),
+        "/tmux_socket".to_string(),
+        "/tmux_socket_source".to_string(),
+        "/topology_convergence".to_string(),
+        format!("/teams/{team_id}/tmux_endpoint"),
+        format!("/teams/{team_id}/tmux_socket"),
+        format!("/teams/{team_id}/tmux_socket_source"),
+        format!("/teams/{team_id}/topology_convergence"),
+    ]
+    .into_iter()
+    .collect()
+}
+
+fn convergence_persistence_refusal(
+    topology_convergence: Option<Value>,
+    owner_epoch: OwnerEpoch,
+    bound_pane_id: Option<PaneId>,
+) -> LeaseResult {
+    LeaseResult {
+        ok: false,
+        status: LeaseStatus::Refused,
+        receiver: None,
+        owner: None,
+        owner_epoch: Some(owner_epoch),
+        reason: Some(LeaseReason::OwnerEpochAdvanced),
+        action: Some(
+            "endpoint convergence was not durably persisted; retry claim-leader or takeover"
+                .to_string(),
+        ),
+        bound_pane_id,
+        topology_convergence,
+    }
+}
+
 fn refused(
     reason: LeaseReason,
     action: &str,
@@ -1531,7 +1687,7 @@ fn save_claim_team_scoped_state(workspace: &Path, state: &Value, target_key: &st
     // preserving helper so the canonical fields survive the compaction.
     teams.insert(
         target_key.to_string(),
-        compact_team_state_preserving_ownership(state, target_key),
+        compact_team_state_preserving_claim_fields(state, target_key),
     );
     let existing_primary_key = existing
         .get("session_name")
@@ -1584,7 +1740,7 @@ fn value_object(value: &Value) -> serde_json::Map<String, Value> {
 ///   and copy each present field into the compacted entry.
 /// - Top-level owner fields stay UNTOUCHED — Stage 3d's canonical-only
 ///   shape is preserved on disk.
-fn compact_team_state_preserving_ownership(state: &Value, target_key: &str) -> Value {
+fn compact_team_state_preserving_claim_fields(state: &Value, target_key: &str) -> Value {
     let mut entry = crate::state::projection::compact_team_state(state);
     let Some(entry_obj) = entry.as_object_mut() else {
         return entry;
@@ -1597,7 +1753,15 @@ fn compact_team_state_preserving_ownership(state: &Value, target_key: &str) -> V
     else {
         return entry;
     };
-    for key in ["team_owner", "leader_receiver", "owner_epoch"] {
+    for key in [
+        "team_owner",
+        "leader_receiver",
+        "owner_epoch",
+        "tmux_endpoint",
+        "tmux_socket",
+        "tmux_socket_source",
+        "topology_convergence",
+    ] {
         if let Some(value) = owner_obj.get(key) {
             entry_obj.insert(key.to_string(), value.clone());
         }

package/crates/team-agent/src/leader/registry.rs

@@ -22,6 +22,7 @@
 use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
 use sha2::{Digest, Sha256};
 
 use crate::transport::Transport;
@@ -98,6 +99,26 @@ pub const AMBIGUOUS_NAMES_FIELD: &str = "ambiguous_names";
 /// a fully-qualified form.
 pub const REASON_AMBIGUOUS: &str = "name_ambiguous";
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RegistryWriteOutcome {
+    pub status: &'static str,
+    pub path: Option<PathBuf>,
+    pub team_key: String,
+    pub workspace_hash: String,
+    pub source: String,
+    pub owner_epoch: u64,
+}
+
+impl RegistryWriteOutcome {
+    #[must_use]
+    pub fn response_json(&self) -> Value {
+        match &self.path {
+            Some(path) => json!({"status": self.status, "path": path.display().to_string()}),
+            None => json!({"status": self.status}),
+        }
+    }
+}
+
 /// Absolute path to `~/.team-agent/leaders`. Returns `None` when the
 /// caller has no HOME (e.g. some CI shells) — callers should treat this as
 /// "no registry" rather than an error, since registry is derived.
@@ -170,6 +191,89 @@ pub fn build_entry(
     }
 }
 
+/// After a canonical leader binding succeeds, write the derived host
+/// discovery entry from the just-persisted state. Registry failure is
+/// non-fatal: callers get a write_failed outcome and the binding remains
+/// successful.
+pub fn register_binding_from_state_best_effort(
+    workspace: &Path,
+    team: Option<&str>,
+    source: &str,
+) -> Option<RegistryWriteOutcome> {
+    let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
+        return None;
+    };
+    let team_key = match team.filter(|team| !team.is_empty()) {
+        Some(team) => team.to_string(),
+        None => crate::state::projection::team_state_key(&state),
+    };
+    let receiver = state
+        .get("teams")
+        .and_then(|value| value.as_object())
+        .and_then(|teams| teams.get(&team_key))
+        .and_then(|team| team.get("leader_receiver"))
+        .or_else(|| state.get("leader_receiver"))
+        .cloned()?;
+    let transport_kind = receiver
+        .get("transport_kind")
+        .and_then(Value::as_str)
+        .unwrap_or("direct_tmux")
+        .to_string();
+    let owner_epoch = receiver
+        .get("owner_epoch")
+        .and_then(Value::as_u64)
+        .or_else(|| {
+            state
+                .get("teams")
+                .and_then(|value| value.as_object())
+                .and_then(|teams| teams.get(&team_key))
+                .and_then(|team| team.get("owner_epoch"))
+                .and_then(Value::as_u64)
+        })
+        .unwrap_or(0);
+    let entry = build_entry(
+        workspace,
+        &team_key,
+        &transport_kind,
+        receiver,
+        owner_epoch,
+        source,
+        chrono::Utc::now().to_rfc3339(),
+    );
+    let event_log = crate::event_log::EventLog::new(workspace);
+    let write_result = write_entry_best_effort(&entry);
+    let status = if let Some(path) = &write_result {
+        let _ = event_log.write(
+            EVENT_REGISTERED,
+            json!({
+                "path": path.display().to_string(),
+                "team_key": team_key,
+                "workspace_hash": entry.workspace_hash,
+                "source": source,
+            }),
+        );
+        "registered"
+    } else {
+        let _ = event_log.write(
+            EVENT_WRITE_FAILED,
+            json!({
+                "team_key": team_key,
+                "workspace_hash": entry.workspace_hash,
+                "source": source,
+            }),
+        );
+        "write_failed"
+    };
+    Some(RegistryWriteOutcome {
+        status,
+        path: write_result,
+        team_key,
+        workspace_hash: entry.workspace_hash,
+        source: source.to_string(),
+        owner_epoch: entry.owner_epoch,
+    })
+}
+
 fn entry_filename(entry: &LeaderRegistryEntry) -> String {
     format!("{}__{}.json", entry.workspace_hash, entry.team_key)
 }

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

@@ -1404,6 +1404,11 @@ fn try_autobind_leader_after_restart(
     let team_str = team;
     match crate::leader::attach_leader(workspace, team_str, None, provider) {
         Ok(result) if result.ok => {
+            let _ = crate::leader::registry::register_binding_from_state_best_effort(
+                workspace,
+                team_str,
+                "restart-auto-attach",
+            );
             eprintln!(
                 "team_agent::restart auto_attach_leader ok pane={:?} team={:?}",
                 result.bound_pane_id.as_ref().map(|p| p.as_str()),

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -3,6 +3,9 @@ use crate::transport::test_support::OfflineTransport;
 use serde_json::json;
 use serial_test::serial;
 
+#[allow(dead_code)]
+struct HermeticTestEnv;
+
 const QS_TEAM_MD: &str =
     "---\nname: quickteam\nobjective: Quick start.\nprovider: codex\n---\n\nQuick-start team.\n";
 pub(super) const QS_VALID_ROLE: &str = "---\nname: implementer\nrole: Implementation Engineer\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nImplement bounded tasks.\n";

package/crates/team-agent/src/lifecycle/tests/phase_b_contracts.rs

@@ -19,6 +19,9 @@ use serde_json::json;
 use std::collections::BTreeSet;
 use std::time::Duration;
 
+#[allow(dead_code)]
+struct HermeticTestEnv;
+
 #[test]
 fn concurrent_reset_discard_session_serializes() {
     let ids = (1..=6).map(|n| format!("w{n}")).collect::<Vec<_>>();

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -9,22 +9,89 @@ use crate::transport::WindowName;
 use serde_json::{json, Map, Value};
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
 
 const ANCESTRY_ENV: &str = "TEAM_AGENT_TEST_PROCESS_ANCESTRY_ARGV_JSON";
-const CALLER_IDENTITY_ENVS: &[&str] = &[
-    "TMUX",
-    "TMUX_PANE",
-    "TEAM_AGENT_LEADER_PANE_ID",
-    "TEAM_AGENT_LEADER_SESSION_UUID",
-    "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
-    "TEAM_AGENT_LEADER_PROVIDER",
-    "TEAM_AGENT_MACHINE_FINGERPRINT",
-    "TEAM_AGENT_WORKSPACE",
-    "TEAM_AGENT_TEAM_ID",
-    "TEAM_AGENT_OWNER_TEAM_ID",
-    "TEAM_AGENT_ACTIVE_TEAM",
-    "TEAM_AGENT_ID",
-];
+
+static HERMETIC_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+struct HermeticTestEnv {
+    root: PathBuf,
+    previous: Vec<(&'static str, Option<String>)>,
+}
+
+impl HermeticTestEnv {
+    fn enter(tag: &str) -> Self {
+        let base = std::env::var_os("TEAM_AGENT_TEST_TMP")
+            .map(PathBuf::from)
+            .unwrap_or_else(std::env::temp_dir);
+        std::fs::create_dir_all(&base).expect("create hermetic test tmp root");
+        let root = base.join(format!(
+            "ta-phase-golden-{tag}-{}-{}",
+            std::process::id(),
+            HERMETIC_COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(root.join("home/.team-agent/leaders"))
+            .expect("create phase golden hermetic root");
+        let root = std::fs::canonicalize(root).expect("canonicalize phase golden hermetic root");
+        let home = root.join("home");
+        let mut previous = Vec::new();
+        for key in std::iter::once("HOME").chain(hermetic_caller_envs().iter().copied()) {
+            previous.push((key, std::env::var(key).ok()));
+        }
+        unsafe {
+            std::env::set_var("HOME", &home);
+            for key in hermetic_caller_envs() {
+                std::env::remove_var(key);
+            }
+        }
+        Self { root, previous }
+    }
+
+    fn workspace(&self, tag: &str) -> PathBuf {
+        let path = self.root.join(format!(
+            "workspace-{tag}-{}",
+            HERMETIC_COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&path).expect("create phase golden workspace");
+        std::fs::canonicalize(path).expect("canonicalize phase golden workspace")
+    }
+}
+
+impl Drop for HermeticTestEnv {
+    fn drop(&mut self) {
+        for (key, value) in self.previous.drain(..).rev() {
+            unsafe {
+                if let Some(value) = value {
+                    std::env::set_var(key, value);
+                } else {
+                    std::env::remove_var(key);
+                }
+            }
+        }
+        if std::env::var("TEAM_AGENT_KEEP_TEST_TMP").as_deref() != Ok("1") {
+            let _ = std::fs::remove_dir_all(&self.root);
+        }
+    }
+}
+
+fn hermetic_caller_envs() -> &'static [&'static str] {
+    &[
+        "TMUX",
+        "TMUX_PANE",
+        "TEAM_AGENT_LEADER_PANE_ID",
+        "TEAM_AGENT_LEADER_SESSION_UUID",
+        "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+        "TEAM_AGENT_LEADER_PROVIDER",
+        "TEAM_AGENT_MACHINE_FINGERPRINT",
+        "TEAM_AGENT_WORKSPACE",
+        "TEAM_AGENT_TEAM_ID",
+        "TEAM_AGENT_OWNER_TEAM_ID",
+        "TEAM_AGENT_ACTIVE_TEAM",
+        "TEAM_AGENT_ID",
+    ]
+}
 
 #[test]
 #[serial_test::serial(env)]
@@ -154,12 +221,9 @@ struct PhaseGolden {
 }
 
 fn run_phase_golden(spec: PhaseGolden) -> Value {
+    let hermetic = HermeticTestEnv::enter(spec.phase);
     let _permission_mode = EnvVarGuard::set(ANCESTRY_ENV, "[]");
-    let _caller_identity = CALLER_IDENTITY_ENVS
-        .iter()
-        .map(|key| EnvVarGuard::unset(key))
-        .collect::<Vec<_>>();
-    let team = two_worker_team_dir();
+    let team = two_worker_team_dir(&hermetic);
     let workspace = team.parent().expect("workspace").to_path_buf();
     seed_healthy_coordinator(&workspace);
     let launch_transport = codex_ready_transport();
@@ -298,8 +362,8 @@ fn phase_b_reset_discard_session(
     }
 }
 
-fn two_worker_team_dir() -> PathBuf {
-    let team = temp_ws().join("teamdir");
+fn two_worker_team_dir(hermetic: &HermeticTestEnv) -> PathBuf {
+    let team = hermetic.workspace("team").join("teamdir");
     std::fs::create_dir_all(team.join("agents")).unwrap();
     std::fs::write(
         team.join("TEAM.md"),
@@ -415,13 +479,6 @@ impl EnvVarGuard {
         Self { key, previous }
     }
 
-    fn unset(key: &'static str) -> Self {
-        let previous = std::env::var(key).ok();
-        unsafe {
-            std::env::remove_var(key);
-        }
-        Self { key, previous }
-    }
 }
 
 impl Drop for EnvVarGuard {

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

@@ -279,12 +279,31 @@ pub(crate) fn latest_reportable_message_for(
     workspace: &Path,
     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))
+}
+
+pub(crate) fn current_reportable_message_for(
+    workspace: &Path,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
 ) -> Option<String> {
     use crate::db::message_store::MessageStore;
     let store = MessageStore::open(workspace).ok()?;
     let conn = crate::db::schema::open_db(store.db_path()).ok()?;
     current_turn_message_for(workspace, &conn, agent_id, owner_team_id)
-        .or_else(|| latest_reportable_message_from_db(&conn, agent_id, owner_team_id))
+}
+
+pub(crate) fn latest_delivered_direct_message_for(
+    workspace: &Path,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<String> {
+    use crate::db::message_store::MessageStore;
+    let store = MessageStore::open(workspace).ok()?;
+    let conn = crate::db::schema::open_db(store.db_path()).ok()?;
+    latest_reportable_message_from_db(&conn, agent_id, owner_team_id)
 }
 
 fn current_turn_message_for(
@@ -441,6 +460,6 @@ fn latest_reportable_message_from_db(
 fn reportable_message_status(status: &str, error: Option<&str>) -> bool {
     matches!(
         status,
-        "delivered" | "target_resolved" | "submitted" | "injected" | "visible"
+        "delivered" | "submitted" | "injected" | "visible"
     ) && (status == "delivered" || error.is_none())
 }

package/crates/team-agent/src/mcp_server/tests/tools.rs

@@ -110,8 +110,16 @@
         .unwrap();
     }
 
+    fn seed_report_scope_state(ws: &std::path::Path, state: &Value) {
+        let cws = std::fs::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
+        let rt = cws.join(".team").join("runtime");
+        std::fs::create_dir_all(&rt).unwrap();
+        std::fs::write(rt.join("state.json"), serde_json::to_string_pretty(state).unwrap())
+            .unwrap();
+    }
+
     #[test]
-    fn report_result_prefers_current_inflight_message_over_old_delivered_fallback() {
+    fn report_result_prefers_current_turn_message_over_old_delivered_fallback() {
         let ws = unique_ws("report-current-message");
         seed_report_message(
             &ws,
@@ -134,6 +142,33 @@
             "target_resolved",
             "2026-07-06T13:27:35.000000+00:00",
         );
+        // 0.5.16 result-attribution-race-locate.md §4/§7.7:
+        // target_resolved alone is not physical-submit proof. Current-turn
+        // attribution comes from the state pointer armed at physical submit.
+        seed_report_scope_state(
+            &ws,
+            &json!({
+                "active_team_key": "gate055",
+                "teams": {
+                    "gate055": {
+                        "team_key": "gate055",
+                        "coordinator": {
+                            "turn_open": {
+                                "armed": true,
+                                "node_id": "probe-worker",
+                                "turn_id": "msg_new"
+                            }
+                        },
+                        "agents": {
+                            "probe-worker": {
+                                "id": "probe-worker",
+                                "current_turn_message_id": "msg_new"
+                            }
+                        }
+                    }
+                }
+            }),
+        );
 
         let tools = TeamOrchestratorTools::with_identity(
             &ws,
@@ -149,7 +184,62 @@
         assert_eq!(
             v.get("task_id"),
             Some(&json!("msg_new")),
-            "current in-flight message must beat stale delivered fallback"
+            "current-turn message must beat stale delivered fallback"
+        );
+    }
+
+    #[test]
+    fn report_result_target_resolved_without_current_turn_uses_task_fallback() {
+        let ws = unique_ws("report-target-resolved-no-current");
+        seed_report_message(
+            &ws,
+            "msg_target_only",
+            "gate055",
+            "target_resolved",
+            "2026-07-06T13:27:35.000000+00:00",
+        );
+        seed_report_scope_state(
+            &ws,
+            &json!({
+                "active_team_key": "gate055",
+                "teams": {
+                    "gate055": {
+                        "team_key": "gate055",
+                        "tasks": [
+                            {
+                                "id": "task_initial",
+                                "assignee": "probe-worker",
+                                "status": "pending"
+                            }
+                        ],
+                        "agents": {
+                            "probe-worker": {"id": "probe-worker"}
+                        }
+                    }
+                }
+            }),
+        );
+
+        let tools = TeamOrchestratorTools::with_identity(
+            &ws,
+            Some(AgentId::new("probe-worker")),
+            Some(TeamKey::new("gate055")),
+        );
+        let ok = tools.report_result(
+            None, Some("target resolved only"), ResultStatus::Success,
+            None, None, None, None, None,
+            None, None,
+        ).expect("report ok");
+        let v = serde_json::to_value(&ok).unwrap();
+        assert_ne!(
+            v.get("task_id"),
+            Some(&json!("msg_target_only")),
+            "0.5.16 locate §4/§7.7: target_resolved is a delivery claim, not physical-submit proof"
+        );
+        assert_eq!(
+            v.get("task_id"),
+            Some(&json!("task_initial")),
+            "without a current-turn pointer, no-task report_result falls through to task fallback"
         );
     }
 

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

@@ -20,9 +20,10 @@ use crate::state::persist::{
 use crate::messaging::{self, MessageTarget, SendOptions};
 
 use super::helpers::{
-    delivery_outcome_value, ensure_object, enum_value, insert_array, is_worker_recipient,
-    json_dumps_default, latest_reportable_message_for, latest_task_for_assignee, non_empty_string,
-    normalized_envelope_value, object_fields, requires_ack_for_target, tool_runtime_error,
+    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,
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
@@ -334,18 +335,26 @@ impl TeamOrchestratorTools {
                 // Blocker-1 (prerelease 0.4.0): scoped-team task inference +
                 // message-scoped fallback, before defaulting to "manual".
                 //   1. explicit arg
-                //   2. latest nonterminal task assigned to this agent in
-                //      teams.<owner>.tasks (scoped) → top-level tasks
-                //   3. current/in-flight reportable direct message to this agent
-                //      with no task id and no result yet (message-scope
-                //      correlation — collect path: is_message_scoped_result)
-                //   4. "manual" — truly uncorrelated; collect still rejects
+                //   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
+                //   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| {
-                            latest_task_for_assignee(
+                            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(),
@@ -354,7 +363,7 @@ impl TeamOrchestratorTools {
                     })
                     .or_else(|| {
                         self.agent_id.as_ref().and_then(|agent| {
-                            latest_reportable_message_for(
+                            latest_task_for_assignee(
                                 &self.workspace,
                                 agent.as_str(),
                                 owner_team_id_str.as_deref(),

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

@@ -1,6 +1,7 @@
 //! internal_delivery.py + delivery.py — coordinator/调度器侧 thin wrapper + 单条 tmux 注入投递
 //! + trust 有界重试 + turn-open arm (card §16/§65)。
 
+use std::cell::{Cell, RefCell};
 use std::path::Path;
 
 use rusqlite::{params, OptionalExtension};
@@ -14,7 +15,7 @@ use crate::provider::wire::{
 };
 use crate::transport::{
     submit_verification_wire, InjectPayload, InjectReport, InjectVerification, Key, PaneId,
-    PaneInfo, SessionName, SubmitVerification, Target, Transport, WindowName,
+    PaneInfo, SessionName, SubmitObserver, SubmitVerification, Target, Transport, WindowName,
 };
 
 use super::helpers::{message_exists, MessageStatusShadow};
@@ -414,7 +415,22 @@ pub fn deliver_pending_message(
     } else {
         InjectPayload::Text(rendered)
     };
-    let inject_report = match transport.inject(&target, &payload, Key::Enter, true) {
+    let submit_observer = CurrentTurnSubmitObserver::new(
+        workspace,
+        &message.sender,
+        &message.recipient,
+        message_id,
+        event_log,
+        canonical_owner_team_id.as_deref(),
+        resolved.metadata.as_ref(),
+    );
+    let inject_report = match transport.inject_with_submit_observer(
+        &target,
+        &payload,
+        Key::Enter,
+        true,
+        Some(&submit_observer),
+    ) {
         Ok(report) => report,
         Err(error) => {
             let reason = format!("inject_failed:{error}");
@@ -500,15 +516,9 @@ pub fn deliver_pending_message(
             });
         }
     };
-    record_current_turn_after_inject_if_leader_to_worker_scoped(
-        workspace,
-        &message.sender,
-        &message.recipient,
-        message_id,
-        event_log,
-        canonical_owner_team_id.as_deref(),
-        resolved.metadata.as_ref(),
-    )?;
+    if let Some(error) = submit_observer.take_error() {
+        return Err(error);
+    }
     let submit_verified = inject_submit_verified(&inject_report);
     let readback_verified = pane_readback_verified(&inject_report);
     // Leader pane: inject success is delivery proof. Worker pane: post-submit
@@ -2109,6 +2119,65 @@ pub fn record_turn_open_if_leader_to_worker(
     )
 }
 
+struct CurrentTurnSubmitObserver<'a> {
+    workspace: &'a Path,
+    sender: &'a str,
+    recipient: &'a str,
+    message_id: &'a str,
+    event_log: &'a EventLog,
+    owner_team_id: Option<&'a str>,
+    metadata: Option<&'a TargetMetadata>,
+    fired: Cell<bool>,
+    error: RefCell<Option<MessagingError>>,
+}
+
+impl<'a> CurrentTurnSubmitObserver<'a> {
+    fn new(
+        workspace: &'a Path,
+        sender: &'a str,
+        recipient: &'a str,
+        message_id: &'a str,
+        event_log: &'a EventLog,
+        owner_team_id: Option<&'a str>,
+        metadata: Option<&'a TargetMetadata>,
+    ) -> Self {
+        Self {
+            workspace,
+            sender,
+            recipient,
+            message_id,
+            event_log,
+            owner_team_id,
+            metadata,
+            fired: Cell::new(false),
+            error: RefCell::new(None),
+        }
+    }
+
+    fn take_error(&self) -> Option<MessagingError> {
+        self.error.borrow_mut().take()
+    }
+}
+
+impl SubmitObserver for CurrentTurnSubmitObserver<'_> {
+    fn after_physical_submit(&self) {
+        if self.fired.replace(true) {
+            return;
+        }
+        if let Err(error) = record_current_turn_after_inject_if_leader_to_worker_scoped(
+            self.workspace,
+            self.sender,
+            self.recipient,
+            self.message_id,
+            self.event_log,
+            self.owner_team_id,
+            self.metadata,
+        ) {
+            *self.error.borrow_mut() = Some(error);
+        }
+    }
+}
+
 fn record_current_turn_after_inject_if_leader_to_worker_scoped(
     workspace: &Path,
     sender: &str,

package/crates/team-agent/src/state/persist.rs

@@ -482,6 +482,7 @@ fn apply_persist_merge_contract(
         // clobber broke Batch 6 CHECK 6 (`shutdown` couldn't route to
         // the shim pid because `state.transport.shim.pid` was gone).
         preserve_transport_shim(incoming, latest);
+        preserve_latest_endpoint_convergence_fields(incoming, latest);
     }
 
     let latest_teams = latest.get("teams").and_then(Value::as_object);
@@ -504,6 +505,7 @@ fn apply_persist_merge_contract(
                 topology_update_agent_ids,
             )?;
             preserve_latest_ownership_fields(incoming_entry, latest_entry);
+            preserve_latest_endpoint_convergence_fields(incoming_entry, latest_entry);
         }
     }
     Ok(())
@@ -574,6 +576,58 @@ fn preserve_latest_ownership_fields(incoming: &mut Value, latest: &Value) {
     }
 }
 
+fn preserve_latest_endpoint_convergence_fields(incoming: &mut Value, latest: &Value) {
+    if !latest_has_preferable_endpoint_convergence(incoming, latest) {
+        return;
+    }
+    let Some(incoming_obj) = incoming.as_object_mut() else {
+        return;
+    };
+    for key in [
+        "tmux_endpoint",
+        "tmux_socket",
+        "tmux_socket_source",
+        "topology_convergence",
+    ] {
+        if let Some(value) = latest.get(key).filter(|value| json_truthy(value)) {
+            incoming_obj.insert(key.to_string(), value.clone());
+        }
+    }
+}
+
+fn latest_has_preferable_endpoint_convergence(incoming: &Value, latest: &Value) -> bool {
+    if latest
+        .get("topology_convergence")
+        .and_then(|marker| marker.get("status"))
+        .and_then(Value::as_str)
+        != Some("converged")
+    {
+        return false;
+    }
+    let latest_epoch = endpoint_convergence_epoch(latest).unwrap_or_else(|| ownership_epoch(latest));
+    let incoming_epoch =
+        endpoint_convergence_epoch(incoming).unwrap_or_else(|| ownership_epoch(incoming));
+    if latest_epoch < incoming_epoch {
+        return false;
+    }
+    !incoming
+        .get("topology_convergence")
+        .is_some_and(|marker| {
+            marker.get("status").and_then(Value::as_str) == Some("converged")
+                && marker
+                    .get("owner_epoch")
+                    .and_then(Value::as_u64)
+                    .is_some_and(|epoch| epoch >= latest_epoch)
+        })
+}
+
+fn endpoint_convergence_epoch(state: &Value) -> Option<u64> {
+    state
+        .get("topology_convergence")
+        .and_then(|marker| marker.get("owner_epoch"))
+        .and_then(Value::as_u64)
+}
+
 fn latest_has_preferable_ownership(incoming: &Value, latest: &Value) -> bool {
     let latest_epoch = ownership_epoch(latest);
     let incoming_epoch = ownership_epoch(incoming);

package/crates/team-agent/src/tmux_backend.rs

@@ -36,7 +36,7 @@ use crate::transport::{
     tmux_query_argv, tmux_send_keys_argv, tmux_spawn_argv, AttachOutcome, BackendKind,
     CaptureRange, CapturedText, InjectPayload, InjectReport, InjectStage, InjectVerification, Key,
     PaneField, PaneId, PaneInfo, PaneMode, SessionName, SetEnvOutcome, SpawnResult,
-    SubmitAttemptObservation, SubmitVerification, Target, Transport, TransportError,
+    SubmitAttemptObservation, SubmitObserver, SubmitVerification, Target, Transport, TransportError,
     TurnVerification, WindowName,
 };
 
@@ -1591,6 +1591,12 @@ fn shell_quote(raw: &str) -> String {
     quoted
 }
 
+fn notify_submit_observer(observer: Option<&dyn SubmitObserver>) {
+    if let Some(observer) = observer {
+        observer.after_physical_submit();
+    }
+}
+
 impl Transport for TmuxBackend {
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
@@ -1702,6 +1708,17 @@ impl Transport for TmuxBackend {
         payload: &InjectPayload,
         submit: Key,
         bracketed: bool,
+    ) -> Result<InjectReport, TransportError> {
+        self.inject_with_submit_observer(target, payload, submit, bracketed, None)
+    }
+
+    fn inject_with_submit_observer(
+        &self,
+        target: &Target,
+        payload: &InjectPayload,
+        submit: Key,
+        bracketed: bool,
+        observer: Option<&dyn SubmitObserver>,
     ) -> Result<InjectReport, TransportError> {
         let pane = pane_from_target(target);
         // U1 #7: pane readback signal for the non-pasted-prompt text path.
@@ -1710,6 +1727,7 @@ impl Transport for TmuxBackend {
             InjectPayload::Empty => {
                 let argv = tmux_empty_inject_argv(&pane, submit);
                 self.run_ok(&argv)?;
+                notify_submit_observer(observer);
             }
             InjectPayload::Text(text) | InjectPayload::TextSkipConsumptionPoll(text) => {
                 let buffer = buffer_name_for_text(text);
@@ -1779,6 +1797,7 @@ impl Transport for TmuxBackend {
                 // check, KeySentAfterVisibleToken verification.
                 if !matches!(submit, Key::Enter) {
                     self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
+                    notify_submit_observer(observer);
                     let total_elapsed_ms = inject_start.elapsed().as_millis() as u64;
                     return Ok(InjectReport {
                         stage_reached: InjectStage::Submit,
@@ -1808,6 +1827,7 @@ impl Transport for TmuxBackend {
                 let poll_consumption = !payload.skip_consumption_poll();
                 if !poll_consumption {
                     if self.run_inject_stage(&submit_argv, InjectStage::Submit).is_ok() {
+                        notify_submit_observer(observer);
                         consumption_attempts = 1;
                     }
                 }
@@ -1858,6 +1878,7 @@ impl Transport for TmuxBackend {
                         consumed = None;
                         break;
                     }
+                    notify_submit_observer(observer);
                     consumption_attempts = attempt + 1;
 
                     // Post-submit token readback (U1 #7 parity: check token

package/crates/team-agent/src/transport.rs

@@ -640,6 +640,21 @@ pub trait Transport: Send + Sync {
         bracketed: bool,
     ) -> Result<InjectReport, TransportError>;
 
+    fn inject_with_submit_observer(
+        &self,
+        target: &Target,
+        payload: &InjectPayload,
+        submit: Key,
+        bracketed: bool,
+        observer: Option<&dyn SubmitObserver>,
+    ) -> Result<InjectReport, TransportError> {
+        let report = self.inject(target, payload, submit, bracketed)?;
+        if let Some(observer) = observer {
+            observer.after_physical_submit();
+        }
+        Ok(report)
+    }
+
     fn send_keys(&self, target: &Target, keys: &[Key]) -> Result<(), TransportError>;
 
     fn capture(
@@ -718,6 +733,10 @@ pub trait Transport: Send + Sync {
     ) -> Result<AttachOutcome, TransportError>;
 }
 
+pub trait SubmitObserver {
+    fn after_physical_submit(&self);
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // 命令构造 seam(STEP-9 头号目标:exact tmux command construction).
 //

package/package.json

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