@team-agent/installer 0.5.71 → 0.5.73

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

@@ -189,6 +189,7 @@ pub(super) fn spawn_agents(
                     tool_categories: &resolved_tool_refs,
                     team_mcp_tools: &["send_message", "report_result"],
                     mcp_config: &mcp_config,
+                    session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
                 },
             )
             .map_err(|e| LifecycleError::Provider(e.to_string()))?

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

@@ -402,6 +402,7 @@ pub(super) fn spawn_agent_window(
             tool_categories: &resolved_tool_refs,
             team_mcp_tools: &["send_message", "report_result"],
             mcp_config: &mcp_config,
+            session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
         };
         match resume_session_id {
             Some(session_id) => {

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

@@ -1846,3 +1846,171 @@ 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);
+    }
+}

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

@@ -375,6 +375,215 @@ fn quick_start_invalid_role_doc_surfaces_real_compile_error() {
     );
 }
 
+#[test]
+fn quick_start_absent_or_empty_roles_preserves_compile_outcome_without_pi_preflight_mutation() {
+    for (label, create_agents, expected) in [
+        ("absent", false, "missing agents directory"),
+        ("empty", true, "no role docs found"),
+    ] {
+        let team = temp_ws().join(format!("teamdir-{label}"));
+        std::fs::create_dir_all(&team).unwrap();
+        std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
+        if create_agents {
+            std::fs::create_dir(team.join("agents")).unwrap();
+        }
+        let workspace = crate::model::paths::team_workspace(&team).unwrap();
+        let team_md_before = std::fs::read(team.join("TEAM.md")).unwrap();
+        let absent_paths = [
+            team.join("team.spec.yaml"),
+            crate::state::persist::runtime_state_path(&workspace),
+            crate::model::paths::runtime_spec_path(&workspace, "quickteam"),
+            workspace.join("team_state.md"),
+            workspace.join(".team/logs/events.jsonl"),
+            workspace.join(".team/runtime/team.db"),
+        ];
+        for path in &absent_paths {
+            assert!(!path.exists(), "precondition: {} must be absent", path.display());
+        }
+
+        let transport = OfflineTransport::new();
+        let mut calls = 0;
+        let mut discover = |_requested: &str| {
+            calls += 1;
+            Ok(Vec::new())
+        };
+        let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
+            &workspace,
+            &team,
+            None,
+            true,
+            None,
+            &transport,
+            true,
+            &mut discover,
+        )
+        .expect_err("an empty role input must preserve the existing compile outcome");
+        drop(discover);
+        assert_eq!(calls, 0, "{label} role input must not invoke Pi discovery");
+        match error {
+            LifecycleError::Compile(message) => {
+                assert!(message.contains(expected), "{label}: {message}");
+            }
+            other => panic!("{label}: expected existing compile outcome, got {other:?}"),
+        }
+        assert_eq!(team_md_before, std::fs::read(team.join("TEAM.md")).unwrap());
+        for path in &absent_paths {
+            assert!(!path.exists(), "{label} role input created {}", path.display());
+        }
+        assert!(transport.calls().is_empty(), "{label}: no transport mutation");
+        assert!(transport.spawn_records().is_empty(), "{label}: no spawn");
+    }
+}
+
+#[test]
+fn quick_start_injected_pi_preflight_is_typed_and_mutation_free() {
+    let role_doc = QS_VALID_ROLE.replace(
+        "provider: codex\nmodel: gpt-5.5",
+        "provider: pi\nmodel: gpt-5.6-sol",
+    );
+    let team = quick_start_team_dir(&role_doc);
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let role_path = team.join("agents/implementer.md");
+    let team_md_path = team.join("TEAM.md");
+    let local_spec_path = team.join("team.spec.yaml");
+    let runtime_state_path = crate::state::persist::runtime_state_path(&workspace);
+    let runtime_spec_path = crate::model::paths::runtime_spec_path(&workspace, "quickteam");
+    let pi_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
+        &workspace,
+        "quickteam",
+        "implementer",
+    );
+    let role_before = std::fs::read(&role_path).unwrap();
+    let team_md_before = std::fs::read(&team_md_path).unwrap();
+    for path in [
+        &local_spec_path,
+        &runtime_state_path,
+        &runtime_spec_path,
+        &pi_paths.wrapper,
+        &pi_paths.sessions,
+    ] {
+        assert!(!path.exists(), "precondition: {} must be absent", path.display());
+    }
+
+    let transport = OfflineTransport::new();
+    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 = quick_start_with_transport_in_workspace_with_display_pi_preflight(
+        &workspace,
+        &team,
+        None,
+        true,
+        None,
+        &transport,
+        true,
+        &mut discover,
+    )
+    .expect_err("unqualified Pi role must fail before quick-start mutation");
+    drop(discover);
+    assert_eq!(calls, 1);
+    match error {
+        LifecycleError::PiModelPreflight {
+            requested,
+            candidates,
+            action,
+            not_ready,
+        } => {
+            assert_eq!(requested, "gpt-5.6-sol");
+            assert_eq!(candidates, vec!["openai-codex/gpt-5.6-sol"]);
+            assert_eq!(
+                action,
+                "copy a candidate into the role, or run `team-agent models --provider pi --search gpt-5.6-sol`"
+            );
+            assert!(!not_ready);
+        }
+        other => panic!("expected typed Pi preflight error, got {other:?}"),
+    }
+    assert_eq!(role_before, std::fs::read(&role_path).unwrap());
+    assert_eq!(team_md_before, std::fs::read(&team_md_path).unwrap());
+    for path in [
+        &local_spec_path,
+        &runtime_state_path,
+        &runtime_spec_path,
+        &pi_paths.wrapper,
+        &pi_paths.sessions,
+    ] {
+        assert!(!path.exists(), "quick-start preflight created {}", path.display());
+    }
+    assert!(transport.calls().is_empty(), "no transport calls before preflight rejection");
+    assert!(transport.spawn_records().is_empty());
+}
+
+#[test]
+fn quick_start_schema_invalid_pi_role_is_mutation_free() {
+    let role_doc = QS_VALID_ROLE
+        .replace(
+            "provider: codex\nmodel: gpt-5.5",
+            "provider: pi\nmodel: openai-codex/gpt-5.6-sol",
+        )
+        .replace("  - mcp_team", "  - fs_read");
+    let team = quick_start_team_dir(&role_doc);
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let role_path = team.join("agents/implementer.md");
+    let team_md_path = team.join("TEAM.md");
+    let role_before = std::fs::read(&role_path).unwrap();
+    let team_md_before = std::fs::read(&team_md_path).unwrap();
+    let pi_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
+        &workspace,
+        "quickteam",
+        "implementer",
+    );
+    let absent_paths = [
+        team.join("team.spec.yaml"),
+        crate::state::persist::runtime_state_path(&workspace),
+        crate::model::paths::runtime_spec_path(&workspace, "quickteam"),
+        workspace.join("team_state.md"),
+        workspace.join(".team/logs/events.jsonl"),
+        workspace.join(".team/runtime/team.db"),
+        pi_paths.wrapper,
+        pi_paths.sessions,
+    ];
+    for path in &absent_paths {
+        assert!(!path.exists(), "precondition: {} must be absent", path.display());
+    }
+
+    let transport = OfflineTransport::new();
+    let mut calls = 0;
+    let mut discover = |_requested: &str| {
+        calls += 1;
+        Ok(Vec::new())
+    };
+    let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
+        &workspace,
+        &team,
+        None,
+        true,
+        None,
+        &transport,
+        true,
+        &mut discover,
+    )
+    .expect_err("invalid Pi schema must fail before quick-start mutation");
+    drop(discover);
+    assert_eq!(calls, 0, "qualified models must not invoke discovery");
+    match error {
+        LifecycleError::Compile(message) => {
+            assert!(message.contains("Pi roles require mcp_team"), "{message}");
+        }
+        other => panic!("expected Pi role schema error, got {other:?}"),
+    }
+    assert_eq!(role_before, std::fs::read(&role_path).unwrap());
+    assert_eq!(team_md_before, std::fs::read(&team_md_path).unwrap());
+    for path in &absent_paths {
+        assert!(!path.exists(), "schema preflight created {}", path.display());
+    }
+    assert!(transport.calls().is_empty(), "no transport calls before schema rejection");
+    assert!(transport.spawn_records().is_empty());
+}
+
 // P0 — launch (dry_run) over a real compiled spec must resolve the REAL route/permission plan
 // (no spawn) — NOT the hardcoded RequirementUnmet stub. Golden: launch/core.py dry_run resolves
 // routing + permissions without starting any process.

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

