@team-agent/installer 0.3.3 → 0.3.5

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

@@ -40,6 +40,7 @@ pub(crate) mod profile_launch;
 pub(crate) mod profile_smoke;
 pub mod restart;
 pub mod types;
+pub(crate) mod worker_command_context;
 
 use std::collections::BTreeMap;
 use std::path::PathBuf;

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

@@ -385,6 +385,31 @@ fn provider_env_exports(
                 exports.insert("GEMINI_API_KEY".to_string(), value.to_string());
             }
         }
+        // C-A-4 cr verdict v2 — copilot BYOK(== compatible_api 档,help-providers 原文
+        // "GitHub authentication is not required" when COPILOT_PROVIDER_BASE_URL set):
+        // profile 值经 env_overlay 落 COPILOT_PROVIDER_BASE_URL/TYPE/API_KEY/WIRE_API
+        // + COPILOT_MODEL。BYOK 必须含 MODEL("A model is required for BYOK")—
+        // 这一硬性校验在 launch 路径处理(profile compile 时无法判别 model 来源)。
+        // Subscription/OfficialApi 不导出 COPILOT_PROVIDER_*(避免误改 auth 通道)。
+        Provider::Copilot => {
+            if auth_mode == AuthMode::CompatibleApi {
+                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_BASE_URL", "BASE_URL") {
+                    exports.insert("COPILOT_PROVIDER_BASE_URL".to_string(), value.to_string());
+                }
+                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_TYPE", "PROVIDER_TYPE") {
+                    exports.insert("COPILOT_PROVIDER_TYPE".to_string(), value.to_string());
+                }
+                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_API_KEY", "API_KEY") {
+                    exports.insert("COPILOT_PROVIDER_API_KEY".to_string(), value.to_string());
+                }
+                if let Some(value) = value_or_alternate(values, "COPILOT_PROVIDER_WIRE_API", "WIRE_API") {
+                    exports.insert("COPILOT_PROVIDER_WIRE_API".to_string(), value.to_string());
+                }
+                if let Some(value) = value_or_alternate(values, "COPILOT_MODEL", "MODEL") {
+                    exports.insert("COPILOT_MODEL".to_string(), value.to_string());
+                }
+            }
+        }
         Provider::Fake => {}
     }
     exports
@@ -412,6 +437,9 @@ fn provider_env_unsets(provider: Provider, auth_mode: AuthMode) -> BTreeSet<Stri
                 unsets.insert("GEMINI_API_KEY".to_string());
             }
         }
+        // C-7-1 cr verdict: 一期 subscription-only(已登录态),exports/unsets 空;
+        // BYOK(COPILOT_PROVIDER_*)二期立项时单独 cr verdict 再开。
+        Provider::Copilot => {}
         Provider::Fake => {}
     }
     unsets
@@ -429,7 +457,48 @@ fn provider_command_overrides(
         _ if agent.model.is_some() => agent.model.clone(),
         _ => profile_model(values).map(str::to_string),
     };
