@team-agent/installer 0.4.11 → 0.5.0

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

@@ -503,20 +503,43 @@ fn is_provider_or_mcp_workspace_command(command: &str) -> bool {
 }
 
 fn parse_workspace_arg(command: &str) -> Option<PathBuf> {
-    let mut parts = command.split_whitespace().peekable();
-    while let Some(part) = parts.next() {
-        if let Some(value) = part.strip_prefix("--workspace=") {
-            if !value.is_empty() {
-                return Some(PathBuf::from(value));
-            }
+    for (start, _) in command.match_indices("--workspace") {
+        let boundary_before = start == 0
+            || command
+                .get(..start)
+                .and_then(|prefix| prefix.chars().next_back())
+                .is_some_and(char::is_whitespace);
+        if !boundary_before {
+            continue;
+        }
+        let after = &command[start + "--workspace".len()..];
+        if let Some(value) = after.strip_prefix('=') {
+            return parse_workspace_value(value);
         }
-        if part == "--workspace" {
-            return parts.peek().map(PathBuf::from);
+        if after.chars().next().is_some_and(char::is_whitespace) {
+            return parse_workspace_value(after);
         }
     }
     None
 }
 
+fn parse_workspace_value(value: &str) -> Option<PathBuf> {
+    let value = value.trim_start();
+    if value.is_empty() {
+        return None;
+    }
+    let value = value
+        .split_once(" --")
+        .map(|(workspace, _)| workspace)
+        .unwrap_or(value)
+        .trim_end();
+    if value.is_empty() {
+        None
+    } else {
+        Some(PathBuf::from(value))
+    }
+}
+
 fn classify_workspace_orphan(workspace: &Path, pid: Pid) -> Option<OrphanReason> {
     if !workspace.is_absolute() {
         return None;
@@ -656,3 +679,38 @@ fn reason_key(reason: &OrphanReason) -> &'static str {
         OrphanReason::PidNotRunning => "pid_not_running",
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_workspace_arg_keeps_trailing_path_with_spaces() {
+        let command = "/tmp/team-agent coordinator --workspace /Volumes/projects/My Agent";
+
+        assert_eq!(
+            parse_workspace_arg(command),
+            Some(PathBuf::from("/Volumes/projects/My Agent"))
+        );
+    }
+
+    #[test]
+    fn parse_workspace_arg_stops_at_next_flag() {
+        let command = "/tmp/team-agent coordinator --workspace /tmp/My Agent --once";
+
+        assert_eq!(
+            parse_workspace_arg(command),
+            Some(PathBuf::from("/tmp/My Agent"))
+        );
+    }
+
+    #[test]
+    fn parse_workspace_arg_supports_equals_form_with_spaces() {
+        let command = "/tmp/team-agent coordinator --workspace=/tmp/My Agent --once";
+
+        assert_eq!(
+            parse_workspace_arg(command),
+            Some(PathBuf::from("/tmp/My Agent"))
+        );
+    }
+}

package/crates/team-agent/src/layout/worker_window_helpers.rs

@@ -1,14 +1,12 @@
-//! 0.3.28 layout step 2 — small provider-wire helper for layout-layer window naming.
+//! 0.3.28 layout step 2 — small window grammar helper for layout-layer naming.
 //!
-//! Mirrors `leader::helpers::provider_wire` so the layout module does not
-//! depend on the leader module's private helpers. Single source of truth
-//! is `provider_command_name` from `crate::provider::adapter` (the
-//! authoritative provider→string mapping).
+//! Command/UI grammar, not provider identity parsing: leader window names
+//! intentionally collapse `claude_code` to `claude` and use executable-style
+//! labels such as `gemini`.
 
 use crate::model::enums::Provider;
 
-/// Window name used inside the leader session, derived from the provider's
-/// wire identifier (e.g. `claude`, `codex`, `copilot`, `fake`). Mirrors
+/// Window name used inside the leader session. Mirrors
 /// Python's `leader_window_name = provider` (see
 /// `runtime/0.2.11/src/team_agent/leader/__init__.py:114-131`).
 pub fn provider_window_name(provider: Provider) -> &'static str {

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

@@ -8,7 +8,9 @@ use crate::transport::PaneInfo;
 
 use super::helpers::{parse_provider, provider_wire};
 
-const PROVIDER_COMMANDS: &[(&str, Provider)] = &[
+// Command grammar, not provider identity parsing: these are process argv/current-command
+// needles observed in tmux panes.
+const COMMAND_GRAMMAR_PROVIDER_COMMANDS: &[(&str, Provider)] = &[
     ("claude", Provider::ClaudeCode),
     ("claude.exe", Provider::ClaudeCode),
     ("codex", Provider::Codex),
@@ -37,7 +39,7 @@ fn attribute_pane_provider_with_process(
 }
 
 pub(crate) fn attribute_command_provider(command: &str) -> Option<Provider> {
-    provider_from_text(command)
+    provider_from_command_text(command)
 }
 
 pub(crate) fn command_matches_provider(provider: Provider, command: &str) -> bool {
@@ -58,7 +60,7 @@ fn provider_from_env(env: &BTreeMap<String, String>) -> Option<Provider> {
 fn provider_from_pid_argv(pid: u32) -> Option<Provider> {
     process_command_line(pid)
         .as_deref()
-        .and_then(provider_from_text)
+        .and_then(provider_from_command_text)
 }
 
 fn provider_from_pid_env(pid: u32) -> Option<Provider> {
@@ -67,9 +69,9 @@ fn provider_from_pid_env(pid: u32) -> Option<Provider> {
         .and_then(provider_from_env_text)
 }
 
-fn provider_from_text(text: &str) -> Option<Provider> {
+fn provider_from_command_text(text: &str) -> Option<Provider> {
     let lower = text.to_ascii_lowercase();
-    PROVIDER_COMMANDS
+    COMMAND_GRAMMAR_PROVIDER_COMMANDS
         .iter()
         .find_map(|(needle, provider)| lower.contains(needle).then_some(*provider))
 }

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

@@ -7,6 +7,7 @@ use serde_json::{json, Value};
 
 use crate::model::ids::{LeaderSessionUuid, OwnerEpoch};
 use crate::provider::Provider;
+use crate::provider::wire::provider_wire;
 use crate::transport::{PaneId, PaneInfo, SessionName, Transport, WindowName};
 
 use super::helpers::{get_path_str, now_ts, parse_provider, prefix, resolve_workspace_for_hash, sha1_hex_prefix};
@@ -902,17 +903,6 @@ fn uuid_prefix(uuid: Option<&LeaderSessionUuid>) -> String {
     uuid.map_or_else(String::new, |value| prefix(value.as_str(), 8).to_string())
 }
 
-fn provider_wire(provider: Provider) -> &'static str {
-    match provider {
-        Provider::Claude => "claude",
-        Provider::ClaudeCode => "claude_code",
-        Provider::Codex => "codex",
-        Provider::Copilot => "copilot",
-        Provider::GeminiCli => "gemini_cli",
-        Provider::Fake => "fake",
-    }
-}
-
 fn event_provider(identity: &OwnerIdentity) -> &'static str {
     provider_wire(identity.provider.unwrap_or(Provider::Codex))
 }

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

@@ -15,9 +15,8 @@ pub fn start_plan(
             plan_path.display()
         )));
     }
-    let text = std::fs::read_to_string(plan_path).map_err(|e| {
-        LifecycleError::InvalidPlan(format!("{}: {e}", plan_path.display()))
-    })?;
+    let text = std::fs::read_to_string(plan_path)
+        .map_err(|e| LifecycleError::InvalidPlan(format!("{}: {e}", plan_path.display())))?;
     let plan = yaml::loads(&text).map_err(|e| LifecycleError::InvalidPlan(e.to_string()))?;
     let plan_id = plan_id_from_plan(plan_path, &plan)?;
     let state_path = plan_state_path(workspace, &plan_id);
@@ -66,7 +65,8 @@ pub fn handle_report_result(
         return Ok(PlanProgress::NoMatch);
     };
     for entry in entries {
-        let entry = entry.map_err(|e| LifecycleError::InvalidPlan(format!("read plan dir: {e}")))?;
+        let entry =
+            entry.map_err(|e| LifecycleError::InvalidPlan(format!("read plan dir: {e}")))?;
         let path = entry.path();
         if path.extension().and_then(|s| s.to_str()) != Some("json") {
             continue;
@@ -112,10 +112,19 @@ fn plan_stages(plan: &Value) -> Result<Vec<PlanStage>, LifecycleError> {
             .transpose()?;
         stages.push(PlanStage {
             id,
-            assignee: raw.get("assignee").and_then(Value::as_str).map(AgentId::new),
-            prompt: raw.get("prompt").and_then(Value::as_str).map(str::to_string),
+            assignee: raw
+                .get("assignee")
+                .and_then(Value::as_str)
+                .map(AgentId::new),
+            prompt: raw
+                .get("prompt")
+                .and_then(Value::as_str)
+                .map(str::to_string),
             on_result: condition,
-            status: raw.get("status").and_then(Value::as_str).map(str::to_string),
+            status: raw
+                .get("status")
+                .and_then(Value::as_str)
+                .map(str::to_string),
         });
     }
     Ok(stages)
@@ -222,6 +231,8 @@ fn json_scalar_to_string(value: &serde_json::Value) -> Option<String> {
         serde_json::Value::String(s) => Some(s.clone()),
         serde_json::Value::Bool(b) => Some(b.to_string()),
         serde_json::Value::Number(n) => Some(n.to_string()),
-        serde_json::Value::Null | serde_json::Value::Array(_) | serde_json::Value::Object(_) => None,
+        serde_json::Value::Null | serde_json::Value::Array(_) | serde_json::Value::Object(_) => {
+            None
+        }
     }
 }

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

@@ -11,6 +11,8 @@ use crate::model::yaml::{self, Value};
 use crate::state::persist::{load_runtime_state, save_runtime_state};
 use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
 
+use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
+
 use super::*;
 
 // ── lifecycle::launch —— 冷启 / quick-start / 危险审批探测 ──────────────────
@@ -124,7 +126,8 @@ pub fn launch_with_transport_in_workspace(
     // Step 10 once Steps 2–9 have eliminated structural co-location.
     if !dry_run {
         if let Ok(state_for_check) = crate::state::persist::load_runtime_state(workspace) {
-            let violations = crate::layout::sessions::assert_topology_invariants(&state_for_check, &spec);
+            let violations =
+                crate::layout::sessions::assert_topology_invariants(&state_for_check, &spec);
             crate::layout::sessions::log_topology_violations(&violations);
         }
     }
@@ -247,9 +250,7 @@ fn spawn_agents(
         // unsupported warning event when the spec asked for an effort the
         // provider can't satisfy.
         let agent_effort = provider_effort_for_spawn(agent, provider);
-        if let Some(event_value) =
-            provider_effort_event_if_dropped(agent, provider, agent_id_raw)
-        {
+        if let Some(event_value) = provider_effort_event_if_dropped(agent, provider, agent_id_raw) {
             let _ = crate::event_log::EventLog::new(workspace)
                 .write("provider.effort_unsupported", event_value);
         }
@@ -279,7 +280,11 @@ fn spawn_agents(
         // 含 "model" 字面,失败信息透传给 leader。
         if matches!(provider, Provider::Copilot) && auth_mode == AuthMode::CompatibleApi {
             let has_model = model.is_some_and(|s| !s.is_empty())
-                || profile_launch.command_overrides.model.as_deref().is_some_and(|s| !s.is_empty())
+                || profile_launch
+                    .command_overrides
+                    .model
+                    .as_deref()
+                    .is_some_and(|s| !s.is_empty())
                 || profile_launch
                     .env_overlay
                     .get("COPILOT_MODEL")
@@ -307,9 +312,8 @@ fn spawn_agents(
                 .join("logs")
                 .join("copilot")
                 .join(agent_id_raw);
-            std::fs::create_dir_all(&log_dir).map_err(|e| {
-                LifecycleError::StatePersist(format!("{}: {e}", log_dir.display()))
-            })?;
+            std::fs::create_dir_all(&log_dir)
+                .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", log_dir.display())))?;
             plan.argv.push("--log-dir".to_string());
             plan.argv.push(log_dir.to_string_lossy().to_string());
             plan.argv.push("--log-level".to_string());
@@ -606,9 +610,7 @@ pub(crate) fn adaptive_placement_for_agent(
             if !is_adaptive_layout_window(window) {
                 continue;
             }
-            let pane_id = agent
-                .get("pane_id")
-                .and_then(serde_json::Value::as_str);
+            let pane_id = agent.get("pane_id").and_then(serde_json::Value::as_str);
             let pane_live = pane_id.is_some_and(|pane| live_panes.contains(pane));
             // E43 Fix A: window_name match — when the agent's pane is live,
             // its live window_name MUST equal the claimed `window`; otherwise
@@ -728,7 +730,9 @@ pub(crate) fn adaptive_existing_placement_for_agent(
         .unwrap_or_default()
         .into_iter()
         .filter(|pane| {
-            pane.window_name.as_ref().is_some_and(|name| name.as_str() == window)
+            pane.window_name
+                .as_ref()
+                .is_some_and(|name| name.as_str() == window)
                 && agent
                     .get("pane_id")
                     .and_then(serde_json::Value::as_str)
@@ -1328,7 +1332,10 @@ fn warn_ignored_owner_team_id(workspace: &Path, team_dir: &Path, runtime_team_ke
     let Ok(Some(ignored)) = crate::compiler::ignored_owner_team_id_from_team_md(team_dir) else {
         return;
     };
-    eprintln!("Warning: ignored TEAM.md {}={}", ignored.field, ignored.value);
+    eprintln!(
+        "Warning: ignored TEAM.md {}={}",
+        ignored.field, ignored.value
+    );
     eprintln!("Reason: owner identity is the canonical runtime team key ({runtime_team_key}), not TEAM.md front matter");
     eprintln!("Action: remove {} from TEAM.md", ignored.field);
     if let Err(err) = crate::event_log::EventLog::new(workspace).write(
@@ -1382,7 +1389,9 @@ fn active_leader_pane_state_across_tmux_sockets(
         .map(|endpoint| crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint))
         .collect::<Vec<_>>();
     active_leader_pane_state_across_transports(
-        transports.iter().map(|transport| transport as &dyn Transport),
+        transports
+            .iter()
+            .map(|transport| transport as &dyn Transport),
         pane,
     )
 }
@@ -2085,12 +2094,7 @@ pub(crate) fn inherited_env_with_team_overrides(
     //   * Strips `COPILOT_DISABLE_TERMINAL_TITLE` (re-injected per-agent by
     //     `apply_copilot_instructions_overlay` based on the WORKER's provider).
     //   * Strips `TMUX` / `TMUX_PANE` (would attach worker to leader's pane).
-    crate::layout::worker_env::worker_spawn_env(
-        std::env::vars(),
-        workspace,
-        agent_id,
-        team_id,
-    )
+    crate::layout::worker_env::worker_spawn_env(std::env::vars(), workspace, agent_id, team_id)
 }
 
 pub(crate) fn apply_mcp_auto_approval_env(
@@ -2112,15 +2116,30 @@ pub(crate) fn apply_mcp_auto_approval_env(
         && safety.inherited
     {
         env.insert("TEAM_AGENT_LEADER_BYPASS".to_string(), "1".to_string());
-        env.insert("TEAM_AGENT_LEADER_BYPASS_SOURCE".to_string(), "leader_process".to_string());
+        env.insert(
+            "TEAM_AGENT_LEADER_BYPASS_SOURCE".to_string(),
+            "leader_process".to_string(),
+        );
         if let Some(provider) = safety.provider.as_deref() {
-            env.insert("TEAM_AGENT_LEADER_BYPASS_PROVIDER".to_string(), provider.to_string());
+            env.insert(
+                "TEAM_AGENT_LEADER_BYPASS_PROVIDER".to_string(),
+                provider.to_string(),
+            );
         }
         if let Some(flag) = safety.flag.as_deref() {
-            env.insert("TEAM_AGENT_LEADER_BYPASS_FLAG".to_string(), flag.to_string());
+            env.insert(
+                "TEAM_AGENT_LEADER_BYPASS_FLAG".to_string(),
+                flag.to_string(),
+            );
         }
-        env.insert("TEAM_AGENT_MCP_AUTO_APPROVE".to_string(), "team_orchestrator".to_string());
-        env.insert("TEAM_AGENT_MCP_AUTO_APPROVE_SOURCE".to_string(), "leader_bypass".to_string());
+        env.insert(
+            "TEAM_AGENT_MCP_AUTO_APPROVE".to_string(),
+            "team_orchestrator".to_string(),
+        );
+        env.insert(
+            "TEAM_AGENT_MCP_AUTO_APPROVE_SOURCE".to_string(),
+            "leader_bypass".to_string(),
+        );
     } else {
         env.insert("TEAM_AGENT_LEADER_BYPASS".to_string(), "0".to_string());
     }
@@ -2163,7 +2182,10 @@ pub(crate) fn apply_copilot_instructions_overlay(
     // 漏关后果定级为【B5 leader 误杀同级 incident】,绝不允许 silent 跳过。
     // 主案:env `COPILOT_DISABLE_TERMINAL_TITLE=1`(help-config 原文 "Can also be
     // disabled via the COPILOT_DISABLE_TERMINAL_TITLE environment variable")。
-    env.insert("COPILOT_DISABLE_TERMINAL_TITLE".to_string(), "1".to_string());
+    env.insert(
+        "COPILOT_DISABLE_TERMINAL_TITLE".to_string(),
+        "1".to_string(),
+    );
     Ok(())
 }
 
@@ -2219,7 +2241,10 @@ fn apply_copilot_mcp_residual_disables(
             let stderr = String::from_utf8_lossy(&out.stderr).to_string();
             std::fs::write(
                 &residual_path,
-                format!("copilot mcp list exit={:?} stderr={stderr}\n", out.status.code()),
+                format!(
+                    "copilot mcp list exit={:?} stderr={stderr}\n",
+                    out.status.code()
+                ),
             )
             .map_err(|e| {
                 LifecycleError::StatePersist(format!("{}: {e}", residual_path.display()))
@@ -2578,7 +2603,10 @@ pub(crate) fn provider_effort_for_spawn_json(
     agent: &serde_json::Value,
     provider: Provider,
 ) -> Option<ProviderEffort> {
-    provider_effort_from_raw(agent.get("effort").and_then(serde_json::Value::as_str), provider)
+    provider_effort_from_raw(
+        agent.get("effort").and_then(serde_json::Value::as_str),
+        provider,
+    )
 }
 
 pub(crate) fn provider_effort_event_if_dropped_json(
@@ -2797,14 +2825,7 @@ pub fn quick_start_in_workspace(
 ) -> Result<QuickStartReport, LifecycleError> {
     let workspace = explicit_quick_start_workspace(workspace);
     let transport = quick_start_tmux_backend(&workspace);
-    quick_start_with_transport_in_workspace(
-        &workspace,
-        agents_dir,
-        name,
-        yes,
-        team_id,
-        &transport,
-    )
+    quick_start_with_transport_in_workspace(&workspace, agents_dir, name, yes, team_id, &transport)
 }
 
 pub fn quick_start_in_workspace_with_display(
@@ -2873,7 +2894,9 @@ pub(crate) fn configure_adaptive_pane_title(
                 "warning": message,
             }),
         ) {
-            eprintln!("Warning: adaptive_layout.pane_title_failed event write failed: {event_error}");
+            eprintln!(
+                "Warning: adaptive_layout.pane_title_failed event write failed: {event_error}"
+            );
         }
     }
 }
@@ -2900,9 +2923,7 @@ pub fn quick_start_with_transport(
     transport: &dyn Transport,
 ) -> Result<QuickStartReport, LifecycleError> {
     let workspace = team_workspace(agents_dir);
-    quick_start_with_transport_in_workspace(
-        &workspace, agents_dir, name, yes, team_id, transport,
-    )
+    quick_start_with_transport_in_workspace(&workspace, agents_dir, name, yes, team_id, transport)
 }
 
 pub fn quick_start_with_transport_in_workspace(
@@ -3090,7 +3111,10 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     let attach_windows = load_runtime_state(&workspace)
         .ok()
         .map(|state| {
-            attach_window_names_with_managed_leader(&state, started_attach_window_names(&launch.started))
+            attach_window_names_with_managed_leader(
+                &state,
+                started_attach_window_names(&launch.started),
+            )
         })
         .unwrap_or_else(|| started_attach_window_names(&launch.started));
     let attach_commands = attach_commands_for_runtime_windows(
@@ -3110,10 +3134,13 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     next_actions.push(
         "quick-start initialized this team; for all subsequent starts use \
          `team-agent restart` to resume context (quick-start refuses on \
-         already-initialised teams)".to_string(),
+         already-initialised teams)"
+            .to_string(),
     );
     if crate::tmux_backend::socket_probe_missing_for_workspace(&workspace) {
-        next_actions.push(crate::tmux_backend::socket_missing_hint_for_workspace(&workspace));
+        next_actions.push(crate::tmux_backend::socket_missing_hint_for_workspace(
+            &workspace,
+        ));
     }
     next_actions.extend(attach_commands.iter().cloned());
     let display_backend = state
@@ -3137,7 +3164,11 @@ pub fn quick_start_with_transport_in_workspace_with_display(
 /// the persisted endpoint synchronized with the transport they actually used,
 /// closing the silent socket-drift gap** (single state-save path; no parallel
 /// "annotate after spawn" race with coordinator).
-pub(crate) fn annotate_runtime_tmux_endpoint(state: &mut serde_json::Value, transport: &dyn Transport, workspace: &Path) {
+pub(crate) fn annotate_runtime_tmux_endpoint(
+    state: &mut serde_json::Value,
+    transport: &dyn Transport,
+    workspace: &Path,
+) {
     let Some(endpoint) = transport.tmux_endpoint() else {
         return;
     };
@@ -3153,7 +3184,10 @@ pub(crate) fn annotate_runtime_tmux_endpoint(state: &mut serde_json::Value, tran
             .unwrap_or_else(|| endpoint.clone())
     };
     if let Some(obj) = state.as_object_mut() {
-        obj.insert("tmux_endpoint".to_string(), serde_json::json!(endpoint_for_state));
+        obj.insert(
+            "tmux_endpoint".to_string(),
+            serde_json::json!(endpoint_for_state),
+        );
         obj.insert(
             "tmux_socket".to_string(),
             obj.get("tmux_endpoint")
@@ -3430,6 +3464,7 @@ fn detect_dangerous_approval_in_argv(argv_tokens: &[String]) -> Option<Dangerous
 }
 
 fn dangerous_leader_flags() -> &'static [(&'static str, &'static str)] {
+    // Process argv command grammar, not persisted provider identity parsing.
     &[
         ("claude", "--dangerously-skip-permissions"),
         ("claude", "--dangerously-skip-permission"),
@@ -3445,6 +3480,7 @@ fn dangerous_leader_flags() -> &'static [(&'static str, &'static str)] {
 }
 
 fn binary_matches_provider(provider: &str, binary: Option<&str>) -> bool {
+    // Binary-name command grammar, not provider identity parsing.
     match (provider, binary) {
         ("codex", Some("codex")) => true,
         ("claude", Some("claude" | "claude-code" | "claude_code")) => true,
@@ -3607,10 +3643,11 @@ pub fn add_agent(
             // team uses. Cold workspaces / first-agent paths safely fall back to
             // `TmuxBackend::for_workspace(team_workspace)` inside the resolver.
             let team_ws = team_workspace(workspace);
-            let transport = crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
-                &team_ws, team,
-            )
-            .unwrap_or_else(|_| crate::tmux_backend::TmuxBackend::for_workspace(&team_ws));
+            let transport =
+                crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
+                    &team_ws, team,
+                )
+                .unwrap_or_else(|_| crate::tmux_backend::TmuxBackend::for_workspace(&team_ws));
             return add_agent_with_transport(
                 workspace,
                 agent_id,
@@ -3622,6 +3659,12 @@ pub fn add_agent(
         }
         Err(error) => return Err(LifecycleError::TeamSelect(error.to_string())),
     };
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &selected.run_workspace,
+        operation: "add-agent",
+        team: Some(selected.team_key.as_str()),
+        agent_id: Some(agent_id),
+    })?;
     // E5 §3:compile_team 要角色定义目录(team_dir),不是 spec 落点(spec_workspace=runtime)。
     let team_dir = selected.team_dir;
     // **0.3.24 add-agent socket drift fix**: route to the live team's persisted
@@ -3658,6 +3701,12 @@ pub fn add_agent_with_transport(
 ) -> Result<AddAgentReport, LifecycleError> {
     let run_workspace = crate::model::paths::canonical_run_workspace(workspace)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &run_workspace,
+        operation: "add-agent",
+        team,
+        agent_id: Some(agent_id),
+    })?;
     add_agent_with_transport_at_paths(
         &run_workspace,
         workspace,
@@ -3950,7 +3999,11 @@ fn inject_agent_into_spec(
                 agents.push(agent);
             }
         }
-        _ => return Err(LifecycleError::Compile("spec.agents missing or not a list".to_string())),
+        _ => {
+            return Err(LifecycleError::Compile(
+                "spec.agents missing or not a list".to_string(),
+            ))
+        }
     }
     // routing.rules 追加 route-<id>(与 compile_team 同形)。
     if let Some((_, Value::Map(routing))) = pairs.iter_mut().find(|(k, _)| k == "routing") {
@@ -4062,12 +4115,27 @@ pub fn fork_agent_with_transport(
         crate::state::selector::SelectorMode::RequireSpec,
     )
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    let lock_workspace = selected.run_workspace.clone();
+    let lock_team_key = selected.team_key.clone();
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &lock_workspace,
+        operation: "fork-agent",
+        team: Some(lock_team_key.as_str()),
+        agent_id: Some(as_agent_id),
+    })?;
+    let selected = crate::state::selector::resolve_active_team(
+        &lock_workspace,
+        Some(lock_team_key.as_str()),
+        crate::state::selector::SelectorMode::RequireSpec,
+    )
+    .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
     // E5 §3:team_dir(角色定义+profiles)恒用户目录。spec 读用 selector 解析的 spec_path
     // (读序 B:runtime 优先、legacy 回落),写恒走 runtime_spec_path(canonical 落点)。
     let fork_team_dir = selected.team_dir.clone();
-    let read_spec_path = selected.spec_path.clone().ok_or_else(|| {
-        LifecycleError::TeamSelect("active team spec not found".to_string())
-    })?;
+    let read_spec_path = selected
+        .spec_path
+        .clone()
+        .ok_or_else(|| LifecycleError::TeamSelect("active team spec not found".to_string()))?;
     let workspace = selected.run_workspace;
     let state = selected.state;
     ensure_owner_allowed_for_state(&state, Some(source_agent_id))?;
@@ -4141,8 +4209,8 @@ pub fn fork_agent_with_transport(
     }
     let new_spec = append_forked_agent(&spec, source_agent, source_agent_id, as_agent_id, label)?;
     // validate 用角色定义目录的 team_workspace(校验 working_directory),非 spec 落点。
-    let validate_ws = crate::model::paths::team_workspace(&fork_team_dir)
-        .unwrap_or_else(|_| workspace.clone());
+    let validate_ws =
+        crate::model::paths::team_workspace(&fork_team_dir).unwrap_or_else(|_| workspace.clone());
     crate::model::spec::validate_spec(&new_spec, &validate_ws)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
     write_spec_atomic(&spec_path, &new_spec)?;
@@ -4322,7 +4390,11 @@ pub fn fork_agent_with_transport(
         );
         return Err(e);
     }
-    if let Err(e) = save_runtime_state(&workspace, &next_state) {
+    if let Err(e) = crate::state::persist::save_runtime_state_with_lifecycle_topology_authority(
+        &workspace,
+        &next_state,
+        &[as_agent_id.as_str()],
+    ) {
         rollback_fork_after_spawn(
             &workspace,
             &spec_path,
@@ -4400,7 +4472,11 @@ fn rollback_fork_after_spawn(
         window: window.clone(),
     });
     let _ = std::fs::write(spec_path, spec_text.as_bytes());
-    let _ = save_runtime_state(workspace, old_state);
+    let _ = crate::state::persist::save_runtime_state_with_deleted_agents(
+        workspace,
+        old_state,
+        &[agent_id.as_str()],
+    );
     cleanup_fork_mcp_artifacts(workspace, agent_id, mcp_config_path, profile_launch);
 }
 
@@ -4948,7 +5024,8 @@ pub(crate) fn override_spec_workspace(spec: &mut Value, workspace: &Path) {
     if let Some((_, Value::List(agents))) = root.iter_mut().find(|(k, _)| k == "agents") {
         for agent in agents {
             if let Value::Map(fields) = agent {
-                if let Some((_, value)) = fields.iter_mut().find(|(k, _)| k == "working_directory") {
+                if let Some((_, value)) = fields.iter_mut().find(|(k, _)| k == "working_directory")
+                {
                     *value = Value::Str(workspace_s.clone());
                 }
             }