@@ -22,7 +22,7 @@ fn command_for_model(model: &str) -> Vec<String> {
         effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/t1/w1/sessions"),
+        session_dir: Some(Path::new("/workspace/.team/runtime/pi/t1/w1/sessions")),
         session: PiSessionSelector::Fresh {
             session_id: "716ba0cb-c491-4471-b41a-43c8d5e1f05a",
         },

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

@@ -1,5 +1,6 @@
 use std::path::Path;
 
+use crate::lifecycle::launch::pi_mcp::{pi_leader_session_scope, PiSessionScope};
 use crate::model::enums::ProviderEffort;
 use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiSessionSelector};
 
@@ -11,7 +12,9 @@ fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
         effort: Some(ProviderEffort::High),
         system_prompt: "frozen worker prompt",
         tool_categories: &["mcp_team", "fs_read", "fs_write", "execute_bash"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
+        )),
         session,
         agent_id: "worker-a",
     }
@@ -30,6 +33,73 @@ fn pi_command_omits_unset_model_and_thinking_flags() {
     assert!(!argv.iter().any(|arg| arg == "--thinking"), "argv={argv:?}");
 }
 
+fn leader_request() -> PiCommandRequest<'static> {
+    PiCommandRequest {
+        executable: Path::new("/verified/pi"),
+        extension: Path::new("/workspace/.team/runtime/pi/current/leader/team-mcp.ts"),
+        model: None,
+        effort: None,
+        system_prompt: "frozen leader prompt",
+        tool_categories: &["mcp_team", "fs_read", "fs_write", "execute_bash"],
+        session_dir: None,
+        session: PiSessionSelector::Fresh {
+            session_id: "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+        },
+        agent_id: "leader",
+    }
+}
+
+#[test]
+fn pi_interactive_leader_argv_preserves_native_session_discovery() {
+    let argv = build_pi_command_argv(leader_request()).expect("native Pi leader command");
+
+    assert_eq!(
+        argv,
+        [
+            "/verified/pi",
+            "-e",
+            "/workspace/.team/runtime/pi/current/leader/team-mcp.ts",
+            "--append-system-prompt",
+            "frozen leader prompt",
+            "--session-id",
+            "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+            "--name",
+            "leader",
+        ]
+        .map(str::to_string)
+    );
+    assert!(!argv.iter().any(|arg| arg == "--session-dir"));
+    for forbidden in ["--cwd", "--workspace", "--session"] {
+        assert!(!argv.iter().any(|arg| arg == forbidden), "argv={argv:?}");
+    }
+}
+
+#[test]
+fn pi_leader_session_scope_keeps_explicit_and_external_routes_isolated() {
+    assert_eq!(
+        pi_leader_session_scope(&[], false, false),
+        PiSessionScope::NativeDefault
+    );
+    for (args, external_path, allow_nested_attach) in [
+        (
+            vec![
+                "--model".to_string(),
+                "openai-codex/gpt-5.6-sol".to_string(),
+            ],
+            false,
+            false,
+        ),
+        (Vec::new(), true, false),
+        (Vec::new(), false, true),
+    ] {
+        assert_eq!(
+            pi_leader_session_scope(&args, external_path, allow_nested_attach),
+            PiSessionScope::Isolated,
+            "only the zero-argument managed route may use Pi's native root"
+        );
+    }
+}
+
 #[test]
 fn pi_command_preserves_direct_pi_defaults_with_only_team_runtime_additions() {
     let fresh = build_pi_command_argv(request(PiSessionSelector::Fresh {

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

@@ -59,7 +59,9 @@ fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<St
         effort: Some(effort),
         system_prompt: "Pi worker contract.",
         tool_categories: tools,
-        session_dir: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/t1/pi-worker/sessions",
+        )),
         session: PiSessionSelector::Fresh {
             session_id: "c5ddf218-24a5-4e74-960c-ab6606ea7e8c",
         },