@team-agent/installer 0.5.16 → 0.5.18

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

@@ -107,20 +107,20 @@ pub enum TickError {
 /// returns `None` and the tick falls back to the raw state — preserving
 /// behavior for legacy single-team workspaces and tests that don't seed
 /// `teams.<key>`. Sibling teams under `state.teams.*` are NOT touched.
-fn coordinator_team_scoped_state(workspace: &std::path::Path, raw_state: &Value) -> Option<Value> {
+fn coordinator_team_scoped_state(
+    workspace: &std::path::Path,
+    raw_state: &Value,
+    daemon_team_key: Option<&str>,
+) -> Option<Value> {
+    let teams = raw_state.get("teams").and_then(Value::as_object)?;
     let active = raw_state
         .get("active_team_key")
         .and_then(Value::as_str)
-        .filter(|s| !s.is_empty())?;
-    let has_team_entry = raw_state
-        .get("teams")
-        .and_then(Value::as_object)
-        .map(|teams| teams.contains_key(active))
-        .unwrap_or(false);
-    if !has_team_entry {
-        return None;
-    }
-    crate::state::projection::select_runtime_state(workspace, Some(active)).ok()
+        .filter(|s| !s.is_empty());
+    let selected = daemon_team_key
+        .filter(|key| !key.is_empty() && teams.contains_key(*key))
+        .or_else(|| active.filter(|key| teams.contains_key(*key)))?;
+    crate::state::projection::select_runtime_state(workspace, Some(selected)).ok()
 }
 
 // ===========================================================================
@@ -149,6 +149,10 @@ pub struct Coordinator {
     /// transport 控制面(tmux session 存活探测等;经 trait 注入,可 mock)。
     #[allow(dead_code)]
     transport: Box<dyn crate::transport::Transport>,
+    /// Daemon CLI-selected team key. When present, tick projection uses this
+    /// instead of a stale root active_team_key.
+    #[allow(dead_code)]
+    daemon_team_key: Option<String>,
     /// bug-084 save 注入钩。`None` ⇔ 真实 `state::save_runtime_state`。
     #[allow(dead_code)]
     save_hook: Option<SaveHook>,
@@ -168,11 +172,17 @@ impl Coordinator {
             workspace,
             provider_registry,
             transport,
+            daemon_team_key: None,
             save_hook: None,
             order_recorder: None,
         }
     }
 
+    pub(crate) fn with_team_key(mut self, team_key: Option<String>) -> Self {
+        self.daemon_team_key = team_key.filter(|key| !key.is_empty());
+        self
+    }
+
     /// 测试装配:直接构出 `Coordinator`(不经 `new` 的 `unimplemented!()`),注入 mock
     /// transport + mock provider registry + 可选 save 注入钩 + ORDER 探针。**纯 test-support
     /// 脚手架**(真实 impl,非 `unimplemented!()`):它只装配字段,不执行任何 daemon 逻辑;
@@ -189,6 +199,7 @@ impl Coordinator {
             workspace,
             provider_registry,
             transport,
+            daemon_team_key: None,
             save_hook,
             order_recorder,
         }
@@ -224,8 +235,12 @@ impl Coordinator {
         // `team-prerelease-040-round3b`) and emit `coordinator.session_missing`
         // even though the right session is alive. Fall back to raw state when
         // no team scope can be derived (legacy single-team workspaces).
-        let mut state = coordinator_team_scoped_state(self.workspace.as_path(), &raw_state)
-            .unwrap_or(raw_state);
+        let mut state = coordinator_team_scoped_state(
+            self.workspace.as_path(),
+            &raw_state,
+            self.daemon_team_key.as_deref(),
+        )
+        .unwrap_or(raw_state);
         let store = crate::message_store::MessageStore::open(self.workspace.as_path())?;
         let event_log = EventLog::new(self.workspace.as_path());
         increment_coordinator_tick_iteration_count(&self.workspace);
@@ -1264,27 +1279,7 @@ impl Coordinator {
     /// `coordinator_health`(`lifecycle.py:26`)。pid + meta + schema 三合一健康。
     /// doctor / start 前置调它。`ok = running ∧ metadata_ok ∧ schema_ok`。
     pub fn health(&self) -> Result<HealthReport, TickError> {
-        let schema = self.schema_health();
-        let pid_path = coordinator_pid_path(&self.workspace);
-        let pid = read_pid_file(&pid_path);
-        let (status, running) = match pid {
-            Some(pid) if pid_is_running(pid).unwrap_or(false) => {
-                (CoordinatorHealthStatus::Running, true)
-            }
-            Some(_) => (CoordinatorHealthStatus::Stale, false),
-            None if pid_path.exists() => (CoordinatorHealthStatus::InvalidPid, false),
-            None => (CoordinatorHealthStatus::Missing, false),
-        };
-        let metadata = read_coordinator_metadata(&self.workspace);
-        let metadata_ok = pid.is_some_and(|p| coordinator_metadata_ok(metadata.as_ref(), p));
-        Ok(HealthReport {
-            ok: running && metadata_ok && schema.ok,
-            status,
-            pid,
-            metadata,
-            metadata_ok,
-            schema,
-        })
+        Ok(super::health::coordinator_health(&self.workspace))
     }
 
     /// `start_coordinator`(`lifecycle.py:49`)。幂等启动:已健康 no-op;metadata 不兼容先 stop 再起;
@@ -1292,40 +1287,7 @@ impl Coordinator {
     /// Python 是 `python -m team_agent.coordinator`,`lifecycle.py:108`)。
     /// **schema 兼容门**:三元任一不匹配 → restart_incompatible,**不可静默继续**(card §89)。
     pub fn start(&self) -> Result<StartReport, StartError> {
-        let health = self
-            .health()
-            .map_err(|e| std::io::Error::other(e.to_string()))?;
-        if health.ok {
-            return Ok(StartReport {
-                ok: true,
-                pid: health.pid,
-                status: StartOutcome::AlreadyRunning,
-                log: Some(coordinator_log_path(&self.workspace)),
-                schema_error: None,
-                action: None,
-            });
-        }
-        if !health.schema.ok {
-            return Ok(StartReport {
-                ok: false,
-                pid: health.pid,
-                status: StartOutcome::SchemaIncompatible,
-                log: None,
-                schema_error: health.schema.error,
-                action: health.schema.action,
-            });
-        }
-        let pid = Pid::new(std::process::id());
-        write_coordinator_metadata(&self.workspace, pid, MetadataSource::Start)?;
-        std::fs::write(coordinator_pid_path(&self.workspace), pid.to_string())?;
-        Ok(StartReport {
-            ok: true,
-            pid: Some(pid),
-            status: StartOutcome::Started,
-            log: Some(coordinator_log_path(&self.workspace)),
-            schema_error: None,
-            action: None,
-        })
+        super::health::start_coordinator(&self.workspace)
     }
 
     /// `stop_coordinator`(`lifecycle.py:229`)。SIGTERM + 清 pid/meta。pid 非整数 → 清文件返回。
@@ -2544,4 +2506,44 @@ mod u1_tests {
             "capture_missing failure must be visible in events.jsonl; got {events}"
         );
     }
+
+    #[test]
+    fn daemon_team_key_projection_beats_stale_root_active_team_key() {
+        let dir = std::env::temp_dir().join(format!(
+            "team-agent-daemon-team-key-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        let raw = serde_json::json!({
+            "active_team_key": "stale-b",
+            "session_name": "team-stale-b",
+            "teams": {
+                "fresh-a": {
+                    "active_team_key": "fresh-a",
+                    "team_key": "fresh-a",
+                    "session_name": "team-fresh-a",
+                    "agents": {}
+                },
+                "stale-b": {
+                    "active_team_key": "stale-b",
+                    "team_key": "stale-b",
+                    "session_name": "team-stale-b",
+                    "agents": {}
+                }
+            }
+        });
+        crate::state::persist::save_runtime_state(&dir, &raw).unwrap();
+
+        let selected =
+            coordinator_team_scoped_state(&dir, &raw, Some("fresh-a")).expect("selected team");
+
+        assert_eq!(
+            selected.get("session_name").and_then(Value::as_str),
+            Some("team-fresh-a")
+        );
+    }
 }

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

@@ -112,6 +112,8 @@ pub enum StartOutcome {
     SchemaIncompatible,
     /// 正常 spawn(`lifecycle.py:121`)。
     Started,
+    /// 当前 CLI 发现 live daemon 的 binary identity 过期,stop 后重新 spawn。
+    StartedAfterRotation,
 }
 
 /// `stop_coordinator` 结果 status(`lifecycle.py:232,238,243,247`)。
@@ -170,11 +172,50 @@ pub struct CoordinatorMetadata {
     pub pid: Pid,
     pub protocol_version: u32,
     pub message_store_schema_version: i64,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub binary_path: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub binary_version: Option<String>,
     pub source: MetadataSource,
     /// ISO8601(`datetime.now(timezone.utc).isoformat()`,`metadata.py:56`)。
     pub updated_at: String,
 }
 
+/// Current coordinator daemon binary identity. Version comes from the compiled
+/// package; path comes from the currently executing CLI binary, not PATH.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CoordinatorBinaryIdentity {
+    pub binary_path: String,
+    pub binary_version: String,
+}
+
+/// Stable machine-readable reason for coordinator metadata rejection.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CoordinatorMetadataMismatchReason {
+    MetadataMissing,
+    PidMismatch,
+    ProtocolVersionMismatch,
+    MessageStoreSchemaVersionMismatch,
+    BinaryIdentityMissing,
+    BinaryVersionMismatch,
+    BinaryPathMismatch,
+}
+
+impl CoordinatorMetadataMismatchReason {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::MetadataMissing => "metadata_missing",
+            Self::PidMismatch => "pid_mismatch",
+            Self::ProtocolVersionMismatch => "protocol_version_mismatch",
+            Self::MessageStoreSchemaVersionMismatch => "message_store_schema_version_mismatch",
+            Self::BinaryIdentityMissing => "binary_identity_missing",
+            Self::BinaryVersionMismatch => "binary_version_mismatch",
+            Self::BinaryPathMismatch => "binary_path_mismatch",
+        }
+    }
+}
+
 // ===========================================================================
 // SchemaHealth(lifecycle.py:197-226)
 // ===========================================================================
