@team-agent/installer 0.3.3 → 0.3.5

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

@@ -72,9 +72,8 @@ pub fn launch_with_transport_in_workspace(
             spec_path.display()
         )));
     }
-    let text = std::fs::read_to_string(spec_path).map_err(|e| {
-        LifecycleError::Compile(format!("{}: {e}", spec_path.display()))
-    })?;
+    let text = std::fs::read_to_string(spec_path)
+        .map_err(|e| LifecycleError::Compile(format!("{}: {e}", spec_path.display())))?;
     let spec = yaml::loads(&text).map_err(|e| LifecycleError::Compile(e.to_string()))?;
     let session_name = spec_session_name(&spec);
     let safety = effective_runtime_config(&spec)?;
@@ -101,8 +100,23 @@ pub fn launch_with_transport_in_workspace(
     let started = if dry_run {
         Vec::new()
     } else {
-        let started = spawn_agents(workspace, spec_path, &spec, &session_name, &safety, transport)?;
-        persist_spawn_agent_state(workspace, spec_path, &spec, &session_name, transport, &started, &safety)?;
+        let started = spawn_agents(
+            workspace,
+            spec_path,
+            &spec,
+            &session_name,
+            &safety,
+            transport,
+        )?;
+        persist_spawn_agent_state(
+            workspace,
+            spec_path,
+            &spec,
+            &session_name,
+            transport,
+            &started,
+            &safety,
+        )?;
         started
     };
     Ok(LaunchReport {
@@ -126,6 +140,10 @@ fn spawn_agents(
     transport: &dyn Transport,
 ) -> Result<Vec<StartedAgent>, LifecycleError> {
     let team_dir = spec_path.parent().unwrap_or_else(|| Path::new("."));
+    let runtime_fast = matches!(
+        spec.get("runtime").and_then(|v| v.get("fast")),
+        Some(Value::Bool(true))
+    );
     let mut started = Vec::new();
     for agent in spec_agent_values(spec) {
         let Some(agent_id_raw) = agent.get("id").and_then(Value::as_str) else {
@@ -152,59 +170,167 @@ 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 role = agent.get("role").and_then(Value::as_str);
-        let tools = worker_tool_refs(agent_tool_strings(agent), safety);
-        let tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
+        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)?;
+        let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(
+            &command_agent,
+            provider,
+            safety,
+        )?;
+        let resolved_tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
         let mcp_team_id =
             runtime_active_team_key_for_spawn(workspace, spec_path, spec, session_name);
         let mcp_config = adapter
             .mcp_config(auth_mode)
             .map_err(|e| LifecycleError::Provider(e.to_string()))?;
         let mcp_config = resolve_mcp_config(mcp_config, workspace, agent_id_raw, &mcp_team_id);
-        let mcp_config_path = write_worker_mcp_config(workspace, agent_id_raw, &mcp_config)?;
-        let profile_dir = team_dir.join("profiles");
-        let profile_launch = crate::lifecycle::profile_launch::prepare_provider_profile_launch_with_profile_dir(
+        let mcp_config_path = write_worker_mcp_config_for_provider(
             workspace,
             agent_id_raw,
-            agent,
-            Some(&profile_dir),
-            Some(&mcp_config),
+            &mcp_config,
+            Some(provider),
         )?;
-        let command_model = profile_launch
-            .command_overrides
-            .model
-            .as_deref()
-            .or(model);
+        let profile_dir = team_dir.join("profiles");
+        let profile_launch =
+            crate::lifecycle::profile_launch::prepare_provider_profile_launch_with_profile_dir(
+                workspace,
+                agent_id_raw,
+                agent,
+                Some(&profile_dir),
+                Some(&mcp_config),
+            )?;
+        let command_model = profile_launch.command_overrides.model.as_deref().or(model);
         let mut plan = adapter
             .build_command_plan(crate::provider::ProviderCommandContext {
                 auth_mode,
                 mcp_config: Some(&mcp_config),
-                system_prompt: role,
+                system_prompt: Some(system_prompt.as_str()),
                 model: command_model,
-                tools: &tool_refs,
+                tools: &resolved_tool_refs,
                 profile_launch: Some(&profile_launch),
             })
             .map_err(|e| LifecycleError::Provider(e.to_string()))?;
         if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
             point_native_mcp_config_at_file(&mut plan.argv, provider, &mcp_config_path);
         }
-        fill_spawn_placeholders_full(
-            &mut plan.argv,
-            workspace,
-            agent_id_raw,
-            Some(&mcp_team_id),
-        );
+        // C-A-4 cr verdict v2 — Copilot BYOK(compatible_api)硬性校验:
+        // "A model is required for BYOK"(help-providers 原文)。检查 agent
+        // 的 model 来源:角色 spec.model > profile COPILOT_MODEL(经 env_overlay)
+        // > --model 旗(本 worker 路径不在 argv 后追加用户 --model)。三者全空 → 报错
+        // 含 "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
+                    .env_overlay
+                    .get("COPILOT_MODEL")
+                    .is_some_and(|v| !v.is_empty());
+            if !has_model {
+                return Err(LifecycleError::RequirementUnmet(
+                    "copilot BYOK profile requires a model (set COPILOT_MODEL, agent.model, or --model)"
+                        .to_string(),
+                ));
+            }
+        }
+        // §B1 + C-7-1 + C-6-2 + C-3-2 cr verdict v2 — Copilot launch-time argv 注入:
+        //   -n <agent_id>      会话命名(main-help:104)→ resume-by-name + 人查 双键
+        //   -C <workspace>     双保险 cwd(main-help:55-56),防 shell 包装意外
+        //   --log-dir <path>   per-worker 定向日志(help-logging)→ 故障期可读 + N18 隔离
+        //   --log-level info   配套日志级别
+        //   --disable-mcp-server <n>...  C-3-2 残留 MCP server 按名禁(扫 mcp list)
+        if matches!(provider, Provider::Copilot) {
+            plan.argv.push("-n".to_string());
+            plan.argv.push(agent_id_raw.to_string());
+            plan.argv.push("-C".to_string());
+            plan.argv.push(workspace.to_string_lossy().to_string());
+            let log_dir = workspace
+                .join(".team")
+                .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()))
+            })?;
+            plan.argv.push("--log-dir".to_string());
+            plan.argv.push(log_dir.to_string_lossy().to_string());
+            plan.argv.push("--log-level".to_string());
+            plan.argv.push("info".to_string());
+            // C-3-2/C-3-3 cr verdict v2 — spawn 前扫 `copilot mcp list` 找用户全局/
+            // workspace 的 MCP 残留,对每个非 team_orchestrator server 追加
+            // --disable-mcp-server <name>,并落 mcp-residual.txt + event。
+            apply_copilot_mcp_residual_disables(
+                &workspace,
+                agent_id_raw,
+                &mut plan.argv,
+                &log_dir,
+            )?;
+        }
+        fill_spawn_placeholders_full(&mut plan.argv, workspace, agent_id_raw, Some(&mcp_team_id));
         let window = WindowName::new(agent_id_raw);
-        let mut env = inherited_env_with_team_overrides(
-            workspace,
-            agent_id_raw,
-            Some(&mcp_team_id),
-        );
+        let mut env =
+            inherited_env_with_team_overrides(workspace, agent_id_raw, Some(&mcp_team_id));
         apply_profile_launch_env(&mut env, &profile_launch);
