@team-agent/installer 0.3.8 → 0.3.10

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.8"
+version = "0.3.10"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.8"
+version = "0.3.10"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/emit.rs

@@ -23,7 +23,7 @@ pub fn emit(output: &CmdOutput, as_json: bool) -> Option<String> {
     }
 }
 
-/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude passthrough 早返回 →
+/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude/copilot passthrough 早返回 →
 /// 解析 argv 到 subcommand → 调对应 handler → 异常落盘 + 信封 + `ExitCode::Error` →
 /// `consume_leader_inbox_summary` → `emit` → `result.ok is False ? Error : Ok`。
 /// **行为入口**:契约可端到端跑 argv→(stdout, exit code)。
@@ -31,7 +31,7 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
     let Some(command) = argv.first().map(String::as_str) else {
         return emit_missing_subcommand_usage();
     };
-    if command == "codex" || command == "claude" {
+    if command == "codex" || command == "claude" || command == "copilot" {
         return cmd_leader_passthrough(command, &argv[1..], cwd)
             .map(emit_result)
             .unwrap_or(ExitCode::Error);
@@ -193,7 +193,7 @@ fn is_known_subcommand(command: &str) -> bool {
 fn command_help(command: Option<&str>) -> String {
     match command {
         None => {
-            let mut commands = vec!["codex", "claude"];
+            let mut commands = vec!["codex", "claude", "copilot"];
             commands.extend_from_slice(DISPATCH_COMMANDS);
             commands.extend_from_slice(SPEC_ONLY_HELP_COMMANDS);
             format!(
@@ -261,7 +261,7 @@ fn emit_unknown_subcommand_usage(command: &str) -> ExitCode {
 
 /// 在已知子命令里找与 `input` 最接近的一个(Levenshtein ≤ 阈值)。无足够接近者 → None。
 fn nearest_subcommand(input: &str) -> Option<&'static str> {
-    let mut candidates: Vec<&'static str> = vec!["codex", "claude"];
+    let mut candidates: Vec<&'static str> = vec!["codex", "claude", "copilot"];
     candidates.extend_from_slice(DISPATCH_COMMANDS);
     candidates.extend_from_slice(SPEC_ONLY_HELP_COMMANDS);
     // 阈值随长度放宽,但短词收紧,避免 'x' 误配任何东西。
@@ -1418,6 +1418,22 @@ mod tests {
                 "top-level --help is missing spec-only help command `{command}`"
             );
         }
+        assert!(
+            top_help.contains("copilot"),
+            "top-level leader passthrough help must list copilot"
+        );
+    }
+
+    #[test]
+    fn copilot_is_listed_as_leader_passthrough_candidate() {
+        assert!(command_help(None).contains("copilot"));
+        assert_eq!(nearest_subcommand("copliot"), Some("copilot"));
+    }
+
+    #[test]
+    fn copilot_help_dispatches_as_leader_passthrough() {
+        let cwd = tmp_workspace();
+        assert_eq!(run(&cli_argv(&["copilot", "--help"]), &cwd), ExitCode::Ok);
     }
 
     #[test]

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

@@ -1,4 +1,4 @@
-//! cli · leader — `codex`/`claude` passthrough(`cmd_leader_passthrough` + `_provider_args` /
+//! cli · leader — `codex`/`claude`/`copilot` passthrough(`cmd_leader_passthrough` + `_provider_args` /
 //! `_leader_launcher_args`)+ leader fallback inbox 摘要(`consume_leader_inbox_summary` 及
 //! `_leader_inbox_entries` / `_leader_inbox_summary` / `_leader_inbox_entry_title`)。
 
@@ -68,9 +68,9 @@ fn without_leader_json(values: &[String]) -> Vec<String> {
     out
 }
 
-/// `codex`/`claude` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
+/// `codex`/`claude`/`copilot` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
 /// **不**进 subparser。`-h`/`--help` 打 usage 直接返回 [`CmdResult::none`]。否则解析 attach
-/// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude}。
+/// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude, copilot}。
 pub fn cmd_leader_passthrough(
     command: &str,
     provider_args: &[String],
@@ -82,15 +82,19 @@ pub fn cmd_leader_passthrough(
     let as_json = leader_launcher_json(provider_args);
     let launcher_args = without_leader_json(provider_args);
     let attach = leader_launcher_args(&launcher_args)?;
-    let provider = if command == "codex" {
-        crate::model::enums::Provider::Codex
-    } else {
-        crate::model::enums::Provider::ClaudeCode
-    };
+    let provider = leader_passthrough_provider(command);
     let value = lifecycle_port::start_leader(provider, &attach.provider_args, cwd, &attach)?;
     Ok(CmdResult::from_json(value, as_json))
 }
 
+pub(crate) fn leader_passthrough_provider(command: &str) -> crate::model::enums::Provider {
+    match command {
+        "codex" => crate::model::enums::Provider::Codex,
+        "copilot" => crate::model::enums::Provider::Copilot,
+        _ => crate::model::enums::Provider::ClaudeCode,
+    }
+}
+
 // =============================================================================
 // leader fallback inbox 摘要(helpers.py `consume_leader_inbox_summary`)
 // =============================================================================

package/crates/team-agent/src/cli/tests/base.rs

@@ -617,5 +617,19 @@ Truncated: more fallback entries available; run team-agent inbox leader";
         assert_eq!(r.exit, ExitCode::Ok);
         let r2 = cmd_leader_passthrough("claude", &["--help".into()], Path::new(".")).unwrap();
         assert_eq!(r2.output, CmdOutput::None);
+        let r3 = cmd_leader_passthrough("copilot", &["--help".into()], Path::new(".")).unwrap();
+        assert_eq!(r3.output, CmdOutput::None);
     }
 
+    #[test]
+    fn cmd_leader_passthrough_maps_copilot_provider() {
+        assert_eq!(leader_passthrough_provider("codex"), crate::model::enums::Provider::Codex);
+        assert_eq!(
+            leader_passthrough_provider("claude"),
+            crate::model::enums::Provider::ClaudeCode
+        );
+        assert_eq!(
+            leader_passthrough_provider("copilot"),
+            crate::model::enums::Provider::Copilot
+        );
+    }

package/crates/team-agent/src/cli/tests/run_delegation.rs

@@ -264,9 +264,13 @@ fn current_uid() -> Option<String> {
             json: true,
         };
         let text = outcome_text(cmd_restart(&args));
+        // RED-2-STILL: entry gate now resolves via canonical_run_workspace; for a no-spec workspace
+        // the "no spec" surfacing may come from either the entry gate ("missing spec for restart")
+        // or, when a stray ancestor .team lets it past, the resolve gate ("active team spec not
+        // found"). Both are the REAL crate::lifecycle error (not a placeholder ok:true).
         assert!(
-            text.contains("missing spec for restart"),
-            "cmd_restart must surface the REAL crate::lifecycle::restart 'missing spec for restart' error \
+            text.contains("missing spec for restart") || text.contains("active team spec not found"),
+            "cmd_restart must surface the REAL crate::lifecycle::restart missing-spec error \
              (not the placeholder's canned ok:true); got {text}"
         );
     }

package/crates/team-agent/src/coordinator/tests/spine.rs

@@ -258,4 +258,10 @@ fn spine_tick_session_missing_emits_event() {
             .any(|e| e.get("event").and_then(|v| v.as_str()) == Some("coordinator.session_missing")),
         "the tmux-missing gate must emit a coordinator.session_missing event before the stop report; got {events:?}"
     );
+    assert!(
+        events
+            .iter()
+            .any(|e| e.get("event").and_then(|v| v.as_str()) == Some("coordinator.session_missing_alert")),
+        "the tmux-missing gate must emit an explicit leader-visible alert before stopping; got {events:?}"
+    );
 }

package/crates/team-agent/src/coordinator/tick.rs

@@ -198,6 +198,7 @@ impl Coordinator {
                     "coordinator.session_missing",
                     serde_json::json!({"session": session_name}),
                 )?;
+                notify_session_missing(self.workspace.as_path(), &state, &event_log, session_name)?;
                 return Ok(empty_tick_report(
                     false,
                     true,
@@ -971,7 +972,8 @@ impl Coordinator {
                         "runtime_approval.auto_approved",
                         serde_json::json!({
                             "agent_id": agent_id,
-                            "tool": prompt.tool,
+                            "server": prompt.server.as_deref(),
+                            "tool": prompt.tool.as_deref(),
                             "choice": choice,
                             "cleared": cleared,
                             "policy_source": approval_policy.source,
@@ -980,6 +982,23 @@ impl Coordinator {
                             "worker_capability_above_leader": approval_policy.worker_capability_above_leader,
                         }),
                     )?;
+                        event_log.write(
+                            "mcp.tool.auto_approved",
+                            serde_json::json!({
+                                "agent_id": agent_id,
+                                "server": prompt.server.as_deref(),
+                                "tool": prompt.tool.as_deref(),
+                                "choice": choice,
+                                "cleared": cleared,
+                                "inherit_reason": approval_policy.inherit_reason(),
+                                "bypass_source": approval_policy.source,
+                                "provider": approval_policy.provider,
+                                "flag": approval_policy.flag,
+                                "inherited": approval_policy.inherited,
+                                "explicit_yes_confirmed": approval_policy.explicit_yes_confirmed,
+                                "worker_capability_above_leader": approval_policy.worker_capability_above_leader,
+                            }),
+                        )?;
                     }
                     RuntimeApprovalDecision::AwaitingHumanConfirm => {
                         let Some(reason) = awaiting_human_confirm_reason(&prompt, auto_answer_allowed) else {
@@ -2110,6 +2129,8 @@ struct RuntimeApprovalPolicy {
     source: String,
     inherited: bool,
     explicit_yes_confirmed: bool,
+    provider: Option<String>,
+    flag: Option<String>,
     worker_capability_above_leader: bool,
 }
 
@@ -2127,6 +2148,14 @@ impl RuntimeApprovalPolicy {
             && (!self.worker_capability_above_leader
                 || (self.source == "runtime_config" && self.explicit_yes_confirmed))
     }
+
+    fn inherit_reason(&self) -> &'static str {
+        match self.source.as_str() {
+            "leader_process" if self.inherited => "leader_bypass",
+            "runtime_config" if self.explicit_yes_confirmed => "runtime_config_explicit_yes",
+            _ => "none",
+        }
+    }
 }
 
 fn runtime_approval_policy_from_agent(agent: &Value) -> RuntimeApprovalPolicy {
@@ -2151,6 +2180,14 @@ fn runtime_approval_policy_from_agent(agent: &Value) -> RuntimeApprovalPolicy {
             .and_then(|p| p.get("explicit_yes_confirmed"))
             .and_then(Value::as_bool)
             .unwrap_or(false),
+        provider: policy
+            .and_then(|p| p.get("provider"))
+            .and_then(Value::as_str)
+            .map(str::to_string),
+        flag: policy
+            .and_then(|p| p.get("flag"))
+            .and_then(Value::as_str)
+            .map(str::to_string),
         worker_capability_above_leader: policy
             .and_then(|p| p.get("worker_capability_above_leader"))
             .and_then(Value::as_bool)
@@ -2423,3 +2460,48 @@ fn remove_file_if_exists(path: &Path) -> Result<(), std::io::Error> {
         Err(e) => Err(e),
     }
 }
+
+fn notify_session_missing(
+    workspace: &Path,
+    state: &Value,
+    event_log: &EventLog,
+    session_name: &str,
+) -> Result<(), TickError> {
+    let content = format!(
+        "coordinator.session_missing\nerror: tmux session {session_name} is missing; coordinator is stopping\naction: restart the team or recover the missing tmux session\nlog: .team/logs/events.jsonl"
+    );
+    let dedupe_key = format!("coordinator.session_missing:{session_name}");
+    match crate::messaging::send_to_leader_receiver(
+        workspace,
+        state,
+        "leader",
+        &content,
+        None,
+        "coordinator",
+        false,
+        Some(&dedupe_key),
+        event_log,
+    ) {
+        Ok(outcome) => {
+            event_log.write(
+                "coordinator.session_missing_alert",
+                serde_json::json!({
+                    "session": session_name,
+                    "leader_notification_status": crate::messaging::helpers::status_wire(outcome.status),
+                    "message_id": outcome.message_id,
+                }),
+            )?;
+        }
+        Err(error) => {
+            event_log.write(
+                "coordinator.session_missing_alert_failed",
+                serde_json::json!({
+                    "session": session_name,
+                    "error": error.to_string(),
+                    "action": "inspect .team/logs/events.jsonl and restart the team",
+                }),
+            )?;
+        }
+    }
+    Ok(())
+}

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

@@ -654,6 +654,8 @@ fn leader_command_provider(command: &str) -> Option<Provider> {
         Some(Provider::ClaudeCode)
     } else if lower.contains("codex") {
         Some(Provider::Codex)
+    } else if lower.contains("copilot") {
+        Some(Provider::Copilot)
     } else if lower.contains("fake") {
         Some(Provider::Fake)
     } else {
@@ -1082,3 +1084,20 @@ pub fn detect_dual_state_divergence(
         "team_owner_epoch": team_epoch,
     })))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn leader_command_provider_recognizes_copilot() {
+        assert_eq!(
+            leader_command_provider("copilot --allow-all-tools"),
+            Some(Provider::Copilot)
+        );
+        assert_eq!(
+            leader_command_provider("/usr/local/bin/copilot"),
+            Some(Provider::Copilot)
+        );
+    }
+}

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

@@ -80,6 +80,18 @@ fn event_named(events: &[Value], name: &str) -> Value {
         .unwrap_or_else(|| panic!("missing event {name}; got {events:?}"))
 }
 
+#[test]
+fn leader_command_provider_recognizes_copilot() {
+    assert_eq!(
+        leader_command_provider("copilot --allow-all-tools"),
+        Some(Provider::Copilot)
+    );
+    assert_eq!(
+        leader_command_provider("/usr/local/bin/copilot"),
+        Some(Provider::Copilot)
+    );
+}
+
 fn last_event_named(events: &[Value], name: &str) -> Value {
     events
         .iter()

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

@@ -590,6 +590,8 @@ fn leader_command_provider(command: &str) -> Option<Provider> {
         Some(Provider::ClaudeCode)
     } else if lower.contains("codex") {
         Some(Provider::Codex)
+    } else if lower.contains("copilot") {
+        Some(Provider::Copilot)
     } else if lower.contains("fake") {
         Some(Provider::Fake)
     } else {

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

@@ -14,8 +14,8 @@ use super::helpers::{
 };
 use super::owner_bind::leader_identity_context;
 use super::{
-    LeaderError, LeaderLaunchOutcome, LeaderLaunchSocket, LeaderLaunchStatus, LeaderStartMode,
-    LeaderStartPlan,
+    LeaderError, LeaderIdentity, LeaderLaunchOutcome, LeaderLaunchSocket, LeaderLaunchStatus,
+    LeaderStartMode, LeaderStartPlan,
 };
 
 // ── leader::start — leader_start_plan / start_leader / session 名 ──
@@ -72,27 +72,7 @@ pub fn leader_start_plan(
     } else {
         LeaderStartMode::NewTmuxSession
     };
-    let mut leader_env = BTreeMap::new();
-    leader_env.insert(
-        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
-        provider_wire(provider).to_string(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
-        identity.leader_session_uuid.as_str().to_string(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
-        identity.machine_fingerprint.clone(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_WORKSPACE".to_string(),
-        identity.workspace_abspath.to_string_lossy().into_owned(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_TEAM_ID".to_string(),
-        identity.team_id.as_str().to_string(),
-    );
+    let leader_env = leader_env_for_identity(provider, &identity);
     let argv = start_argv(
         mode,
         provider,
@@ -119,6 +99,37 @@ pub fn leader_start_plan(
     })
 }
 
+pub(crate) fn leader_env_for_identity(
+    provider: Provider,
+    identity: &LeaderIdentity,
+) -> BTreeMap<String, String> {
+    let mut leader_env = BTreeMap::new();
+    leader_env.insert(
+        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+        provider_wire(provider).to_string(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
+        identity.leader_session_uuid.as_str().to_string(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
+        identity.machine_fingerprint.clone(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_WORKSPACE".to_string(),
+        identity.workspace_abspath.to_string_lossy().into_owned(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_TEAM_ID".to_string(),
+        identity.team_id.as_str().to_string(),
+    );
+    if provider == Provider::Copilot {
+        leader_env.insert("COPILOT_DISABLE_TERMINAL_TITLE".to_string(), "1".to_string());
+    }
+    leader_env
+}
+
 /// `start_leader`(card §46;`__init__.py:60`)。计算并执行 leader 启动计划(spawn + 信号处理)。
 /// 进程退出后 `Err`/退出码经 caller 处理(此处返 `Result` 替代 Python 的 `SystemExit`)。
 pub fn start_leader(

package/crates/team-agent/src/leader/tests/identity.rs

@@ -90,6 +90,28 @@ use super::*;
         }
     }
 
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_leader_env_disables_terminal_title_only_for_copilot() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_lsp_copilot_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let identity = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
+
+        let copilot = leader_env_for_identity(Provider::Copilot, &identity);
+        assert_eq!(
+            copilot.get("COPILOT_DISABLE_TERMINAL_TITLE").map(String::as_str),
+            Some("1")
+        );
+
+        for provider in [Provider::Codex, Provider::ClaudeCode] {
+            let leader_env = leader_env_for_identity(provider, &identity);
+            assert!(
+                !leader_env.contains_key("COPILOT_DISABLE_TERMINAL_TITLE"),
+                "{provider:?} leader env must not include copilot title override"
+            );
+        }
+    }
+
     // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
     // Lock CORRECT Python v0.2.11 leader-identity behavior the contracts missed.
     // Golden re-probed via /tmp/probe_p2_leader.py vs team-agent-public @ 439bef8

package/crates/team-agent/src/leader/tests/wake_start_owner.rs

@@ -134,6 +134,19 @@ use super::*;
         assert!(got.as_str().starts_with("team-agent-leader-claude_code-proj-"), "got {}", got.as_str());
     }
 
+    #[test]
+    fn leader_session_name_uses_copilot_provider_string() {
+        let base = std::env::temp_dir().join(format!("ta_rs_lsn_copilot_{}", std::process::id()));
+        let dir = base.join("proj");
+        std::fs::create_dir_all(&dir).unwrap();
+        let got = leader_session_name(Provider::Copilot, &dir);
+        assert!(
+            got.as_str().starts_with("team-agent-leader-copilot-proj-"),
+            "got {}",
+            got.as_str()
+        );
+    }
+
     // =====================================================================
     // 6. Family A 正源 owner 绑定 — bind_owner_from_caller_pane(unimplemented → RED)
     // =====================================================================

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

@@ -288,6 +288,7 @@ fn spawn_agents(
         let mut env =
             inherited_env_with_team_overrides(workspace, agent_id_raw, Some(&mcp_team_id));
         apply_profile_launch_env(&mut env, &profile_launch);
+        apply_mcp_auto_approval_env(&mut env, &safety);
         // 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();
@@ -1390,6 +1391,39 @@ pub(crate) fn inherited_env_with_team_overrides(
     env
 }
 
+pub(crate) fn apply_mcp_auto_approval_env(
+    env: &mut BTreeMap<String, String>,
+    safety: &DangerousApproval,
+) {
+    for key in [
+        "TEAM_AGENT_LEADER_BYPASS",
+        "TEAM_AGENT_LEADER_BYPASS_SOURCE",
+        "TEAM_AGENT_LEADER_BYPASS_PROVIDER",
+        "TEAM_AGENT_LEADER_BYPASS_FLAG",
+        "TEAM_AGENT_MCP_AUTO_APPROVE",
+        "TEAM_AGENT_MCP_AUTO_APPROVE_SOURCE",
+    ] {
+        env.remove(key);
+    }
+    if safety.enabled
+        && matches!(safety.source, DangerousApprovalSource::LeaderProcess)
+        && safety.inherited
+    {
+        env.insert("TEAM_AGENT_LEADER_BYPASS".to_string(), "1".to_string());
+        env.insert("TEAM_AGENT_LEADER_BYPASS_SOURCE".to_string(), "leader_process".to_string());
+        if let Some(provider) = safety.provider.as_deref() {
+            env.insert("TEAM_AGENT_LEADER_BYPASS_PROVIDER".to_string(), provider.to_string());
+        }
+        if let Some(flag) = safety.flag.as_deref() {
+            env.insert("TEAM_AGENT_LEADER_BYPASS_FLAG".to_string(), flag.to_string());
+        }
+        env.insert("TEAM_AGENT_MCP_AUTO_APPROVE".to_string(), "team_orchestrator".to_string());
+        env.insert("TEAM_AGENT_MCP_AUTO_APPROVE_SOURCE".to_string(), "leader_bypass".to_string());
+    } else {
+        env.insert("TEAM_AGENT_LEADER_BYPASS".to_string(), "0".to_string());
+    }
+}
+
 /// BUG / B2 灵魂件 + C-1-2 + C-6-1 cr verdict — Copilot per-worker AGENTS.md
 /// 写入 + `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` 注入。
 ///
@@ -2971,6 +3005,7 @@ pub fn fork_agent_with_transport(
     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);
+    apply_mcp_auto_approval_env(&mut env, &safety);
     // 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.

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

@@ -108,17 +108,31 @@ pub(crate) fn start_agent_at_paths(
     let provider = agent_provider(&agent);
     let session_id = agent_session_id(&agent);
     let rollout_path = agent_rollout_path(&agent);
-    let rollout_exists = rollout_path
+    let resume_backing_exists = session_id
         .as_ref()
-        .map(|p| p.as_path().exists())
+        .map(|session| {
+            resume_backing_exists_for_agent(
+                workspace,
+                agent_id,
+                &agent,
+                provider,
+                session,
+                rollout_path.as_ref(),
+            )
+        })
         .unwrap_or(false);
     let start_mode = decide_start_mode(
         provider_wire(provider),
         session_id.as_ref(),
         rollout_path.as_ref(),
-        rollout_exists,
+        resume_backing_exists,
         allow_fresh,
     );
+    if matches!(start_mode, StartMode::Noop) {
+        return Err(LifecycleError::RequirementUnmet(format!(
+            "resume_not_ready: session backing store missing for agent {agent_id}; rerun with --allow-fresh to start fresh"
+        )));
+    }
     let spawn_session_id = if matches!(start_mode, StartMode::Resumed) {
         session_id.as_ref()
     } else {

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

@@ -122,6 +122,7 @@ pub(super) fn spawn_agent_window(
         team_id.as_deref(),
     );
     crate::lifecycle::launch::apply_profile_launch_env(&mut env, &profile_launch);
+    crate::lifecycle::launch::apply_mcp_auto_approval_env(&mut env, safety);
     let spawn_cwd = spawn_cwd_override
         .or_else(|| {
             agent
@@ -242,6 +243,80 @@ pub(super) fn agent_rollout_path(agent: &serde_json::Value) -> Option<RolloutPat
         .map(RolloutPath::new)
 }
 
+pub(super) fn resume_backing_exists_for_agent(
+    workspace: &Path,
+    agent_id: &AgentId,
+    agent: &serde_json::Value,
+    provider: Provider,
+    session_id: &SessionId,
+    rollout_path: Option<&RolloutPath>,
+) -> bool {
+    match provider {
+        Provider::Codex => rollout_path_exists(rollout_path),
+        Provider::Claude | Provider::ClaudeCode => {
+            rollout_path_exists(rollout_path)
+                || event_log_transcript_exists(workspace, agent_id.as_str(), session_id.as_str())
+        }
+        Provider::Copilot => copilot_session_store_has_session(session_id.as_str()),
+        Provider::GeminiCli | Provider::Fake => {
+            let _ = agent;
+            true
+        }
+    }
+}
+
+fn rollout_path_exists(rollout_path: Option<&RolloutPath>) -> bool {
+    rollout_path
+        .as_ref()
+        .is_some_and(|path| path.as_path().exists())
+}
+
+fn event_log_transcript_exists(workspace: &Path, agent_id: &str, session_id: &str) -> bool {
+    let Ok(events) = crate::event_log::EventLog::new(workspace).tail(0) else {
+        return false;
+    };
+    events.iter().rev().any(|event| {
+        event.get("event").and_then(serde_json::Value::as_str) == Some("session.captured")
+            && ["agent_id", "worker_id"]
+                .iter()
+                .any(|key| event.get(*key).and_then(serde_json::Value::as_str) == Some(agent_id))
+            && event.get("session_id").and_then(serde_json::Value::as_str) == Some(session_id)
+            && event_transcript_path(event).is_some_and(|path| path.exists())
+    })
+}
+
+fn event_transcript_path(event: &serde_json::Value) -> Option<PathBuf> {
+    event
+        .get("rollout_path")
+        .or_else(|| event.get("transcript_path"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|path| !path.is_empty())
+        .map(PathBuf::from)
+}
+
+fn copilot_session_store_has_session(session_id: &str) -> bool {
+    let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
+        return false;
+    };
+    let db_path = home.join(".copilot").join("session-store.db");
+    if !db_path.exists() {
+        return false;
+    }
+    let Ok(conn) = rusqlite::Connection::open_with_flags(
+        db_path,
+        rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
+    ) else {
+        return false;
+    };
+    conn
+        .query_row(
+            "select 1 from sessions where id = ?1 limit 1",
+            [session_id],
+            |_| Ok(()),
+        )
+        .is_ok()
+}
+
 pub(crate) fn refresh_missing_provider_sessions(
     state: &mut serde_json::Value,
 ) -> Result<bool, LifecycleError> {