@team-agent/installer 0.5.112 → 0.5.113

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

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

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/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};

package/crates/team-agent/src/provider/adapters/claude.rs

@@ -11,6 +11,7 @@
 use crate::model::enums::{AuthMode, Provider};
 use crate::provider::adapter::{next_session_token, prompt_needs_native_mcp, BasicProviderAdapter};
 use crate::provider::{McpConfig, ProviderAdapter, ProviderError};
+use crate::provider::command_helpers::{append_opt_pair, append_pair};
 
 pub(crate) fn claude_launch_command(
     adapter: &BasicProviderAdapter,
@@ -30,8 +31,7 @@ pub(crate) fn claude_launch_command(
         false,
         None,
     )?;
-    argv.push("--session-id".to_string());
-    argv.push(next_session_token());
+    append_pair(&mut argv, "--session-id", next_session_token());
     Ok(argv)
 }
 
@@ -54,21 +54,14 @@ pub(crate) fn claude_base_command(
             .expect("claude provider must define a bypass flag");
         argv.push(flag.to_string());
     } else {
-        argv.push("--permission-mode".to_string());
-        argv.push("default".to_string());
-    }
-    if let Some(model) = model {
-        argv.push("--model".to_string());
-        argv.push(model.to_string());
+        append_pair(&mut argv, "--permission-mode", "default");
     }
+    append_opt_pair(&mut argv, "--model", model);
     if let Some(effort) = effort {
         argv.push("--effort".to_string());
         argv.push(effort.as_str().to_string());
     }
-    if let Some(prompt) = system_prompt {
-        argv.push("--append-system-prompt".to_string());
-        argv.push(prompt.to_string());
-    }
+    append_opt_pair(&mut argv, "--append-system-prompt", system_prompt);
     if !managed_mcp_config
         && (mcp_config.is_some()
             || auth_mode == AuthMode::CompatibleApi
@@ -79,8 +72,7 @@ pub(crate) fn claude_base_command(
         } else {
             serde_json::json!({"mcpServers": adapter.mcp_config(auth_mode)?.raw})
         };
-        argv.push("--mcp-config".to_string());
-        argv.push(raw.to_string());
+        append_pair(&mut argv, "--mcp-config", raw.to_string());
     }
     Ok(argv)
 }

package/crates/team-agent/src/provider/adapters/codex.rs

@@ -8,6 +8,7 @@
 
 use crate::model::enums::AuthMode;
 use crate::provider::adapter::json_inline;
+use crate::provider::command_helpers::{append_opt_pair, append_pair};
 use crate::provider::{McpConfig, ProviderCommandOverrides};
 
 pub(crate) fn codex_base_command(
@@ -36,24 +37,17 @@ pub(crate) fn codex_base_command(
         "--disable".to_string(),
         "apps".to_string(),
     ]);
-    if let Some(profile) = overrides.and_then(|o| o.codex_profile.as_deref()) {
-        argv.push("--profile".to_string());
-        argv.push(profile.to_string());
-    }
+    append_opt_pair(&mut argv, "--profile", overrides.and_then(|o| o.codex_profile.as_deref()));
     if dangerously_skip_permissions {
         // 0.5.66 bypass 单源:flag 由 provider_bypass_flag 表供给。
         let flag = crate::provider::bypass_flags::provider_bypass_flag(crate::model::enums::Provider::Codex)
             .expect("codex provider must define a bypass flag");
         argv.push(flag.to_string());
     }
