@team-agent/installer 0.5.14 → 0.5.16

package/Cargo.lock

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

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

@@ -4167,6 +4167,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/lifecycle/restart/agent.rs

@@ -255,6 +255,7 @@ pub(crate) fn start_agent_at_paths(
         Some(&safety),
         layout_placement.as_ref(),
         None,
+        None,
         Some(resolved_team_key.as_str()),
     )?;
     verify_spawned_pane_matches_target(

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

@@ -26,6 +26,7 @@ pub(super) fn spawn_agent_window(
     safety: Option<&DangerousApproval>,
     layout_placement: Option<&crate::lifecycle::launch::LayoutPlacement>,
     spawn_cwd_override: Option<&Path>,
+    tmux_endpoint_source: Option<&str>,
     // Issue 2 (Round 3b gate review §6): explicit owner_team_id override.
     // When `Some`, callers (restart/rebuild.rs, restart/agent.rs) thread the
     // resolved `selected.team_key` through here so the worker's MCP env /
@@ -205,6 +206,7 @@ pub(super) fn spawn_agent_window(
         let tmux_start_mode_pre_spawn =
             predict_tmux_start_mode(layout_placement, into_existing_session);
         let spawn_epoch = state_spawn_epoch_for_agent(workspace, agent_id);
+        let tmux_endpoint = transport.tmux_endpoint();
         let event_log = crate::event_log::EventLog::new(workspace);
         let _ = event_log.write(
             "provider.worker.spawn_argv",
@@ -220,6 +222,8 @@ pub(super) fn spawn_agent_window(
                 "tmux_start_mode": tmux_start_mode_pre_spawn,
                 "spawn_epoch": spawn_epoch,
                 "source": "restart",
+                "tmux_endpoint": tmux_endpoint,
+                "tmux_endpoint_source": tmux_endpoint_source.unwrap_or("transport"),
             }),
         );
     }
@@ -564,6 +568,27 @@ pub(crate) fn lifecycle_worker_transport_for_selected_state(
         .map_err(|e| LifecycleError::TeamSelect(e.to_string()))
 }
 
+pub(super) fn lifecycle_worker_tmux_backend_selection_for_state(
+    run_workspace: &Path,
+    state: &serde_json::Value,
+) -> Result<crate::tmux_backend::RuntimeTmuxBackendSelection, LifecycleError> {
+    if let Some(kind) = state.pointer("/transport/kind").and_then(|v| v.as_str()) {
+        if kind.eq_ignore_ascii_case("conpty") {
+            return Err(LifecycleError::TeamSelect(format!(
+                "backend_kind_mismatch: state.transport.kind={kind:?} but the legacy \
+                 tmux-typed lifecycle resolver was invoked; caller must migrate to \
+                 `lifecycle_worker_transport_for_selected_state` (Phase 1d Batch 2/3)"
+            )));
+        }
+    }
+    Ok(
+        crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
+            run_workspace,
+            Some(state),
+        ),
+    )
+}
+
 pub(super) fn lifecycle_worker_tmux_backend_for_state(
     run_workspace: &Path,
     state: &serde_json::Value,

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

@@ -23,16 +23,51 @@ pub fn restart_with_session_convergence_deadline(
     team: Option<&str>,
     session_converge_deadline_ms: Option<u64>,
 ) -> Result<RestartReport, LifecycleError> {
-    let paths = lifecycle_paths(workspace, team)?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
-    restart_with_transport_with_session_convergence_deadline(
-        workspace,
+    let context = resolve_restart_context(workspace, team)?;
+    restart_with_selected_team_and_transport(
+        context.selected,
         allow_fresh,
-        team,
-        &transport,
+        &context.transport,
         session_converge_deadline_ms,
         None,
+        Some(context.tmux_endpoint_source),
+    )
+}
+
+struct ResolvedRestartContext {
+    selected: crate::state::selector::SelectedTeam,
+    transport: crate::tmux_backend::TmuxBackend,
+    tmux_endpoint_source: &'static str,
+}
+
+fn resolve_restart_context(
+    workspace: &Path,
+    team: Option<&str>,
+) -> Result<ResolvedRestartContext, LifecycleError> {
+    let resolved_ws = crate::model::paths::canonical_run_workspace(workspace)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if crate::lifecycle::restart::input_has_no_local_team_context(&resolved_ws) {
+        return Err(LifecycleError::TeamSelect(format!(
+            "active team spec not found: input_workspace={} expected_runtime_dir={}",
+            workspace.display(),
+            crate::model::paths::runtime_dir(&resolved_ws).display()
+        )));
+    }
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RequireSpec,
     )
+    .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    let transport_selection = lifecycle_worker_tmux_backend_selection_for_state(
+        &selected.run_workspace,
+        &selected.state,
+    )?;
+    Ok(ResolvedRestartContext {
+        selected,
+        transport: transport_selection.backend,
+        tmux_endpoint_source: transport_selection.tmux_endpoint_source.as_str(),
+    })
 }
 
 /// `restart` with an injected transport (tests: recording mock; prod: real TmuxBackend). The Route-B
@@ -129,6 +164,24 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             expected.display()
         )));
     }
