@team-agent/installer 0.5.68 → 0.5.70

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

@@ -0,0 +1,145 @@
+use std::path::Path;
+
+use crate::model::enums::ProviderEffort;
+use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiSessionSelector};
+
+fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
+    PiCommandRequest {
+        executable: Path::new("/verified/pi"),
+        extension: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts"),
+        model: Some("team-agent/qwen3.8-27b"),
+        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,
+        agent_id: "worker-a",
+    }
+}
+
+#[test]
+fn pi_command_omits_unset_model_and_thinking_flags() {
+    let mut request = request(PiSessionSelector::Fresh {
+        session_id: "a2320d4e-7b3a-44ae-b3b8-d5de57033b01",
+    });
+    request.model = None;
+    request.effort = None;
+    let argv = build_pi_command_argv(request).expect("Pi provider defaults");
+
+    assert!(!argv.iter().any(|arg| arg == "--model"), "argv={argv:?}");
+    assert!(!argv.iter().any(|arg| arg == "--thinking"), "argv={argv:?}");
+}
+
+#[test]
+fn pi_command_preserves_direct_pi_defaults_with_only_team_runtime_additions() {
+    let fresh = build_pi_command_argv(request(PiSessionSelector::Fresh {
+        session_id: "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+    }))
+    .expect("fresh Pi command");
+    assert_eq!(
+        fresh,
+        [
+            "/verified/pi",
+            "-e",
+            "/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts",
+            "--model",
+            "team-agent/qwen3.8-27b",
+            "--thinking",
+            "high",
+            "--append-system-prompt",
+            "frozen worker prompt",
+            "--session-dir",
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
+            "--session-id",
+            "da8c3622-2378-4d05-a26c-e826a6ef6d63",
+            "--name",
+            "worker-a",
+        ]
+        .map(str::to_string)
+    );
+
+    let resume = build_pi_command_argv(request(PiSessionSelector::Resume {
+        path: Path::new(
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions/2026/08/session.jsonl",
+        ),
+    }))
+    .expect("resume Pi command");
+    assert!(resume.windows(2).any(|pair| {
+        pair == [
+            "--session",
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions/2026/08/session.jsonl",
+        ]
+    }));
+    assert!(!resume.iter().any(|arg| arg == "--session-id"));
+
+    for argv in [&fresh, &resume] {
+        for forbidden in [
+            "rpc",
+            "--mode",
+            "--print",
+            "-p",
+            "-r",
+            "--resume",
+            "-c",
+            "--continue",
+            "--mcp-config",
+            "--provider",
+            "--fork",
+            "--workspace",
+            "--cwd",
+            "--rules",
+            "--always-approve",
+            "--force",
+            "--trust",
+            "--sandbox",
+            "--no-extensions",
+            "--no-approve",
+            "--no-context-files",
+            "--no-skills",
+            "--no-prompt-templates",
+            "--tui-mode",
+            "--tools",
+            "--system-prompt",
+        ] {
+            assert!(
+                !argv.iter().any(|arg| arg == forbidden),
+                "materializer-owned Pi argv must not inherit {forbidden}: {argv:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn pi_command_keeps_direct_plugins_skills_context_auth_and_tools() {
+    let argv = build_pi_command_argv(request(PiSessionSelector::Fresh {
+        session_id: "76f682b1-ecc3-4586-850f-ab2e2bb04cb3",
+    }))
+    .expect("fresh Pi command");
+
+    for forbidden in [
+        "--no-context-files",
+        "--no-extensions",
+        "--no-approve",
+        "--no-skills",
+        "--no-prompt-templates",
+        "--tools",
+        "--system-prompt",
+        "--tui-mode",
+    ] {
+        assert_eq!(
+            argv.iter().filter(|arg| arg.as_str() == forbidden).count(),
+            0,
+            "TeamMate Pi must preserve the direct Pi default instead of adding {forbidden}; argv={argv:?}"
+        );
+    }
+    assert!(argv.windows(2).any(|pair| {
+        pair == [
+            "-e",
+            "/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts",
+        ]
+    }));
+    assert_eq!(argv.iter().filter(|arg| arg.as_str() == "-e").count(), 1);
+    assert!(argv
+        .windows(2)
+        .any(|pair| pair == ["--append-system-prompt", "frozen worker prompt"]));
+}

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

@@ -0,0 +1,243 @@
+use std::path::Path;
+use std::sync::atomic::{AtomicU32, Ordering};
+
+use crate::compiler::{compile_role_agent, CompiledRole};
+use crate::lifecycle::launch::pi_mcp::{parse_pi_list_models_table, select_exact_pi_model};
+use crate::model::enums::ProviderEffort;
+use crate::model::yaml::Value;
+use crate::model::ModelError;
+use crate::provider::adapters::pi::{
+    build_pi_command_argv, pi_tool_mapping, PiCommandRequest, PiSessionSelector, PiToolMapping,
+};
+
+const CATALOG: &[u8] = include_bytes!("fixtures/pi_list_models_g0.stdout.txt");
+static NEXT_ROLE: AtomicU32 = AtomicU32::new(0);
+
+fn compile_pi_role(front_matter: &str) -> Result<CompiledRole, ModelError> {
+    compile_pi_role_with_team(front_matter, &Value::Map(Vec::new()))
+}
+
+fn compile_pi_role_with_team(
+    front_matter: &str,
+    team_meta: &Value,
+) -> Result<CompiledRole, ModelError> {
+    let seq = NEXT_ROLE.fetch_add(1, Ordering::Relaxed);
+    let root = std::env::temp_dir().join(format!(
+        "team-agent-pi-compiler-{}-{seq}",
+        std::process::id()
+    ));
+    std::fs::create_dir_all(&root).expect("create role fixture root");
+    let role = root.join("pi-worker.md");
+    std::fs::write(
+        &role,
+        format!("---\n{front_matter}\n---\nPi worker contract.\n"),
+    )
+    .expect("write role fixture");
+    let result = compile_role_agent(&role, team_meta, "/workspace");
+    std::fs::remove_dir_all(root).expect("remove role fixture root");
+    result
+}
+
+fn valid_role_with(extra: &str) -> String {
+    format!(
+        "name: pi-worker\nrole: developer\nprovider: pi\nmodel: team-agent/qwen3.8-27b\nauth_mode: subscription\neffort: medium\ntools:\n  - mcp_team\n  - fs_read\n  - fs_list\n  - fs_write\n  - execute_bash\ndangerously_skip_permissions: true\n{extra}"
+    )
+}
+
+fn compile_error(result: Result<CompiledRole, ModelError>) -> ModelError {
+    match result {
+        Err(error) => error,
+        Ok(_) => panic!("incomplete Pi role must refuse"),
+    }
+}
+
+fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<String>, String> {
+    build_pi_command_argv(PiCommandRequest {
+        executable: Path::new("/verified/pi"),
+        extension: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/team-mcp.ts"),
+        model: Some(model),
+        effort: Some(effort),
+        system_prompt: "Pi worker contract.",
+        tool_categories: tools,
+        session_dir: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/sessions"),
+        session: PiSessionSelector::Fresh {
+            session_id: "c5ddf218-24a5-4e74-960c-ab6606ea7e8c",
+        },
+        agent_id: "pi-worker",
+    })
+    .map_err(|error| error.to_string())
+}
+
+#[test]
+fn pi_role_requires_mcp_team_and_preserves_provider_defaults() {
+    let positive = compile_pi_role(&valid_role_with(""));
+    assert!(positive.is_ok(), "fully explicit Pi role must compile");
+
+    let missing_mcp = valid_role_with("").replace("  - mcp_team\n", "");
+    let unqualified =
+        valid_role_with("").replace("model: team-agent/qwen3.8-27b", "model: qwen3.8-27b");
+
+    for (label, role) in [
+        ("mcp_team", missing_mcp),
+        ("qualified exact model", unqualified),
+    ] {
+        let error = compile_error(compile_pi_role(&role));
+        assert!(
+            error.to_string().to_ascii_lowercase().contains(label),
+            "error must name {label}; got {error}"
+        );
+    }
+
+    let defaults = valid_role_with("")
+        .replace("model: team-agent/qwen3.8-27b\n", "")
+        .replace("effort: medium\n", "");
+    let team_meta = Value::Map(vec![
+        (
+            "provider_models".to_string(),
+            Value::Map(vec![(
+                "pi".to_string(),
+                Value::Str("team-default/forced-model".to_string()),
+            )]),
+        ),
+        (
+            "default_model".to_string(),
+            Value::Str("global-default/forced-model".to_string()),
+        ),
+        (
+            "provider_effort".to_string(),
+            Value::Str("high".to_string()),
+        ),
+    ]);
+    let compiled = compile_pi_role_with_team(&defaults, &team_meta)
+        .expect("Pi model and effort may use provider defaults");
+    assert_eq!(
+        compiled.agent.get("model"),
+        Some(&Value::Null),
+        "omitted Pi model must not inherit a synthesized framework default"
+    );
+    assert!(
+        compiled.agent.get("effort").is_none(),
+        "omitted Pi effort must not inherit a synthesized framework default"
+    );
+
+    let models = parse_pi_list_models_table(CATALOG).expect("catalog fixture");
+    assert!(select_exact_pi_model(&models, "team-agent/qwen3.8-27b").is_ok());
+    assert!(select_exact_pi_model(&models, "foo/bar").is_err());
+}
+
+#[test]
+fn pi_role_uses_standard_bypass_field_without_fabricating_argv() {
+    let compiled = compile_pi_role(&valid_role_with("")).expect("true acknowledgement");
+    assert_eq!(
+        compiled.agent.get("dangerously_skip_permissions"),
+        Some(&Value::Bool(true))
+    );
+
+    let argv = command(
+        &["mcp_team"],
+        ProviderEffort::Medium,
+        "team-agent/qwen3.8-27b",
+    )
+    .expect("true acknowledgement maps to intrinsic unrestricted mode");
+    for forbidden in [
+        "--approve",
+        "--always-approve",
+        "--force",
+        "--trust",
+        "--sandbox",
+        "dangerous_auto_approve",
+    ] {
+        assert!(
+            !argv.iter().any(|arg| arg == forbidden),
+            "Pi acknowledgement must not fabricate a bypass flag {forbidden}: {argv:?}"
+        );
+    }
+
+    let false_ack = valid_role_with("").replace(
+        "dangerously_skip_permissions: true",
+        "dangerously_skip_permissions: false",
+    );
+    let compiled = compile_pi_role(&false_ack).expect("standard false bypass value");
+    assert_eq!(
+        compiled.agent.get("dangerously_skip_permissions"),
+        Some(&Value::Bool(false))
+    );
+
+    let missing_ack = valid_role_with("").replace("dangerously_skip_permissions: true\n", "");
+    let text = compile_error(compile_pi_role(&missing_ack)).to_string();
+    assert!(
+        text.contains("missing front matter field dangerously_skip_permissions"),
+        "got {text}"
+    );
+}
+
+#[test]
+fn pi_max_effort_is_supported_without_model_suffix() {
+    let max_role = valid_role_with("").replace("effort: medium", "effort: max");
+    compile_pi_role(&max_role).expect("Pi supports explicit max effort");
+
+    let argv =
+        command(&["mcp_team"], ProviderEffort::Max, "team-agent/qwen3.8-27b").expect("max Pi argv");
+    assert!(
+        argv.windows(2).any(|pair| pair == ["--thinking", "max"]),
+        "max must map to --thinking max: {argv:?}"
+    );
+    assert!(
+        argv.windows(2)
+            .any(|pair| pair == ["--model", "team-agent/qwen3.8-27b"]),
+        "model must remain exact and unsuffixed: {argv:?}"
+    );
+    assert!(!argv.iter().any(|arg| arg.ends_with(":max")));
+
+    let models = parse_pi_list_models_table(CATALOG).expect("catalog fixture");
+    assert!(select_exact_pi_model(&models, "team-agent/qwen3.8-27b:max").is_err());
+}
+
+#[test]
+fn pi_role_tools_validate_team_capabilities_without_replacing_direct_pi_tools() {
+    assert_eq!(pi_tool_mapping("mcp_team"), PiToolMapping::Mcp);
+    assert_eq!(
+        pi_tool_mapping("fs_read"),
+        PiToolMapping::Builtin(&["read"])
+    );
+    assert_eq!(
+        pi_tool_mapping("fs_list"),
+        PiToolMapping::Builtin(&["grep", "find", "ls"])
+    );
+    assert_eq!(
+        pi_tool_mapping("fs_write"),
+        PiToolMapping::Builtin(&["edit", "write"])
+    );
+    assert_eq!(
+        pi_tool_mapping("execute_bash"),
+        PiToolMapping::Builtin(&["bash"])
+    );
+
+    for unsupported in ["git_diff", "network", "provider_builtin", "not_a_tool"] {
+        assert_eq!(
+            pi_tool_mapping(unsupported),
+            PiToolMapping::Unsupported,
+            "unknown categories must not silently broaden to bash"
+        );
+        assert!(
+            command(
+                &["mcp_team", unsupported],
+                ProviderEffort::Medium,
+                "team-agent/qwen3.8-27b"
+            )
+            .is_err(),
+            "unsupported tool must refuse the command: {unsupported}"
+        );
+    }
+
+    let argv = command(
+        &["mcp_team", "fs_write", "fs_read", "fs_list", "execute_bash"],
+        ProviderEffort::Medium,
+        "team-agent/qwen3.8-27b",
+    )
+    .expect("known standard role tools");
+    assert!(
+        !argv.iter().any(|arg| arg == "--tools"),
+        "role tools validate Team Agent capabilities but must not replace direct Pi tools: {argv:?}"
+    );
+}