@team-agent/installer 0.5.112 → 0.5.114

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

@@ -100,7 +100,7 @@ pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline
 // timer + worker timing writer so `lifecycle::launch::launch_with_transport_in_workspace`
 // can emit the same instrumentation event family with `source="launch"`.
 pub(crate) use rebuild::{
-    provider_wire_from_state, write_worker_spawn_timing_event, RestartPhaseTimer,
+    provider_wire_from_state, write_worker_spawn_timing_event, LifecyclePhase, RestartPhaseTimer,
 };
 pub use rebuild::{restart, restart_with_session_convergence_deadline};
 pub(crate) use rebuild::{

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

@@ -165,14 +165,15 @@ fn purge_agent_help_and_dispatch_are_consistent() {
         output_text(&case.run(["purge-agent", "ghost", "--workspace", case.ws(), "--json"]));
     if help.contains("purge-agent") {
         assert!(
-            !command.contains("invalid choice") && !command.contains("unknown subcommand") && !command.contains("Commands:"),
+            !command.contains("invalid choice") && !command.contains("unknown subcommand")
+                && !command.contains("Unknown command:") && !command.contains("Commands:"),
             "RED6: help exposes purge-agent, so dispatch must be real or the command must be removed from help; help={help} command={command}"
         );
     } else {
         assert!(
             command.contains("unknown subcommand")
                 || command.contains("invalid choice")
-                || command.contains("没有这个操作"),
+                || command.contains("Unknown command:"),
             "RED6: if purge-agent is not implemented, help and dispatch must agree it is absent; help={help} command={command}"
         );
     }

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

@@ -433,8 +433,11 @@ pub enum LifecycleError {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct LaunchReport {
     pub session_name: SessionName,
-    /// 实际起的 worker(冷启;dry-run 时空)。
+    /// Legacy transport starts; their targets belong to the team transport.
     pub started: Vec<StartedAgent>,
+    /// Committed contract starts, without fabricating legacy pane/window targets.
+    /// Empty on dry-run; populated only after the contract startup returns success.
+    pub contract_started: Vec<AgentId>,
     /// 是否 dry-run(只解析路由/权限,不起进程)。
     pub dry_run: bool,
     /// Selected tmux endpoint for the team transport when known.

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

@@ -63,16 +63,16 @@ pub(crate) struct WorkerCommandAgent {
 }
 
 impl WorkerCommandAgent {
-/// ---
-/// purpose: 从 spec 的 YAML agent 节点读出命令上下文
-/// params:
-///   agent: 单个 agent 的 YAML 节点
-///   fallback_id: agent 节点没写 id 时的兜底 id
-///   provider: 已解析的 provider
-/// returns: 填好的 WorkerCommandAgent
-/// errors: communication_mode 取值非法时返回 LifecycleError
-/// contract_id: lifecycle.worker_command_agent.from_source
-/// ---
+    /// ---
+    /// purpose: 从 spec 的 YAML agent 节点读出命令上下文
+    /// params:
+    ///   agent: 单个 agent 的 YAML 节点
+    ///   fallback_id: agent 节点没写 id 时的兜底 id
+    ///   provider: 已解析的 provider
+    /// returns: 填好的 WorkerCommandAgent
+    /// errors: communication_mode 取值非法时返回 LifecycleError
+    /// contract_id: lifecycle.worker_command_agent.from_source
+    /// ---
     pub(crate) fn from_yaml(
         agent: &crate::model::yaml::Value,
         fallback_id: Option<&str>,
@@ -117,16 +117,16 @@ impl WorkerCommandAgent {
         })
     }
 
-/// ---
-/// purpose: 从 runtime state 的 JSON agent 节点读出命令上下文
-/// params:
-///   agent: 单个 agent 的 JSON 节点
-///   fallback_id: agent 节点没写 id 时的兜底 id
-///   provider: 已解析的 provider
-/// returns: 填好的 WorkerCommandAgent
-/// errors: communication_mode 取值非法时返回 LifecycleError
-/// contract_id: lifecycle.worker_command_agent.from_source
-/// ---
+    /// ---
+    /// purpose: 从 runtime state 的 JSON agent 节点读出命令上下文
+    /// params:
+    ///   agent: 单个 agent 的 JSON 节点
+    ///   fallback_id: agent 节点没写 id 时的兜底 id
+    ///   provider: 已解析的 provider
+    /// returns: 填好的 WorkerCommandAgent
+    /// errors: communication_mode 取值非法时返回 LifecycleError
+    /// contract_id: lifecycle.worker_command_agent.from_source
+    /// ---
     pub(crate) fn from_json(
         agent: &serde_json::Value,
         fallback_id: Option<&str>,
@@ -190,7 +190,8 @@ pub(crate) fn compile_worker_system_prompt(
         mcp_tool_name(agent.provider, "team_orchestrator", "get_team_status")
     );
     let report_result = mcp_tool_name(agent.provider, "team_orchestrator", "report_result");
-    let runtime_contract = runtime_contract_section(&send_message, &report_result, &get_team_status);
+    let runtime_contract =
+        runtime_contract_section(&send_message, &report_result, &get_team_status);
     let communication_contract = agent.communication_mode.runtime_contract(&send_message);
     let mut chunks = vec![
         identity_section(agent),
@@ -235,7 +236,7 @@ fn mcp_tool_name(provider: Provider, server: &str, tool: &str) -> String {
     }
 }
 
-fn runtime_contract_section(
+pub(crate) fn runtime_contract_section(
     send_message: &str,
     report_result: &str,
     get_team_status: &str,
@@ -255,10 +256,15 @@ fn communication_mode(value: Option<&str>) -> Result<CommunicationMode, Lifecycl
 }
 
 fn identity_section(agent: &WorkerCommandAgent) -> String {
-    format!(
-        "You are Team Agent worker `{}` with role `{}`. When asked about your role or identity, answer with this Team Agent worker identity first, not only the generic provider product identity.",
+    worker_identity_section(
         agent.id.as_deref().unwrap_or("unknown"),
-        agent.role.as_deref().unwrap_or("developer")
+        agent.role.as_deref().unwrap_or("developer"),
+    )
+}
+
+pub(crate) fn worker_identity_section(id: &str, role: &str) -> String {
+    format!(
+        "You are Team Agent worker `{id}` with role `{role}`. When asked about your role or identity, answer with this Team Agent worker identity first, not only the generic provider product identity."
     )
 }
 
@@ -344,7 +350,9 @@ mod tests {
                     "Do not reply to pure ACKs, greetings, or unchanged status notices (such as \"paused\" or \"waiting\"); after reporting a blocker once or completing a task, remain silent until a new actionable instruction arrives."
                 ));
                 assert!(!prompt.contains("Silence and resumption (mandatory)"));
-                assert!(!prompt.contains("When you receive a message from the leader or a teammate, you MUST respond"));
+                assert!(!prompt.contains(
+                    "When you receive a message from the leader or a teammate, you MUST respond"
+                ));
                 match mode {
                     CommunicationMode::LeaderCentric => {
                         assert!(prompt.contains(
@@ -352,7 +360,9 @@ mod tests {
                         ));
                     }
                     CommunicationMode::Orchestrated => {
-                        assert!(prompt.contains("Respond to task-related messages through Team Agent MCP tools."));
+                        assert!(prompt.contains(
+                            "Respond to task-related messages through Team Agent MCP tools."
+                        ));
                         assert!(prompt.contains("A pure ACK, unrelated status, or non-task message does not require a response."));
                     }
                 }

package/crates/team-agent/src/main.rs

@@ -5,6 +5,12 @@ fn main() -> anyhow::Result<()> {
         .skip(1)
         .map(|arg| arg.to_string_lossy().into_owned());
     let command = args.next();
+    #[cfg(unix)]
+    if matches!(command.as_deref(), Some("contract-mcp")) {
+        team_agent::contract_runtime::mcp::run(&args.collect::<Vec<_>>())
+            .map_err(|error| anyhow::anyhow!(error.to_string()))?;
+        return Ok(());
+    }
     if matches!(command.as_deref(), Some("fake-worker")) {
         let mut workspace = None;
         let mut agent_id = None;

package/crates/team-agent/src/messaging/delivery.rs

@@ -1926,7 +1926,11 @@ fn delivery_transport_for_recipient<'a>(
         }
         return DeliveryTransport::Borrowed(product_transport);
     };
-    if socket == crate::tmux_backend::socket_name_for_workspace(workspace) {
+    // An exact endpoint match can reuse the supplied channel; do not select
+    // another server merely because it has a pane with the same numeric id.
+    if product_transport.tmux_endpoint().as_deref() == Some(socket)
+        || socket == crate::tmux_backend::socket_name_for_workspace(workspace)
+    {
         DeliveryTransport::Borrowed(product_transport)
     } else {
         // 0.5.4 gate054 cross-team leak fix: when `leader_receiver.tmux_socket`
@@ -2523,6 +2527,51 @@ pub(crate) fn recipient_is_busy(state: &serde_json::Value, recipient: &str) -> b
 }
 
 fn leader_rollout_path(state: &serde_json::Value) -> Option<std::path::PathBuf> {
+    if let Some(receiver) = leader_receiver_value(state).filter(|receiver| {
+        receiver.get("provider").and_then(serde_json::Value::as_str) == Some("pi")
+            && receiver.get("native_session").is_some()
+    }) {
+        let native = receiver.get("native_session")?;
+        for key in ["pane_id", "tmux_socket", "leader_session_uuid", "owner_epoch"] {
+            let bound = native.get(key)?;
+            if bound.is_null() || receiver.get(key) != Some(bound) {
+                return None;
+            }
+        }
+        // Managed Pi's native ID is distinct from leader_session_uuid.
+        // The JSONL appears asynchronously. Resolve only inside the recorded
+        // root, by exact id/cwd/spawn time; ambiguity or an unknown
+        // NativeDefault root stays unavailable (no HOME scan).
+        let context = crate::provider::CaptureSessionContext {
+            agent_id: "leader".into(),
+            spawn_cwd: native.get("spawn_cwd")?.as_str()?.into(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some(native.get("spawned_at")?.as_str()?.into()),
+            expected_session_id: Some(crate::provider::SessionId::new(
+                native.get("expected_session_id")?.as_str()?,
+            )),
+            provider_projects_root: Some(native.get("provider_projects_root")?.as_str()?.into()),
+        };
+        if !context.spawn_cwd.is_absolute()
+            || !context.provider_projects_root.as_ref()?.is_absolute()
+        {
+            return None;
+        }
+        let candidates = crate::provider::session_scan::scan_session_candidates_once(
+            Provider::Pi,
+            &context,
+        )
+        .ok()?;
+        return match candidates.as_slice() {
+            [candidate] => candidate
+                .captured
+                .rollout_path
+                .as_ref()
+                .map(|path| path.as_path().to_path_buf()),
+            _ => None,
+        };
+    }
     state
         .get("leader")
         .and_then(|leader| leader.get("rollout_path"))

package/crates/team-agent/src/messaging/send.rs

@@ -265,6 +265,16 @@ pub fn send_message(
             }
         }
     }
+    #[cfg(unix)]
+    if state
+        .get("agents")
+        .and_then(|agents| agents.get(recipient))
+        .is_some_and(crate::contract_runtime::framework::is_contract)
+    {
+        return crate::contract_runtime::framework::enqueue(
+            workspace, &state, recipient, content, opts,
+        );
+    }
     let stale_worker_target_missing =
         stale_worker_target_missing_preflight(workspace, &state, recipient)?;
     let coordinator_unavailable = if stale_worker_target_missing {

package/crates/team-agent/src/messaging/tests/leader_inject_acceptance.rs

@@ -77,6 +77,131 @@ fn tmux_leader_submit_without_provider_receipt_stays_pending_then_accepts_same_r
     assert!(case.delivery_consumed_at(&message_id).is_some());
 }
 
+fn pi_receipt_case(tag: &str) -> (Case, serde_json::Value) {
+    let mut case = Case::new_without_rollout(tag);
+    let root = case.workspace.join("pi-sessions");
+    std::fs::create_dir_all(&root).unwrap();
+    case.rollout = root.join("not-derived-from-the-session-id.jsonl");
+    let receiver = &mut case.state["leader_receiver"];
+    receiver["provider"] = serde_json::json!("pi");
+    receiver["tmux_socket"] = serde_json::json!(case.workspace.join("fixture-tmux.sock"));
+    receiver["leader_session_uuid"] = serde_json::json!("team-owner-not-native-id");
+    receiver["owner_epoch"] = serde_json::json!(1);
+    receiver["native_session"] = serde_json::json!({
+        "expected_session_id": "native-pi-session",
+        "provider_projects_root": root,
+        "spawn_cwd": case.workspace,
+        "spawned_at": "2026-10-10T03:59:07Z",
+        "pane_id": "%leader",
+        "tmux_socket": receiver["tmux_socket"],
+        "leader_session_uuid": "team-owner-not-native-id",
+        "owner_epoch": 1,
+    });
+    crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+    let header = serde_json::json!({
+        "type": "session", "version": 3, "id": "native-pi-session",
+        "cwd": case.workspace, "timestamp": "2026-10-10T03:59:08Z",
+    });
+    (case, header)
+}
+
+#[test]
+fn pi_leader_receipt_binds_exact_header_and_consumes_without_reinjection() {
+    let (case, header) = pi_receipt_case("pi-native-receipt");
+    let endpoint = case.state["leader_receiver"]["tmux_socket"].as_str().unwrap();
+    assert!(Path::new(endpoint).is_absolute());
+    let unbound = crate::messaging::resolve_live_leader_channel(
+        &case.workspace,
+        &case.state["leader_receiver"],
+        &RecordingTransport::new(""),
+    );
+    assert!(
+        matches!(
+            unbound,
+            crate::messaging::LeaderChannelResolution::Unbound(
+                crate::messaging::LeaderChannelUnbound::EndpointMismatch
+            )
+        ),
+        "{unbound:?}"
+    );
+    let transport = RecordingTransport {
+        endpoint: Some(endpoint.to_string()),
+        ..RecordingTransport::new("")
+    };
+    let message_id = case.seed_message("Pi receipt canary");
+    std::fs::write(&case.rollout, format!("{header}\n")).unwrap();
+    let first = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    )
+    .unwrap();
+    assert!(first.ok, "{first:?}");
+    assert_eq!(
+        case.message_status(&message_id),
+        "submitted_pending_acceptance"
+    );
+    assert_eq!(transport.inject_count(), 1);
+
+    let received = serde_json::json!({
+        "type": "message", "message": {"role": "user", "content": [
+            {"type": "text", "text": format!("5535 [team-agent-token:{message_id}]")}
+        ]}
+    });
+    std::fs::write(&case.rollout, format!("{header}\n{received}\n")).unwrap();
+    let second = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    )
+    .unwrap();
+    assert!(second.ok, "{second:?}");
+    assert_eq!(case.message_status(&message_id), "delivered");
+    assert!(case.delivery_consumed_at(&message_id).is_some());
+    assert_eq!(transport.inject_count(), 1);
+}
+
+#[test]
+fn pi_leader_receipt_refuses_missing_ambiguous_stale_and_other_owner_backing() {
+    use crate::messaging::delivery::{observe_leader_receipt, LeaderReceiptObservation::*};
+    let (mut case, header) = pi_receipt_case("pi-native-receipt-fences");
+    let old = case.workspace.join("old-leader.jsonl");
+    std::fs::write(&old, "[team-agent-token:canary]").unwrap();
+    case.state["leader"] = serde_json::json!({"rollout_path": old});
+    // An old root leader receipt cannot substitute for this native session.
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+    for (field, value) in [
+        ("id", serde_json::json!("another-session")),
+        ("cwd", serde_json::json!(case.workspace.join("other"))),
+        ("timestamp", serde_json::json!("2026-10-10T03:59:06Z")),
+    ] {
+        let mut wrong = header.clone();
+        wrong[field] = value;
+        std::fs::write(&case.rollout, format!("{wrong}\n[team-agent-token:canary]\n")).unwrap();
+        assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+    }
+    std::fs::write(&case.rollout, format!("{header}\n")).unwrap();
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), TokenAbsent);
+    let duplicate = case.rollout.with_file_name("duplicate.jsonl");
+    std::fs::write(&duplicate, format!("{header}\n[team-agent-token:canary]\n")).unwrap();
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+    std::fs::remove_file(duplicate).unwrap();
+    for key in ["pane_id", "tmux_socket", "leader_session_uuid", "owner_epoch"] {
+        let mut moved = case.state.clone();
+        moved["leader_receiver"][key] = serde_json::json!("changed");
+        assert_eq!(observe_leader_receipt(&moved, "canary"), SourceUnavailable);
+    }
+    case.state["leader_receiver"]["native_session"]["provider_projects_root"] =
+        serde_json::Value::Null;
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+}
+
 #[test]
 fn attached_leader_mailbox_is_rechecked_by_the_normal_delivery_tick() {
     let case = Case::new("mailbox");
@@ -428,6 +553,7 @@ impl Case {
 struct RecordingTransport {
     injects: Arc<AtomicUsize>,
     capture: Arc<Mutex<String>>,
+    endpoint: Option<String>,
 }
 
 impl RecordingTransport {
@@ -435,6 +561,7 @@ impl RecordingTransport {
         Self {
             injects: Arc::new(AtomicUsize::new(0)),
             capture: Arc::new(Mutex::new(capture.to_string())),
+            endpoint: None,
         }
     }
 
@@ -444,6 +571,10 @@ impl RecordingTransport {
 }
 
 impl Transport for RecordingTransport {
+    fn tmux_endpoint(&self) -> Option<String> {
+        self.endpoint.clone()
+    }
+
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
     }

package/crates/team-agent/src/model/spec.rs

@@ -16,8 +16,8 @@ use crate::model::enums::TaskStatus;
 use crate::model::errors::ModelError;
 use crate::model::ids::TaskId;
 use crate::model::task_graph::{find_dependency_cycle, TaskNode};
-use crate::model::yaml::Value as Yaml;
 use crate::model::yaml;
+use crate::model::yaml::Value as Yaml;
 use crate::provider::wire::parse_canonical_provider;
 
 const LEGACY_DISPLAY_KEY: &str = concat!("display", "_backend");
@@ -733,10 +733,13 @@ fn semantic_errors(spec: &Yaml, base_dir: &Path) -> Vec<String> {
 
     for (idx, agent) in agents.iter().enumerate() {
         let provider = agent.get("provider");
-        if !provider
-            .and_then(Yaml::as_str)
-            .is_some_and(|p| parse_canonical_provider(p).is_some())
-        {
+        if !provider.and_then(Yaml::as_str).is_some_and(|p| {
+            #[cfg(unix)]
+            if crate::contract_runtime::registry::descriptor(p).is_some() {
+                return true;
+            }
+            parse_canonical_provider(p).is_some()
+        }) {
             e.push(format!(
                 "/agents/{idx}/provider: unknown provider {}",
                 py_repr(provider)
@@ -1066,7 +1069,11 @@ mod tests {
             .iter()
             .filter(|m| m.starts_with("/agents/dangerously_skip_permissions: missing"))
             .collect();
-        assert_eq!(missing.len(), 1, "exactly one missing-field error, got: {errors:#?}");
+        assert_eq!(
+            missing.len(),
+            1,
+            "exactly one missing-field error, got: {errors:#?}"
+        );
         assert!(
             missing[0].contains("`codex_implementer`"),
             "must name the role id, got: {}",
@@ -1083,7 +1090,11 @@ mod tests {
     #[test]
     fn test_invalid_dangerously_type_rejected() {
         let text = include_str!("testdata/team.spec.yaml");
-        let bad = text.replacen("    dangerously_skip_permissions: false\n", "    dangerously_skip_permissions: \"yes\"\n", 1);
+        let bad = text.replacen(
+            "    dangerously_skip_permissions: false\n",
+            "    dangerously_skip_permissions: \"yes\"\n",
+            1,
+        );
         assert_ne!(text, bad, "fixture must contain the field");
         let spec = yaml::loads(&bad).unwrap();
         let errors = all_spec_errors(&spec);
@@ -1091,7 +1102,11 @@ mod tests {
             .iter()
             .filter(|m| m.starts_with("/agents/dangerously_skip_permissions: must be a boolean"))
             .collect();
-        assert_eq!(type_errs.len(), 1, "exactly one type error, got: {errors:#?}");
+        assert_eq!(
+            type_errs.len(),
+            1,
+            "exactly one type error, got: {errors:#?}"
+        );
         assert!(
             type_errs[0].contains("`codex_implementer`"),
             "must name the role id, got: {}",
@@ -1139,10 +1154,7 @@ mod tests {
     // 缺失 role frontmatter 值时编译为安全默认 false；此处锁定公共编译入口的结果。
     #[test]
     fn test_all_7_triggers_use_compiled_default_bypass() {
-        let team = std::env::temp_dir().join(format!(
-            "ta-spec-7trigger-{}",
-            std::process::id()
-        ));
+        let team = std::env::temp_dir().join(format!("ta-spec-7trigger-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&team);
         std::fs::create_dir_all(team.join("agents")).unwrap();
         std::fs::write(

package/crates/team-agent/src/provider/adapter.rs

@@ -300,6 +300,10 @@ pub fn get_adapter(p: Provider) -> Box<dyn ProviderAdapter> {
     Box::new(BasicProviderAdapter { provider: p })
 }
 
+#[cfg(test)]
+#[path = "tests/command_helpers.rs"]
+mod command_helpers_tests;
+
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct BasicProviderAdapter {
     provider: Provider,
@@ -480,22 +484,13 @@ impl ProviderAdapter for BasicProviderAdapter {
                 Ok(argv)
             }
             Provider::Grok => Ok(grok_launch_command(
-                self,
-                auth_mode,
-                mcp_config,
                 system_prompt,
                 model,
                 dangerously_skip_permissions,
             )?),
             Provider::CursorAgent => Ok(cursor_agent_base_command(
-                self,
-                auth_mode,
-                mcp_config,
-                system_prompt,
                 model,
                 dangerously_skip_permissions,
-                false,
-                None,
             )?),
             Provider::Pi => Err(ProviderError::Command(
                 "Pi commands require the shared lifecycle materializer".to_string(),
@@ -596,14 +591,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                 // never written and restart could not resume.
                 let expected = next_session_token();
                 let mut argv = grok_base_command(
-                    self,
-                    ctx.auth_mode,
-                    ctx.mcp_config,
                     ctx.system_prompt,
                     ctx.model,
                     ctx.dangerously_skip_permissions,
-                    ctx.profile_launch
-                        .is_some_and(|profile| profile.managed_mcp_config),
                     ctx.effort,
                 )?;
                 argv.push("--session-id".to_string());
@@ -637,15 +627,8 @@ impl ProviderAdapter for BasicProviderAdapter {
                 // U-01 create-chat 无登录超时；禁止发明 --session-id。
                 // pending 只能是 CLI chatId，本拍不造假 uuid。
                 let argv = cursor_agent_base_command(
-                    self,
-                    ctx.auth_mode,
-                    ctx.mcp_config,
-                    ctx.system_prompt,
                     ctx.model,
                     ctx.dangerously_skip_permissions,
-                    ctx.profile_launch
-                        .is_some_and(|profile| profile.managed_mcp_config),
-                    ctx.effort,
                 )?;
                 Ok(CommandPlan {
                     argv,
@@ -816,7 +799,7 @@ impl ProviderAdapter for BasicProviderAdapter {
             // copilot --resume 接受 id|name)。
             Provider::Copilot => {
                 let mut argv =
-                    copilot_base_command_resume(auth_mode, mcp_config, system_prompt, model, dangerously_skip_permissions);
+                    copilot_base_command(auth_mode, mcp_config, system_prompt, model, dangerously_skip_permissions);
                 argv.push("--resume".to_string());
                 argv.push(session_id.as_str().to_string());
                 Ok(argv)
@@ -824,13 +807,9 @@ impl ProviderAdapter for BasicProviderAdapter {
             // Grok resume: base + `--resume <id>` (grok -r/--resume 接受 id|title)。
             Provider::Grok => {
                 let mut argv = grok_base_command(
-                    self,
-                    auth_mode,
-                    mcp_config,
                     system_prompt,
                     model,
                     dangerously_skip_permissions,
-                    false,
                     None,
                 )?;
                 argv.push("--resume".to_string());
@@ -839,16 +818,7 @@ impl ProviderAdapter for BasicProviderAdapter {
             }
             // Cursor resume: base + `--resume <chatId>`。
             Provider::CursorAgent => {
-                let mut argv = cursor_agent_base_command(
-                    self,
-                    auth_mode,
-                    mcp_config,
-                    system_prompt,
-                    model,
-                    dangerously_skip_permissions,
-                    false,
-                    None,
-                )?;
+                let mut argv = cursor_agent_base_command(model, dangerously_skip_permissions)?;
                 // Put --resume immediately after `agent` so the CLI treats it as
                 // the session mode rather than a trailing flag after --workspace.
                 argv.insert(1, "--resume".to_string());
@@ -941,14 +911,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                     ));
                 };
                 let mut argv = grok_base_command(
-                    self,
-                    ctx.auth_mode,
-                    ctx.mcp_config,
                     ctx.system_prompt,
                     ctx.model,
                     ctx.dangerously_skip_permissions,
-                    ctx.profile_launch
-                        .is_some_and(|profile| profile.managed_mcp_config),
                     ctx.effort,
                 )?;
                 argv.push("--resume".to_string());
@@ -968,15 +933,8 @@ impl ProviderAdapter for BasicProviderAdapter {
                     ));
                 }
                 let mut argv = cursor_agent_base_command(
-                    self,
-                    ctx.auth_mode,
-                    ctx.mcp_config,
-                    ctx.system_prompt,
                     ctx.model,
                     ctx.dangerously_skip_permissions,
-                    ctx.profile_launch
-                        .is_some_and(|profile| profile.managed_mcp_config),
-                    ctx.effort,
                 )?;
                 argv.push("--resume".to_string());
                 argv.push(raw.to_string());
@@ -1067,13 +1025,9 @@ impl ProviderAdapter for BasicProviderAdapter {
             // (grok help: --fork-session 需配合 --resume/--continue)。
             Provider::Grok => {
                 let mut argv = grok_base_command(
-                    self,
-                    auth_mode,
-                    mcp_config,
                     system_prompt,
                     model,
                     dangerously_skip_permissions,
-                    false,
                     None,
                 )?;
                 argv.push("--session-id".to_string());
@@ -1191,7 +1145,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                     .ok_or_else(|| {
                         ProviderError::Command("copilot fork root was not materialized".to_string())
                     })?;
-                let mut argv = copilot_base_command_resume(
+                let mut argv = copilot_base_command(
                     ctx.auth_mode,
                     ctx.mcp_config,
                     ctx.system_prompt,
@@ -1214,14 +1168,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                     ));
                 };
                 let mut argv = grok_base_command(
-                    self,
-                    ctx.auth_mode,
-                    ctx.mcp_config,
                     ctx.system_prompt,
                     ctx.model,
                     ctx.dangerously_skip_permissions,
-                    ctx.profile_launch
-                        .is_some_and(|profile| profile.managed_mcp_config),
                     ctx.effort,
                 )?;
                 argv.push("--session-id".to_string());
@@ -1405,7 +1354,7 @@ pub(crate) fn json_inline(value: &serde_json::Value) -> String {
 // the extracted base-command functions, not directly by this file.
 use super::adapters::claude::{claude_base_command, claude_launch_command};
 use super::adapters::codex::codex_base_command;
-use super::adapters::copilot::{copilot_base_command, copilot_base_command_resume};
+use super::adapters::copilot::copilot_base_command;
 use super::adapters::cursor_agent::cursor_agent_base_command;
 use super::adapters::fake::fake_worker_command;
 use super::adapters::grok::{grok_base_command, grok_launch_command};