@team-agent/installer 0.3.9 → 0.3.11

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

@@ -342,13 +342,12 @@ fn start_mode_serde_names_match_python_start_mode_strings() {
 }
 
 // ───────────────────────────────────────────────────────────────────────
-// decide_start_mode — bug-085 四象限 (start.py:66-69 + 179-190)
-// golden 实跑(PYTHONPATH=… python3 /tmp/x.py,_resume_rollout_missing + start_mode 逻辑):
+// decide_start_mode — bug-085 四象限 + E20 #264 gap closure.
 //   codex sess  rollout-present any-fresh   -> resumed
-//   codex sess  rollout-MISSING !allow_fresh -> resumed  (随后真实 resume 失败)
-//   codex sess  rollout-MISSING  allow_fresh -> fresh_after_missing_rollout   ← bug-085 唯一臂
+//   codex sess  backing-MISSING !allow_fresh -> noop/refuse (绝不静默 resume 死 session)
+//   codex sess  backing-MISSING  allow_fresh -> fresh_after_missing_rollout
 //   codex no-sess any                        -> fresh
-//   claude(非codex) sess rollout-missing fresh -> resumed (非 codex 永不"缺 rollout")
+//   claude/copilot sess backing-missing       -> fresh_after_missing_rollout 或 noop/refuse
 //   claude no-sess                            -> fresh
 // 这是 bug-085 把 start_mode 分类从 start_agent 的 lock+spawn 全路径剥离出来的命门。
 // ───────────────────────────────────────────────────────────────────────
@@ -375,11 +374,11 @@ fn decide_start_mode_codex_missing_rollout_with_allow_fresh_is_fresh_after_missi
 }
 
 #[test]
