@team-agent/installer 0.5.112 → 0.5.114

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

@@ -45,7 +45,7 @@ use super::*;
 /// params:
 ///   spec_path: spec 路径，team 目录优先取 state 里的 team_dir
 ///   session_name: 目标 tmux session
-/// returns: 已起席位清单，含目标 pane、启动模式、布局与显示信息；spawn 后 pane 已死的席位被跳过
+/// returns: legacy 启动收据与独立 contract 已提交席位 ID；不为私有 socket 伪造 legacy pane
 /// errors: 命令拼装或 transport spawn 失败时返回 LifecycleError
 /// ---
 pub(super) fn spawn_agents(
@@ -54,7 +54,7 @@ pub(super) fn spawn_agents(
     spec: &Value,
     session_name: &SessionName,
     transport: &dyn Transport,
-) -> Result<Vec<StartedAgent>, LifecycleError> {
+) -> Result<(Vec<StartedAgent>, Vec<AgentId>), LifecycleError> {
     // E5 解耦:team_dir(角色定义 + profiles 所在)≠ spec_path.parent()(spec 已迁出到 .team/runtime)。
     // 优先取 state.team_dir(角色目录),回落 spec_path.parent()(legacy 同目录布局)。
     let team_dir_buf = crate::state::persist::load_runtime_state(workspace)
@@ -74,6 +74,10 @@ pub(super) fn spawn_agents(
         Some(Value::Bool(true))
     );
     let mut started = Vec::new();
+    #[cfg(unix)]
+    let mut contract_started = Vec::new();
+    #[cfg(not(unix))]
+    let contract_started = Vec::new();
     for agent in spec_agent_values(spec) {
         let Some(agent_id_raw) = agent.get("id").and_then(Value::as_str) else {
             continue;
@@ -81,6 +85,26 @@ pub(super) fn spawn_agents(
         if agent_is_paused(agent) {
             continue;
         }
+        #[cfg(unix)]
+        if agent
+            .get("provider")
+            .and_then(Value::as_str)
+            .is_some_and(|provider| {
+                crate::contract_runtime::registry::descriptor(provider).is_some()
+            })
+        {
+            let team = runtime_team_key_for_spec(spec_path, spec, session_name);
+            crate::contract_runtime::framework::start_role(
+                workspace,
+                team_dir,
+                &team,
+                agent_id_raw,
+            )?;
+            contract_started.push(AgentId::new(agent_id_raw));
+            // No legacy target is manufactured for the private native socket.
+            // persist_spawn_agent_state projects the actual K3 seat separately.
+            continue;
+        }
         let agent_id = AgentId::new(agent_id_raw);
         let provider = agent
             .get("provider")
@@ -99,11 +123,12 @@ pub(super) fn spawn_agents(
         // has both the role instruction AND the callable Team Agent MCP capability.
         // probe5 RED proved that `build_command(.., None, None, ..)` left the worker
         // without `report_result`; placeholders are substituted at spawn time.
-        let command_agent = crate::lifecycle::worker_command_context::WorkerCommandAgent::from_yaml(
-            agent,
-            Some(agent_id_raw),
-            provider,
-        )?;
+        let command_agent =
+            crate::lifecycle::worker_command_context::WorkerCommandAgent::from_yaml(
+                agent,
+                Some(agent_id_raw),
+                provider,
+            )?;
         let system_prompt =
             crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
         // 0.5.66 bypass 单源:per-agent safety 只服务 env 注入与审计,不参与 argv 决策。
@@ -431,7 +456,7 @@ pub(super) fn spawn_agents(
             managed_mcp_config: plan.managed_mcp_config || profile_launch.managed_mcp_config,
         });
     }
-    Ok(started)
+    Ok((started, contract_started))
 }
 
 /// ---
@@ -451,7 +476,11 @@ pub(crate) fn agent_id_spec_source_path(workspace: &Path, agent_id: &str) -> Str
         });
     team_dir
         .map(|dir| dir.join("agents").join(format!("{agent_id}.md")))
-        .unwrap_or_else(|| workspace.join(".team/current/agents").join(format!("{agent_id}.md")))
+        .unwrap_or_else(|| {
+            workspace
+                .join(".team/current/agents")
+                .join(format!("{agent_id}.md"))
+        })
         .display()
         .to_string()
 }

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