@@ -244,6 +285,8 @@ pub struct HealthReport {
     pub metadata: Option<CoordinatorMetadata>,
     /// 三元全等(`coordinator_metadata_ok`,`metadata.py:37-43`)。
     pub metadata_ok: bool,
+    pub metadata_mismatch_reason: Option<String>,
+    pub current_binary_identity: CoordinatorBinaryIdentity,
     pub schema: SchemaHealth,
 }
 
@@ -253,6 +296,10 @@ pub struct StartReport {
     pub ok: bool,
     pub pid: Option<Pid>,
     pub status: StartOutcome,
+    pub previous_pid: Option<Pid>,
+    pub binary_path: Option<String>,
+    pub binary_version: Option<String>,
+    pub rotation_reason: Option<String>,
     /// coordinator.log 路径(成功路径,`lifecycle.py:54/121`)。
     pub log: Option<PathBuf>,
     /// schema_incompatible 时的修复 hint / 失败原因。

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

@@ -9,7 +9,9 @@ use crate::cli::CliError;
 use crate::coordinator::health::{
     coordinator_metadata_ok, pid_is_running, read_coordinator_metadata, terminate_pid_tree,
 };
-use crate::coordinator::types::{OrphanReason, Pid, WorkspacePath};
+use crate::coordinator::types::{
+    CoordinatorMetadata, OrphanReason, Pid, WorkspacePath, PROTOCOL_VERSION,
+};
 // Phase 1d Batch 6: `TmuxBackend` import removed — all sites now use
 // `transport_factory::tmux_socket_name_transport` for grep-visibility.
 use crate::transport::{SessionName, Transport};
@@ -477,8 +479,7 @@ fn ps_command_rows() -> Vec<ProcessRow> {
         Command::new("ps").args(["-axww", "-o", "pid=,command="]),
         "ps_table",
         None,
-    )
-    {
+    ) {
         Ok(output) if output.status.success() => output,
         _ => return Vec::new(),
     };
@@ -490,9 +491,7 @@ fn ps_command_rows() -> Vec<ProcessRow> {
 
 fn parse_ps_command_line(line: &str) -> Option<ProcessRow> {
     let line = line.trim_start();
-    let split = line
-        .find(char::is_whitespace)
-        .unwrap_or(line.len());
+    let split = line.find(char::is_whitespace).unwrap_or(line.len());
     let pid = line.get(..split)?.trim().parse::<u32>().ok()?;
     let command = line.get(split..)?.trim().to_string();
     Some(ProcessRow {
@@ -568,7 +567,7 @@ fn classify_workspace_orphan(workspace: &Path, pid: Pid) -> Option<OrphanReason>
     }
     let workspace_path = WorkspacePath::new(workspace.to_path_buf());
     let metadata = read_coordinator_metadata(&workspace_path);
-    if metadata.is_some() && !coordinator_metadata_ok(metadata.as_ref(), pid) {
+    if coordinator_process_metadata_mismatch(metadata.as_ref(), pid) {
         return Some(OrphanReason::MetadataMismatch);
     }
     if pid_is_running(pid).ok() == Some(false) {
@@ -577,6 +576,15 @@ fn classify_workspace_orphan(workspace: &Path, pid: Pid) -> Option<OrphanReason>
     None
 }
 
+fn coordinator_process_metadata_mismatch(metadata: Option<&CoordinatorMetadata>, pid: Pid) -> bool {
+    let Some(metadata) = metadata else {
+        return false;
+    };
+    metadata.pid != pid
+        || metadata.protocol_version != PROTOCOL_VERSION
+        || metadata.message_store_schema_version != crate::db::schema::SCHEMA_VERSION
+}
+
 fn classify_workspace_without_pid(workspace: &Path) -> Option<OrphanReason> {
     if !workspace.is_absolute() {
         return None;
@@ -592,10 +600,7 @@ fn classify_workspace_without_pid(workspace: &Path) -> Option<OrphanReason> {
 
 fn ephemeral_workspace_hint(workspace: &Path) -> Option<String> {
     let text = workspace.to_string_lossy();
-    let patterns = [
-        "ta_doctor_comms_orphans-",
-        "team-agent-watcher-dedupe",
-    ];
+    let patterns = ["ta_doctor_comms_orphans-", "team-agent-watcher-dedupe"];
     patterns
         .iter()
         .find(|pattern| text.contains(**pattern))
@@ -626,8 +631,7 @@ fn ps_parent_map() -> BTreeMap<u32, u32> {
         Command::new("ps").args(["-axo", "pid=,ppid="]),
         "ps_parent",
         None,
-    )
-    {
+    ) {
         Ok(output) if output.status.success() => output,
         _ => return BTreeMap::new(),
     };
@@ -732,4 +736,22 @@ mod tests {
             Some(PathBuf::from("/tmp/My Agent"))
         );
     }
+
+    #[test]
+    fn process_orphan_metadata_ignores_binary_identity_rotation() {
+        let metadata = CoordinatorMetadata {
+            pid: Pid::new(123),
+            protocol_version: PROTOCOL_VERSION,
+            message_store_schema_version: crate::db::schema::SCHEMA_VERSION,
+            binary_path: Some("/old/team-agent".to_string()),
+            binary_version: Some("0.5.17".to_string()),
+            source: crate::coordinator::MetadataSource::Boot,
+            updated_at: "2026-07-09T00:00:00+00:00".to_string(),
+        };
+
+        assert!(
+            !coordinator_process_metadata_mismatch(Some(&metadata), Pid::new(123)),
+            "binary identity drift is a rotation signal, not orphan cleanup proof"
+        );
+    }
 }

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/agent.rs

@@ -157,7 +157,8 @@ pub(crate) fn start_agent_at_paths(
             write_team_state(spec_workspace, &spec, &state)?;
         }
         replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
-        let coordinator_started = start_coordinator_for_workspace(workspace)?;
+        let coordinator = start_coordinator_for_workspace(workspace, Some(&team_key))?;
+        let coordinator_started = coordinator.ok;
         let target = format!("{}:{window}", session_name.as_str());
         if let Some(new_binding) = refreshed_binding.as_ref() {
             if old_binding.as_ref() != Some(new_binding) {
@@ -310,7 +311,8 @@ pub(crate) fn start_agent_at_paths(
         tmux_start_mode_for_spawn(&spawn, into_existing_session),
     )?;
     replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
-    let coordinator_started = start_coordinator_for_workspace(workspace)?;
+    let coordinator = start_coordinator_for_workspace(workspace, Some(&team_key))?;
+    let coordinator_started = coordinator.ok;
     Ok(StartAgentOutcome::Running {
         env: AgentActionEnvelope {
             agent_id: agent_id.clone(),

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

@@ -449,10 +449,13 @@ fn window_present_in_live(
     false
 }
 
-pub(super) fn start_coordinator_for_workspace(workspace: &Path) -> Result<bool, LifecycleError> {
+pub(super) fn start_coordinator_for_workspace(
+    workspace: &Path,
+    team_key: Option<&str>,
+) -> Result<crate::lifecycle::CoordinatorStartSummary, LifecycleError> {
     let workspace = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
-    crate::coordinator::start_coordinator(&workspace)
-        .map(|report| report.ok)
+    crate::coordinator::health::start_coordinator_with_team(&workspace, team_key)
+        .map(|report| crate::lifecycle::CoordinatorStartSummary::from_start_report(&report))
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 

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

@@ -590,6 +590,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "fail",
+            None,
         )?;
         return Ok(RestartReport::Failed {
             session_name,
@@ -606,6 +607,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "fail",
+            None,
         )?;
         return Ok(RestartReport::Failed {
             session_name,
@@ -824,6 +826,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "fail",
+            None,
         )?;
         return Ok(RestartReport::Failed {
             session_name,
@@ -833,7 +836,9 @@ fn restart_with_selected_team_and_transport(
         });
     }
     drop(lifecycle_lock);
-    let coordinator_started = start_coordinator_for_workspace(&selected.run_workspace)?;
+    let coordinator =
+        start_coordinator_for_workspace(&selected.run_workspace, Some(&selected.team_key))?;
+    let coordinator_started = coordinator.ok;
     wait_restart_readiness_or_timeout(
         &selected.run_workspace,
         &state,
@@ -862,6 +867,7 @@ fn restart_with_selected_team_and_transport(
             &successful_agents,
             &failed_agents,
             "partial",
+            Some(&coordinator),
         )?;
         // 0.3.30 Bug 1: auto-attach on partial restart too — workers that did
         // come up still need a leader_receiver pane to deliver report_result.
@@ -875,6 +881,7 @@ fn restart_with_selected_team_and_transport(
             agents: successful_agents,
             failed_agents,
             coordinator_started,
+            coordinator,
             next_actions,
             attach_commands,
         });
@@ -884,6 +891,7 @@ fn restart_with_selected_team_and_transport(
         &successful_agents,
         &failed_agents,
         "ok",
+        Some(&coordinator),
     )?;
     // 0.3.30 Bug 1: auto-attach leader from caller's TMUX_PANE if available.
     // Mirrors quick-start's seed_launched_owner_from_env behaviour: a restart
@@ -900,6 +908,7 @@ fn restart_with_selected_team_and_transport(
         session_name,
         agents: successful_agents,
         coordinator_started,
+        coordinator,
         next_actions,
         attach_commands,
     })
@@ -1404,6 +1413,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()),
@@ -1948,27 +1962,32 @@ fn write_restart_completed_event(
     successful_agents: &[RestartedAgent],
     failed_agents: &[RestartFailedAgent],
     rc: &str,
+    coordinator: Option<&crate::lifecycle::CoordinatorStartSummary>,
 ) -> Result<(), LifecycleError> {
+    let mut payload = serde_json::json!({
+        "rc": rc,
+        "status": rc,
+        "successful_agents": successful_agents
+            .iter()
+            .map(|agent| agent.agent_id.as_str())
+            .collect::<Vec<_>>(),
+        "failed_agents": failed_agents
+            .iter()
+            .map(|failure| serde_json::json!({
+                "agent_id": failure.agent_id.as_str(),
+                "phase": failure.phase,
+                "error": failure.error,
+            }))
+            .collect::<Vec<_>>(),
+    });
+    if let (Some(object), Some(coordinator)) = (payload.as_object_mut(), coordinator) {
+        object.insert(
+            "coordinator".to_string(),
+            crate::lifecycle::coordinator_start_summary_value(coordinator),
+        );
+    }
     crate::event_log::EventLog::new(workspace)
-        .write(
-            "restart.completed",
-            serde_json::json!({
-                "rc": rc,
-                "status": rc,
-                "successful_agents": successful_agents
-                    .iter()
-                    .map(|agent| agent.agent_id.as_str())
-                    .collect::<Vec<_>>(),
-                "failed_agents": failed_agents
-                    .iter()
-                    .map(|failure| serde_json::json!({
-                        "agent_id": failure.agent_id.as_str(),
-                        "phase": failure.phase,
-                        "error": failure.error,
-                    }))
-                    .collect::<Vec<_>>(),
-            }),
-        )
+        .write("restart.completed", payload)
         .map(|_| ())
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }

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";