-fn decide_start_mode_codex_missing_rollout_without_allow_fresh_stays_resumed() {
-    // 关键陷阱:rollout 缺但 !allow_fresh → 仍 Resumed(start.py 不擅自丢 context)。
+fn decide_start_mode_codex_missing_rollout_without_allow_fresh_refuses() {
+    // E20 C①:backing 缺且 !allow_fresh → 诚实拒绝,绝不 resume 进死 session。
     assert_eq!(
         decide_start_mode("codex", Some(&sid("s1")), None, false, false),
-        StartMode::Resumed
+        StartMode::Noop
     );
 }
 
@@ -408,12 +407,24 @@ fn decide_start_mode_no_session_is_fresh() {
 }
 
 #[test]
-fn decide_start_mode_non_codex_never_fresh_after_missing_rollout() {
-    // 非 codex provider:rollout 概念不适用,_resume_rollout_missing 恒 false。
-    assert_eq!(
-        decide_start_mode("claude", Some(&sid("s1")), None, false, true),
-        StartMode::Resumed
-    );
+fn decide_start_mode_checks_backing_for_all_resumable_providers() {
+    for provider in ["claude", "claude_code", "copilot"] {
+        assert_eq!(
+            decide_start_mode(provider, Some(&sid("s1")), None, false, true),
+            StartMode::FreshAfterMissingRollout,
+            "{provider} missing backing + allow_fresh must not resume"
+        );
+        assert_eq!(
+            decide_start_mode(provider, Some(&sid("s1")), None, false, false),
+            StartMode::Noop,
+            "{provider} missing backing + !allow_fresh must refuse"
+        );
+        assert_eq!(
+            decide_start_mode(provider, Some(&sid("s1")), Some(&rp("/r")), true, false),
+            StartMode::Resumed,
+            "{provider} existing backing remains resumable"
+        );
+    }
     assert_eq!(
         decide_start_mode("claude", None, None, false, true),
         StartMode::Fresh
@@ -533,8 +544,11 @@ fn classify_restart_plan_never_interacted_null_session_with_allow_fresh_marks_fo
 fn classify_restart_plan_codex_with_session_still_resumes() {
     // E6 层2 回归锁(不误伤): codex worker first_send_at=null 但 session_id 已捕 →
     // 仍走 Resume(分流轴是 session_id 有无,不是 interacted)。防层2 修法把 has_session 也误判。
+    let ws = temp_ws();
+    let rollout = ws.join("codex-rollout.jsonl");
+    std::fs::write(&rollout, "{}\n").unwrap();
     let state = json!({
-        "agents": { "w1": { "provider": "codex", "session_id": "sess-codex-abc" } }
+        "agents": { "w1": { "provider": "codex", "session_id": "sess-codex-abc", "rollout_path": rollout.to_string_lossy() } }
     });
     let plan = classify_restart_plan(&state, false).expect("纯验证不应 Err");
     assert_eq!(plan.decisions.len(), 1);
@@ -978,6 +992,66 @@ fn leader_pane_env_cross_socket_all_probe_errors_stays_unknown() {
     assert_eq!(state, LeaderPaneEnvState::Unknown);
 }
 
+#[test]
+fn mcp_auto_approval_env_marks_leader_bypass_namespace_only() {
+    let mut env = std::collections::BTreeMap::new();
+    let safety = DangerousApproval {
+        enabled: true,
+        source: DangerousApprovalSource::LeaderProcess,
+        inherited: true,
+        provider: Some("codex".to_string()),
+        flag: Some("--dangerously-bypass-approvals-and-sandbox".to_string()),
+        worker_capability_above_leader: false,
+        ancestry_binary_name: Some("codex".to_string()),
+        unexpected_binary: false,
+    };
+
+    apply_mcp_auto_approval_env(&mut env, &safety);
+
+    assert_eq!(env.get("TEAM_AGENT_LEADER_BYPASS").map(String::as_str), Some("1"));
+    assert_eq!(
+        env.get("TEAM_AGENT_MCP_AUTO_APPROVE").map(String::as_str),
+        Some("team_orchestrator")
+    );
+    assert_eq!(
+        env.get("TEAM_AGENT_MCP_AUTO_APPROVE_SOURCE").map(String::as_str),
+        Some("leader_bypass")
+    );
+    assert_eq!(
+        env.get("TEAM_AGENT_LEADER_BYPASS_FLAG").map(String::as_str),
+        Some("--dangerously-bypass-approvals-and-sandbox")
+    );
+}
+
+#[test]
+fn mcp_auto_approval_env_clears_when_leader_is_restricted() {
+    let mut env = std::collections::BTreeMap::from([
+        (
+            "TEAM_AGENT_MCP_AUTO_APPROVE".to_string(),
+            "team_orchestrator".to_string(),
+        ),
+        ("TEAM_AGENT_MCP_AUTO_APPROVE_SOURCE".to_string(), "leader_bypass".to_string()),
+    ]);
+    let safety = DangerousApproval {
+        enabled: false,
+        source: DangerousApprovalSource::Disabled,
+        inherited: false,
+        provider: None,
+        flag: None,
+        worker_capability_above_leader: false,
+        ancestry_binary_name: None,
+        unexpected_binary: false,
+    };
+
+    apply_mcp_auto_approval_env(&mut env, &safety);
+
+    assert_eq!(env.get("TEAM_AGENT_LEADER_BYPASS").map(String::as_str), Some("0"));
+    assert!(
+        !env.contains_key("TEAM_AGENT_MCP_AUTO_APPROVE"),
+        "restricted leader must not leave MCP auto-approval env behind: {env:?}"
+    );
+}
+
 struct EnvVarGuard {
     key: &'static str,
     previous: Option<String>,

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

@@ -945,6 +945,10 @@ const DELEG_ROLE_WORKER2: &str = "---\nname: worker2\nrole: Second Worker\nprovi
 pub(super) fn restart_ws_two_resumable_workers() -> PathBuf {
     let ws = temp_ws().join("restartteam");
     std::fs::create_dir_all(ws.join("agents")).unwrap();
+    let alpha_rollout = ws.join("alpha-rollout.jsonl");
+    let bravo_rollout = ws.join("bravo-rollout.jsonl");
+    std::fs::write(&alpha_rollout, "{}\n").unwrap();
+    std::fs::write(&bravo_rollout, "{}\n").unwrap();
     std::fs::write(ws.join("TEAM.md"), "---\nname: restartteam\nobjective: Restart probe.\nprovider: codex\n---\n\nteam.\n").unwrap();
     std::fs::write(ws.join("agents").join("alpha.md"), DELEG_ROLE_ALPHA).unwrap();
     std::fs::write(ws.join("agents").join("bravo.md"), DELEG_ROLE_BRAVO).unwrap();
@@ -955,8 +959,8 @@ pub(super) fn restart_ws_two_resumable_workers() -> PathBuf {
         &json!({
             "session_name": "team-restartteam",
             "agents": {
-                "alpha": {"status": "running", "provider": "codex", "session_id": "sess-a", "first_send_at": "2026-05-27T10:00:00+00:00"},
-                "bravo": {"status": "running", "provider": "codex", "session_id": "sess-b", "first_send_at": "2026-05-27T10:00:00+00:00"}
+                "alpha": {"status": "running", "provider": "codex", "session_id": "sess-a", "rollout_path": alpha_rollout.to_string_lossy(), "first_send_at": "2026-05-27T10:00:00+00:00"},
+                "bravo": {"status": "running", "provider": "codex", "session_id": "sess-b", "rollout_path": bravo_rollout.to_string_lossy(), "first_send_at": "2026-05-27T10:00:00+00:00"}
             }
         }),
     )
@@ -965,6 +969,33 @@ pub(super) fn restart_ws_two_resumable_workers() -> PathBuf {
     ws
 }
 
+fn restart_ws_one_resumable_worker() -> PathBuf {
+    let ws = temp_ws().join("restartone");
+    std::fs::create_dir_all(ws.join("agents")).unwrap();
+    let rollout = ws.join("alpha-rollout.jsonl");
+    std::fs::write(&rollout, "{}\n").unwrap();
+    std::fs::write(
+        ws.join("TEAM.md"),
+        "---\nname: restartone\nobjective: Restart readiness probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(ws.join("agents").join("alpha.md"), DELEG_ROLE_ALPHA).unwrap();
+    let spec = crate::compiler::compile_team(&ws).expect("compile 1-agent team");
+    std::fs::write(ws.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-restartone",
+            "agents": {
+                "alpha": {"status": "running", "provider": "codex", "session_id": "sess-a", "rollout_path": rollout.to_string_lossy(), "first_send_at": "2026-05-27T10:00:00+00:00"}
+            }
+        }),
+    )
+    .unwrap();
+    seed_healthy_coordinator(&ws);
+    ws
+}
+
 // 2 [P0] — restart_with_transport must drive the REAL Route-B resume spawn: one spawn per resumable
 // worker. The first resumed worker recreates the session with spawn_first; later workers may use
 // spawn_into only after a live-session check proves that recreated session still exists. Each spawn
@@ -1020,6 +1051,38 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
     );
 }
 
+#[test]
+fn restart_times_out_when_spawned_worker_pane_is_not_addressable() {
+    let ws = restart_ws_one_resumable_worker();
+    let transport = OfflineTransport::new().with_spawned_panes_addressable(false);
+
+    let result =
+        restart_with_transport_with_readiness_deadline(&ws, false, None, &transport, Some(0));
+
+    let text = format!("{result:?}");
+    assert!(
+        text.contains("restart not ready")
+            && text.contains("worker pane addressable: no")
+            && text.contains("Action:")
+            && text.contains("Log:"),
+        "restart must refuse with N38 readiness timeout details, not return ok; got {text}"
+    );
+    assert!(
+        !matches!(result, Ok(RestartReport::Restarted { .. })),
+        "restart readiness timeout must not return Restarted ok"
+    );
+    let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
+    let timeout = events
+        .iter()
+        .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.readiness_timeout"))
+        .expect("restart.readiness_timeout event");
+    assert_eq!(
+        timeout.get("worker_pane_addressable").and_then(|v| v.as_bool()),
+        Some(false),
+        "timeout event must carry the failed readiness condition: {timeout}"
+    );
+}
+
 // 3 [P0] — start_agent_with_transport on a non-paused agent with a session_id must spawn EXACTLY ONE
 // worker (resume) carrying the provider build_command. Today the stub returns RequirementUnmet with
 // ZERO spawns -> RED at recorded.len().
@@ -1027,11 +1090,13 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
 fn start_agent_with_transport_spawns_resume_not_stub() {
     let ws = temp_ws().join("startagentws");
     std::fs::create_dir_all(&ws).unwrap();
+    let rollout = ws.join("alpha-rollout.jsonl");
+    std::fs::write(&rollout, "{}\n").unwrap();
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
             "session_name": "team-sa",
-            "agents": {"alpha": {"status": "running", "provider": "codex", "session_id": "sess-a", "first_send_at": "2026-05-27T10:00:00+00:00"}}
+            "agents": {"alpha": {"status": "running", "provider": "codex", "session_id": "sess-a", "rollout_path": rollout.to_string_lossy(), "first_send_at": "2026-05-27T10:00:00+00:00"}}
         }),
     )
     .unwrap();

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

@@ -88,11 +88,13 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
 fn respawn_ws_one_resumable_worker() -> PathBuf {
     let ws = temp_ws().join("respawn_dead_session");
     std::fs::create_dir_all(&ws).unwrap();
+    let rollout = ws.join("alpha-rollout.jsonl");
+    std::fs::write(&rollout, "{}\n").unwrap();
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
             "session_name": "team-sa",
-            "agents": {"alpha": {"status": "running", "provider": "codex", "session_id": "sess-a", "first_send_at": "2026-05-27T10:00:00+00:00"}}
+            "agents": {"alpha": {"status": "running", "provider": "codex", "session_id": "sess-a", "rollout_path": rollout.to_string_lossy(), "first_send_at": "2026-05-27T10:00:00+00:00"}}
         }),
     )
     .unwrap();

