@team-agent/installer 0.5.3 → 0.5.4

package/Cargo.lock

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

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

@@ -1,14 +1,20 @@
 //! diagnose/preflight/wait-ready CLI helpers.
 use super::*;
-use crate::provider::wire::{command_name, provider_wire};
+use crate::provider::wire::{command_name, parse_provider, provider_wire};
 use crate::transport::Transport;
 
 pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value, Value) {
     let mut issues = Vec::new();
     let mut repairs = Vec::new();
 
-    if let Some(session_name) = state.get("session_name").and_then(Value::as_str).filter(|s| !s.is_empty()) {
-        match backend.has_session(&crate::transport::SessionName::new(session_name.to_string())) {
+    if let Some(session_name) = state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+    {
+        match backend.has_session(&crate::transport::SessionName::new(
+            session_name.to_string(),
+        )) {
             Ok(true) => {}
             Ok(false) => {
                 issues.push(json!("tmux_session_missing"));
@@ -69,13 +75,55 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
         }
     }
 
-    if let Some(session_name) = state.get("session_name").and_then(Value::as_str).filter(|s| !s.is_empty()) {
-        if let Ok(windows) = backend.list_windows(&crate::transport::SessionName::new(session_name.to_string())) {
+    if let Some(session_name) = state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+    {
+        if let Ok(windows) = backend.list_windows(&crate::transport::SessionName::new(
+            session_name.to_string(),
+        )) {
             if let Some(agents) = state.get("agents").and_then(Value::as_object) {
                 for (agent_id, agent_state) in agents {
+                    let provider = agent_state
+                        .get("provider")
+                        .and_then(Value::as_str)
+                        .and_then(parse_provider)
+                        .unwrap_or(crate::provider::Provider::Codex);
+                    let rollout_path = agent_state
+                        .get("rollout_path")
+                        .and_then(Value::as_str)
+                        .filter(|path| !path.is_empty())
+                        .map(crate::provider::RolloutPath::new);
+                    let identity_probe =
+                        crate::lifecycle::restart::session_identity_probe_for_agent(
+                            &crate::model::ids::AgentId::new(agent_id.clone()),
+                            provider,
+                            rollout_path.as_ref(),
+                        );
+                    if identity_probe.identity_ok == Some(false) {
+                        let issue = format!("session_identity_mismatch:{agent_id}");
+                        issues.push(json!(issue));
+                        repairs.push(json!({
+                            "issue": format!("session_identity_mismatch:{agent_id}"),
+                            "action": format!(
+                                "run `team-agent restart --allow-fresh` to discard the poisoned session tuple for `{agent_id}`"
+                            ),
+                            "expected_agent_id": agent_id,
+                            "embedded_agent_id": identity_probe.embedded_agent_id,
+                            "rollout_path": identity_probe
+                                .rollout_path
+                                .map(|path| path.to_string_lossy().to_string()),
+                        }));
+                    }
                     let window = ["window", "window_name"]
                         .iter()
-                        .find_map(|key| agent_state.get(*key).and_then(Value::as_str).filter(|s| !s.is_empty()))
+                        .find_map(|key| {
+                            agent_state
+                                .get(*key)
+                                .and_then(Value::as_str)
+                                .filter(|s| !s.is_empty())
+                        })
                         .unwrap_or(agent_id);
                     if !windows.iter().any(|w| w.as_str() == window) {
                         issues.push(json!(format!("worker_window_missing:{agent_id}")));
@@ -131,6 +179,80 @@ fn leader_receiver_attached(state: &Value) -> bool {
     mode_direct && status_attached && pane_present
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn write_codex_identity_rollout(
+        workspace: &std::path::Path,
+        session_id: &str,
+        embedded_agent_id: &str,
+    ) -> std::path::PathBuf {
+        let path = workspace.join("rollout-poison.jsonl");
+        let text = format!(
+            "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\"}}}}}}\n\
+             {{\"type\":\"turn_context\",\"payload\":{{}}}}\n\
+             {{\"type\":\"response_item\",\"payload\":{{\"content\":[{{\"type\":\"input_text\",\"text\":\"You are Team Agent worker `{embedded_agent_id}` with role `fixture`.\"}}]}}}}\n",
+            workspace.to_string_lossy()
+        );
+        std::fs::write(&path, text).expect("write rollout");
+        path
+    }
+
+    #[test]
+    fn diagnose_surfaces_codex_session_identity_mismatch() {
+        let workspace =
+            std::env::temp_dir().join(format!("ta-diagnose-crossbind-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&workspace);
+        std::fs::create_dir_all(&workspace).unwrap();
+        let rollout = write_codex_identity_rollout(
+            &workspace,
+            "019f3327-c35a-7023-b3cd-1bea93a7a157",
+            "ios-dev",
+        );
+        let state = json!({
+            "session_name": "team-fixture",
+            "leader_receiver": {
+                "mode": "direct_tmux",
+                "status": "attached",
+                "pane_id": "%leader",
+                "provider": "codex"
+            },
+            "agents": {
+                "frontend": {
+                    "provider": "codex",
+                    "status": "running",
+                    "session_id": "019f3327-c35a-7023-b3cd-1bea93a7a157",
+                    "rollout_path": rollout.to_string_lossy(),
+                    "captured_at": "2026-07-05T17:04:04Z",
+                    "captured_via": "fs_watch",
+                    "spawn_cwd": workspace.to_string_lossy(),
+                    "window": "frontend"
+                }
+            }
+        });
+        let backend = crate::transport::test_support::OfflineTransport::new()
+            .with_session_present(true)
+            .with_windows(vec![crate::transport::WindowName::new("frontend")]);
+        let (issues, repairs) = diagnose_runtime(&state, &backend);
+        assert!(
+            issues
+                .as_array()
+                .is_some_and(|items| items.iter().any(|item| item.as_str()
+                    == Some("session_identity_mismatch:frontend"))),
+            "diagnose must surface session_identity_mismatch for poisoned Codex tuples; issues={issues}"
+        );
+        assert!(
+            repairs.as_array().is_some_and(|items| items.iter().any(|item| {
+                item.get("issue").and_then(Value::as_str)
+                    == Some("session_identity_mismatch:frontend")
+            })),
+            "diagnose should include an explicit repair hint for the mismatched tuple; repairs={repairs}"
+        );
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+}
+
 pub(crate) fn build_preflight_report(team: &std::path::Path) -> Result<Value, CliError> {
     let mut checks = Vec::new();
     let mut next_actions = Vec::new();
@@ -150,7 +272,9 @@ pub(crate) fn build_preflight_report(team: &std::path::Path) -> Result<Value, Cl
                 "ok": false,
                 "error": error.to_string(),
             }));
-            next_actions.push(json!("fix TEAM.md and role front matter, then run preflight again"));
+            next_actions.push(json!(
+                "fix TEAM.md and role front matter, then run preflight again"
+            ));
             None
         }
     };
@@ -183,7 +307,11 @@ pub(crate) fn build_preflight_report(team: &std::path::Path) -> Result<Value, Cl
 
     let workspace = crate::model::paths::team_workspace(team)
         .map_err(|error| CliError::Runtime(error.to_string()))?;
-    let profile_dir_exists = workspace.join(".team").join("current").join("profiles").exists()
+    let profile_dir_exists = workspace
+        .join(".team")
+        .join("current")
+        .join("profiles")
+        .exists()
         || team.join("profiles").exists();
     let profile_dir_check = json!({
         "name": "profile_dir",
@@ -229,7 +357,10 @@ pub(crate) fn build_preflight_report(team: &std::path::Path) -> Result<Value, Cl
     let summary = if ok {
         "preflight passed".to_string()
     } else {
-        format!("preflight found blockers: {}", blocker_names(&blockers).join(", "))
+        format!(
+            "preflight found blockers: {}",
+            blocker_names(&blockers).join(", ")
+        )
     };
     let checks_value = Value::Array(checks);
     let details_log = write_details_log(
@@ -255,7 +386,9 @@ pub(crate) fn build_preflight_report(team: &std::path::Path) -> Result<Value, Cl
     Ok(report)
 }
 
-pub(crate) fn build_profile_smoke_check_for_team(team: &std::path::Path) -> Result<Value, CliError> {
+pub(crate) fn build_profile_smoke_check_for_team(
+    team: &std::path::Path,
+) -> Result<Value, CliError> {
     let workspace = crate::model::paths::team_workspace(team)
         .map_err(|error| CliError::Runtime(error.to_string()))?;
     let spec = match crate::compiler::compile_team(team) {
@@ -376,10 +509,14 @@ pub(crate) fn build_wait_ready_report(
             }));
         }
     };
-    let timeout = if timeout.is_finite() && timeout > 0.0 { timeout } else { 0.0 };
+    let timeout = if timeout.is_finite() && timeout > 0.0 {
+        timeout
+    } else {
+        0.0
+    };
     let deadline = std::time::Instant::now() + std::time::Duration::from_secs_f64(timeout);
     let mut readiness;
-    let mut state_read_error: Option<String> = None;
+    let mut state_read_error: Option<String>;
     loop {
         let mut state = match crate::state::projection::select_runtime_state(
             &selected.run_workspace,
@@ -419,7 +556,9 @@ pub(crate) fn build_wait_ready_report(
             "error",
             "state_read_error",
             "runtime state could not be read",
-            vec![json!("inspect .team/runtime/state.json (corrupt or unreadable) and retry")],
+            vec![json!(
+                "inspect .team/runtime/state.json (corrupt or unreadable) and retry"
+            )],
         )
     } else if awaiting_trust {
         (
@@ -427,11 +566,17 @@ pub(crate) fn build_wait_ready_report(
             "pending",
             "awaiting_trust_prompt",
             "workers are awaiting trust prompt",
-            vec![json!("answer the provider trust prompt, then run wait-ready again")],
+            vec![json!(
+                "answer the provider trust prompt, then run wait-ready again"
+            )],
         )
     } else if ready {
         (true, "ready", "ready", "workers ready", Vec::new())
-    } else if readiness.get("session_capture_complete").and_then(Value::as_bool) == Some(false) {
+    } else if readiness
+        .get("session_capture_complete")
+        .and_then(Value::as_bool)
+        == Some(false)
+    {
         (
             false,
             "pending",
@@ -445,7 +590,9 @@ pub(crate) fn build_wait_ready_report(
             "timeout",
             "workers_not_ready",
             "workers not ready before timeout",
-            vec![json!("inspect team-agent diagnose output and worker terminals")],
+            vec![json!(
+                "inspect team-agent diagnose output and worker terminals"
+            )],
         )
     };
     let details_log = write_details_log(
@@ -479,7 +626,11 @@ fn inject_tmux_session_present(workspace: &std::path::Path, state: &mut Value) {
     // runtime actually uses (state.tmux_endpoint / tmux_socket), not the
     // workspace-hash socket. Otherwise readiness reports `process_started=false`
     // even though the session is alive on the persisted socket.
-    let Some(session_name) = state.get("session_name").and_then(Value::as_str).filter(|s| !s.is_empty()) else {
+    let Some(session_name) = state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+    else {
         return;
     };
     let session_name_owned = session_name.to_string();
@@ -519,14 +670,11 @@ pub(crate) fn wait_readiness(state: &Value) -> Value {
         .get("leader_receiver")
         .and_then(Value::as_object)
         .is_some_and(|receiver| {
-            receiver
-                .get("status")
-                .and_then(Value::as_str)
-                == Some("attached")
+            receiver.get("status").and_then(Value::as_str) == Some("attached")
                 || receiver
-                .get("pane_id")
-                .and_then(Value::as_str)
-                .is_some_and(|pane| !pane.is_empty() && pane != "__team_agent_unbound__")
+                    .get("pane_id")
+                    .and_then(Value::as_str)
+                    .is_some_and(|pane| !pane.is_empty() && pane != "__team_agent_unbound__")
         });
 
     if let Some(agents) = agents {
@@ -544,8 +692,7 @@ pub(crate) fn wait_readiness(state: &Value) -> Value {
                         Some("running" | "busy" | "ready")
                     )
             });
-        mcp_ready = !agents.is_empty()
-            && agents.values().all(agent_mcp_ready);
+        mcp_ready = !agents.is_empty() && agents.values().all(agent_mcp_ready);
         task_prompt_delivered = !agents.is_empty()
             && (message_counts_positive(state.get("messages"))
                 || agents.values().all(|agent| {
@@ -560,7 +707,8 @@ pub(crate) fn wait_readiness(state: &Value) -> Value {
                 .and_then(Value::as_str)
                 == Some("awaiting_trust_prompt")
         });
-        incomplete_sessions = crate::session_capture::incomplete_interacted_resumable_agent_ids(state);
+        incomplete_sessions =
+            crate::session_capture::incomplete_interacted_resumable_agent_ids(state);
     }
     let all_resumable_have_session = incomplete_sessions.is_empty();
     let session_capture_incomplete = !all_resumable_have_session;
@@ -591,7 +739,9 @@ fn inject_message_counts(workspace: &std::path::Path, state: &mut Value) -> Resu
     let mut stmt = conn
         .prepare("select status, count(*) from messages group by status order by status")
         .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+    let mut rows = stmt
+        .query([])
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
     let mut messages = Map::new();
     while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
         let status: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -619,7 +769,10 @@ fn message_counts_positive(value: Option<&Value>) -> bool {
 fn legacy_process_started(agents: &serde_json::Map<String, Value>) -> bool {
     !agents.is_empty()
         && agents.values().all(|agent| {
-            agent.get("pane_id").and_then(Value::as_str).is_some_and(|s| !s.is_empty())
+            agent
+                .get("pane_id")
+                .and_then(Value::as_str)
+                .is_some_and(|s| !s.is_empty())
                 || agent.get("pid").and_then(Value::as_i64).is_some()
                 || agent.get("process_started").and_then(Value::as_bool) == Some(true)
                 || fake_agent_started(agent)
@@ -717,7 +870,10 @@ fn preflight_blockers(checks: &[Value]) -> Vec<Value> {
         .iter()
         .filter(|check| check.get("ok").and_then(Value::as_bool) == Some(false))
         .map(|check| {
-            let name = check.get("name").and_then(Value::as_str).unwrap_or("unknown");
+            let name = check
+                .get("name")
+                .and_then(Value::as_str)
+                .unwrap_or("unknown");
             let reason = check
                 .get("error")
                 .or_else(|| check.get("reason"))
@@ -747,7 +903,11 @@ fn yaml_path_str<'a>(value: &'a crate::model::yaml::Value, keys: &[&str]) -> Opt
     current.as_str()
 }
 
-fn write_details_log(workspace: &std::path::Path, prefix: &str, value: &Value) -> Result<std::path::PathBuf, CliError> {
+fn write_details_log(
+    workspace: &std::path::Path,
+    prefix: &str,
+    value: &Value,
+) -> Result<std::path::PathBuf, CliError> {
     let logs = workspace.join(".team").join("logs");
     std::fs::create_dir_all(&logs)?;
     let path = logs.join(format!("{prefix}-{}.json", timestamp_slug()));

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

@@ -210,14 +210,22 @@ pub mod lifecycle_port {
     /// `&*box`. Factory refusal falls back to the workspace tmux
     /// backend byte-equivalent to today so daemon liveness paths
     /// don't crash.
-    pub fn shutdown(workspace: &Path, keep_logs: bool, team: Option<&str>) -> Result<Value, CliError> {
+    pub fn shutdown(
+        workspace: &Path,
+        keep_logs: bool,
+        team: Option<&str>,
+    ) -> Result<Value, CliError> {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let state = shutdown_state_for_team(&run_ws, team)?;
         if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
             let transport = shutdown_transport_for_endpoint(endpoint);
             return shutdown_with_transport_and_state(
-                workspace, keep_logs, team, &transport, Some(state),
+                workspace,
+                keep_logs,
+                team,
+                &transport,
+                Some(state),
             );
         }
         let boxed: Box<dyn crate::transport::Transport> =
@@ -352,11 +360,7 @@ pub mod lifecycle_port {
         let anchor_sessions = anchor_sessions_from_state(state, &pane_targets, event_log);
         match sessions_to_kill(&sessions, &anchor_sessions) {
             KillDecision::KillServerExclusive => {
-                if state
-                    .get("tmux_socket_source")
-                    .and_then(Value::as_str)
-                    == Some("leader_env")
-                {
+                if state.get("tmux_socket_source").and_then(Value::as_str) == Some("leader_env") {
                     let _ = event_log.write(
                         "shutdown.kill_server_skipped_shared_socket",
                         json!({
@@ -463,10 +467,7 @@ pub mod lifecycle_port {
             .cloned()
             .collect::<Vec<_>>();
         if let Some(anchored) = target_spared_for_anchor {
-            if !spared
-                .iter()
-                .any(|s| s.as_str() == anchored.as_str())
-            {
+            if !spared.iter().any(|s| s.as_str() == anchored.as_str()) {
                 spared.push(anchored);
             }
         }
@@ -486,7 +487,10 @@ pub mod lifecycle_port {
             // (this function) computes its own `to_kill` from `target`. Any
             // leader-prefixed entry here is a topology violation introduced
             // somewhere upstream. Log loudly and skip the kill.
-            if session.as_str().starts_with(crate::leader::LEADER_SESSION_PREFIX) {
+            if session
+                .as_str()
+                .starts_with(crate::leader::LEADER_SESSION_PREFIX)
+            {
                 eprintln!(
                     "team_agent::layout shutdown_invariant_violation kind=KillListContainsLeaderSession \
                      session=`{}` action=skipping_kill (post-Step-9 will hard-fail)",
@@ -723,11 +727,7 @@ pub mod lifecycle_port {
             if crate::state::projection::state_is_managed_leader(&state)
                 && session_has_leader_anchor
             {
-                let _ = event_log_write_session_spared(
-                    &run_workspace,
-                    session,
-                    &leader_anchor_ids,
-                );
+                let _ = event_log_write_session_spared(&run_workspace, session, &leader_anchor_ids);
                 push_unique_session(&mut spared_sessions, session.clone());
                 let worker_panes = collect_session_worker_panes(
                     &state,
@@ -742,10 +742,8 @@ pub mod lifecycle_port {
                         }
                     }
                 }
-                let _ = crate::lifecycle::display::close_team_display_backends(
-                    &run_workspace,
-                    session,
-                );
+                let _ =
+                    crate::lifecycle::display::close_team_display_backends(&run_workspace, session);
             } else {
                 push_unique_session(&mut killed_sessions, session.clone());
                 if let Err(error) = transport.kill_session(session) {
@@ -753,10 +751,8 @@ pub mod lifecycle_port {
                         kill_error = Some(error.to_string());
                     }
                 }
-                let _ = crate::lifecycle::display::close_team_display_backends(
-                    &run_workspace,
-                    session,
-                );
+                let _ =
+                    crate::lifecycle::display::close_team_display_backends(&run_workspace, session);
             }
         }
         deadline.check("reap_workspace_residuals")?;
@@ -953,7 +949,7 @@ pub mod lifecycle_port {
         // byte-preserving. The Unix behavior is a no-op (no shim
         // concept there); adding a placeholder key would just noise
         // up the fixtures.
-        let mut response = json!({
+        let response = json!({
             "ok": ok,
             "status": status,
             "phase": phase,
@@ -979,6 +975,8 @@ pub mod lifecycle_port {
             },
         });
         #[cfg(windows)]
+        let mut response = response;
+        #[cfg(windows)]
         {
             if let Some(obj) = response.as_object_mut() {
                 obj.insert(
@@ -1291,10 +1289,7 @@ pub mod lifecycle_port {
         // probes when the primary transport is ConPTY; the primary
         // transport check above already covered the honest question
         // ("does the shim still have this session?").
-        let primary_is_conpty = matches!(
-            transport.kind(),
-            crate::transport::BackendKind::ConPty
-        );
+        let primary_is_conpty = matches!(transport.kind(), crate::transport::BackendKind::ConPty);
         if !primary_is_conpty {
             let workspace_transport = shutdown_workspace_transport(workspace);
             match crate::transport::Transport::has_session(&workspace_transport, session) {
@@ -2938,14 +2933,38 @@ pub mod lifecycle_port {
                                     );
                                 }
                             }
+                            if let crate::provider::session::ResumeRefusalReason::SessionIdentityMismatch {
+                                expected_agent_id,
+                                embedded_agent_id,
+                                session_id,
+                                rollout_path,
+                            } = reason
+                            {
+                                entry.insert(
+                                    "expected_agent_id".to_string(),
+                                    json!(expected_agent_id),
+                                );
+                                entry.insert(
+                                    "embedded_agent_id".to_string(),
+                                    json!(embedded_agent_id),
+                                );
+                                entry.insert(
+                                    "poisoned_session_id".to_string(),
+                                    json!(session_id),
+                                );
+                                if let Some(path) = rollout_path {
+                                    entry.insert(
+                                        "rollout_path".to_string(),
+                                        json!(path.to_string_lossy()),
+                                    );
+                                }
+                            }
                         }
                         Value::Object(entry)
                     })
                     .collect();
-                let unresumable_ids: Vec<&str> = unresumable
-                    .iter()
-                    .map(|w| w.agent_id.as_str())
-                    .collect();
+                let unresumable_ids: Vec<&str> =
+                    unresumable.iter().map(|w| w.agent_id.as_str()).collect();
                 // Layer 2 self-healing (leader follow-up 2026-06-22): when
                 // EVERY unresumable worker shares the same structured
                 // refusal_reason wire string, refine the top-level `status`
@@ -3036,6 +3055,46 @@ pub mod lifecycle_port {
                                 unresumable_ids.join(", "),
                             ),
                         ),
+                        "session_identity_mismatch" => {
+                            let mut lines = Vec::new();
+                            for w in unresumable.iter() {
+                                if let Some(
+                                    crate::provider::session::ResumeRefusalReason::SessionIdentityMismatch {
+                                        expected_agent_id,
+                                        embedded_agent_id,
+                                        session_id,
+                                        rollout_path,
+                                    },
+                                ) = w.refusal_reason.as_ref()
+                                {
+                                    let path = rollout_path
+                                        .as_ref()
+                                        .map(|p| p.to_string_lossy().into_owned())
+                                        .unwrap_or_else(|| "<unknown>".to_string());
+                                    lines.push(format!(
+                                        "  {}: session {} points to transcript identity {} at {} (expected {})",
+                                        w.agent_id.as_str(),
+                                        session_id,
+                                        embedded_agent_id,
+                                        path,
+                                        expected_agent_id
+                                    ));
+                                }
+                            }
+                            let mut msg = format!(
+                                "restart refused: provider session identity mismatch for {} worker(s) ({}). Pass --allow-fresh to discard the poisoned tuple and start fresh.",
+                                unresumable.len(),
+                                unresumable_ids.join(", "),
+                            );
+                            if !lines.is_empty() {
+                                msg.push_str("\nMismatched sessions:");
+                                for line in &lines {
+                                    msg.push('\n');
+                                    msg.push_str(line);
+                                }
+                            }
+                            ("refused_session_identity_mismatch".to_string(), msg)
+                        }
                         _ => ("refused_resume_atomicity".to_string(), error.clone()),
                     }
                 } else {

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

@@ -553,6 +553,19 @@ impl Coordinator {
                 }),
             )?;
         }
+        for mismatch in &report.identity_mismatches {
+            event_log.write(
+                "provider.session.identity_mismatch",
+                serde_json::json!({
+                    "agent_id": mismatch.agent_id,
+                    "expected_agent_id": mismatch.expected_agent_id,
+                    "embedded_agent_id": mismatch.embedded_agent_id,
+                    "session_id": mismatch.session_id,
+                    "rollout_path": mismatch.rollout_path,
+                    "spawn_cwd": mismatch.spawn_cwd,
+                }),
+            )?;
+        }
         for ambiguous in report.ambiguous {
             let candidate_count = report
                 .candidate_count_by_agent

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

@@ -374,6 +374,8 @@ fn spawn_agents(
                 );
             }
         }
+        let spawn_epoch = u64::try_from(started.len()).unwrap_or(u64::MAX);
+        let spawned_at = spawn_timestamp_for_agent(u32::try_from(spawn_epoch).unwrap_or(u32::MAX));
         // E6 层1 实证3 + 诊断留痕:落最终 worker argv(spawn 前的真实形态)。
         // 任何"--session-id 预定 UUID 没生效"必须能从 events.jsonl 回答:argv 里到底有没有它。
         // 抽出 --session-id 值单列,方便和盘上 ~/.claude/projects/<cwd> 实际落的 UUID 对账。
@@ -393,6 +395,10 @@ fn spawn_agents(
                     "argv": plan.argv,
                     "session_id_in_argv": session_id_in_argv,
                     "expected_session_id": plan.expected_session_id.as_ref().map(|s| s.as_str()),
+                    "spawn_cwd": workspace.to_string_lossy(),
+                    "spawned_at": spawned_at.as_str(),
+                    "source": "launch",
+                    "spawn_epoch": spawn_epoch,
                 }),
             );
         }
@@ -473,6 +479,7 @@ fn spawn_agents(
             agent_id,
             start_mode: StartMode::Fresh,
             target: spawn.pane_id.as_str().to_string(),
+            spawned_at,
             session_id: None,
             rollout_path: None,
             pending_session_id: plan.expected_session_id.clone(),
@@ -872,7 +879,9 @@ fn persist_spawn_agent_state(
             continue;
         }
         let pane_pid = pane_pids_by_agent.get(id).copied();
-        let spawned_at = spawn_timestamp_for_agent(spawn_index);
+        let spawned_at = started_agent
+            .map(|started| started.spawned_at.clone())
+            .unwrap_or_else(|| spawn_timestamp_for_agent(spawn_index));
         spawn_index = spawn_index.saturating_add(1);
         agents.insert(
             id.to_string(),
@@ -2970,11 +2979,10 @@ pub fn quick_start_in_workspace_with_display_and_backend(
     // `state.transport.shim.pipe_ready = true` marker so its
     // `conpty_pipe_ready` gate opens.
     #[cfg(windows)]
-    let state_value = std::fs::read_to_string(crate::state::persist::runtime_state_path(
-        &workspace,
-    ))
-    .ok()
-    .and_then(|t| serde_json::from_str::<serde_json::Value>(&t).ok());
+    let state_value =
+        std::fs::read_to_string(crate::state::persist::runtime_state_path(&workspace))
+            .ok()
+            .and_then(|t| serde_json::from_str::<serde_json::Value>(&t).ok());
     #[cfg(windows)]
     let input = match state_value.as_ref() {
         Some(v) => input.with_state(Some(v)),