+        // Python providers.py:145 + launch/core.py:253 — fresh launch runs the worker
+        // with cwd=workspace, same as the RS fork/add and restart paths.
+        let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
+        // BUG / C-1-2 / C-6-1 cr verdict — Copilot system_prompt 走 spawn env overlay +
+        // per-worker AGENTS.md(B2 灵魂件降级):写
+        //   <workspace>/.team/runtime/copilot-instructions/<agent_id>/AGENTS.md
+        // 全文 == compile_worker_system_prompt 输出,并通过 spawn env
+        // `COPILOT_CUSTOM_INSTRUCTIONS_DIRS=<该目录>` 让 copilot CLI 加载。
+        // **禁** silent 写 ~/.copilot/AGENTS.md(C-1-2)+ **禁** -i 作首条消息(C-1-5)。
+        if matches!(provider, Provider::Copilot) {
+            apply_copilot_instructions_overlay(
+                workspace,
+                agent_id_raw,
+                system_prompt.as_str(),
+                &mut env,
+            )?;
+            // C-A-6 cr verdict v2 — Copilot worker env 全量继承下,用户 shell 的
+            // COPILOT_GITHUB_TOKEN / GH_TOKEN / GITHUB_TOKEN 会穿透 + 按 cmd-login 实证
+            // **优先于凭据库**(可能静默改变 auth 通道)。一期只观测不剥除(剥除是
+            // 行为变更,cr 裁);命中任一就发 warn event 让 user 可见。
+            let mut passthrough: Vec<String> = Vec::new();
+            for key in ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"] {
+                if env.get(key).is_some_and(|v| !v.is_empty()) {
+                    passthrough.push(key.to_string());
+                }
+            }
+            if !passthrough.is_empty() {
+                let event_log = crate::event_log::EventLog::new(workspace);
+                let _ = event_log.write(
+                    "provider.copilot.token_passthrough_warning",
+                    serde_json::json!({
+                        "agent_id": agent_id_raw,
+                        "tokens": passthrough,
+                        "reason": "user shell GITHUB_TOKEN family takes precedence over copilot credential store (cmd-login)",
+                    }),
+                );
+            }
+        }
         let spawn = if started.is_empty() {
-            transport.spawn_first(session_name, &window, &plan.argv, team_dir, &env)
+            transport.spawn_first_with_env_unset(
+                session_name,
+                &window,
+                &plan.argv,
+                workspace,
+                &env,
+                &env_unset,
+            )
         } else {
-            transport.spawn_into(session_name, &window, &plan.argv, team_dir, &env)
+            transport.spawn_into_with_env_unset(
+                session_name,
+                &window,
+                &plan.argv,
+                workspace,
+                &env,
+                &env_unset,
+            )
         }
         .map_err(|e| LifecycleError::Transport(e.to_string()))?;
         let _ = adapter.handle_startup_prompts(
@@ -213,6 +339,11 @@ fn spawn_agents(
             30,
             0.5,
         );
+        // Python launch/core.py:235-237 — runtime.fast toggles the provider's fast mode
+        // after spawn; provider specifics live behind the adapter (F032).
+        if runtime_fast {
+            let _ = adapter.enable_fast_mode(transport, &Target::Pane(spawn.pane_id.clone()));
+        }
         if matches!(transport.liveness(&spawn.pane_id), Ok(PaneLiveness::Dead)) {
             continue;
         }
@@ -258,12 +389,7 @@ fn persist_spawn_agent_state(
     let team_id = explicit_active_team_key(&state)
         .unwrap_or_else(|| runtime_team_key_for_spec(spec_path, spec, session_name));
     let worker_tmux_socket = launched_worker_tmux_socket(transport, workspace);
-    drop_worker_pane_seeded_owner(
-        &mut state,
-        &team_id,
-        started,
-        worker_tmux_socket.as_deref(),
-    );
+    drop_worker_pane_seeded_owner(&mut state, &team_id, started, worker_tmux_socket.as_deref());
     // Only persist running state for agents whose spawn still has a live target.
     let live_windows: BTreeSet<String> = transport
         .list_windows(session_name)
@@ -276,10 +402,7 @@ fn persist_spawn_agent_state(
         .map(|agent| agent.agent_id.as_str().to_string())
         .collect();
     let pane_pids_by_agent = pane_pids_by_started_agent(transport, started);
-    let profile_dir = spec_path
-        .parent()
-        .unwrap_or(workspace)
-        .join("profiles");
+    let profile_dir = spec_path.parent().unwrap_or(workspace).join("profiles");
     let mut agents = serde_json::Map::new();
     let mut spawn_index = 0_u32;
     for agent in spec_agent_values(spec) {
@@ -317,9 +440,7 @@ fn persist_spawn_agent_state(
         let pane_pid = pane_pids_by_agent.get(id).copied();
         let spawned_at = spawn_timestamp_for_agent(spawn_index);
         spawn_index = spawn_index.saturating_add(1);
-        let started_agent = started
-            .iter()
-            .find(|agent| agent.agent_id.as_str() == id);
+        let started_agent = started.iter().find(|agent| agent.agent_id.as_str() == id);
         agents.insert(
             id.to_string(),
             running_agent_state(
@@ -327,7 +448,7 @@ fn persist_spawn_agent_state(
                 id,
                 provider,
                 workspace,
-                spec_path.parent().unwrap_or(workspace),
+                workspace,
                 &spawned_at,
                 &team_id,
                 Some(agent_id_to_pane_id(started, id)),
@@ -373,7 +494,10 @@ fn agent_id_to_pane_id<'a>(started: &'a [StartedAgent], agent_id: &str) -> &'a s
         .unwrap_or("")
 }
 
-fn save_launched_team_state(workspace: &Path, launched: &serde_json::Value) -> Result<(), LifecycleError> {
+fn save_launched_team_state(
+    workspace: &Path,
+    launched: &serde_json::Value,
+) -> Result<(), LifecycleError> {
     save_launched_team_state_for_key(workspace, launched, None)
 }
 
@@ -404,7 +528,8 @@ fn save_launched_team_state_for_key(
     };
     let mut projected = crate::state::projection::project_top_level_view(&merged, &launched_key);
     drop_unbound_top_level_owner(&mut projected);
-    save_runtime_state(workspace, &projected).map_err(|e| LifecycleError::StatePersist(e.to_string()))
+    save_runtime_state(workspace, &projected)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
 fn drop_bare_worker_seeded_owner(launched: &mut serde_json::Value, launched_key: &str) {
@@ -506,7 +631,11 @@ fn drop_unbound_top_level_owner(state: &mut serde_json::Value) {
     }
 }
 
-fn drop_foreign_seeded_owner(existing: &serde_json::Value, launched_key: &str, launched: &mut serde_json::Value) {
+fn drop_foreign_seeded_owner(
+    existing: &serde_json::Value,
+    launched_key: &str,
+    launched: &mut serde_json::Value,
+) {
     let Some(pane) = launched
         .get("team_owner")
         .and_then(|owner| owner.get("pane_id"))
@@ -549,8 +678,7 @@ fn drop_worker_pane_seeded_owner(
         .ok()
         .filter(|value| !value.is_empty());
     let has_leader_identity_env = has_positive_caller_leader_env();
-    let seeded_from_bare_tmux =
-        !has_leader_identity_env && tmux_pane.as_deref() == Some(pane);
+    let seeded_from_bare_tmux = !has_leader_identity_env && tmux_pane.as_deref() == Some(pane);
     let caller_tmux_socket = crate::tmux_backend::socket_name_from_tmux_env();
     if seeded_from_bare_tmux
         && (tmux_sockets_match_or_unknown(caller_tmux_socket.as_deref(), worker_tmux_socket)
@@ -563,19 +691,14 @@ fn drop_worker_pane_seeded_owner(
 
 fn seeded_pane_looks_like_worker(pane: &str, started: &[StartedAgent]) -> bool {
     pane.ends_with("-first")
-        || started
-            .iter()
-            .any(|agent| {
-                pane == agent.target
-                    || pane.starts_with(agent.target.as_str())
-                    || agent.target.starts_with(pane)
-            })
+        || started.iter().any(|agent| {
+            pane == agent.target
+                || pane.starts_with(agent.target.as_str())
+                || agent.target.starts_with(pane)
+        })
 }
 
-fn launched_worker_tmux_socket(
-    transport: &dyn Transport,
-    workspace: &Path,
-) -> Option<String> {
+fn launched_worker_tmux_socket(transport: &dyn Transport, workspace: &Path) -> Option<String> {
     if matches!(transport.kind(), crate::transport::BackendKind::Tmux) {
         Some(crate::tmux_backend::socket_name_for_workspace(workspace))
     } else {
@@ -583,10 +706,7 @@ fn launched_worker_tmux_socket(
     }
 }
 
-fn tmux_sockets_match_or_unknown(
-    caller_socket: Option<&str>,
-    worker_socket: Option<&str>,
-) -> bool {
+fn tmux_sockets_match_or_unknown(caller_socket: Option<&str>, worker_socket: Option<&str>) -> bool {
     match (caller_socket, worker_socket) {
         (Some(caller), Some(worker)) => caller == worker,
         (Some(_), None) => false,
@@ -595,7 +715,9 @@ fn tmux_sockets_match_or_unknown(
 }
 
 fn env_nonempty(key: &str) -> bool {
-    std::env::var(key).ok().is_some_and(|value| !value.is_empty())
+    std::env::var(key)
+        .ok()
+        .is_some_and(|value| !value.is_empty())
 }
 
 fn seed_unbound_launched_owner(launched: &mut serde_json::Value, launched_key: &str) {
@@ -664,7 +786,11 @@ fn unbound_launched_owner(
     }))
 }
 
-fn owner_pane_belongs_to_other_team(existing: &serde_json::Value, launched_key: &str, pane: &str) -> bool {
+fn owner_pane_belongs_to_other_team(
+    existing: &serde_json::Value,
+    launched_key: &str,
+    pane: &str,
+) -> bool {
     existing
         .get("teams")
         .and_then(serde_json::Value::as_object)
@@ -700,18 +826,25 @@ fn running_agent_state(
         .and_then(Value::as_str)
         .and_then(parse_auth_mode)
         .unwrap_or(AuthMode::Subscription);
-    let profile = agent.get("profile").map(yaml_value_to_json).unwrap_or(serde_json::Value::Null);
+    let profile = agent
+        .get("profile")
+        .map(yaml_value_to_json)
+        .unwrap_or(serde_json::Value::Null);
     let window = agent.get("window").and_then(Value::as_str).unwrap_or(id);
     let mcp_config = crate::provider::get_adapter(provider)
         .mcp_config(auth_mode)
         .map_err(|e| LifecycleError::Provider(e.to_string()))?;
     let mcp_config = resolve_mcp_config(mcp_config, workspace, id, team_id);
-    let mcp_config_path = write_worker_mcp_config(workspace, id, &mcp_config)?;
+    let mcp_config_path =
+        write_worker_mcp_config_for_provider(workspace, id, &mcp_config, Some(provider))?;
     let mut state = serde_json::Map::new();
     state.insert("status".to_string(), serde_json::json!("running"));
     state.insert("provider".to_string(), serde_json::json!(provider));
     state.insert("agent_id".to_string(), serde_json::json!(id));
-    state.insert("model".to_string(), model.map_or(serde_json::Value::Null, |m| serde_json::json!(m)));
+    state.insert(
+        "model".to_string(),
+        model.map_or(serde_json::Value::Null, |m| serde_json::json!(m)),
+    );
     state.insert("auth_mode".to_string(), serde_json::json!(auth_mode));
     state.insert("profile".to_string(), profile);
     if agent.get("profile").is_some() {
@@ -737,7 +870,10 @@ fn running_agent_state(
     state.insert("rollout_path".to_string(), serde_json::Value::Null);
     state.insert("captured_at".to_string(), serde_json::Value::Null);
     state.insert("captured_via".to_string(), serde_json::Value::Null);
-    state.insert("attribution_confidence".to_string(), serde_json::Value::Null);
+    state.insert(
+        "attribution_confidence".to_string(),
+        serde_json::Value::Null,
+    );
     if let Some(started_agent) = started_agent {
         persist_started_agent_plan_state(&mut state, started_agent);
     }
@@ -832,6 +968,20 @@ pub(crate) fn write_worker_mcp_config(
     workspace: &Path,
     agent_id: &str,
     config: &crate::provider::McpConfig,
+) -> Result<PathBuf, LifecycleError> {
+    write_worker_mcp_config_for_provider(workspace, agent_id, config, None)
+}
+
+/// C-3-4 cr verdict v2 — Copilot 的 mcp config schema 字段名是 `transport`
+/// (实测 cmd-mcp-add 原文取值 stdio|http|sse),不是 canonical 的 `type`。当
+/// provider==Copilot 时写出文件前先做 type→transport 翻译;其它 provider 不动。
+/// 文件路径同 canonical `<ws>/.team/runtime/mcp/<agent_id>.json`,因为 launch
+/// 路径会用 `--additional-mcp-config @<file>` 直指它。
+pub(crate) fn write_worker_mcp_config_for_provider(
+    workspace: &Path,
+    agent_id: &str,
+    config: &crate::provider::McpConfig,
+    provider: Option<Provider>,
 ) -> Result<PathBuf, LifecycleError> {
     let path = workspace
         .join(".team/runtime/mcp")
@@ -840,22 +990,70 @@ pub(crate) fn write_worker_mcp_config(
         std::fs::create_dir_all(parent)
             .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", parent.display())))?;
     }
-    let body = serde_json::to_string_pretty(&serde_json::json!({"mcpServers": config.raw}))
+    let raw = if matches!(provider, Some(Provider::Copilot)) {
+        copilot_translate_mcp_servers(&config.raw)
+    } else {
+        config.raw.clone()
+    };
+    let body = serde_json::to_string_pretty(&serde_json::json!({"mcpServers": raw}))
         .map_err(|e| LifecycleError::StatePersist(format!("serialize mcp config: {e}")))?;
     std::fs::write(&path, body)
         .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", path.display())))?;
     Ok(path)
 }
 
-pub(crate) fn point_native_mcp_config_at_file(argv: &mut [String], provider: Provider, path: &Path) {
-    if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
-        return;
-    }
-    let Some(index) = argv.iter().position(|arg| arg == "--mcp-config") else {
-        return;
+/// C-3-4 cr verdict v2 — McpConfig.raw 是 `{name: {type, command, args, env}}` 形;
+/// copilot mcp add schema 取 `transport` 替 `type`(stdio|http|sse 同值)。仅
+/// 字段名变换,其余字段全保留。
+fn copilot_translate_mcp_servers(raw: &serde_json::Value) -> serde_json::Value {
+    let Some(servers) = raw.as_object() else {
+        return raw.clone();
     };
-    if let Some(value) = argv.get_mut(index.saturating_add(1)) {
-        *value = path.to_string_lossy().to_string();
+    let mut translated = serde_json::Map::new();
+    for (name, server) in servers {
+        let Some(obj) = server.as_object() else {
+            translated.insert(name.clone(), server.clone());
+            continue;
+        };
+        let mut out = serde_json::Map::new();
+        for (key, value) in obj {
+            if key == "type" {
+                out.insert("transport".to_string(), value.clone());
+            } else {
+                out.insert(key.clone(), value.clone());
+            }
+        }
+        translated.insert(name.clone(), serde_json::Value::Object(out));
+    }
+    serde_json::Value::Object(translated)
+}
+
+pub(crate) fn point_native_mcp_config_at_file(
+    argv: &mut [String],
+    provider: Provider,
+    path: &Path,
+) {
+    match provider {
+        Provider::Claude | Provider::ClaudeCode => {
+            let Some(index) = argv.iter().position(|arg| arg == "--mcp-config") else {
+                return;
+            };
+            if let Some(value) = argv.get_mut(index.saturating_add(1)) {
+                *value = path.to_string_lossy().to_string();
+            }
+        }
+        // §C1 note: copilot `--additional-mcp-config` 接受 `@file`,直接指向既有
+        // `.team/runtime/mcp/<agent>.json`(launch 路径 write_worker_mcp_config 已写)。
+        // 既避免 inline JSON 包 mcpServers wrapper 的语义错位,也更利于 ps 验法。
+        Provider::Copilot => {
+            let Some(index) = argv.iter().position(|arg| arg == "--additional-mcp-config") else {
+                return;
+            };
+            if let Some(value) = argv.get_mut(index.saturating_add(1)) {
+                *value = format!("@{}", path.to_string_lossy());
+            }
+        }
+        _ => {}
     }
 }
 
@@ -874,13 +1072,19 @@ fn permissions_json(
     let resolved = permissions::resolve_permissions(&AgentPermissionInput {
         id: Some(AgentId::new(id)),
         provider,
-        role: agent.get("role").and_then(Value::as_str).map(str::to_string),
+        role: agent
+            .get("role")
+            .and_then(Value::as_str)
+            .map(str::to_string),
         tools,
     })?;
     let mut out = serde_json::Map::new();
     out.insert("agent_id".to_string(), serde_json::json!(id));
     out.insert("provider".to_string(), serde_json::json!(provider));
-    out.insert("tools".to_string(), serde_json::json!(resolved.sorted_tool_strings()));
+    out.insert(
+        "tools".to_string(),
+        serde_json::json!(resolved.sorted_tool_strings()),
+    );
     out.insert(
         "resolved_tools".to_string(),
         serde_json::Value::Array(
@@ -896,7 +1100,10 @@ fn permissions_json(
                 .collect(),
         ),
     );
-    out.insert("has_prompt_only".to_string(), serde_json::json!(resolved.has_prompt_only));
+    out.insert(
+        "has_prompt_only".to_string(),
+        serde_json::json!(resolved.has_prompt_only),
+    );
     Ok(serde_json::Value::Object(out))
 }
 
@@ -920,9 +1127,10 @@ fn spawn_timestamp_for_agent(offset_micros: u32) -> String {
     match std::env::var("TEAM_AGENT_TEST_FIXED_SPAWNED_AT") {
         Ok(value) => chrono::DateTime::parse_from_rfc3339(&value)
             .map(|dt| {
-                (dt.with_timezone(&chrono::Utc) + chrono::Duration::microseconds(i64::from(offset_micros)))
-                    .format("%Y-%m-%dT%H:%M:%S%.6f+00:00")
-                    .to_string()
+                (dt.with_timezone(&chrono::Utc)
+                    + chrono::Duration::microseconds(i64::from(offset_micros)))
+                .format("%Y-%m-%dT%H:%M:%S%.6f+00:00")
+                .to_string()
             })
             .unwrap_or(value),
         Err(_) => spawn_timestamp(),
@@ -964,6 +1172,10 @@ pub(crate) fn inherited_env_with_team_overrides(
         "TEAM_AGENT_WORKSPACE".to_string(),
         workspace.to_string_lossy().to_string(),
     );
+    // Python providers.py:131 — TEAM_AGENT_ID must be the worker ITSELF, overriding any
+    // value inherited from the launching process (an add-agent/fork issued from another
+    // worker's MCP server carries the CALLER's TEAM_AGENT_ID in its environ).
+    env.insert("TEAM_AGENT_ID".to_string(), agent_id.to_string());
     env.insert("TEAM_AGENT_AGENT_ID".to_string(), agent_id.to_string());
     if let Some(tid) = team_id.filter(|s| !s.is_empty()) {
         env.insert("TEAM_AGENT_OWNER_TEAM_ID".to_string(), tid.to_string());
@@ -971,6 +1183,190 @@ pub(crate) fn inherited_env_with_team_overrides(
     env
 }
 
+/// BUG / B2 灵魂件 + C-1-2 + C-6-1 cr verdict — Copilot per-worker AGENTS.md
+/// 写入 + `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` 注入。
+///
+/// 目录布局:`<workspace>/.team/runtime/copilot-instructions/<agent_id>/AGENTS.md`
+///   * 含 `<agent_id>` segment(C-6-2 per-agent isolation,N18 精神)
+///   * 文件内容 ≡ `compile_worker_system_prompt` 输出(B2 ps/文件双验法)
+///   * **禁** silent 写全局 `~/.copilot/AGENTS.md`(C-1-2 grep guard)
+///
+/// 失败回 `LifecycleError::StatePersist` 以与既有 state 持久化错误同源,
+/// 不 silent 吞(MUST-NOT-13 诚实)。
+pub(crate) fn apply_copilot_instructions_overlay(
+    workspace: &Path,
+    agent_id: &str,
+    system_prompt: &str,
+    env: &mut BTreeMap<String, String>,
+) -> Result<(), LifecycleError> {
+    let dir = workspace
+        .join(".team")
+        .join("runtime")
+        .join("copilot-instructions")
+        .join(agent_id);
+    std::fs::create_dir_all(&dir)
+        .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", dir.display())))?;
+    let agents_md = dir.join("AGENTS.md");
+    std::fs::write(&agents_md, system_prompt.as_bytes())
+        .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", agents_md.display())))?;
+    env.insert(
+        "COPILOT_CUSTOM_INSTRUCTIONS_DIRS".to_string(),
+        dir.to_string_lossy().to_string(),
+    );
+    // ★ C-4 P0(N39 红线 / MUST-12) — copilot config 默认 `updateTerminalTitle=true`
+    // 会改 tmux window 名(help-config 原文)。tmux window 名是框架定位 agent 的
+    // anchor(window==agent_id);copilot 静默改写 → 寻址 / kill / 保护集 三处同源
+    // 派生漂移 → B5 protected_set 误判、MUST-12 pane 身份失锚、N39 同源派生破。
+    // 漏关后果定级为【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());
+    Ok(())
+}
+
+/// C-3-2/C-3-3 cr verdict v2 — Copilot spawn 前调 `copilot mcp list` 扫用户全局
+/// `~/.copilot/mcp-config.json` 与 workspace `.mcp.json` 的 MCP 残留;对每个非
+/// `team_orchestrator` server 追加 `--disable-mcp-server <name>`(main-help:72-73)
+/// 并落 `<log_dir>/mcp-residual.txt` + emit `provider.copilot.mcp_residual_detected`
+/// event(MUST-NOT-13 诚实记录,非 silent)。
+///
+/// 失败回 `LifecycleError::StatePersist`,不 silent 吞;`copilot mcp list` 自身
+/// 无法运行(命令缺失 / 退出码非零)时,仅记 `mcp-residual.txt` 的 unavailable
+/// 行,不阻断 spawn(provider 一期 subscription-only,工具链可能未完全就绪)。
+fn apply_copilot_mcp_residual_disables(
+    workspace: &Path,
+    agent_id: &str,
+    argv: &mut Vec<String>,
+    log_dir: &Path,
+) -> Result<(), LifecycleError> {
+    let listing = std::process::Command::new("copilot")
+        .arg("mcp")
+        .arg("list")
+        .output();
+    let residual_path = log_dir.join("mcp-residual.txt");
+    match listing {
+        Ok(out) if out.status.success() => {
+            let text = String::from_utf8_lossy(&out.stdout).to_string();
+            std::fs::write(&residual_path, &text).map_err(|e| {
+                LifecycleError::StatePersist(format!("{}: {e}", residual_path.display()))
+            })?;
+            let residual_servers = parse_copilot_mcp_list_server_names(&text);
+            let non_orchestrator: Vec<String> = residual_servers
+                .iter()
+                .filter(|name| name.as_str() != "team_orchestrator")
+                .cloned()
+                .collect();
+            for name in &non_orchestrator {
+                argv.push("--disable-mcp-server".to_string());
+                argv.push(name.clone());
+            }
+            if !non_orchestrator.is_empty() {
+                let event_log = crate::event_log::EventLog::new(workspace);
+                let _ = event_log.write(
+                    "provider.copilot.mcp_residual_detected",
+                    serde_json::json!({
+                        "agent_id": agent_id,
+                        "residual_servers": non_orchestrator,
+                        "log_path": residual_path.to_string_lossy(),
+                    }),
+                );
+            }
+        }
+        Ok(out) => {
+            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()),
+            )
+            .map_err(|e| {
+                LifecycleError::StatePersist(format!("{}: {e}", residual_path.display()))
+            })?;
+        }
+        Err(e) => {
+            std::fs::write(
+                &residual_path,
+                format!("copilot mcp list unavailable: {e}\n"),
+            )
+            .map_err(|e| {
+                LifecycleError::StatePersist(format!("{}: {e}", residual_path.display()))
+            })?;
+        }
+    }
+    Ok(())
+}
+
+/// 解析 `copilot mcp list` 输出取 server 名集合(te 真机实证 v2,1.0.59 形态):
+/// ```text
+/// User servers:
+///   foo (local)
+///   bar (http)
+/// Builtin servers:
+///   github-mcp-server (local)
+/// ```
+/// 或空集形态(te 真机实证 fake HOME 无 mcp-config.json):
+/// ```text
+/// No MCP servers configured.
+///
+/// Add a server with:
+///   copilot mcp add <name> -- <command> [args...]
+///   copilot mcp add --transport http <name> <url>
+/// ```
+///
+/// 规则:
+/// 1. 首行含 "No MCP servers configured" → 立即返空(避免把 "Add a server with"
+///    段下的 help 行误识为 server)
+/// 2. 段标题行(非缩进、以 `:` 结尾):只有 *servers:* 后缀的段(User/Builtin/
+///    Workspace servers:)才进 server-listing 模式;其余段(如 "Add a server with:")
+///    进 skip 模式直到下个 servers: 段或文档结束
+/// 3. servers: 段内的缩进行取首段 token,剥 ` (local)`/` (http)`/` (sse)` 后缀
+/// 4. 空行 / 不识别行容忍跳过(诚实降级:漏识 = silent 残留,在 mcp-residual.txt
+///    全量落盘留证)
+fn parse_copilot_mcp_list_server_names(text: &str) -> Vec<String> {
+    let mut out: Vec<String> = Vec::new();
+    let mut in_servers_section = false;
+    for line in text.lines() {
+        let trimmed_end = line.trim_end();
+        if trimmed_end.is_empty() {
+            continue;
+        }
+        // C-3-2 fix(te 真机实证):空集 sentinel 立即返空。
+        if trimmed_end
+            .trim_start()
+            .starts_with("No MCP servers configured")
+        {
+            return Vec::new();
+        }
+        // 段标题行(非缩进):决定后续缩进行是否取 server 名。"*servers:" 是
+        // listing 段(User/Builtin/Workspace),其它段都 skip(如 "Add a server with:"
+        // 下面的 help 命令缩进行)。
+        if !(line.starts_with(' ') || line.starts_with('\t')) {
+            let lower = trimmed_end.to_ascii_lowercase();
+            in_servers_section = lower.trim_end_matches(':').ends_with("servers");
+            continue;
+        }
+        if !in_servers_section {
+            continue;
+        }
+        let trimmed = trimmed_end.trim_start();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let mut token = trimmed.split_whitespace().next().unwrap_or("").to_string();
+        // 剥常见装饰后缀(实测形如 "(local)"/"(http)"/"(sse)" 是独立 whitespace
+        // 分隔的 token,首段 token 通常不带括号;若实际 copilot 把括号粘连首段
+        // token,这里多做一次后缀剥离守护)。
+        if let Some(idx) = token.find('(') {
+            token.truncate(idx);
+        }
+        token = token.trim_end_matches(':').trim().to_string();
+        if token.is_empty() {
+            continue;
+        }
+        out.push(token);
+    }
+    out
+}
+
 pub(crate) fn apply_profile_launch_env(
     env: &mut BTreeMap<String, String>,
     profile_launch: &crate::provider::ProviderProfileLaunch,
@@ -1078,7 +1474,10 @@ pub(crate) fn fill_spawn_placeholders_full(
             *arg = workspace_text.clone();
         } else if arg == "{agent_id}" {
             *arg = agent_id.to_string();
-        } else if arg.contains("{workspace}") || arg.contains("{agent_id}") || arg.contains("{team_id}") {
+        } else if arg.contains("{workspace}")
+            || arg.contains("{agent_id}")
+            || arg.contains("{team_id}")
+        {
             *arg = arg
                 .replace("{workspace}", &workspace_text)
                 .replace("{agent_id}", agent_id)
@@ -1087,30 +1486,12 @@ pub(crate) fn fill_spawn_placeholders_full(
     }
 }
 
-fn agent_tool_strings(agent: &Value) -> Vec<String> {
-    agent
-        .get("tools")
-        .and_then(Value::as_list)
-        .map(|items| {
-            items
-                .iter()
-                .filter_map(Value::as_str)
-                .map(str::to_string)
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
 fn spec_team_id(spec: &Value) -> Option<String> {
     spec.get("team")
         .and_then(|v| v.get("id").or_else(|| v.get("name")))
         .and_then(Value::as_str)
         .map(str::to_string)
-        .or_else(|| {
-            spec.get("name")
-                .and_then(Value::as_str)
-                .map(str::to_string)
-        })
+        .or_else(|| spec.get("name").and_then(Value::as_str).map(str::to_string))
 }
 
 fn runtime_active_team_key_for_spawn(
@@ -1158,6 +1539,7 @@ fn parse_provider(raw: &str) -> Option<Provider> {
         "claude" => Some(Provider::Claude),
         "claude_code" => Some(Provider::ClaudeCode),
         "codex" => Some(Provider::Codex),
+        "copilot" => Some(Provider::Copilot),
         "gemini_cli" => Some(Provider::GeminiCli),
         "fake" => Some(Provider::Fake),
         _ => None,
@@ -1173,7 +1555,10 @@ fn parse_auth_mode(raw: &str) -> Option<AuthMode> {
     }
 }
 
-fn quick_start_requested_team_key<'a>(team_id: Option<&'a str>, name: Option<&'a str>) -> Option<&'a str> {
+fn quick_start_requested_team_key<'a>(
+    team_id: Option<&'a str>,
+    name: Option<&'a str>,
+) -> Option<&'a str> {
     team_id.or(name).filter(|team| !team.is_empty())
 }
 
@@ -1239,7 +1624,7 @@ fn quick_start_depth_guard(
     Ok(QuickStartDepth {
         parent_team_key: Some(parent_key),
         team_depth,
-        })
+    })
 }
 
 fn infer_parent_team_from_active_state(state: &serde_json::Value) -> Option<String> {
@@ -1255,9 +1640,7 @@ fn has_live_runtime_teams(state: &serde_json::Value) -> bool {
     state
         .get("teams")
         .and_then(serde_json::Value::as_object)
-        .is_some_and(|teams| {
-            teams.values().any(team_has_running_agent)
-        })
+        .is_some_and(|teams| teams.values().any(team_has_running_agent))
 }
 
 fn team_has_running_agent(team: &serde_json::Value) -> bool {
@@ -1265,20 +1648,18 @@ fn team_has_running_agent(team: &serde_json::Value) -> bool {
         .and_then(serde_json::Value::as_object)
         .is_some_and(|agents| {
             agents.values().any(|agent| {
-                agent
-                    .get("status")
-                    .and_then(serde_json::Value::as_str)
-                    == Some("running")
+                agent.get("status").and_then(serde_json::Value::as_str) == Some("running")
             })
         })
 }
 
 fn looks_ambiguous_child_team_key(team: &str) -> bool {
     let team = team.trim().to_ascii_lowercase();
-    team != "child" && (team.starts_with("child-")
-        || team.starts_with("child_")
-        || team.starts_with("child.")
-        || team.starts_with("child"))
+    team != "child"
+        && (team.starts_with("child-")
+            || team.starts_with("child_")
+            || team.starts_with("child.")
+            || team.starts_with("child"))
 }
 
 fn looks_grandchild_team_key(team: &str) -> bool {
@@ -1290,7 +1671,11 @@ fn looks_grandchild_team_key(team: &str) -> bool {
         || team.starts_with("grandchild")
 }
 
-fn annotate_team_depth(state: &mut serde_json::Value, parent_team_key: Option<&str>, team_depth: u64) {
+fn annotate_team_depth(
+    state: &mut serde_json::Value,
+    parent_team_key: Option<&str>,
+    team_depth: u64,
+) {
     let Some(obj) = state.as_object_mut() else {
         return;
     };
@@ -1337,9 +1722,7 @@ fn runtime_state_has_quick_start_team(state: &serde_json::Value, team: &str) ->
         || state
             .get("session_name")
             .and_then(serde_json::Value::as_str)
-            .is_some_and(|session| {
-                session == team || session.strip_prefix("team-") == Some(team)
-            })
+            .is_some_and(|session| session == team || session.strip_prefix("team-") == Some(team))
 }
 
 fn json_team_identity_matches(state: &serde_json::Value, team: &str) -> bool {
@@ -1412,7 +1795,9 @@ 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, fresh, team_id, transport)
+    quick_start_with_transport_in_workspace(
+        &workspace, agents_dir, name, yes, fresh, team_id, transport,
+    )
 }
 
 pub fn quick_start_with_transport_in_workspace(
@@ -1468,11 +1853,12 @@ pub fn quick_start_with_transport_in_workspace(
                         .map(SessionName::new),
                     state_path: Some(state_path),
                     next_actions: vec![
-                        "run restart to resume the existing team or pass --fresh to replace it".to_string(),
+                        "run restart to resume the existing team or pass --fresh to replace it"
+                            .to_string(),
                     ],
-        });
-    }
-}
+                });
+            }
+        }
     }
     // CR-040/042: repeated quick-start from one template with distinct --team-id/--name
     // must NOT collide on the template-derived tmux session. Override the compiled
@@ -1488,12 +1874,12 @@ pub fn quick_start_with_transport_in_workspace(
         runtime_team_key_for_spec(&spec_path, &spec, &session_name)
     });
     let spec_path = agents_dir.join("team.spec.yaml");
-    std::fs::write(&spec_path, yaml::dumps(&spec)).map_err(|e| {
-        LifecycleError::StatePersist(format!("{}: {e}", spec_path.display()))
-    })?;
+    std::fs::write(&spec_path, yaml::dumps(&spec))
+        .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", spec_path.display())))?;
     let _store = crate::message_store::MessageStore::open(&workspace)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let resolved_spec_path = std::fs::canonicalize(&spec_path).unwrap_or_else(|_| spec_path.clone());
+    let resolved_spec_path =
+        std::fs::canonicalize(&spec_path).unwrap_or_else(|_| spec_path.clone());
     let state = initial_runtime_state(&spec, &resolved_spec_path, &workspace, agents_dir);
     save_launched_team_state_for_key(&workspace, &state, Some(&state_team_key))?;
     annotate_persisted_team_depth(
@@ -1505,14 +1891,16 @@ pub fn quick_start_with_transport_in_workspace(
     // FIX (rt-host-a real-machine finding): dry_run=false so launch_with_transport calls spawn_agents
     // and really creates the tmux session + worker windows (was hardcoded true → never spawned, which
     // also starved the coordinator: no session → first tick TmuxSessionMissing → run_daemon loop exits).
-    let mut launch = launch_with_transport_in_workspace(&workspace, &spec_path, false, yes, true, transport)?;
+    let mut launch =
+        launch_with_transport_in_workspace(&workspace, &spec_path, false, yes, true, transport)?;
     annotate_persisted_team_depth(
         &workspace,
         &state_team_key,
         team_depth.parent_team_key.as_deref(),
         team_depth.team_depth,
     )?;
-    launch.leader_receiver_attached = launched_team_receiver_is_attached(&workspace, &state_team_key);
+    launch.leader_receiver_attached =
+        launched_team_receiver_is_attached(&workspace, &state_team_key);
     launch.session_capture_incomplete_agents =
         quick_start_session_capture_incomplete_agents(&workspace, &state_team_key);
     let coordinator_workspace = crate::coordinator::WorkspacePath::new(workspace.clone());
@@ -1532,12 +1920,29 @@ pub fn quick_start_with_transport_in_workspace(
     //   asynchronously after spawn), so the verdict is PendingToolLoad — never
     //   bare Ready.
     let worker_readiness = quick_start_worker_readiness(&workspace, &state_team_key);
+    let attach_commands = crate::tmux_backend::attach_commands_for_windows(
+        &workspace,
+        &session_name,
+        launch
+            .started
+            .iter()
+            .map(|started| started.agent_id.as_str()),
+    );
+    let mut next_actions = vec![format!(
+        "team compiled; real spawn is behind the transport/provider boundary; {coordinator_action}"
+    )];
+    next_actions.extend(attach_commands.iter().cloned());
+    let display_backend = state
+        .get("display_backend")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("none")
+        .to_string();
     Ok(QuickStartReport::Ready {
         session_name,
         launch: Box::new(launch),
-        next_actions: vec![format!(
-            "team compiled; real spawn is behind the transport/provider boundary; {coordinator_action}"
-        )],
+        next_actions,
+        attach_commands,
+        display_backend,
         worker_readiness,
     })
 }
@@ -1556,7 +1961,10 @@ fn quick_start_worker_readiness(workspace: &Path, team_key: &str) -> QuickStartR
         .and_then(serde_json::Value::as_object)
         .and_then(|teams| teams.get(team_key))
         .unwrap_or(&state);
-    let Some(agents) = team_state.get("agents").and_then(serde_json::Value::as_object) else {
+    let Some(agents) = team_state
+        .get("agents")
+        .and_then(serde_json::Value::as_object)
+    else {
         return QuickStartReadiness::PendingToolLoad;
     };
     let all_spawned = !agents.is_empty();
@@ -1575,9 +1983,12 @@ fn quick_start_worker_readiness(workspace: &Path, team_key: &str) -> QuickStartR
     if !unhealthy.is_empty() {
         unhealthy.sort();
         unhealthy.dedup();
-        QuickStartReadiness::Degraded { unhealthy_agents: unhealthy }
+        QuickStartReadiness::Degraded {
+            unhealthy_agents: unhealthy,
+        }
     } else {
-        let incomplete_agents = crate::session_capture::incomplete_interacted_resumable_agent_ids(team_state);
+        let incomplete_agents =
+            crate::session_capture::incomplete_interacted_resumable_agent_ids(team_state);
         let all_resumable_have_session = incomplete_agents.is_empty();
         let _readiness_ready = all_spawned && all_attached_receiver && all_resumable_have_session;
         QuickStartReadiness::PendingToolLoad
@@ -1621,10 +2032,7 @@ fn team_uses_fake_model_harness(team_state: &serde_json::Value) -> bool {
         .is_some_and(|agents| {
             !agents.is_empty()
                 && agents.values().all(|agent| {
-                    agent
-                        .get("model")
-                        .and_then(serde_json::Value::as_str)
-                        == Some("fake")
+                    agent.get("model").and_then(serde_json::Value::as_str) == Some("fake")
                 })
         })
 }
@@ -1649,9 +2057,11 @@ fn leader_receiver_is_attached(team_state: &serde_json::Value) -> bool {
 /// `--dangerously-*` flag,产出危险审批继承态。launch 在 inherited=false 且无 --yes 时拒。
 pub fn detect_dangerous_approval() -> Result<DangerousApproval, LifecycleError> {
     if let Ok(raw) = std::env::var("TEAM_AGENT_TEST_PROCESS_ANCESTRY_ARGV_JSON") {
-        let argv_tokens = serde_json::from_str::<Vec<String>>(&raw)
-            .map_err(|e| LifecycleError::StatePersist(format!("invalid test ancestry argv: {e}")))?;
-        return Ok(detect_dangerous_approval_in_argv(&argv_tokens).unwrap_or_else(disabled_dangerous_approval));
+        let argv_tokens = serde_json::from_str::<Vec<String>>(&raw).map_err(|e| {
+            LifecycleError::StatePersist(format!("invalid test ancestry argv: {e}"))
+        })?;
+        return Ok(detect_dangerous_approval_in_argv(&argv_tokens)
+            .unwrap_or_else(disabled_dangerous_approval));
     }
     for argv_tokens in process_ancestry_argv(std::process::id()) {
         if let Some(detected) = detect_dangerous_approval_in_argv(&argv_tokens) {
@@ -1667,7 +2077,8 @@ fn detect_dangerous_approval_in_argv(argv_tokens: &[String]) -> Option<Dangerous
     for token in argv_tokens {
         for (provider, flag) in dangerous_leader_flags() {
             if token == flag {
-                let unexpected_binary = !binary_matches_provider(provider, ancestry_binary_name.as_deref());
+                let unexpected_binary =
+                    !binary_matches_provider(provider, ancestry_binary_name.as_deref());
                 return Some(DangerousApproval {
                     enabled: true,
                     source: DangerousApprovalSource::LeaderProcess,
@@ -1857,9 +2268,9 @@ pub fn add_agent(
         }
         Err(error) => return Err(LifecycleError::TeamSelect(error.to_string())),
     };
-    let team_dir = selected
-        .spec_workspace
-        .ok_or_else(|| LifecycleError::TeamSelect("active team spec workspace not found".to_string()))?;
+    let team_dir = selected.spec_workspace.ok_or_else(|| {
+        LifecycleError::TeamSelect("active team spec workspace not found".to_string())
+    })?;
     add_agent_with_transport_at_paths(
         &selected.run_workspace,
         &team_dir,
@@ -1910,8 +2321,9 @@ fn add_agent_with_transport_at_paths(
         .map(str::to_string)
         .or_else(|| explicit_active_team_key(&runtime_state))
         .unwrap_or_else(|| crate::state::projection::team_state_key(&runtime_state));
-    let owner_state = crate::state::projection::select_runtime_state(run_workspace, Some(&canonical_team_key))
-        .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    let owner_state =
+        crate::state::projection::select_runtime_state(run_workspace, Some(&canonical_team_key))
+            .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
     ensure_owner_allowed_for_state(&owner_state, Some(agent_id))?;
     if !role_file_path.exists() {
         return Err(LifecycleError::Compile(format!(
@@ -1929,9 +2341,8 @@ fn add_agent_with_transport_at_paths(
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
     let safety = effective_runtime_config(&spec)?;
     let spec_path = team_dir.join("team.spec.yaml");
-    std::fs::write(&spec_path, yaml::dumps(&spec)).map_err(|e| {
-        LifecycleError::StatePersist(format!("{}: {e}", spec_path.display()))
-    })?;
+    std::fs::write(&spec_path, yaml::dumps(&spec))
+        .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", spec_path.display())))?;
     let (meta, _) = crate::compiler::read_front_matter(&dynamic_role_file)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
     upsert_agent_state_from_role(
@@ -1978,8 +2389,9 @@ fn upsert_agent_state_from_role(
     dynamic_role_file: &Path,
     safety: &DangerousApproval,
 ) -> Result<(), LifecycleError> {
-    let mut state = crate::state::projection::select_runtime_state(workspace, Some(canonical_team_key))
-        .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    let mut state =
+        crate::state::projection::select_runtime_state(workspace, Some(canonical_team_key))
+            .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
     if !state.is_object() {
         state = serde_json::json!({});
     }
@@ -2027,10 +2439,7 @@ fn upsert_agent_state_from_role(
     if let Some(profile) = meta.get("profile").and_then(Value::as_str) {
         if let Some(obj) = entry.as_object_mut() {
             obj.insert("profile".to_string(), serde_json::json!(profile));
-            if let Some(team_dir) = dynamic_role_file
-                .parent()
-                .and_then(Path::parent)
-            {
+            if let Some(team_dir) = dynamic_role_file.parent().and_then(Path::parent) {
                 obj.insert(
                     "_profile_dir".to_string(),
                     serde_json::json!(team_dir.join("profiles").to_string_lossy().to_string()),
@@ -2077,6 +2486,7 @@ pub fn fork_agent(
     workspace: &Path,
     source_agent_id: &AgentId,
     as_agent_id: &AgentId,
+    label: Option<&str>,
     open_display: bool,
     team: Option<&str>,
 ) -> Result<ForkAgentReport, LifecycleError> {
@@ -2090,6 +2500,7 @@ pub fn fork_agent(
         workspace,
         source_agent_id,
         as_agent_id,
+        label,
         open_display,
         team,
         &crate::tmux_backend::TmuxBackend::for_workspace(&selected.run_workspace),
@@ -2100,6 +2511,7 @@ pub fn fork_agent_with_transport(
     workspace: &Path,
     source_agent_id: &AgentId,
     as_agent_id: &AgentId,
+    label: Option<&str>,
     open_display: bool,
     team: Option<&str>,
     transport: &dyn Transport,
@@ -2111,9 +2523,9 @@ pub fn fork_agent_with_transport(
         crate::state::selector::SelectorMode::RequireSpec,
     )
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
-    let spec_workspace = selected
-        .spec_workspace
-        .ok_or_else(|| LifecycleError::TeamSelect("active team spec workspace not found".to_string()))?;
+    let spec_workspace = selected.spec_workspace.ok_or_else(|| {
+        LifecycleError::TeamSelect("active team spec workspace not found".to_string())
+    })?;
     let workspace = selected.run_workspace;
     let state = selected.state;
     ensure_owner_allowed_for_state(&state, Some(source_agent_id))?;
@@ -2126,8 +2538,9 @@ pub fn fork_agent_with_transport(
             "agent id already exists: {as_agent_id}"
         )));
     }
-    let source_agent = find_spec_agent(&spec, source_agent_id)
-        .ok_or_else(|| LifecycleError::RequirementUnmet(format!("unknown worker agent id: {source_agent_id}")))?;
+    let source_agent = find_spec_agent(&spec, source_agent_id).ok_or_else(|| {
+        LifecycleError::RequirementUnmet(format!("unknown worker agent id: {source_agent_id}"))
+    })?;
     let session_id = state
         .get("agents")
         .and_then(|v| v.get(source_agent_id.as_str()))
@@ -2157,13 +2570,14 @@ pub fn fork_agent_with_transport(
             as_agent_id.as_str()
         )));
     }
-    let new_spec = append_forked_agent(&spec, source_agent, source_agent_id, as_agent_id)?;
+    let new_spec = append_forked_agent(&spec, source_agent, source_agent_id, as_agent_id, label)?;
     crate::model::spec::validate_spec(&new_spec, &spec_workspace)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
     std::fs::write(&spec_path, yaml::dumps(&new_spec))
         .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", spec_path.display())))?;
-    let new_agent = find_spec_agent(&new_spec, as_agent_id)
-        .ok_or_else(|| LifecycleError::RequirementUnmet(format!("unknown worker agent id: {as_agent_id}")))?;
+    let new_agent = find_spec_agent(&new_spec, as_agent_id).ok_or_else(|| {
+        LifecycleError::RequirementUnmet(format!("unknown worker agent id: {as_agent_id}"))
+    })?;
     let provider = new_agent
         .get("provider")
         .and_then(Value::as_str)
@@ -2185,46 +2599,56 @@ pub fn fork_agent_with_transport(
             "{provider_str} does not support native session fork"
         )));
     }
-    let role = new_agent.get("role").and_then(Value::as_str);
     let model = new_agent.get("model").and_then(Value::as_str);
     let safety = effective_runtime_config(&new_spec)?;
-    let tools = worker_tool_refs(agent_tool_strings(new_agent), &safety);
-    let tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
+    let command_agent = crate::lifecycle::worker_command_context::WorkerCommandAgent::from_yaml(
+        new_agent,
+        Some(as_agent_id.as_str()),
+        provider,
+    );
+    let system_prompt =
+        crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
+    let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(
+        &command_agent,
+        provider,
+        &safety,
+    )?;
+    let resolved_tool_refs: Vec<&str> = tools.iter().map(String::as_str).collect();
     let fork_team = crate::messaging::leader_receiver::active_team_key(&workspace, &state);
-    let mcp_config = adapter
-        .mcp_config(auth_mode)
-        .map_err(|e| {
-            let _ = std::fs::write(&spec_path, text.as_bytes());
-            LifecycleError::Provider(e.to_string())
-        })?;
+    let mcp_config = adapter.mcp_config(auth_mode).map_err(|e| {
+        let _ = std::fs::write(&spec_path, text.as_bytes());
+        LifecycleError::Provider(e.to_string())
+    })?;
     let mcp_config = resolve_mcp_config(mcp_config, &workspace, as_agent_id.as_str(), &fork_team);
-    let mcp_config_path = write_worker_mcp_config(&workspace, as_agent_id.as_str(), &mcp_config)
-        .map_err(|e| {
-            let _ = std::fs::write(&spec_path, text.as_bytes());
-            e
-        })?;
-    let profile_dir = spec_workspace.join("profiles");
-    let profile_launch = crate::lifecycle::profile_launch::prepare_provider_profile_launch_with_profile_dir(
+    let mcp_config_path = write_worker_mcp_config_for_provider(
         &workspace,
         as_agent_id.as_str(),
-        new_agent,
-        Some(&profile_dir),
-        Some(&mcp_config),
-    )?;
-    let command_model = profile_launch
-        .command_overrides
-        .model
-        .as_deref()
-        .or(model);
+        &mcp_config,
+        Some(provider),
+    )
+    .map_err(|e| {
+        let _ = std::fs::write(&spec_path, text.as_bytes());
+        e
+    })?;
+    let profile_dir = spec_workspace.join("profiles");
+    let profile_launch =
+        crate::lifecycle::profile_launch::prepare_provider_profile_launch_with_profile_dir(
+            &workspace,
+            as_agent_id.as_str(),
+            new_agent,
+            Some(&profile_dir),
+            Some(&mcp_config),
+        )?;
+    let command_model = profile_launch.command_overrides.model.as_deref().or(model);
     let mut plan = adapter
         .fork_plan(
             Some(&session_id),
             crate::provider::ProviderCommandContext {
                 auth_mode,
                 mcp_config: Some(&mcp_config),
-                system_prompt: role,
+                system_prompt: Some(system_prompt.as_str()),
                 model: command_model,
-                tools: &tool_refs,
+                tools: &resolved_tool_refs,
                 profile_launch: Some(&profile_launch),
             },
         )
@@ -2235,23 +2659,40 @@ pub fn fork_agent_with_transport(
     if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
         point_native_mcp_config_at_file(&mut plan.argv, provider, &mcp_config_path);
     }
-    fill_spawn_placeholders_full(&mut plan.argv, &workspace, as_agent_id.as_str(), Some(&fork_team));
-    let window = WindowName::new(as_agent_id.as_str());
-    // fork inherits the parent agent's owner team via runtime state (`active_team_key`).
-    let mut env = inherited_env_with_team_overrides(
+    fill_spawn_placeholders_full(
+        &mut plan.argv,
         &workspace,
         as_agent_id.as_str(),
         Some(&fork_team),
     );
+    let window = WindowName::new(as_agent_id.as_str());
+    // fork inherits the parent agent's owner team via runtime state (`active_team_key`).
+    let mut env =
+        inherited_env_with_team_overrides(&workspace, as_agent_id.as_str(), Some(&fork_team));
     apply_profile_launch_env(&mut env, &profile_launch);
     // golden operations.py:336 -> _tmux_start_command_for_agent_window (runtime.py:1017-1020): branch on
     // _tmux_session_exists — an ABSENT session => new-session (spawn_first), present => new-window
     // (spawn_into). The Rust restart seam (restart.rs spawn_agent_window) uses the same branch.
     let session_live = transport.has_session(&session_name).unwrap_or(false);
+    let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
     let spawn_result = if session_live {
-        transport.spawn_into(&session_name, &window, &plan.argv, &workspace, &env)
+        transport.spawn_into_with_env_unset(
+            &session_name,
+            &window,
+            &plan.argv,
+            &workspace,
+            &env,
+            &env_unset,
+        )
     } else {
-        transport.spawn_first(&session_name, &window, &plan.argv, &workspace, &env)
+        transport.spawn_first_with_env_unset(
+            &session_name,
+            &window,
+            &plan.argv,
+            &workspace,
+            &env,
+            &env_unset,
+        )
     };
     let spawn = spawn_result.map_err(|e| {
         let _ = std::fs::write(&spec_path, text.as_bytes());
@@ -2324,26 +2765,25 @@ pub fn fork_agent_with_transport(
         );
         return Err(e);
     }
-    let coordinator_started =
-        crate::coordinator::start_coordinator(&crate::coordinator::WorkspacePath::new(
-            workspace.to_path_buf(),
-        ))
-        .map(|report| report.ok)
-        .map_err(|e| {
-            rollback_fork_after_spawn(
-                &workspace,
-                &spec_path,
-                &text,
-                &old_state,
-                transport,
-                &session_name,
-                &window,
-                &mcp_config_path,
-                as_agent_id,
-                &profile_launch,
-            );
-            LifecycleError::StatePersist(e.to_string())
-        })?;
+    let coordinator_started = crate::coordinator::start_coordinator(
+        &crate::coordinator::WorkspacePath::new(workspace.to_path_buf()),
+    )
+    .map(|report| report.ok)
+    .map_err(|e| {
+        rollback_fork_after_spawn(
+            &workspace,
+            &spec_path,
+            &text,
+            &old_state,
+            transport,
+            &session_name,
+            &window,
+            &mcp_config_path,
+            as_agent_id,
+            &profile_launch,
+        );
+        LifecycleError::StatePersist(e.to_string())
+    })?;
     Ok(ForkAgentReport {
         source_agent_id: source_agent_id.clone(),
         new_agent_id: as_agent_id.clone(),
@@ -2384,8 +2824,7 @@ fn maybe_fail_fork_after_spawn(step: &str) -> Result<(), LifecycleError> {
     if reason.is_empty() {
         return Ok(());
     }
-    let should_fail = reason == step
-        || (step == "start_coordinator" && reason == "coordinator");
+    let should_fail = reason == step || (step == "start_coordinator" && reason == "coordinator");
     if !should_fail {
         return Ok(());
     }
@@ -2429,16 +2868,13 @@ fn find_spec_agent<'a>(spec: &'a Value, agent_id: &AgentId) -> Option<&'a Value>
     if leader_is_agent {
         return None;
     }
-    spec.get("agents")?
-        .as_list()?
-        .iter()
-        .find(|agent| {
-            agent
-                .get("id")
-                .and_then(Value::as_str)
-                .map(|id| id == agent_id.as_str())
-                .unwrap_or(false)
-        })
+    spec.get("agents")?.as_list()?.iter().find(|agent| {
+        agent
+            .get("id")
+            .and_then(Value::as_str)
+            .map(|id| id == agent_id.as_str())
+            .unwrap_or(false)
+    })
 }
 
 fn append_forked_agent(
@@ -2446,6 +2882,7 @@ fn append_forked_agent(
     source_agent: &Value,
     source_agent_id: &AgentId,
     as_agent_id: &AgentId,
+    label: Option<&str>,
 ) -> Result<Value, LifecycleError> {
     let mut new_agent = source_agent.clone();
     set_yaml_map_value(
@@ -2454,11 +2891,16 @@ fn append_forked_agent(
         Value::Str(as_agent_id.as_str().to_string()),
     )?;
     // golden operations.py:315 `str(label or new_agent.get("role") or as_agent_id)` — Python `or`
-    // falsiness: an EMPTY-string role is falsy and falls through to as_agent_id.
-    let role = new_agent
-        .get("role")
-        .and_then(Value::as_str)
+    // falsiness: an EMPTY-string label/role is falsy and falls through to the next tier.
+    // The label IS the forked agent's new role (it feeds the identity prompt — B2 family).
+    let role = label
         .filter(|s| !s.is_empty())
+        .or_else(|| {
+            new_agent
+                .get("role")
+                .and_then(Value::as_str)
+                .filter(|s| !s.is_empty())
+        })
         .unwrap_or_else(|| as_agent_id.as_str())
         .to_string();
     set_yaml_map_value(&mut new_agent, "role", Value::Str(role.clone()))?;
@@ -2477,12 +2919,17 @@ fn append_forked_agent(
     )?;
 
     let Value::Map(pairs) = spec else {
-        return Err(LifecycleError::Compile("spec root is not a map".to_string()));
+        return Err(LifecycleError::Compile(
+            "spec root is not a map".to_string(),
+        ));
     };
     let mut out = Vec::new();
     for (key, value) in pairs {
         if key == "agents" {
-            let mut agents = value.as_list().map(|items| items.to_vec()).unwrap_or_default();
+            let mut agents = value
+                .as_list()
+                .map(|items| items.to_vec())
+                .unwrap_or_default();
             agents.push(new_agent.clone());
             out.push((key.clone(), Value::List(agents)));
         } else if key == "runtime" {
@@ -2496,7 +2943,9 @@ fn append_forked_agent(
 
 fn set_yaml_map_value(value: &mut Value, key: &str, next: Value) -> Result<(), LifecycleError> {
     let Value::Map(pairs) = value else {
-        return Err(LifecycleError::Compile("agent entry is not a map".to_string()));
+        return Err(LifecycleError::Compile(
+            "agent entry is not a map".to_string(),
+        ));
     };
     if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
         *existing = next;
@@ -2515,10 +2964,15 @@ fn runtime_with_startup_agent(runtime: &Value, agent_id: &AgentId) -> Value {
     for (key, value) in pairs {
         if key == "startup_order" {
             saw_startup = true;
-            let mut order = value.as_list().map(|items| items.to_vec()).unwrap_or_default();
-            let already_present = order
-                .iter()
-                .any(|item| item.as_str().map(|id| id == agent_id.as_str()).unwrap_or(false));
+            let mut order = value
+                .as_list()
+                .map(|items| items.to_vec())
+                .unwrap_or_default();
+            let already_present = order.iter().any(|item| {
+                item.as_str()
+                    .map(|id| id == agent_id.as_str())
+                    .unwrap_or(false)
+            });
             if !already_present {
                 order.push(Value::Str(agent_id.as_str().to_string()));
             }
@@ -2574,18 +3028,37 @@ fn upsert_forked_agent_state(
     let mut entry = serde_json::Map::new();
     entry.insert("status".to_string(), serde_json::json!("running"));
     entry.insert("provider".to_string(), serde_json::json!(provider));
-    entry.insert("agent_id".to_string(), serde_json::json!(as_agent_id.as_str()));
-    entry.insert("window".to_string(), serde_json::json!(as_agent_id.as_str()));
-    entry.insert("forked_from".to_string(), serde_json::json!(source_agent_id.as_str()));
+    entry.insert(
+        "agent_id".to_string(),
+        serde_json::json!(as_agent_id.as_str()),
+    );
+    entry.insert(
+        "window".to_string(),
+        serde_json::json!(as_agent_id.as_str()),
+    );
+    entry.insert(
+        "forked_from".to_string(),
+        serde_json::json!(source_agent_id.as_str()),
+    );
     entry.insert(
         "spawn_cwd".to_string(),
         serde_json::json!(spawn_cwd.to_string_lossy().to_string()),
     );
-    entry.insert("pane_id".to_string(), serde_json::json!(spawn.pane_id.as_str()));
+    entry.insert(
+        "pane_id".to_string(),
+        serde_json::json!(spawn.pane_id.as_str()),
+    );
     if let Some(pid) = spawn.child_pid {
         entry.insert("pane_pid".to_string(), serde_json::json!(pid));
     }
-    for key in ["auth_mode", "model", "model_source", "profile", "_profile_dir", "role"] {
+    for key in [
+        "auth_mode",
+        "model",
+        "model_source",
+        "profile",
+        "_profile_dir",
+        "role",
+    ] {
         if let Some(value) = spec_agent.get(key) {
             entry.insert(key.to_string(), yaml_value_to_json(value));
         }
@@ -2602,9 +3075,15 @@ fn upsert_forked_agent_state(
     entry.insert("rollout_path".to_string(), serde_json::Value::Null);
     entry.insert("captured_at".to_string(), serde_json::Value::Null);
     entry.insert("captured_via".to_string(), serde_json::Value::Null);
-    entry.insert("attribution_confidence".to_string(), serde_json::Value::Null);
+    entry.insert(
+        "attribution_confidence".to_string(),
+        serde_json::Value::Null,
+    );
     persist_command_plan_state(&mut entry, plan, profile_launch);
-    agent_map.insert(as_agent_id.as_str().to_string(), serde_json::Value::Object(entry));
+    agent_map.insert(
+        as_agent_id.as_str().to_string(),
+        serde_json::Value::Object(entry),
+    );
     if let Some(entry) = agent_map
         .get_mut(as_agent_id.as_str())
         .and_then(serde_json::Value::as_object_mut)
@@ -2642,12 +3121,9 @@ pub(crate) fn ensure_owner_allowed_for_state(
         None,
     )
     .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    if let Some(refusal) = crate::state::owner_gate::check_team_owner(
-        state,
-        &caller,
-        false,
-        &NoopLiveness,
-    ) {
+    if let Some(refusal) =
+        crate::state::owner_gate::check_team_owner(state, &caller, false, &NoopLiveness)
+    {
         return Err(LifecycleError::OwnerRefused(refusal.to_string()));
     }
     Ok(())
@@ -2676,7 +3152,10 @@ fn initial_runtime_state(
         let Some(id) = agent.get("id").and_then(Value::as_str) else {
             continue;
         };
-        let provider = agent.get("provider").and_then(Value::as_str).unwrap_or("codex");
+        let provider = agent
+            .get("provider")
+            .and_then(Value::as_str)
+            .unwrap_or("codex");
         let role = agent.get("role").and_then(Value::as_str).unwrap_or(id);
         let model = agent.get("model").and_then(Value::as_str);
         let auth_mode = agent.get("auth_mode").and_then(Value::as_str);
@@ -2698,7 +3177,9 @@ fn initial_runtime_state(
         .get("runtime")
         .and_then(|runtime| runtime.get("display_backend"))
         .and_then(Value::as_str)
-        .and_then(|backend| serde_json::from_value::<DisplayBackend>(serde_json::json!(backend)).ok());
+        .and_then(|backend| {
+            serde_json::from_value::<DisplayBackend>(serde_json::json!(backend)).ok()
+        });
     let display_backend =
         crate::lifecycle::display::resolve_display_backend(requested_display, None).backend;
     let mut state = serde_json::Map::new();
@@ -2720,11 +3201,16 @@ fn initial_runtime_state(
     );
     state.insert(
         "leader".to_string(),
-        spec.get("leader").map(yaml_value_to_json).unwrap_or(serde_json::Value::Null),
+        spec.get("leader")
+            .map(yaml_value_to_json)
+            .unwrap_or(serde_json::Value::Null),
     );
     state.insert("agents".to_string(), serde_json::Value::Object(agents));
     state.insert("tasks".to_string(), spec_tasks_json(spec));
-    state.insert("display_backend".to_string(), serde_json::json!(display_backend));
+    state.insert(
+        "display_backend".to_string(),
+        serde_json::json!(display_backend),
+    );
     let mut state = serde_json::Value::Object(state);
     if !seed_launched_owner_from_env(&mut state) {
         let team_id = crate::state::projection::team_state_key(&state);
@@ -2800,9 +3286,7 @@ fn has_positive_caller_leader_env() -> bool {
 fn spec_tasks_json(spec: &Value) -> serde_json::Value {
     spec.get("tasks")
         .and_then(Value::as_list)
-        .map(|tasks| {
-            serde_json::Value::Array(tasks.iter().map(yaml_value_to_json).collect())
-        })
+        .map(|tasks| serde_json::Value::Array(tasks.iter().map(yaml_value_to_json).collect()))
         .unwrap_or_else(|| serde_json::json!([]))
 }
 
@@ -2841,7 +3325,10 @@ fn override_spec_session_name(spec: &mut Value, session_name: &str) {
             if let Some((_, existing)) = runtime.iter_mut().find(|(k, _)| k == "session_name") {
                 *existing = Value::Str(session_name.to_string());
             } else {
-                runtime.push(("session_name".to_string(), Value::Str(session_name.to_string())));
+                runtime.push((
+                    "session_name".to_string(),
+                    Value::Str(session_name.to_string()),
+                ));
             }
         }
         Some(other) => {
@@ -2863,12 +3350,22 @@ fn override_spec_session_name(spec: &mut Value, session_name: &str) {
 }
 
 fn spec_session_name(spec: &Value) -> SessionName {
-    let name = spec
+    if let Some(name) = spec
         .get("runtime")
         .and_then(|v| v.get("session_name"))
         .and_then(Value::as_str)
-        .unwrap_or("team-agent");
-    SessionName::new(name)
+        .filter(|name| !name.is_empty())
+    {
+        return SessionName::new(name);
+    }
+    // Python launch/core.py:56 — fallback derives from the team name, not a constant.
+    let team_name = spec
+        .get("team")
+        .and_then(|team| team.get("name"))
+        .and_then(Value::as_str)
+        .filter(|name| !name.is_empty())
+        .unwrap_or("agent");
+    SessionName::new(format!("team-{team_name}"))
 }
 
 fn spec_agents(spec: &Value) -> Vec<AgentId> {
@@ -2948,20 +3445,11 @@ fn disabled_dangerous_approval() -> DangerousApproval {
     }
 }
 
-pub(crate) fn effective_runtime_config_for_worker_spawn() -> Result<DangerousApproval, LifecycleError> {
+pub(crate) fn effective_runtime_config_for_worker_spawn(
+) -> Result<DangerousApproval, LifecycleError> {
     detect_dangerous_approval()
 }
 
-pub(crate) fn worker_tool_refs(
-    mut tools: Vec<String>,
-    safety: &DangerousApproval,
-) -> Vec<String> {
-    if safety.enabled && !tools.iter().any(|tool| tool == "dangerous_auto_approve") {
-        tools.push("dangerous_auto_approve".to_string());
-    }
-    tools
-}
-
 fn write_launch_permission_audit(
     workspace: &Path,
     safety: &DangerousApproval,
@@ -3019,6 +3507,5 @@ fn agent_id_exists_in_team_dir(team_dir: &Path, agent_id: &AgentId) -> bool {
         .exists()
 }
 
-
 mod plan;
 pub use plan::{handle_report_result, start_plan};