+    restart_with_selected_team_and_transport(
+        selected,
+        allow_fresh,
+        transport,
+        session_converge_deadline_ms,
+        readiness_deadline_ms,
+        None,
+    )
+}
+
+fn restart_with_selected_team_and_transport(
+    selected: crate::state::selector::SelectedTeam,
+    allow_fresh: bool,
+    transport: &dyn crate::transport::Transport,
+    session_converge_deadline_ms: Option<u64>,
+    readiness_deadline_ms: Option<u64>,
+    tmux_endpoint_source: Option<&str>,
+) -> Result<RestartReport, LifecycleError> {
     let lifecycle_lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &selected.run_workspace,
         operation: "restart",
@@ -381,6 +434,13 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             &raw_agent,
         );
         if has_endpoint_convergence_marker(&state) && is_fake_model_harness_agent(&agent) {
+            write_fake_harness_spawn_argv_event(
+                &selected.run_workspace,
+                decision,
+                &agent,
+                transport,
+                tmux_endpoint_source,
+            );
             mark_fake_harness_agent_respawned(
                 &mut state,
                 &decision.agent_id,
@@ -438,6 +498,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             Some(&safety),
             layout_placement.as_ref(),
             None,
+            tmux_endpoint_source,
             // Issue 2 (Round 3b gate review §6): thread the resolved
             // selected.team_key so the worker MCP env carries the right
             // owner_team_id even when top-level active_team_key is stale.
@@ -783,7 +844,14 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         restart_readiness_poll_interval(),
     )?;
     let attach_commands =
-        crate::tmux_backend::attach_command_for_session(&selected.run_workspace, &session_name)
+        crate::tmux_backend::attach_command_for_transport_session(transport, &session_name)
+            .or_else(|| {
+                crate::tmux_backend::attach_command_for_runtime_state_session_or_workspace(
+                    &selected.run_workspace,
+                    Some(&state),
+                    &session_name,
+                )
+            })
             .into_iter()
             .collect::<Vec<_>>();
     let mut next_actions = Vec::new();
@@ -1719,6 +1787,29 @@ fn mark_fake_harness_agent_respawned(
     agent.insert("owner_team_id".to_string(), serde_json::json!(team_key));
 }
 
+fn write_fake_harness_spawn_argv_event(
+    workspace: &Path,
+    decision: &RestartedAgent,
+    agent: &serde_json::Value,
+    transport: &dyn crate::transport::Transport,
+    tmux_endpoint_source: Option<&str>,
+) {
+    let _ = crate::event_log::EventLog::new(workspace).write(
+        "provider.worker.spawn_argv",
+        serde_json::json!({
+            "agent_id": decision.agent_id.as_str(),
+            "provider": agent_provider(agent),
+            "argv": [],
+            "session_id_in_argv": null,
+            "expected_session_id": decision.session_id.as_ref().map(|s| s.as_str()),
+            "tmux_start_mode": "fake_harness",
+            "source": "restart",
+            "tmux_endpoint": transport.tmux_endpoint(),
+            "tmux_endpoint_source": tmux_endpoint_source.unwrap_or("transport"),
+        }),
+    );
+}
+
 fn restart_failed_agent(
     decision: &RestartedAgent,
     phase: impl Into<String>,

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

@@ -524,7 +524,7 @@ fn normalize_string(text: String, ctx: &mut NormalizeCtx, key: Option<&str>) ->
     if key_is_timestamp(key) {
         return json!("<TS>");
     }
-    if key.contains("endpoint") {
+    if key.contains("endpoint") && value_looks_like_endpoint_path(&text) {
         return json!("<SOCKET>");
     }
     if key_is_id(key, &text) {
@@ -557,6 +557,13 @@ fn normalize_path_string(text: &str, ctx: &NormalizeCtx) -> String {
     normalize_socket_token(&out)
 }
 
+fn value_looks_like_endpoint_path(text: &str) -> bool {
+    text.starts_with('/')
+        || text.starts_with("ta-")
+        || text.contains("/tmux-")
+        || text.contains("tmux-")
+}
+
 fn normalize_team_agent_binary_path(text: &str) -> String {
     let mut out = text.to_string();
     // 0.5.0 hermetic 教训「环境路径类 token 化」的直接延伸

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,
 };
 
@@ -566,6 +566,14 @@ pub(crate) fn attach_command_for_session(
     ))
 }
 
+pub(crate) fn attach_command_for_transport_session(
+    transport: &dyn crate::transport::Transport,
+    session_name: &SessionName,
+) -> Option<String> {
+    let endpoint = transport.tmux_endpoint()?;
+    Some(attach_command_for_endpoint_session(&endpoint, session_name))
+}
+
 /// Bug #7 (prerelease 0.4.0 gate review §6): when the runtime state carries a
 /// persisted `tmux_endpoint` / `tmux_socket` (e.g. `/private/tmp/tmux-501/default`),
 /// the attach command MUST point at THAT endpoint, not the workspace-hash
@@ -591,6 +599,26 @@ pub(crate) fn attach_command_for_runtime_state_or_workspace(
     attach_command_for_workspace(workspace, session_name, window_name)
 }
 
+pub(crate) fn attach_command_for_runtime_state_session_or_workspace(
+    workspace: &Path,
+    state: Option<&serde_json::Value>,
+    session_name: &SessionName,
+) -> Option<String> {
+    if let Some((endpoint, _source)) = runtime_tmux_endpoint_from_state(state) {
+        return Some(attach_command_for_endpoint_session(endpoint, session_name));
+    }
+    attach_command_for_session(workspace, session_name)
+}
+
+fn attach_command_for_endpoint_session(endpoint: &str, session_name: &SessionName) -> String {
+    let flag = if Path::new(endpoint).is_absolute() {
+        "-S"
+    } else {
+        "-L"
+    };
+    format!("tmux {flag} {endpoint} attach -t {}", session_name.as_str())
+}
+
 pub(crate) fn attach_commands_for_windows<'a>(
     workspace: &Path,
     session_name: &SessionName,
@@ -1563,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
@@ -1674,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.
@@ -1682,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);
@@ -1751,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,
@@ -1780,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;
                     }
                 }
@@ -1830,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.14",
+  "version": "0.5.16",
   "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.14",
-    "@team-agent/cli-darwin-x64": "0.5.14",
-    "@team-agent/cli-linux-x64": "0.5.14"
+    "@team-agent/cli-darwin-arm64": "0.5.16",
+    "@team-agent/cli-darwin-x64": "0.5.16",
+    "@team-agent/cli-linux-x64": "0.5.16"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",