-    if let Some(model) = model {
-        argv.push("--model".to_string());
-        argv.push(model.to_string());
-    }
+    append_opt_pair(&mut argv, "--model", model);
     if let Some(overrides) = overrides {
         for config in &overrides.codex_config {
-            argv.push("-c".to_string());
-            argv.push(config.clone());
+            append_pair(&mut argv, "-c", config.clone());
         }
     }
     if let Some(effort) = effort {
@@ -66,8 +60,7 @@ pub(crate) fn codex_base_command(
             .replace('\\', "\\\\")
             .replace('"', "\\\"")
             .replace('\n', "\\n");
-        argv.push("-c".to_string());
-        argv.push(format!("developer_instructions=\"{escaped}\""));
+        append_pair(&mut argv, "-c", format!("developer_instructions=\"{escaped}\""));
     }
     if let Some(config) = mcp_config {
         append_codex_mcp_overrides(&mut argv, &config.raw);
@@ -91,8 +84,7 @@ pub(crate) fn append_codex_mcp_overrides(argv: &mut Vec<String>, raw: &serde_jso
             if key == "env" {
                 if let Some(env) = value.as_object() {
                     for (env_key, env_value) in env {
-                        argv.push("-c".to_string());
-                        argv.push(format!(
+                        append_pair(argv, "-c", format!(
                             "mcp_servers.{name}.env.{env_key}={}",
                             json_inline(env_value)
                         ));
@@ -100,12 +92,10 @@ pub(crate) fn append_codex_mcp_overrides(argv: &mut Vec<String>, raw: &serde_jso
                 }
                 continue;
             }
-            argv.push("-c".to_string());
-            argv.push(format!("mcp_servers.{name}.{key}={}", json_inline(value)));
+            append_pair(argv, "-c", format!("mcp_servers.{name}.{key}={}", json_inline(value)));
         }
         // Every MCP server gets a 600s tool timeout so long-running
         // team_orchestrator calls (report_result etc.) survive the codex default.
-        argv.push("-c".to_string());
-        argv.push(format!("mcp_servers.{name}.tool_timeout_sec=600.0"));
+        append_pair(argv, "-c", format!("mcp_servers.{name}.tool_timeout_sec=600.0"));
     }
 }

package/crates/team-agent/src/provider/adapters/copilot.rs

@@ -3,12 +3,13 @@
 //!
 //! Extracted from `provider/adapter.rs` (0.4.x decoupling step 2). Pure
 //! extraction — byte-identical to the original inline forms. Scope kept
-//! small: base command + resume + MCP type→transport
+//! small: base command + MCP type→transport
 //! translation. Auth hint (`copilot_auth_hint`) stays in `adapter.rs`;
 //! session-store scanning lives under `provider/session_scan/copilot.rs`.
 
 use crate::model::enums::AuthMode;
 use crate::provider::McpConfig;
+use crate::provider::command_helpers::{append_opt_pair, append_pair};
 
 pub(crate) fn copilot_base_command(
     auth_mode: AuthMode,
@@ -35,18 +36,13 @@ pub(crate) fn copilot_base_command(
         argv.push(flag.to_string());
     }
     // mcp_team ∈ canonical → approval-free (whole-server pattern).
-    argv.push("--allow-tool".to_string());
-    argv.push("team_orchestrator".to_string());
-    if let Some(model) = model {
-        argv.push("--model".to_string());
-        argv.push(model.to_string());
-    }
+    append_pair(&mut argv, "--allow-tool", "team_orchestrator");
+    append_opt_pair(&mut argv, "--model", model);
     if let Some(config) = mcp_config {
         // Copilot mcp config schema field is `transport` (stdio|http|sse),
         // not the canonical `type`. McpConfig.raw is canonical; only copilot
         // translates type→transport for --additional-mcp-config.
-        argv.push("--additional-mcp-config".to_string());
-        argv.push(copilot_translate_mcp_config(&config.raw).to_string());
+        append_pair(&mut argv, "--additional-mcp-config", copilot_translate_mcp_config(&config.raw).to_string());
     }
     argv
 }
@@ -77,16 +73,3 @@ pub(crate) fn copilot_translate_mcp_config(raw: &serde_json::Value) -> serde_jso
     }
     serde_json::Value::Object(translated)
 }
-
-/// Resume path = base + `--resume <sid>` (drop --session-id); kept separate
-/// to avoid the plan accidentally emitting --session-id and --resume in the
-/// same frame.
-pub(crate) fn copilot_base_command_resume(
-    auth_mode: AuthMode,
-    mcp_config: Option<&McpConfig>,
-    system_prompt: Option<&str>,
-    model: Option<&str>,
-    dangerously_skip_permissions: bool,
-) -> Vec<String> {
-    copilot_base_command(auth_mode, mcp_config, system_prompt, model, dangerously_skip_permissions)
-}