package/crates/team-agent/src/mcp_server/helpers.rs

@@ -146,7 +146,10 @@ impl serde_json::ser::Formatter for PythonJsonFormatter {
         }
     }
 
-    fn begin_object_value<W: ?Sized + std::io::Write>(&mut self, writer: &mut W) -> std::io::Result<()> {
+    fn begin_object_value<W: ?Sized + std::io::Write>(
+        &mut self,
+        writer: &mut W,
+    ) -> std::io::Result<()> {
         writer.write_all(b": ")
     }
 }
@@ -171,7 +174,11 @@ pub(crate) fn ensure_object(value: &mut Value) {
     }
 }
 
-pub(crate) fn insert_array(obj: &mut serde_json::Map<String, Value>, key: &str, value: Option<&[Value]>) {
+pub(crate) fn insert_array(
+    obj: &mut serde_json::Map<String, Value>,
+    key: &str,
+    value: Option<&[Value]>,
+) {
     if let Some(items) = value {
         obj.insert(key.to_string(), Value::Array(items.to_vec()));
     }
@@ -198,11 +205,20 @@ pub(crate) fn object_fields(value: Value) -> serde_json::Map<String, Value> {
 }
 
 pub(crate) fn delivery_outcome_value(out: &DeliveryOutcome) -> Value {
-    serde_json::json!({
+    let mut value = serde_json::json!({
         "ok": out.ok,
         "status": enum_value(out.status),
         "message_id": out.message_id,
-    })
+    });
+    if let Some(obj) = value.as_object_mut() {
+        if let Some(reason) = out.reason {
+            obj.insert("reason".to_string(), enum_value(reason));
+        }
+        if let Some(warning) = out.verification.as_deref() {
+            obj.insert("warning".to_string(), Value::String(warning.to_string()));
+        }
+    }
+    value
 }
 
 pub(crate) fn latest_task_for_assignee(workspace: &Path, agent_id: &str) -> Option<String> {
@@ -218,7 +234,10 @@ pub(crate) fn latest_task_for_assignee(workspace: &Path, agent_id: &str) -> Opti
             .and_then(Value::as_str)
             .unwrap_or("")
             .to_ascii_lowercase();
-        if matches!(status.as_str(), "done" | "success" | "failed" | "blocked" | "cancelled") {
+        if matches!(
+            status.as_str(),
+            "done" | "success" | "failed" | "blocked" | "cancelled"
+        ) {
             continue;
         }
         if let Some(id) = task.get("id").and_then(text_of_value) {

package/crates/team-agent/src/mcp_server/normalize.rs

@@ -65,7 +65,10 @@ pub fn normalize_change_kind(value: Option<&str>, description: &str) -> ChangeKi
                 ChangeKind::Created
             } else if desc.contains("removed") || desc.contains("deleted") {
                 ChangeKind::Deleted
-            } else if desc.contains("verified") || desc.contains("observed") || desc.contains("inspected") {
+            } else if desc.contains("verified")
+                || desc.contains("observed")
+                || desc.contains("inspected")
+            {
                 ChangeKind::Observed
             } else {
                 ChangeKind::Modified
@@ -127,6 +130,7 @@ pub fn compact_tool_result(result: &Value) -> ToolResult {
             "ok",
             "status",
             "reason",
+            "warning",
             "error",
             "message_id",
             "agent_id",
@@ -195,7 +199,10 @@ pub fn compact_tool_result(result: &Value) -> ToolResult {
     Ok(ToolOk { fields })
 }
 
-pub(crate) fn normalize_changes(value: Option<&Value>, envelope_summary: &str) -> Vec<NormalizedChange> {
+pub(crate) fn normalize_changes(
+    value: Option<&Value>,
+    envelope_summary: &str,
+) -> Vec<NormalizedChange> {
     items_from_value(value)
         .iter()
         .filter_map(|item| {
@@ -267,7 +274,9 @@ pub(crate) fn normalize_risks(value: Option<&Value>) -> Vec<NormalizedRisk> {
         .filter_map(|item| match item {
             Value::Object(obj) => Some(NormalizedRisk {
                 severity: normalize_risk_severity(
-                    obj.get("severity").or_else(|| obj.get("level")).and_then(Value::as_str),
+                    obj.get("severity")
+                        .or_else(|| obj.get("level"))
+                        .and_then(Value::as_str),
                 ),
                 description: obj
                     .get("description")
@@ -325,9 +334,7 @@ pub(crate) fn normalize_next_actions(value: Option<&Value>) -> Vec<NormalizedNex
                 .or_else(|| obj.get("todo"))
                 .or_else(|| obj.get("message"))
                 .and_then(text_of_value)
-                .map(|description| NormalizedNextAction {
-                    description,
-                }),
+                .map(|description| NormalizedNextAction { description }),
             scalar => text_of_value(scalar).map(|description| NormalizedNextAction { description }),
         })
         .collect()