@@ -119,6 +119,23 @@ pub(super) fn persist_spawn_agent_state(
         let Some(id) = agent.get("id").and_then(Value::as_str) else {
             continue;
         };
+        #[cfg(unix)]
+        if agent
+            .get("provider")
+            .and_then(Value::as_str)
+            .is_some_and(|provider| {
+                crate::contract_runtime::registry::descriptor(provider).is_some()
+            })
+        {
+            let projected = if agent_is_paused(agent) {
+                serde_json::json!({"agent_id":id,"provider":"kiro","runtime_family":"contract","status":"paused","pane_id":null})
+            } else {
+                crate::contract_runtime::framework::project_seat(workspace, &team_id, id)
+                    .map_err(|error| LifecycleError::StatePersist(error.to_string()))?
+            };
+            agents.insert(id.to_string(), projected);
+            continue;
+        }
         let provider = agent
             .get("provider")
             .and_then(Value::as_str)

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

@@ -133,7 +133,11 @@ pub fn launch_with_transport_in_workspace(
     // 所有角色都未声明 dangerously_skip_permissions=true → 写 warning 事件不阻塞。
     // TODO(0.6.0): remove(0.6.0 彻底删源头 A 后此警示无意义)。
     emit_dangerous_flag_no_role_declared_warning(workspace, &spec);
-    phase_timer.emit(workspace, "launch.phase", "compile_spec");
+    phase_timer.emit(
+        workspace,
+        "launch.phase",
+        super::restart::LifecyclePhase::CompileSpec,
+    );
     let session_name = spec_session_name(&spec);
     if !dry_run && transport_has_session(transport, &session_name) {
         return Err(LifecycleError::SessionConflict(format!(
@@ -142,11 +146,16 @@ pub fn launch_with_transport_in_workspace(
         )));
     }
     let routes = spec_routes(&spec);
-    let started = if dry_run {
-        Vec::new()
+    let (started, contract_started) = if dry_run {
+        (Vec::new(), Vec::new())
     } else {
-        phase_timer.emit(workspace, "launch.phase", "spawn_all");
-        let started = spawn_agents(workspace, spec_path, &spec, &session_name, transport)?;
+        phase_timer.emit(
+            workspace,
+            "launch.phase",
+            super::restart::LifecyclePhase::SpawnAll,
+        );
+        let (started, contract_started) =
+            spawn_agents(workspace, spec_path, &spec, &session_name, transport)?;
         persist_spawn_agent_state(
             workspace,
             spec_path,
@@ -164,14 +173,16 @@ pub fn launch_with_transport_in_workspace(
             .first()
             .map(|agent| agent.spawned_at.as_str())
             .unwrap_or(session_name.as_str());
-        transport
-            .set_session_owner_with_generation(
-                &session_name,
-                workspace,
-                &owner_team,
-                generation,
-            )
-            .map_err(|error| LifecycleError::Transport(error.to_string()))?;
+        if !started.is_empty() {
+            transport
+                .set_session_owner_with_generation(
+                    &session_name,
+                    workspace,
+                    &owner_team,
+                    generation,
+                )
+                .map_err(|error| LifecycleError::Transport(error.to_string()))?;
+        }
         // 0.5.38: per-worker timing tags (source="launch") so operators can
         // trace which worker's spawn dominates wall time. Zeros for now on
         // the sub-timings — Step 1 first enables shape assertion; a later
@@ -208,7 +219,7 @@ pub fn launch_with_transport_in_workspace(
                 "launch",
             );
         }
-        started
+        (started, contract_started)
     };
     // 0.3.28 Step 1: topology invariant guard (warn-only during migration).
     // Logs each violation to stderr; never panics. Promoted to hard error at
@@ -223,6 +234,7 @@ pub fn launch_with_transport_in_workspace(
     Ok(LaunchReport {
         session_name,
         started,
+        contract_started,
         dry_run,
         tmux_endpoint: transport.tmux_endpoint(),
         routes,
@@ -348,13 +360,13 @@ pub use cursor_mcp_iso::{
     materialize_cursor_mcp_project,
 };
 mod cursor_mcp;
+pub(crate) use cursor_mcp::apply_cursor_mcp_enable_profile_env;
 pub use cursor_mcp::{
     apply_cursor_mcp_overlay, apply_cursor_spawn_workspace_pointers,
     apply_cursor_workspace_physical_path, cursor_mcp_enable_argv, cursor_mcp_enable_working_dir,
     enable_cursor_workspace_mcp, enable_cursor_workspace_mcp_with_profile, physical_workspace_path,
     prepare_cursor_seat_mcp, refuse_second_cursor_occupant,
 };
-pub(crate) use cursor_mcp::apply_cursor_mcp_enable_profile_env;
 
 mod cursor_create_chat;
 
@@ -363,9 +375,9 @@ pub(super) use worker_env::*;
 pub(crate) use worker_env::{
     apply_copilot_instructions_overlay, apply_cursor_agent_rules_overlay,
     apply_cursor_subscription_proxy_env_with_profile, apply_mcp_auto_approval_env,
-    apply_profile_launch_env, auth_mode_env_value,
-    fill_spawn_placeholders, fill_spawn_placeholders_full, inherited_env_with_team_overrides,
-    persist_command_plan_state, spawn_timestamp,
+    apply_profile_launch_env, auth_mode_env_value, fill_spawn_placeholders,
+    fill_spawn_placeholders_full, inherited_env_with_team_overrides, persist_command_plan_state,
+    spawn_timestamp,
 };
 pub use worker_env::{apply_cursor_subscription_proxy_env, CursorProxyPresence};
 
@@ -393,18 +405,18 @@ pub(crate) use quick_start_transport::{
 };
 
 pub mod readiness;
+pub(super) use readiness::*;
 pub use readiness::{
     classify_leader_binding, launched_team_receiver_is_attached, selected_team_leader_receiver,
     LeaderBindingClass,
 };
-pub(super) use readiness::*;
 
 mod add_agent;
 pub(super) use add_agent::*;
 pub use add_agent::{add_agent, add_agent_force};
 pub(crate) use add_agent::{
-    add_agent_with_transport, add_agent_with_transport_force,
-    add_agent_with_transport_at_paths_locked, force_recreate_with_transport_locked,
+    add_agent_with_transport, add_agent_with_transport_at_paths_locked,
+    add_agent_with_transport_force, force_recreate_with_transport_locked,
 };
 
 pub(crate) mod add_agent_state;
@@ -428,21 +440,20 @@ pub(super) use ownership::*;
 pub(crate) use ownership::{ensure_owner_allowed, ensure_owner_allowed_for_state, state_path};
 
 pub mod spec_state;
-pub use spec_state::{
-    seed_launched_owner_from_caller_with_provider_lookup, worker_session_name_pub,
-};
 pub(crate) use spec_state::{
     effective_runtime_config_for_worker_spawn, effective_runtime_config_for_worker_spawn_json,
 };
 use spec_state::{
-    env_nonempty, has_positive_caller_leader_env, initial_runtime_state,
-    override_spec_runtime_str, seed_launched_owner_from_env,
-    spec_agent_values, spec_agents, spec_default_assignee, spec_routes, spec_session_name,
-    spec_tasks_json, team_workspace, yaml_value_to_json,
+    env_nonempty, has_positive_caller_leader_env, initial_runtime_state, override_spec_runtime_str,
+    seed_launched_owner_from_env, spec_agent_values, spec_agents, spec_default_assignee,
+    spec_routes, spec_session_name, spec_tasks_json, team_workspace, yaml_value_to_json,
 };
 pub(crate) use spec_state::{
     override_spec_session_name, override_spec_workspace, spec_agent_id_set, write_spec_atomic,
 };
+pub use spec_state::{
+    seed_launched_owner_from_caller_with_provider_lookup, worker_session_name_pub,
+};
 
 #[cfg(test)]
 mod tests {

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

@@ -31,6 +31,7 @@ use crate::lifecycle::LifecycleError;
 use crate::model::enums::{AuthMode, Provider};
 use crate::model::yaml::Value as YamlValue;
 use crate::provider::{McpConfig, ProviderCommandOverrides, ProviderProfileLaunch};
+use crate::provider::command_helpers::append_env_pair;
 
 const COMPATIBLE_NETWORK_ENV_KEYS: &[&str] = &[
     "HTTPS_PROXY",
@@ -463,40 +464,26 @@ fn provider_env_exports(
     }
     match provider {
         Provider::Claude | Provider::ClaudeCode => {
-            if let Some(value) = value_or_alternate(values, "ANTHROPIC_BASE_URL", "BASE_URL") {
-                exports.insert("ANTHROPIC_BASE_URL".to_string(), value.to_string());
-            }
+            append_env_pair(&mut exports, "ANTHROPIC_BASE_URL", value_or_alternate(values, "ANTHROPIC_BASE_URL", "BASE_URL"));
             if auth_mode == AuthMode::OfficialApi {
-                if let Some(value) = value_or_alternate(values, "ANTHROPIC_API_KEY", "API_KEY") {
-                    exports.insert("ANTHROPIC_API_KEY".to_string(), value.to_string());
-                }
+                append_env_pair(&mut exports, "ANTHROPIC_API_KEY", value_or_alternate(values, "ANTHROPIC_API_KEY", "API_KEY"));
             }
-            if let Some(value) = value_or_alternate(values, "ANTHROPIC_AUTH_TOKEN", "AUTH_TOKEN")
+            append_env_pair(&mut exports, "ANTHROPIC_AUTH_TOKEN", value_or_alternate(values, "ANTHROPIC_AUTH_TOKEN", "AUTH_TOKEN")
                 .or_else(|| {
                     (auth_mode == AuthMode::CompatibleApi)
                         .then(|| value_or_alternate(values, "ANTHROPIC_API_KEY", "API_KEY"))
                         .flatten()
-                })
-            {
-                exports.insert("ANTHROPIC_AUTH_TOKEN".to_string(), value.to_string());
-            }
-            if let Some(value) = profile_model(values) {
-                exports.insert("ANTHROPIC_MODEL".to_string(), value.to_string());
-            }
+                }));
+            append_env_pair(&mut exports, "ANTHROPIC_MODEL", profile_model(values));
         }
         Provider::Codex => {
-            if let Some(value) = value_or_alternate(values, "OPENAI_API_KEY", "API_KEY") {
-                exports.insert("TEAM_AGENT_PROVIDER_API_KEY".to_string(), value.to_string());
-                exports.insert("OPENAI_API_KEY".to_string(), value.to_string());
-            }
-            if let Some(value) = values.get("BASE_URL").filter(|value| !value.is_empty()) {
-                exports.insert("OPENAI_BASE_URL".to_string(), value.to_string());
-            }
+            let key = value_or_alternate(values, "OPENAI_API_KEY", "API_KEY");
+            append_env_pair(&mut exports, "TEAM_AGENT_PROVIDER_API_KEY", key);
+            append_env_pair(&mut exports, "OPENAI_API_KEY", key);
+            append_env_pair(&mut exports, "OPENAI_BASE_URL", values.get("BASE_URL").filter(|value| !value.is_empty()).map(String::as_str));
         }
         Provider::GeminiCli => {
-            if let Some(value) = value_or_alternate(values, "GEMINI_API_KEY", "API_KEY") {
-                exports.insert("GEMINI_API_KEY".to_string(), value.to_string());
-            }
+            append_env_pair(&mut exports, "GEMINI_API_KEY", value_or_alternate(values, "GEMINI_API_KEY", "API_KEY"));
         }
         // C-A-4 cr verdict v2 — copilot BYOK(== compatible_api 档,help-providers 原文
         // "GitHub authentication is not required" when COPILOT_PROVIDER_BASE_URL set):
@@ -506,28 +493,14 @@ fn provider_env_exports(
         // Subscription/OfficialApi 不导出 COPILOT_PROVIDER_*(避免误改 auth 通道)。
         Provider::Copilot => {
             if auth_mode == AuthMode::CompatibleApi {
-                if let Some(value) =
-                    value_or_alternate(values, "COPILOT_PROVIDER_BASE_URL", "BASE_URL")
-                {
-                    exports.insert("COPILOT_PROVIDER_BASE_URL".to_string(), value.to_string());
-                }
-                if let Some(value) =
-                    value_or_alternate(values, "COPILOT_PROVIDER_TYPE", "PROVIDER_TYPE")
-                {
-                    exports.insert("COPILOT_PROVIDER_TYPE".to_string(), value.to_string());
-                }
-                if let Some(value) =
-                    value_or_alternate(values, "COPILOT_PROVIDER_API_KEY", "API_KEY")
-                {
-                    exports.insert("COPILOT_PROVIDER_API_KEY".to_string(), value.to_string());
-                }
-                if let Some(value) =
-                    value_or_alternate(values, "COPILOT_PROVIDER_WIRE_API", "WIRE_API")
-                {
-                    exports.insert("COPILOT_PROVIDER_WIRE_API".to_string(), value.to_string());
-                }
-                if let Some(value) = value_or_alternate(values, "COPILOT_MODEL", "MODEL") {
-                    exports.insert("COPILOT_MODEL".to_string(), value.to_string());
+                for (key, alternate) in [
+                    ("COPILOT_PROVIDER_BASE_URL", "BASE_URL"),
+                    ("COPILOT_PROVIDER_TYPE", "PROVIDER_TYPE"),
+                    ("COPILOT_PROVIDER_API_KEY", "API_KEY"),
+                    ("COPILOT_PROVIDER_WIRE_API", "WIRE_API"),
+                    ("COPILOT_MODEL", "MODEL"),
+                ] {
+                    append_env_pair(&mut exports, key, value_or_alternate(values, key, alternate));
                 }
             }
         }
@@ -539,6 +512,45 @@ fn provider_env_exports(
     exports
 }
 
+#[cfg(test)]
+mod append_env_contract {
+    use super::*;
+
+    #[test]
+    fn profile_append_keeps_native_keys_alternates_and_auth_gates() {
+        let values: BTreeMap<String, String> = [
+            ("API_KEY", "dummy"), ("BASE_URL", " raw\nbase "),
+            ("AUTH_TOKEN", "dummy-token"), ("MODEL", " raw model "),
+            ("PROVIDER_TYPE", "custom"), ("WIRE_API", "responses"),
+            ("OPENAI_API_KEY", "native-dummy"),
+        ].into_iter().map(|(k, v)| (k.to_string(), v.to_string())).collect();
+        let map = |pairs: &[(&str, &str)]| -> BTreeMap<String, String> {
+            pairs.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect()
+        };
+        for provider in [Provider::Claude, Provider::ClaudeCode] {
+            assert_eq!(provider_env_exports(provider, AuthMode::OfficialApi, &values), map(&[
+                ("ANTHROPIC_BASE_URL", " raw\nbase "), ("ANTHROPIC_API_KEY", "dummy"),
+                ("ANTHROPIC_AUTH_TOKEN", "dummy-token"), ("ANTHROPIC_MODEL", " raw model "),
+            ]));
+        }
+        assert_eq!(provider_env_exports(Provider::Codex, AuthMode::CompatibleApi, &values), map(&[
+            ("TEAM_AGENT_PROVIDER_API_KEY", "native-dummy"), ("OPENAI_API_KEY", "native-dummy"),
+            ("OPENAI_BASE_URL", " raw\nbase "),
+        ]));
+        assert_eq!(provider_env_exports(Provider::GeminiCli, AuthMode::OfficialApi, &values), map(&[("GEMINI_API_KEY", "dummy")]));
+        assert_eq!(provider_env_exports(Provider::Copilot, AuthMode::CompatibleApi, &values), map(&[
+            ("COPILOT_PROVIDER_BASE_URL", " raw\nbase "), ("COPILOT_PROVIDER_TYPE", "custom"),
+            ("COPILOT_PROVIDER_API_KEY", "dummy"), ("COPILOT_PROVIDER_WIRE_API", "responses"),
+            ("COPILOT_MODEL", " raw model "),
+        ]));
+        assert!(provider_env_exports(Provider::Copilot, AuthMode::OfficialApi, &values).is_empty());
+        for provider in crate::provider::wire::all_providers() {
+            assert!(provider_env_exports(*provider, AuthMode::Subscription, &values).is_empty());
+            assert!(provider_env_exports(*provider, AuthMode::CompatibleApi, &BTreeMap::new()).is_empty());
+        }
+    }
+}
+
 /// ---
 /// purpose: 给出该 provider 与 auth_mode 下必须从子进程环境里清掉的变量名集
 /// returns: 变量名集合；claude 系清掉会让子进程并入父会话的那组标识

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

@@ -41,6 +41,71 @@ use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest}
 // `pane_verify_ms`, `startup_prompt_handler_ms`, `tmux_start_mode`) so
 // bounded-concurrency spawn can be justified with real numbers.
 
+/// Stable wire labels for launch/restart timing events, not readiness states.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum LifecyclePhase {
+    ResolveContext,
+    CompileSpec,
+    PlanClassification,
+    Teardown,
+    SpawnAll,
+    SaveState,
+    CoordinatorStart,
+    ReadinessWait,
+    Completed,
+}
+
+impl LifecyclePhase {
+    pub(crate) fn as_str(self) -> &'static str {
+        match self {
+            Self::ResolveContext => "resolve_context",
+            Self::CompileSpec => "compile_spec",
+            Self::PlanClassification => "plan_classification",
+            Self::Teardown => "teardown",
+            Self::SpawnAll => "spawn_all",
+            Self::SaveState => "save_state",
+            Self::CoordinatorStart => "coordinator_start",
+            Self::ReadinessWait => "readiness_wait",
+            Self::Completed => "completed",
+        }
+    }
+
+    /// Pure event formatting shared by launch/restart; no clock, I/O or readiness policy.
+    pub(crate) fn event_fields(self, elapsed_ms: u64) -> serde_json::Value {
+        serde_json::json!({
+            "phase": self.as_str(),
+            "elapsed_ms": elapsed_ms,
+        })
+    }
+}
+
+#[test]
+fn lifecycle_phase_wire_labels_remain_stable() {
+    for (phase, wire) in [
+        (LifecyclePhase::ResolveContext, "resolve_context"),
+        (LifecyclePhase::CompileSpec, "compile_spec"),
+        (LifecyclePhase::PlanClassification, "plan_classification"),
+        (LifecyclePhase::Teardown, "teardown"),
+        (LifecyclePhase::SpawnAll, "spawn_all"),
+        (LifecyclePhase::SaveState, "save_state"),
+        (LifecyclePhase::CoordinatorStart, "coordinator_start"),
+        (LifecyclePhase::ReadinessWait, "readiness_wait"),
+        (LifecyclePhase::Completed, "completed"),
+    ] {
+        assert_eq!(phase.as_str(), wire);
+        for elapsed_ms in [0, 123, u64::MAX] {
+            assert_eq!(phase.event_fields(elapsed_ms), serde_json::json!({
+                "phase": wire,
+                "elapsed_ms": elapsed_ms,
+            }));
+            assert_eq!(
+                serde_json::to_string(&phase.event_fields(elapsed_ms)).expect("phase JSON"),
+                format!("{{\"phase\":\"{wire}\",\"elapsed_ms\":{elapsed_ms}}}"),
+            );
+        }
+    }
+}
+
 pub(crate) struct RestartPhaseTimer {
     started_at: std::time::Instant,
 }
@@ -71,15 +136,9 @@ impl RestartPhaseTimer {
 ///   phase: 阶段名
 /// returns: 写事件失败被吞掉，不影响主流程
 /// ---
-    pub(crate) fn emit(&self, workspace: &Path, kind: &'static str, phase: &'static str) {
+    pub(crate) fn emit(&self, workspace: &Path, kind: &'static str, phase: LifecyclePhase) {
         let event_log = crate::event_log::EventLog::new(workspace);
-        let _ = event_log.write(
-            kind,
-            serde_json::json!({
-                "phase": phase,
-                "elapsed_ms": self.elapsed_ms(),
-            }),
-        );
+        let _ = event_log.write(kind, phase.event_fields(self.elapsed_ms()));
     }
 }
 
@@ -305,7 +364,7 @@ fn restart_with_selected_team_and_transport(
     // resolved a context; downstream phases are emitted with monotonic
     // `elapsed_ms` for at-a-glance latency triage.
     let phase_timer = RestartPhaseTimer::start();
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "resolve_context");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::ResolveContext);
     let lifecycle_lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &selected.run_workspace,
         operation: "restart",
@@ -345,7 +404,7 @@ fn restart_with_selected_team_and_transport(
     // 写 runtime spec。角色缺(TEAM.md/agents 不在)→ 显式拒(列缺哪些),旧 spec 原地保留不删不用。
     let spec =
         rebuild_runtime_spec_from_roles(&selected.run_workspace, &selected.team_key, &state)?;
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "compile_spec");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::CompileSpec);
     // 重建后 spec_workspace 恒为 runtime spec 的父目录(.team/runtime/<team_key>/)。
     let runtime_spec =
         crate::model::paths::runtime_spec_path(&selected.run_workspace, &selected.team_key);
@@ -441,7 +500,7 @@ fn restart_with_selected_team_and_transport(
     phase_timer.emit(
         &selected.run_workspace,
         "restart.phase",
-        "plan_classification",
+        LifecyclePhase::PlanClassification,
     );
     write_restart_resume_decision_events(
         &selected.run_workspace,
@@ -558,8 +617,8 @@ fn restart_with_selected_team_and_transport(
             &topology_authority_agent_ids,
         )?;
     }
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "teardown");
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "spawn_all");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::Teardown);
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::SpawnAll);
     // 0.5.40 Slice 3 (tmux-server-death-locate §7 Slice 3): when the
     // pre-spawn teardown was DEFERRED (live worker session with
     // authoritative running agents), snapshot the pre-spawn agent rows
@@ -582,8 +641,8 @@ fn restart_with_selected_team_and_transport(
     // tmux session is created deterministically; the remaining independent
     // decisions run their `transport.spawn_into` in parallel via a thread
     // scope with concurrency capped at `min(4, workers-1)`. Every spawn
-    // result is collected in-memory; `verify_spawned_agent_live` +
-    // `mark_agent_respawned` are then applied in ORIGINAL PLAN ORDER so
+    // result is collected in-memory; `mark_agent_respawned` is then
+    // applied in ORIGINAL PLAN ORDER so
     // persisted `spawn_epoch` / `spawned_at` / `pane_id` / `window` stay
     // deterministic regardless of thread completion order. Failure
     // aggregation stays equivalent to serial: per-agent errors go into
@@ -837,17 +896,14 @@ fn restart_with_selected_team_and_transport(
             agent.get("dangerously_skip_permissions"),
             Some(serde_json::Value::Bool(true))
         );
-        if let Err(error) = verify_spawned_agent_live(&decision.agent_id, &spawn, transport)
-            .and_then(|_| {
-                mark_agent_respawned(
-                    &mut state,
-                    &decision.agent_id,
-                    decision.restart_mode,
-                    &spawn,
-                    transport,
-                    launched_bypass,
-                )
-            })
+        if let Err(error) = mark_agent_respawned(
+            &mut state,
+            &decision.agent_id,
+            decision.restart_mode,
+            &spawn,
+            transport,
+            launched_bypass,
+        )
         {
             let error = error.to_string();
             mark_agent_restart_failed(&mut state, decision, &error);
@@ -1026,7 +1082,7 @@ fn restart_with_selected_team_and_transport(
         &capture_backfill_skip_agent_ids,
         &topology_authority_agent_ids,
     )?;
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "save_state");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::SaveState);
     if fatal_resume_failure {
         let attach_commands = Vec::new();
         let next_actions = restart_failure_next_actions(&failed_agents);
@@ -1304,10 +1360,10 @@ fn restart_with_selected_team_and_transport(
     phase_timer.emit(
         &selected.run_workspace,
         "restart.phase",
-        "coordinator_start",
+        LifecyclePhase::CoordinatorStart,
     );
     let coordinator_started = coordinator.ok;
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "readiness_wait");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::ReadinessWait);
     wait_restart_readiness_or_timeout(
         &selected.run_workspace,
         &state,
@@ -1331,7 +1387,7 @@ fn restart_with_selected_team_and_transport(
     let mut next_actions = Vec::new();
     if !failed_agents.is_empty() {
         next_actions.extend(restart_failure_next_actions(&failed_agents));
-        phase_timer.emit(&selected.run_workspace, "restart.phase", "completed");
+        phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::Completed);
         write_restart_completed_event(
             &selected.run_workspace,
             &successful_agents,
@@ -1360,7 +1416,7 @@ fn restart_with_selected_team_and_transport(
             leader_bind_reason,
         });
     }
-    phase_timer.emit(&selected.run_workspace, "restart.phase", "completed");
+    phase_timer.emit(&selected.run_workspace, "restart.phase", LifecyclePhase::Completed);
     write_restart_completed_event(
         &selected.run_workspace,
         &successful_agents,
@@ -1852,14 +1908,6 @@ fn yes_no(value: bool) -> &'static str {
     }
 }
 
-fn verify_spawned_agent_live(
-    _agent_id: &AgentId,
-    _spawn: &SpawnedAgentWindow,
-    _transport: &dyn crate::transport::Transport,
-) -> Result<(), LifecycleError> {
-    Ok(())
-}
-
 /// 0.3.30 Bug 1: restart success path auto-attach.
 /// When `TMUX_PANE` is present in the caller's env, treat the restart as if
 /// the user had also run `attach-leader` from that pane. Mirrors quick-start's
@@ -3088,8 +3136,8 @@ fn run_bounded_parallel_worker_spawns(
     outcomes
 }
 
-/// 0.5.38 Step 2: serial post-spawn stage. Runs verify_spawned_agent_live +
-/// mark_agent_respawned in plan order, emits worker.spawn_timing, and
+/// 0.5.38 Step 2: serial post-spawn stage. Runs mark_agent_respawned
+/// in plan order, emits worker.spawn_timing, and
 /// updates the successful/failed agent lists exactly like the pre-0.5.38
 /// serial loop. Keeping this serial guarantees deterministic persisted
 /// state (`spawn_epoch`, `spawned_at`, etc.) regardless of parallel
@@ -3111,17 +3159,14 @@ fn apply_marked_respawn(
     launched_bypass: bool,
 ) {
     let verify_start = std::time::Instant::now();
-    if let Err(error) =
-        verify_spawned_agent_live(&decision.agent_id, spawn, transport).and_then(|_| {
-            mark_agent_respawned(
-                state,
-                &decision.agent_id,
-                decision.restart_mode,
-                spawn,
-                transport,
-                launched_bypass,
-            )
-        })
+    if let Err(error) = mark_agent_respawned(
+        state,
+        &decision.agent_id,
+        decision.restart_mode,
+        spawn,
+        transport,
+        launched_bypass,
+    )
     {
         let error = error.to_string();
         mark_agent_restart_failed(state, decision, &error);