-    ProviderCommandOverrides { model }
+    let mut codex_profile = None;
+    let mut codex_config = Vec::new();
+    // Python provider_env.py:62-79 (_provider_command_overrides codex branch).
+    match agent.provider {
+        Provider::Codex => {
+            codex_profile = value_or_alternate(values, "CODEX_PROFILE", "NATIVE_PROFILE")
+                .map(str::to_string);
+            let model_provider = values.get("MODEL_PROVIDER").filter(|v| !v.is_empty());
+            let base_url = values.get("BASE_URL").filter(|v| !v.is_empty());
+            if agent.auth_mode == AuthMode::CompatibleApi {
+                if let (Some(model_provider), Some(base_url)) = (model_provider, base_url) {
+                    if safe_codex_provider_id(model_provider) {
+                        codex_config.push(format!("model_provider=\"{model_provider}\""));
+                        let prefix = format!("model_providers.{model_provider}");
+                        codex_config.push(format!("{prefix}.base_url=\"{base_url}\""));
+                        codex_config
+                            .push(format!("{prefix}.env_key=\"TEAM_AGENT_PROVIDER_API_KEY\""));
+                        if let Some(wire_api) = values.get("WIRE_API").filter(|v| !v.is_empty()) {
+                            codex_config.push(format!("{prefix}.wire_api=\"{wire_api}\""));
+                        }
+                        if let Some(name) = values.get("PROVIDER_NAME").filter(|v| !v.is_empty()) {
+                            codex_config.push(format!("{prefix}.name=\"{name}\""));
+                        }
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    ProviderCommandOverrides {
+        model,
+        codex_profile,
+        codex_config,
+    }
+}
+
+/// Python helpers.py:33-34 `_safe_codex_provider_id`: `[A-Za-z0-9_-]+`.
+fn safe_codex_provider_id(value: &str) -> bool {
+    !value.is_empty()
+        && value
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
 }
 
 fn write_runtime_env_file(
@@ -636,15 +705,48 @@ fn mcp_server_names(mcp_servers: &serde_json::Value) -> Vec<String> {
         .unwrap_or_default()
 }
 
+/// swallow batch 4 C1-C4 (MUST-NOT-9/13): a CORRUPT provider-config JSON fails
+/// EXPLICITLY — the old `unwrap_or_default` turned a parse failure into an empty map
+/// that the subsequent write flattened back over the user's file (silent destructive
+/// rewrite). A missing file stays Ok(empty) — only an existing-but-unparseable file
+/// errors, naming the path + parse detail + next action; the file is never touched.
 fn read_json_object(
     path: &Path,
 ) -> Result<serde_json::Map<String, serde_json::Value>, LifecycleError> {
-    let Ok(text) = std::fs::read_to_string(path) else {
-        return Ok(serde_json::Map::new());
+    let text = match std::fs::read_to_string(path) {
+        Ok(text) => text,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+            return Ok(serde_json::Map::new());
+        }
+        Err(error) => {
+            return Err(LifecycleError::RequirementUnmet(format!(
+                "profile_invalid_json: {} could not be read: {error}; fix or remove the file (or restore a backup) and relaunch",
+                path.display()
+            )));
+        }
     };
     match serde_json::from_str::<serde_json::Value>(&text) {
         Ok(serde_json::Value::Object(map)) => Ok(map),
-        Ok(_) | Err(_) => Ok(serde_json::Map::new()),
+        Ok(other) => Err(LifecycleError::RequirementUnmet(format!(
+            "profile_invalid_json: {} is not a JSON object (found {}); fix or remove the file (or restore a backup) and relaunch",
+            path.display(),
+            json_kind(&other)
+        ))),
+        Err(error) => Err(LifecycleError::RequirementUnmet(format!(
+            "profile_invalid_json: {} could not be parsed: {error}; fix or remove the file (or restore a backup) and relaunch",
+            path.display()
+        ))),
+    }
+}
+
+fn json_kind(value: &serde_json::Value) -> &'static str {
+    match value {
+        serde_json::Value::Null => "null",
+        serde_json::Value::Bool(_) => "a boolean",
+        serde_json::Value::Number(_) => "a number",
+        serde_json::Value::String(_) => "a string",
+        serde_json::Value::Array(_) => "an array",
+        serde_json::Value::Object(_) => "an object",
     }
 }
 
@@ -732,6 +834,9 @@ fn required_profile_keys(provider: Provider, auth_mode: AuthMode) -> &'static [&
             AuthMode::Subscription => &[],
         },
         Provider::GeminiCli => &["API_KEY"],
+        // C-7-1 cr verdict: copilot 一期 subscription-only,无 BYOK required key 集合;
+        // 二期 BYOK 立项时填(向后兼容字段保留)。
+        Provider::Copilot => &[],
         Provider::Fake => &[],
     }
 }
@@ -794,6 +899,7 @@ pub(crate) 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,

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

@@ -184,7 +184,9 @@ impl SmokeTarget {
                     kind: SmokeKind::OpenAi,
                 })
             }
-            Provider::GeminiCli | Provider::Fake => Err("unsupported_provider_smoke_skipped"),
+            // C-7-1 cr verdict: copilot 一期 subscription-only,无 BYOK HTTP smoke
+            // 入口;同 GeminiCli/Fake 走 unsupported_provider_smoke_skipped。
+            Provider::Copilot | Provider::GeminiCli | Provider::Fake => Err("unsupported_provider_smoke_skipped"),
         }
     }
 
