@team-agent/installer 0.5.77 → 0.5.80

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

@@ -40,6 +40,7 @@ use team_agent::transport::test_support::OfflineTransport;
 #[test]
 #[serial(env)]
 fn cursor_fresh_spawn_does_not_invent_session_id() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-fresh");
     let (ws, _home, _guard, team) = seed_cursor("pending");
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &transport)
@@ -79,6 +80,7 @@ fn cursor_fresh_spawn_does_not_invent_session_id() {
 #[test]
 #[serial(env)]
 fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-resume");
     let (ws, home, _guard, team) = seed_cursor("resume");
     let first = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &first)
@@ -180,6 +182,7 @@ fn cursor_classify_resumes_when_archive_present_and_refuses_when_missing() {
 #[test]
 #[serial(env)]
 fn cursor_fork_agent_refuses_as_unsupported_not_unverified() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-fork");
     let (ws, _home, _guard, team) = seed_cursor("fork");
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &transport)

package/crates/team-agent/src/lifecycle/tests/fixtures/pi_list_models_spaced_ids.stdout.txt

@@ -0,0 +1,9 @@
+provider      model                         context  max-out  thinking  images
+cursor        claude-opus-4-7@1m:fast       1M       16.4K    yes       yes
+cursor        claude-opus-4-7@1m:slow       1M       16.4K    yes       yes
+openai-codex  gpt-5.6-luna                  272K     128K     yes       yes
+team-agent    Claude Opus 4.6 (Thinking)    200K     32.8K    yes       yes
+team-agent    Claude Sonnet 4.6 (Thinking)  200K     32.8K    yes       yes
+team-agent    Gemini 3.8 Flash              200K     32.8K    yes       yes
+team-agent    gpt-5.6-luna                  200K     32.8K    yes       yes
+team-agent    qwen3.8-27b                   262.1K   32.8K    yes       yes

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