@@ -508,6 +510,7 @@ fn provider_wire(provider: Provider) -> &'static str {
         Provider::Claude => "claude",
         Provider::ClaudeCode => "claude_code",
         Provider::Codex => "codex",
+        Provider::Copilot => "copilot",
         Provider::GeminiCli => "gemini_cli",
         Provider::Fake => "fake",
     }

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

@@ -451,10 +451,21 @@ fn write_start_agent_start_event(
     let adapter = crate::provider::get_adapter(provider);
     // Contract C / F6.4: event log must record the same context-aware argv that the
     // actual spawn used — so the role/tools/MCP context appears in `start_agent.agent_start`.
-    let role = agent.get("role").and_then(|v| v.as_str());
     let safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn()?;
-    let tools = crate::lifecycle::launch::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_json(
+            agent,
+            Some(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 mcp_config = adapter
         .mcp_config(auth_mode)
         .map_err(|e| LifecycleError::Provider(e.to_string()))?;
@@ -484,9 +495,9 @@ fn write_start_agent_start_event(
     let context = 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),
     };
     let mut plan = match session_id {

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

@@ -29,7 +29,6 @@ pub(super) fn spawn_agent_window(
     // Contract C / F6.4: thread compiled role/tools/MCP context through restart as well —
     // a restarted worker must come back up with the SAME callable MCP capability + role
     // prompt as a fresh launch, else `report_result` becomes unreachable after every restart.
-    let role = agent.get("role").and_then(|v| v.as_str());
     let detected_safety;
     let safety = if let Some(safety) = safety {
         safety
@@ -37,8 +36,20 @@ pub(super) fn spawn_agent_window(
         detected_safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn()?;
         &detected_safety
     };
-    let tools = crate::lifecycle::launch::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_json(
+            agent,
+            Some(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();
     // owner_team_id resolution: prefer the runtime-state row's `owner_team_id` (set by
     // launch/restart); fall back to the active team key for paths that don't write the
     // row first (e.g. add-agent calls spawn before upserting team metadata).
@@ -78,9 +89,9 @@ pub(super) fn spawn_agent_window(
     let context = 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),
     };
     let mut plan = match resume_session_id {
@@ -120,10 +131,25 @@ pub(super) fn spawn_agent_window(
                 .map(Path::new)
         })
         .unwrap_or(workspace);
+    let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
     let result = if into_existing_session {
-        transport.spawn_into(session_name, &window, &plan.argv, spawn_cwd, &env)
+        transport.spawn_into_with_env_unset(
+            session_name,
+            &window,
+            &plan.argv,
+            spawn_cwd,
+            &env,
+            &env_unset,
+        )
     } else {
-        transport.spawn_first(session_name, &window, &plan.argv, spawn_cwd, &env)
+        transport.spawn_first_with_env_unset(
+            session_name,
+            &window,
+            &plan.argv,
+            spawn_cwd,
+            &env,
+            &env_unset,
+        )
     };
     let spawn = result.map_err(|e| LifecycleError::Transport(e.to_string()))?;
     let _ = adapter.handle_startup_prompts(
@@ -319,24 +345,6 @@ pub(crate) fn restart_required_missing_session_agent_ids(state: &serde_json::Val
     missing.sort();
     missing
 }
-/// Tools list off an agent's runtime state entry (`tools: [...]`). Restart paths
-/// don't have the full spec object, only the runtime state — so they read tools from
-/// the state row, falling back to an empty list. Contract C requires the worker
-/// command be built with the tool list, even on restart.
-pub(super) fn agent_tool_strings(agent: &serde_json::Value) -> Vec<String> {
-    agent
-        .get("tools")
-        .and_then(|v| v.as_array())
-        .map(|items| {
-            items
-                .iter()
-                .filter_map(|v| v.as_str())
-                .map(str::to_string)
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
 pub(super) fn agent_window(agent: &serde_json::Value, agent_id: &AgentId) -> String {
     agent
         .get("window")
@@ -351,6 +359,7 @@ pub(super) 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,
@@ -362,6 +371,7 @@ pub(super) fn provider_wire(provider: Provider) -> &'static str {
         Provider::Claude => "claude",
         Provider::ClaudeCode => "claude_code",
         Provider::Codex => "codex",
+        Provider::Copilot => "copilot",
         Provider::GeminiCli => "gemini_cli",
         Provider::Fake => "fake",
     }

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

@@ -1,6 +1,6 @@
-use super::*;
 use super::common::*;
 use super::selection::classify_restart_plan;
+use super::*;
 
 // ── lifecycle::restart —— 整队 Route B resume-or-fresh 重建 ──────────────────
 
@@ -101,10 +101,9 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
     let mut state = selected.state;
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state, None)?;
-    let spec_workspace = selected
-        .spec_workspace
-        .as_ref()
-        .ok_or_else(|| LifecycleError::TeamSelect("active team spec workspace not found".to_string()))?;
+    let spec_workspace = selected.spec_workspace.as_ref().ok_or_else(|| {
+        LifecycleError::TeamSelect("active team spec workspace not found".to_string())
+    })?;
     let spec = load_team_spec(spec_workspace)?;
     let safety = crate::lifecycle::launch::effective_runtime_config(&spec)?;
     let mut convergence = converge_missing_provider_sessions(
@@ -236,10 +235,20 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     let coordinator_started = start_coordinator_for_workspace(&selected.run_workspace)?;
+    let attach_commands = crate::tmux_backend::attach_commands_for_windows(
+        &selected.run_workspace,
+        &session_name,
+        plan.decisions
+            .iter()
+            .map(|decision| decision.agent_id.as_str()),
+    );
+    let next_actions = attach_commands.clone();
     Ok(RestartReport::Restarted {
         session_name,
         agents: plan.decisions,
         coordinator_started,
+        next_actions,
+        attach_commands,
     })
 }
 
@@ -456,10 +465,7 @@ fn mark_leader_receiver_rebind_required(state: &mut serde_json::Value, session_n
         .and_then(|v| v.as_str())
         .is_some_and(|status| status == "attached")
     {
-        receiver.insert(
-            "status".to_string(),
-            serde_json::json!("rebind_required"),
-        );
+        receiver.insert("status".to_string(), serde_json::json!("rebind_required"));
     }
 }
 
@@ -520,11 +526,7 @@ fn mark_agent_respawned(
     if let Some(pane_pid) = pane_pid {
         agent.insert("pane_pid".to_string(), serde_json::json!(pane_pid));
     }
-    crate::lifecycle::launch::persist_command_plan_state(
-        agent,
-        &spawn.plan,
-        &spawn.profile_launch,
-    );
+    crate::lifecycle::launch::persist_command_plan_state(agent, &spawn.plan, &spawn.profile_launch);
     persist_effective_approval_policy_for_restart(agent, safety);
     agent.remove("startup_prompts");
     agent.remove("startup_prompt_status");
@@ -583,8 +585,7 @@ fn write_restart_resume_decision_event(
 
     let path = workspace.join(".team").join("logs").join("events.jsonl");
     if let Some(parent) = path.parent() {
-        std::fs::create_dir_all(parent)
-            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        std::fs::create_dir_all(parent).map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     }
     let mut event = serde_json::json!({
         "ts": chrono::Utc::now().to_rfc3339(),
@@ -615,8 +616,8 @@ fn write_restart_resume_decision_event(
             }
         }
     }
-    let line = serde_json::to_string(&event)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    let line =
+        serde_json::to_string(&event).map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     let mut file = std::fs::OpenOptions::new()
         .create(true)
         .append(true)
@@ -667,7 +668,10 @@ pub fn select_restart_state(
         .get("active_team_key")
         .and_then(serde_json::Value::as_str)
         .filter(|s| !s.is_empty())
-        .map_or_else(|| crate::state::projection::team_state_key(&selected), str::to_string);
+        .map_or_else(
+            || crate::state::projection::team_state_key(&selected),
+            str::to_string,
+        );
     Ok(restart_candidate_from_state(workspace, &key, &selected))
 }
 
@@ -733,12 +737,14 @@ fn restart_candidate_has_context(state: &serde_json::Value) -> bool {
         .and_then(serde_json::Value::as_object)
         .is_some_and(|agents| {
             agents.values().any(|agent| {
-                ["session_id", "rollout_path", "first_send_at"].iter().any(|key| {
-                    agent
-                        .get(*key)
-                        .and_then(serde_json::Value::as_str)
-                        .is_some_and(|s| !s.is_empty())
-                })
+                ["session_id", "rollout_path", "first_send_at"]
+                    .iter()
+                    .any(|key| {
+                        agent
+                            .get(*key)
+                            .and_then(serde_json::Value::as_str)
+                            .is_some_and(|s| !s.is_empty())
+                    })
             })
         })
 }

package/crates/team-agent/src/lifecycle/tests/agent_ops.rs

@@ -90,7 +90,7 @@ fn lanea_stop_agent_unknown_agent_is_unknown_worker_not_owner_refused() {
 #[test]
 fn lanea_fork_agent_unknown_source_is_unknown_worker_before_session_check() {
     let ws = lanea_team_ws("stopped");
-    let text = format!("{:?}", fork_agent(&ws, &aid("ghost"), &aid("newfork"), false, None));
+    let text = format!("{:?}", fork_agent(&ws, &aid("ghost"), &aid("newfork"), None, false, None));
     assert!(
         text.contains("unknown worker"),
         "fork_agent must reject an UNKNOWN source as 'unknown worker agent id: ghost' BEFORE the session-id \
@@ -105,7 +105,7 @@ fn lanea_fork_agent_unknown_source_is_unknown_worker_before_session_check() {
 fn lanea_fork_agent_duplicate_target_is_already_exists_before_session_check() {
     let ws = lanea_team_ws("stopped");
     // target 'bravo' already exists in the spec -> duplicate; source 'alpha' exists (its session_id is irrelevant).
-    let text = format!("{:?}", fork_agent(&ws, &aid("alpha"), &aid("bravo"), false, None));
+    let text = format!("{:?}", fork_agent(&ws, &aid("alpha"), &aid("bravo"), None, false, None));
     assert!(
         text.contains("already exists"),
         "fork_agent must reject a DUPLICATE target 'bravo' as 'agent id already exists' BEFORE the session-id \

package/crates/team-agent/src/lifecycle/tests/core.rs

@@ -185,14 +185,14 @@ fn plan_condition_rejects_out_of_grammar() {
 
 // ───────────────────────────────────────────────────────────────────────
 // resolve_display_backend — display/backend.py
-// 默认 adaptive;非默认非静默(non_default=true 触发 display.backend_resolved)。
+// 默认 none;非默认非静默(non_default=true 触发 display.backend_resolved)。
 // ───────────────────────────────────────────────────────────────────────
 
 #[test]
-fn resolve_backend_defaults_to_adaptive_when_none_requested() {
+fn resolve_backend_defaults_to_none_when_none_requested() {
     let r = resolve_display_backend(None, None);
-    assert_eq!(r.backend, DisplayBackend::Adaptive);
-    assert!(!r.non_default, "默认 adaptive 不应标记 non_default");
+    assert_eq!(r.backend, DisplayBackend::None);
+    assert!(!r.non_default, "默认 none 不应标记 non_default");
 }
 
 #[test]
@@ -841,7 +841,7 @@ fn close_team_display_empty_workspace_closes_nothing_not_error() {
 #[test]
 fn fork_agent_on_unowned_workspace_does_not_silently_fork() {
     let ws = temp_ws();
-    match fork_agent(&ws, &aid("src"), &aid("dst"), false, None) {
+    match fork_agent(&ws, &aid("src"), &aid("dst"), None, false, None) {
         // 允许:owner 门 / team 选择 / 缺 spec(provider 命令构造前的上游门)。
         Err(LifecycleError::OwnerRefused(_))
         | Err(LifecycleError::TeamSelect(_))

package/crates/team-agent/src/lifecycle/tests/lane_ops.rs

@@ -464,7 +464,7 @@ fn lanea_remove_rollback_restores_via_spec_state_file_path() {
 fn lanea_fork_dup_target_leader_id_is_already_exists() {
     let ws = fork_ws(DELEG_ROLE_ALPHA);
     let tx = LaneTransport::new("team-laneateam", &[]);
-    let text = format!("{:?}", fork_agent_with_transport(&ws, &aid("alpha"), &aid("leader"), false, None, &tx));
+    let text = format!("{:?}", fork_agent_with_transport(&ws, &aid("alpha"), &aid("leader"), None, false, None, &tx));
     assert!(
         text.contains("already exists"),
         "golden operations.py:301-302 (_find_agent matches the leader): forking ONTO the leader id must raise \
@@ -481,7 +481,7 @@ fn lanea_fork_dup_target_leader_id_is_already_exists() {
 fn lanea_fork_window_already_exists_guard_before_spec_mutation() {
     let ws = fork_ws(DELEG_ROLE_ALPHA);
     let tx = LaneTransport::new("team-laneateam", &["newfork"]); // the target window already exists
-    let text = format!("{:?}", fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), false, None, &tx));
+    let text = format!("{:?}", fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx));
     assert!(
         text.contains("tmux window already exists for fork target: team-laneateam:newfork"),
         "golden operations.py:310-312: a pre-existing target window must raise 'tmux window already exists for \
@@ -505,7 +505,7 @@ fn lanea_fork_window_already_exists_guard_before_spec_mutation() {
 fn lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm() {
     let ws = fork_ws(DELEG_ROLE_ALPHA_COMPAT); // source alpha auth_mode=compatible_api -> native fork unsupported
     let tx = LaneTransport::new("team-laneateam", &[]);
-    let result = fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), false, None, &tx);
+    let result = fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx);
     let text = format!("{result:?}");
     assert!(
         text.contains("codex does not support native session fork"),
@@ -530,7 +530,7 @@ fn lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm() {
 fn lanea_fork_report_session_id_is_not_pane_id() {
     let ws = fork_ws(DELEG_ROLE_ALPHA); // codex+subscription -> native fork supported -> full success path
     let tx = LaneTransport::new("team-laneateam", &[]);
-    let report = fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), false, None, &tx).expect("fork ok (codex subscription supports fork)");
+    let report = fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx).expect("fork ok (codex subscription supports fork)");
     assert_ne!(
         report.session_id,
         Some(crate::provider::SessionId::new("%newfork")),

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -226,6 +226,7 @@ fn fork_agent_proceeds_past_owner_gate_for_unowned_workspace() {
         &ws,
         &AgentId::new("w1"),
         &AgentId::new("w1-fork"),
+        None,
         false,
         None,
         &transport,
@@ -886,8 +887,8 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
     );
     assert_eq!(
         state["display_backend"],
-        json!("adaptive"),
-        "golden resolve_display_backend(None, source='launch') defaults to adaptive"
+        json!("none"),
+        "golden resolve_display_backend(None, source='launch') defaults to none"
     );
 }
 
@@ -960,7 +961,8 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
     assert!(agent["captured_at"].is_null());
     assert!(agent["captured_via"].is_null());
     assert!(agent["attribution_confidence"].is_null());
-    assert_eq!(agent["spawn_cwd"], json!(team.to_string_lossy()));
+    // D5 (#264) / Python launch/core.py:253 — fresh launch persists spawn_cwd=workspace.
+    assert_eq!(agent["spawn_cwd"], json!(workspace.to_string_lossy()));
     assert_eq!(agent["spawned_at"], json!(FIXED_SPAWNED_AT));
     assert_eq!(
         agent["pane_id"],

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

@@ -483,6 +483,8 @@ pub enum QuickStartReport {
         session_name: SessionName,
         launch: Box<LaunchReport>,
         next_actions: Vec<String>,
+        attach_commands: Vec<String>,
+        display_backend: String,
         /// BUG-7: real readiness verdict. `Ready` ⇒ the wrapper completed AND the
         /// caller already verified tool-set availability; the framework itself
         /// never emits this without an external observable confirming worker
@@ -613,6 +615,8 @@ pub enum RestartReport {
         session_name: SessionName,
         agents: Vec<RestartedAgent>,
         coordinator_started: bool,
+        next_actions: Vec<String>,
+        attach_commands: Vec<String>,
     },
     /// atomic refusal(`reason=resume_atomicity`):某 interacted worker 不可 resume
     /// 且非 allow_fresh。**nothing created yet**,无需回滚。