@@ -518,11 +518,8 @@ fn assert_provider_mcp_table(case: &Case, provider: Provider, clone_id: &str) {
         }
         Provider::CursorAgent => {
             apply_cursor_mcp_overlay(&overlay_root, &cfg).expect("cursor overlay");
-            let text = std::fs::read_to_string(
-                team_agent::lifecycle::cursor_mcp_json_path(&overlay_root, clone_id)
-                    .expect("iso path"),
-            )
-            .expect("cursor mcp.json");
+            let text = std::fs::read_to_string(overlay_root.join(".cursor/mcp.json"))
+                .expect("cursor mcp.json");
             assert!(
                 text.contains("\"team_orchestrator\""),
                 "cursor MCP injection must keep team_orchestrator; text={text}"

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

@@ -21,6 +21,13 @@ mod hermetic_guard;
 #[allow(dead_code)]
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
+fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
+    let env = hermetic_guard::HermeticTestEnv::enter(tag);
+    env.scrub_tmux();
+    env.assert_no_real_tmux();
+    env
+}
+
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
@@ -31,6 +38,7 @@ use team_agent::transport::test_support::OfflineTransport;
 #[test]
 #[serial(env)]
 fn grok_role_effort_medium_reaches_argv() {
+    let _hermetic = enter_hermetic("grok-effort-medium");
     let (ws, _home, _guard, team) = seed_grok("effort-medium", Some("medium"));
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("grokteam"), &transport)
@@ -45,6 +53,7 @@ fn grok_role_effort_medium_reaches_argv() {
 #[test]
 #[serial(env)]
 fn grok_role_without_effort_emits_zero_effort_flags() {
+    let _hermetic = enter_hermetic("grok-effort-absent");
     let (ws, _home, _guard, team) = seed_grok("effort-absent", None);
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("grokteam"), &transport)
@@ -60,6 +69,7 @@ fn grok_role_without_effort_emits_zero_effort_flags() {
 #[test]
 #[serial(env)]
 fn grok_restart_keeps_declared_effort_medium() {
+    let _hermetic = enter_hermetic("grok-effort-restart");
     let (ws, _home, _guard, team) = seed_grok("effort-restart", Some("medium"));
     let first = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("grokteam"), &first)

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

@@ -14,6 +14,13 @@ mod hermetic_guard;
 #[allow(dead_code)]
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
+fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
+    let env = hermetic_guard::HermeticTestEnv::enter(tag);
+    env.scrub_tmux();
+    env.assert_no_real_tmux();
+    env
+}
+
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
@@ -183,7 +190,7 @@ fn sample_mcp_config(agent_id: &str, workspace: &str) -> McpConfig {
 fn two_grok_seats_coexist_when_toml_has_no_per_seat_keys() {
     let ws = tmp_dir("grok-cwd-coexist");
     let home = tmp_dir("grok-cwd-coexist-home");
-    seed_grok_home(&home);
+    seed_grok_home(&home, Some(&ws));
     let _guard = HomeGuard::set(&home);
     let team = write_grok_team_agents(&ws, "grokteam", &["g1", "g2"]);
 
@@ -209,9 +216,10 @@ fn two_grok_seats_coexist_when_toml_has_no_per_seat_keys() {
 #[test]
 #[serial(env)]
 fn leftover_per_seat_key_is_cleared_before_start() {
+    let _hermetic = enter_hermetic("grok-overlay-leftover-seat");
     let ws = tmp_dir("grok-cwd-per-seat");
     let home = tmp_dir("grok-cwd-per-seat-home");
-    seed_grok_home(&home);
+    seed_grok_home(&home, Some(&ws));
     let _guard = HomeGuard::set(&home);
     let grok = ws.join(".grok");
     std::fs::create_dir_all(&grok).unwrap();
@@ -279,12 +287,46 @@ TEAM_AGENT_WORKSPACE = "/stale-ws"
     );
 }
 
+#[test]
+#[serial(env)]
+fn grok_untrusted_folder_refuses_to_start() {
+    let _hermetic = enter_hermetic("grok-overlay-untrusted");
+    let ws = tmp_dir("grok-untrusted");
+    let home = tmp_dir("grok-untrusted-home");
+    seed_grok_home(&home, None);
+    let _guard = HomeGuard::set(&home);
+    let team = write_grok_team(&ws, "grokteam", "grok_writer");
+    let err = quick_start_with_transport_in_workspace(
+        &ws,
+        &team,
+        None,
+        true,
+        Some("grokteam"),
+        &OfflineTransport::new(),
+    )
+    .expect_err("untrusted folder must not start a grok seat");
+    let text = err.to_string();
+    assert!(
+        text.contains("not trusted") && text.contains("action:"),
+        "untrusted-folder error must be actionable; err={text}"
+    );
+    assert!(
+        text.contains("grok --trust") || text.contains("/hooks-trust"),
+        "next step must name grok --trust or /hooks-trust; err={text}"
+    );
+}
+
 #[test]
 #[serial(env)]
 fn grok_missing_login_refuses_to_start() {
     let ws = tmp_dir("grok-nologin");
     let home = tmp_dir("grok-nologin-home");
     std::fs::create_dir_all(home.join(".grok")).unwrap();
+    std::fs::write(
+        home.join(".grok").join("trusted_folders.toml"),
+        format!("[folders.\"{}\"]\ntrusted = true\n", ws.display()),
+    )
+    .unwrap();
     let _guard = HomeGuard::set(&home);
     let err = ensure_grok_login_and_folder_trust(&ws).expect_err("missing auth.json");
     match err {
@@ -298,29 +340,13 @@ fn grok_missing_login_refuses_to_start() {
     }
 }
 
-#[test]
-#[serial(env)]
-fn grok_login_present_allows_start_without_inspect_or_toml_trust() {
-    let ws = tmp_dir("grok-login-only");
-    let home = tmp_dir("grok-login-only-home");
-    seed_grok_home(&home);
-    let _guard = HomeGuard::set(&home);
-
-    assert!(!home.join("bin/grok").exists(), "no inspect shim may exist");
-    assert!(
-        !home.join(".grok/trusted_folders.toml").exists(),
-        "no trusted TOML may be required"
-    );
-    ensure_grok_login_and_folder_trust(&ws)
-        .expect("valid login alone must allow Grok TUI to own folder consent");
-}
-
 #[test]
 #[serial(env)]
 fn grok_spawn_writes_resolved_team_agent_into_project_grok_config() {
+    let _hermetic = enter_hermetic("grok-overlay-spawn");
     let ws = tmp_dir("grok-mcp-overlay");
     let home = tmp_dir("grok-mcp-overlay-home");
-    seed_grok_home(&home);
+    seed_grok_home(&home, Some(&ws));
     let _guard = HomeGuard::set(&home);
     let team = write_grok_team(&ws, "grokteam", "grok_writer");
     let config_path = ws.join(".grok").join("config.toml");
@@ -435,40 +461,37 @@ fn write_grok_team_agents(ws: &Path, team_key: &str, agent_ids: &[&str]) -> Path
     team
 }
 
-fn seed_grok_home(home: &Path) {
+fn seed_grok_home(home: &Path, trusted_cwd: Option<&Path>) {
     let grok = home.join(".grok");
     std::fs::create_dir_all(&grok).unwrap();
     std::fs::write(grok.join("auth.json"), r#"{"test":"ok"}"#).unwrap();
+    if let Some(cwd) = trusted_cwd {
+        std::fs::write(
+            grok.join("trusted_folders.toml"),
+            format!("[folders.\"{}\"]\ntrusted = true\n", cwd.display()),
+        )
+        .unwrap();
+    }
 }
 
 struct HomeGuard {
-    prev_home: Option<String>,
-    prev_path: Option<String>,
+    prev: Option<String>,
 }
 
 impl HomeGuard {
     fn set(home: &Path) -> Self {
-        let prev_home = std::env::var("HOME").ok();
-        let prev_path = std::env::var("PATH").ok();
+        let prev = std::env::var("HOME").ok();
         std::env::set_var("HOME", home);
-        std::env::set_var("PATH", home.join("bin"));
-        Self {
-            prev_home,
-            prev_path,
-        }
+        Self { prev }
     }
 }
 
 impl Drop for HomeGuard {
     fn drop(&mut self) {
-        match &self.prev_home {
+        match &self.prev {
             Some(value) => std::env::set_var("HOME", value),
             None => std::env::remove_var("HOME"),
         }
-        match &self.prev_path {
-            Some(value) => std::env::set_var("PATH", value),
-            None => std::env::remove_var("PATH"),
-        }
     }
 }
 

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

@@ -13,6 +13,13 @@ mod hermetic_guard;
 #[allow(dead_code)]
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
+fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
+    let env = hermetic_guard::HermeticTestEnv::enter(tag);
+    env.scrub_tmux();
+    env.assert_no_real_tmux();
+    env
+}
+
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
@@ -91,6 +98,7 @@ fn grok_role_missing_model_refuses_to_start() {
 #[test]
 #[serial(env)]
 fn grok_role_explicit_model_reaches_argv() {
+    let _hermetic = enter_hermetic("grok-explicit-model");
     let ws = tmp_dir("grok-with-model");
     let home = tmp_dir("grok-with-model-home");
     seed_grok_home(&home, Some(&ws));
@@ -124,7 +132,9 @@ fn grok_role_explicit_model_reaches_argv() {
 
 /// 3. claude 角色缺 model ⇒ 行为不变（仍能启动，不被 grok 的硬性 model 要求误伤）。
 #[test]
+#[serial(env)]
 fn claude_role_missing_model_still_starts() {
+    let _hermetic = enter_hermetic("grok-claude-missing-model");
     let ws = tmp_dir("claude-no-model");
     let team = write_role_team(
         &ws,

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

@@ -21,6 +21,13 @@ mod hermetic_guard;
 #[allow(dead_code)]
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
+fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
+    let env = hermetic_guard::HermeticTestEnv::enter(tag);
+    env.scrub_tmux();
+    env.assert_no_real_tmux();
+    env
+}
+
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
@@ -35,6 +42,7 @@ use team_agent::transport::test_support::OfflineTransport;
 #[test]
 #[serial(env)]
 fn grok_fresh_spawn_binds_pending_session_id_to_argv_session_id() {
+    let _hermetic = enter_hermetic("grok-resume-pending");
     let (ws, _home, _guard, team) = seed_grok("pending");
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("grokteam"), &transport)
@@ -68,6 +76,7 @@ fn grok_fresh_spawn_binds_pending_session_id_to_argv_session_id() {
 #[test]
 #[serial(env)]
 fn grok_restart_uses_resume_when_session_captured_and_archive_present() {
+    let _hermetic = enter_hermetic("grok-resume-captured");
     let (ws, home, _guard, team) = seed_grok("resume");
     let first = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("grokteam"), &first)

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

@@ -229,7 +229,7 @@ got {status:?}"
 #[test]
 #[serial(t3_event)]
 fn t3_unknown_business_status_is_preserved_without_normalized_event() {
-    let harness = McpSimHarness::new_without_tmux();
+    let harness = McpSimHarness::new();
     let mut worker = harness.spawn_mcp_client("worker_a", "teamA");
     let status = "garbage-status-xyz";
     let call = worker.call_tool(
@@ -423,7 +423,8 @@ check behind it = false green); it must reflect an actual doctor result"
 /// unparseable / unsuccessful, the hint must not default to Present (auth misreported
 /// as available). PATH-shims a `claude` that prints garbage and exits non-zero.
 /// Mutates the process-global PATH/HOME — must not race host_cotenant's ps/tmux
-/// shims (P0 pid-probe isolation), hence `#[serial(pid_probe)]`.
+/// shims (P0 pid-probe isolation) or other env-mutating tests, hence
+/// `#[serial(env, pid_probe)]`.
 #[test]
 #[serial(env, pid_probe)]
 fn t3_claude_auth_hint_parse_failure_is_not_present() {

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

@@ -1846,171 +1846,3 @@ fn lanea_fork_rollback_complete_on_post_spawn_failure() {
     // Golden contract (operations.py:384-394): a post-spawn failure kills the spawned window, restores
     // the old spec text + prior state, and runs cleanup_mcp before re-raising.
 }
-
-#[test]
-fn schema_invalid_pi_role_is_rejected_before_normal_and_force_mutation() {
-    let ws = lanea_ws_agents(json!({
-        "alpha": { "status": "stopped", "provider": "codex", "window": "alpha" },
-        "bravo": { "status": "running", "provider": "codex", "window": "bravo" }
-    }));
-    let tx = LaneTransport::new("team-laneateam", &[]);
-    seed_healthy_coordinator(&ws);
-    let role_dir = ws.join("role-masters");
-    std::fs::create_dir_all(&role_dir).unwrap();
-    let role = role_dir.join("invalid-pi.md");
-    std::fs::write(
-        &role,
-        CHARLIE_ROLE
-            .replace(
-                "provider: codex\nmodel: gpt-5.5",
-                "provider: pi\nmodel: openai-codex/gpt-5.6-sol",
-            )
-            .replace("  - mcp_team", "  - fs_read"),
-    )
-    .unwrap();
-
-    let spec_path = selected_spec_path(&ws);
-    let state_path = crate::state::persist::runtime_state_path(&ws);
-    let event_path = ws.join(".team/logs/events.jsonl");
-    let copied_role = ws.join("agents/charlie.md");
-    let team_state_path = ws.join("team_state.md");
-    let charlie_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
-        &ws,
-        "laneateam",
-        "charlie",
-    );
-    let alpha_paths =
-        crate::lifecycle::launch::pi_mcp::pi_seat_paths(&ws, "laneateam", "alpha");
-    let spec_before = std::fs::read(&spec_path).unwrap();
-    let state_before = std::fs::read(&state_path).unwrap();
-    let role_before = std::fs::read(&role).unwrap();
-    let alpha_before = serde_json::from_slice::<serde_json::Value>(&state_before).unwrap()
-        ["agents"]["alpha"]
-        .clone();
-    for path in [
-        &event_path,
-        &copied_role,
-        &team_state_path,
-        &charlie_paths.wrapper,
-        &charlie_paths.sessions,
-        &alpha_paths.wrapper,
-        &alpha_paths.sessions,
-    ] {
-        assert!(!path.exists(), "precondition: {} must be absent", path.display());
-    }
-
-    let assert_schema_error = |error: crate::lifecycle::LifecycleError| match error {
-        crate::lifecycle::LifecycleError::Compile(message) => {
-            assert!(message.contains("Pi roles require mcp_team"), "{message}");
-        }
-        other => panic!("expected Pi role schema error, got {other:?}"),
-    };
-    let assert_unchanged = |expected_role: &[u8]| {
-        assert_eq!(spec_before, std::fs::read(&spec_path).unwrap());
-        assert_eq!(state_before, std::fs::read(&state_path).unwrap());
-        assert_eq!(expected_role, std::fs::read(&role).unwrap());
-        for path in [
-            &event_path,
-            &copied_role,
-            &team_state_path,
-            &charlie_paths.wrapper,
-            &charlie_paths.sessions,
-            &alpha_paths.wrapper,
-            &alpha_paths.sessions,
-        ] {
-            assert!(!path.exists(), "preflight created {}", path.display());
-        }
-        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-        assert_eq!(state["agents"]["alpha"], alpha_before);
-        assert!(state["agents"].get("charlie").is_none(), "no reservation row");
-        assert!(tx.spawns().is_empty());
-        assert!(tx.killed().is_empty());
-    };
-
-    let mut normal_calls = 0;
-    let mut normal_discover = |_requested: &str| {
-        normal_calls += 1;
-        Ok(Vec::new())
-    };
-    let normal = crate::lifecycle::add_agent_with_transport_pi_preflight(
-        &ws,
-        &aid("charlie"),
-        &role,
-        false,
-        None,
-        &tx,
-        &mut normal_discover,
-    )
-    .expect_err("invalid Pi schema must fail before reservation");
-    drop(normal_discover);
-    assert_eq!(normal_calls, 0);
-    assert_schema_error(normal);
-    assert_unchanged(&role_before);
-
-    let mut force_calls = 0;
-    let mut force_discover = |_requested: &str| {
-        force_calls += 1;
-        Ok(Vec::new())
-    };
-    let force = crate::lifecycle::add_agent_with_transport_force_pi_preflight(
-        &ws,
-        &aid("alpha"),
-        &role,
-        false,
-        None,
-        true,
-        &tx,
-        &mut force_discover,
-    )
-    .expect_err("invalid Pi replacement schema must fail before old-seat consumption");
-    drop(force_discover);
-    assert_eq!(force_calls, 0);
-    assert_schema_error(force);
-    assert_unchanged(&role_before);
-
-    std::fs::write(
-        &role,
-        CHARLIE_ROLE.replace(
-            "provider: codex\nmodel: gpt-5.5",
-            "provider: pi\nmodel: gpt-5.6-sol",
-        ),
-    )
-    .unwrap();
-    let model_role_before = std::fs::read(&role).unwrap();
-    let assert_model_diagnostic = |error: crate::lifecycle::LifecycleError| match error {
-        crate::lifecycle::LifecycleError::PiModelPreflight {
-            requested,
-            candidates,
-            not_ready,
-            ..
-        } => {
-            assert_eq!(requested, "gpt-5.6-sol");
-            assert_eq!(candidates, vec!["openai-codex/gpt-5.6-sol"]);
-            assert!(!not_ready);
-        }
-        other => panic!("expected typed Pi preflight error, got {other:?}"),
-    };
-    for (force, agent_id) in [(false, "charlie"), (true, "alpha")] {
-        let mut calls = 0;
-        let mut discover = |requested: &str| {
-            calls += 1;
-            assert_eq!(requested, "gpt-5.6-sol");
-            Ok(vec!["openai-codex/gpt-5.6-sol".into()])
-        };
-        let error = crate::lifecycle::add_agent_with_transport_force_pi_preflight(
-            &ws,
-            &aid(agent_id),
-            &role,
-            false,
-            None,
-            force,
-            &tx,
-            &mut discover,
-        )
-        .expect_err("unqualified Pi model must fail before mutation");
-        drop(discover);
-        assert_eq!(calls, 1);
-        assert_model_diagnostic(error);
-        assert_unchanged(&model_role_before);
-    }
-}