@team-agent/installer 0.5.69 → 0.5.71

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

@@ -3,8 +3,9 @@ use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU32, Ordering};
 
 use crate::lifecycle::launch::pi_mcp::{
-    parse_pi_list_models_table, validate_pi_adapter_identity, validate_pi_executable_chain,
-    validate_pi_wrapper_source, write_pi_wrapper, PiAdapterIdentity, PiExecutableChain,
+    parse_pi_list_models_table, pi_seat_paths, resolve_pi_executable_chain,
+    validate_pi_adapter_identity, validate_pi_executable_chain, validate_pi_wrapper_source,
+    write_pi_wrapper, write_pi_wrapper_with_publish, PiAdapterIdentity, PiExecutableChain,
     PiExecutableFileType, PiWrapperRequest,
 };
 use crate::provider::McpConfig;
@@ -18,15 +19,20 @@ const INDEX_DIGEST: &str = "16d260ac25b66346baab6ecef76680324336953bafc7be8cf95b
 const CATALOG_DIGEST: &str = "726cedb6c3f6fe80a0d7b98918d8ed5063695e01f510a48f46c4bad5daab49fe";
 static NEXT_ROOT: AtomicU32 = AtomicU32::new(0);
 const PI_WRAPPER_CHILD: &str = "TEAM_AGENT_TEST_PI_WRAPPER_CHILD";
-const PI_WRAPPER_NEGATIVE_CHILD: &str = "TEAM_AGENT_TEST_PI_WRAPPER_NEGATIVE_CHILD";
+const PI_WRAPPER_AMBIENT_CHILD: &str = "TEAM_AGENT_TEST_PI_WRAPPER_AMBIENT_CHILD";
+const PI_SYMLINK_CHILD: &str = "TEAM_AGENT_TEST_PI_SYMLINK_CHILD";
 const PI_WRAPPER_PARENT_PID: &str = "TEAM_AGENT_TEST_PI_WRAPPER_PARENT_PID";
 const PI_WRAPPER_TEST: &str = concat!(
     "lifecycle::tests::pi_executable_mcp_red::",
     "pi_wrapper_is_atomic_per_seat_and_embeds_exact_candidate"
 );
-const PI_WRAPPER_NEGATIVE_TEST: &str = concat!(
+const PI_WRAPPER_AMBIENT_TEST: &str = concat!(
     "lifecycle::tests::pi_executable_mcp_red::",
-    "pi_wrapper_import_failure_has_no_ambient_merge_fallback"
+    "pi_wrapper_runtime_registration_does_not_copy_ambient_config"
+);
+const PI_SYMLINK_TEST: &str = concat!(
+    "lifecycle::tests::pi_executable_mcp_red::",
+    "pi_standard_npm_symlink_is_a_verified_launch_entry"
 );
 
 fn run_process_isolated(marker: &str, test_name: &str, body: impl FnOnce()) {
@@ -165,6 +171,60 @@ fn pi_executable_chain_freezes_wrapper_real_binary_catalog_and_plugin_identity()
     std::fs::remove_dir_all(root).expect("remove executable chain fixture");
 }
 
+#[test]
+fn pi_standard_npm_symlink_is_a_verified_launch_entry() {
+    run_process_isolated(PI_SYMLINK_CHILD, PI_SYMLINK_TEST, || {
+        assert_isolated_child();
+        let root = temp_root("npm-symlink");
+        let bin = root.join("bin");
+        let later_bin = root.join("later-bin");
+        let package_root = root.join("pi-mcp-adapter");
+        std::fs::create_dir_all(&bin).expect("create bin");
+        std::fs::create_dir_all(&later_bin).expect("create later bin");
+        std::fs::create_dir_all(&package_root).expect("create adapter root");
+        let real = root.join("cli.js");
+        let script = format!(
+            "#!/bin/sh\ncase \"$1\" in\n  --version) printf '0.84.4\\n' ;;\n  --list-models) printf 'provider model\\nteam-agent qwen3.8-27b\\n' ;;\n  list) printf 'npm:pi-mcp-adapter\\n{}\\n' ;;\n  *) exit 64 ;;\nesac\n",
+            package_root.display()
+        );
+        std::fs::write(&real, &script).expect("write protocol-capable Pi entry");
+        std::fs::set_permissions(&real, std::fs::Permissions::from_mode(0o755))
+            .expect("make Pi entry executable");
+        std::os::unix::fs::symlink(&real, bin.join("pi")).expect("create npm-style symlink");
+        std::fs::write(later_bin.join("pi"), script).expect("write later Pi wrapper");
+        std::fs::set_permissions(later_bin.join("pi"), std::fs::Permissions::from_mode(0o755))
+            .expect("make later Pi wrapper executable");
+        std::fs::write(
+            package_root.join("package.json"),
+            br#"{"name":"pi-mcp-adapter","version":"2.30.0","pi":{"extensions":["./index.ts"]}}"#,
+        )
+        .expect("write adapter package");
+        std::fs::write(
+            package_root.join("index.ts"),
+            b"export const createMcpAdapter = () => {};\n",
+        )
+        .expect("write adapter entry");
+        unsafe {
+            std::env::set_var(
+                "PATH",
+                std::env::join_paths([&bin, &later_bin]).expect("join fixture PATH"),
+            );
+        }
+
+        let (chain, models) = resolve_pi_executable_chain()
+            .expect("the first PATH Pi entry must define direct Pi behavior");
+        assert_eq!(chain.path_entry, bin.join("pi"));
+        assert_eq!(chain.path_entry_type, PiExecutableFileType::Symlink);
+        assert_eq!(chain.launch_executable, bin.join("pi"));
+        assert_eq!(
+            chain.real_binary,
+            std::fs::canonicalize(&real).expect("canonical real Pi entry")
+        );
+        assert_eq!(models, ["team-agent/qwen3.8-27b"]);
+        std::fs::remove_dir_all(root).expect("remove symlink fixture");
+    });
+}
+
 #[test]
 fn pi_adapter_detector_requires_exact_2_30_0_entry_and_digest() {
     let root = temp_root("adapter-identity");
@@ -234,18 +294,37 @@ fn pi_wrapper_is_atomic_body(hermetic: &HermeticTestEnv) {
     );
 
     let source = std::fs::read_to_string(&written).expect("read wrapper");
-    assert!(source.contains(adapter.index_ts.to_string_lossy().as_ref()));
     assert!(source.contains(candidate.to_string_lossy().as_ref()));
     assert!(source.contains("TEAM_AGENT_ID") && source.contains("worker-a"));
     assert!(source.contains("TEAM_AGENT_OWNER_TEAM_ID") && source.contains("team-a"));
-    assert!(source.contains("lifecycle") && source.contains("lazy"));
-    assert!(source.contains("directTools") && source.contains("false"));
-    assert!(source.contains("toolPrefix") && source.contains("server"));
+    assert!(source.contains("pi-mcp-adapter:runtime-register:v1"));
+    assert!(source.contains("session_start") && source.contains("session_shutdown"));
     assert!(source.contains("includeTools"));
     assert!(source.contains("send_message") && source.contains("report_result"));
+    assert!(!source.contains("createMcpAdapter"));
+    assert!(!source.contains("directTools"));
+    assert!(!source.contains("toolPrefix"));
+    assert!(!source.contains("\"lifecycle\""));
     assert!(!source.contains("command: \"team-agent\""));
     assert!(!source.contains("--mcp-config"));
 
+    let other_destination = workspace.join(".team/runtime/pi/team-a/worker-b/team-mcp.ts");
+    write_pi_wrapper(PiWrapperRequest {
+        destination: &other_destination,
+        adapter: &adapter,
+        candidate_executable: &candidate,
+        mcp_config: &mcp_config(&candidate, &workspace, "worker-b"),
+        team_id: "team-a",
+        agent_id: "worker-b",
+        workspace: &workspace,
+        include_tools: &["send_message", "report_result"],
+    })
+    .expect("write second seat wrapper");
+    let other_source = std::fs::read_to_string(&other_destination).expect("read second wrapper");
+    assert!(source.contains("worker-a") && !source.contains("worker-b"));
+    assert!(other_source.contains("worker-b") && !other_source.contains("worker-a"));
+    assert_ne!(written, other_destination);
+
     let entries = std::fs::read_dir(destination.parent().expect("wrapper parent"))
         .expect("list wrapper parent")
         .map(|entry| entry.expect("entry").file_name())
@@ -259,8 +338,126 @@ fn pi_wrapper_is_atomic_body(hermetic: &HermeticTestEnv) {
 }
 
 #[test]
-fn pi_wrapper_import_failure_has_no_ambient_merge_fallback() {
-    run_process_isolated(PI_WRAPPER_NEGATIVE_CHILD, PI_WRAPPER_NEGATIVE_TEST, || {
+fn pi_leader_wrapper_materializes_from_empty_unicode_wsl_workspace() {
+    let root = temp_root("empty-unicode-leader");
+    let workspace = root.join("mnt/f/测试基础设施");
+    let candidate = root.join("candidate/team-agent");
+    std::fs::create_dir_all(&workspace).expect("create empty Unicode workspace");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+    assert!(
+        !workspace.join(".team").exists(),
+        "fixture must begin without a .team directory"
+    );
+
+    let paths = pi_seat_paths(&workspace, "current", "leader");
+    let adapter = adapter_identity(&root);
+    let written = write_pi_wrapper(PiWrapperRequest {
+        destination: &paths.wrapper,
+        adapter: &adapter,
+        candidate_executable: &candidate,
+        mcp_config: &mcp_config(&candidate, &workspace, "leader"),
+        team_id: "current",
+        agent_id: "leader",
+        workspace: &workspace,
+        include_tools: &["assign_task", "send_message"],
+    })
+    .expect("materialize Pi leader wrapper from an empty Unicode workspace");
+
+    assert_eq!(written, paths.wrapper);
+    assert!(written.is_file(), "published leader wrapper must exist");
+    assert!(
+        paths.runtime_root.is_dir(),
+        "leader runtime root must be created recursively"
+    );
+    let source = std::fs::read_to_string(&written).expect("read complete leader wrapper");
+    validate_pi_wrapper_source(&source, &adapter, &candidate)
+        .expect("published leader wrapper must be complete and valid");
+    assert!(source.contains("TEAM_AGENT_ID") && source.contains("leader"));
+    assert!(source.contains("TEAM_AGENT_OWNER_TEAM_ID") && source.contains("current"));
+    std::fs::remove_dir_all(root).expect("remove Unicode leader fixture");
+}
+
+#[test]
+fn pi_wrapper_permissions_are_finalized_before_atomic_publish() {
+    let source = include_str!("../launch/pi_mcp.rs");
+    let write_start = source
+        .find("pub(crate) fn write_pi_wrapper")
+        .expect("write_pi_wrapper source");
+    let write_source = &source[write_start..];
+    let permissions = write_source
+        .find("file.set_permissions")
+        .expect("wrapper permissions must use the open temp-file handle");
+    let publish = write_source
+        .find("publish(&temp, request.destination)")
+        .expect("atomic wrapper publish");
+
+    assert!(
+        permissions < publish,
+        "DrvFS may not resolve the destination immediately after rename; finalize mode through the open temp-file handle before publishing"
+    );
+    assert!(
+        !write_source.contains("std::fs::set_permissions(request.destination"),
+        "atomic publish must not require a second destination-path lookup"
+    );
+}
+
+#[test]
+fn pi_wrapper_publish_needs_no_final_path_metadata_lookup() {
+    let root = temp_root("publish-path-enoent");
+    let workspace = root.join("mnt/f/测试基础设施");
+    let candidate = root.join("candidate/team-agent");
+    std::fs::create_dir_all(&workspace).expect("create Unicode workspace");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+
+    let paths = pi_seat_paths(&workspace, "current", "leader");
+    let published_parent = paths.runtime_root.clone();
+    let hidden_parent = published_parent.with_file_name("leader-after-rename");
+    let adapter = adapter_identity(&root);
+    write_pi_wrapper_with_publish(
+        PiWrapperRequest {
+            destination: &paths.wrapper,
+            adapter: &adapter,
+            candidate_executable: &candidate,
+            mcp_config: &mcp_config(&candidate, &workspace, "leader"),
+            team_id: "current",
+            agent_id: "leader",
+            workspace: &workspace,
+            include_tools: &["assign_task", "send_message"],
+        },
+        |temp, destination| {
+            std::fs::rename(temp, destination)?;
+            std::fs::rename(&published_parent, &hidden_parent)?;
+            assert_eq!(
+                std::fs::metadata(destination)
+                    .expect_err("simulate DrvFS final-path metadata ENOENT after rename")
+                    .kind(),
+                std::io::ErrorKind::NotFound
+            );
+            Ok(())
+        },
+    )
+    .expect("successful publish must not perform final-path metadata operations");
+
+    let published = hidden_parent.join("team-mcp.ts");
+    assert!(published.is_file(), "rename published a complete wrapper");
+    assert_eq!(
+        std::fs::metadata(&published)
+            .expect("published wrapper metadata through converged path")
+            .permissions()
+            .mode()
+            & 0o777,
+        0o600
+    );
+    std::fs::remove_dir_all(root).expect("remove publish-path fixture");
+}
+
+#[test]
+fn pi_wrapper_runtime_registration_does_not_copy_ambient_config() {
+    run_process_isolated(PI_WRAPPER_AMBIENT_CHILD, PI_WRAPPER_AMBIENT_TEST, || {
         let hermetic = HermeticTestEnv::enter("pi-wrapper-negative-send");
         assert_isolated_child();
         pi_wrapper_import_failure_body(&hermetic);
@@ -293,24 +490,13 @@ fn pi_wrapper_import_failure_body(hermetic: &HermeticTestEnv) {
         workspace: &workspace,
         include_tools: &["send_message", "report_result"],
     })
-    .expect("isolated wrapper ignores ambient config");
+    .expect("runtime wrapper leaves ambient config to direct Pi");
     let source = std::fs::read_to_string(&destination).expect("wrapper source");
     assert!(!source.contains("ambient-evil"));
     validate_pi_wrapper_source(&source, &adapter, &candidate)
-        .expect("exact isolated import and candidate");
-
-    let broken = source.replace(
-        adapter.index_ts.to_string_lossy().as_ref(),
-        "/missing/pi-mcp-adapter/index.ts",
-    );
-    let error = validate_pi_wrapper_source(&broken, &adapter, &candidate)
-        .expect_err("broken import must refuse");
-    let text = error.to_string();
-    assert!(
-        text.contains("import") || text.contains("adapter"),
-        "got {text}"
-    );
-    assert!(!broken.contains("--mcp-config"));
+        .expect("runtime registration and exact candidate");
+    assert!(!source.contains("createMcpAdapter"));
+    assert!(!source.contains("--mcp-config"));
 
     let missing_proxy_tools = source.replace("\"includeTools\"", "\"missingTools\"");
     validate_pi_wrapper_source(&missing_proxy_tools, &adapter, &candidate)

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

@@ -56,8 +56,8 @@ fn resume_argv(path: &Path) -> Result<Vec<String>, ProviderError> {
     build_pi_command_argv(PiCommandRequest {
         executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts"),
-        model: "team-agent/qwen3.8-27b",
-        effort: ProviderEffort::Medium,
+        model: Some("team-agent/qwen3.8-27b"),
+        effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
         session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),

package/crates/team-agent/src/provider/adapters/pi.rs

@@ -3,14 +3,13 @@
 //! contract:
 //!   provides:
 //!     - name: build_pi_command_argv
-//!       what: 仅从已验证输入构造隔离的 regular-TUI Pi argv
+//!       what: 仅从已验证输入构造保留 direct Pi 配置的 Team Agent argv
 //! boundary:
 //!   - 不发现 executable、catalog、adapter 或 MCP 配置
 //!   - 除 resume exact backing 存在性外不读文件；不写文件、不启动进程
 //! maturity: wired
 //! ---
 
-use std::collections::BTreeSet;
 use std::path::Path;
 
 use crate::model::enums::ProviderEffort;
@@ -47,8 +46,8 @@ pub(crate) enum PiSessionSelector<'a> {
 pub(crate) struct PiCommandRequest<'a> {
     pub executable: &'a Path,
     pub extension: &'a Path,
-    pub model: &'a str,
-    pub effort: ProviderEffort,
+    pub model: Option<&'a str>,
+    pub effort: Option<ProviderEffort>,
     pub system_prompt: &'a str,
     pub tool_categories: &'a [&'a str],
     pub session_dir: &'a Path,
@@ -57,7 +56,7 @@ pub(crate) struct PiCommandRequest<'a> {
 }
 
 /// ---
-/// purpose: 从已验证 semantic request 构造无 ambient flag 的 Pi argv
+/// purpose: 从已验证 semantic request 构造仅追加 Team Agent MCP/提示/session 的 Pi argv
 /// returns: exact ordered fresh/resume argv
 /// errors: 必需字段、mcp_team 或工具 category 非法时返回 ProviderError
 /// ---
@@ -67,23 +66,21 @@ pub(crate) fn build_pi_command_argv(
     if request.executable.as_os_str().is_empty()
         || request.extension.as_os_str().is_empty()
         || request.session_dir.as_os_str().is_empty()
-        || request.model.trim().is_empty()
+        || request.model.is_some_and(|model| model.trim().is_empty())
         || request.system_prompt.trim().is_empty()
         || request.agent_id.trim().is_empty()
     {
         return Err(ProviderError::Command(
-            "Pi command requires executable, extension, model, prompt, session directory, and agent id"
+            "Pi command requires executable, extension, prompt, session directory, and agent id"
                 .to_string(),
         ));
     }
 
-    let mut tools = BTreeSet::new();
+    let mut has_mcp = false;
     for category in request.tool_categories {
         match pi_tool_mapping(category) {
-            PiToolMapping::Mcp => {
-                tools.insert("mcp");
-            }
-            PiToolMapping::Builtin(names) => tools.extend(names.iter().copied()),
+            PiToolMapping::Mcp => has_mcp = true,
+            PiToolMapping::Builtin(_) => {}
             PiToolMapping::Unsupported => {
                 return Err(ProviderError::Command(format!(
                     "Pi does not support Team Agent tool category {category:?}"
@@ -91,7 +88,7 @@ pub(crate) fn build_pi_command_argv(
             }
         }
     }
-    if !tools.contains("mcp") {
+    if !has_mcp {
         return Err(ProviderError::Command(
             "Pi command requires mcp_team".to_string(),
         ));
@@ -99,26 +96,23 @@ pub(crate) fn build_pi_command_argv(
 
     let mut argv = vec![
         request.executable.to_string_lossy().into_owned(),
-        "--no-extensions".to_string(),
         "-e".to_string(),
         request.extension.to_string_lossy().into_owned(),
-        "--no-approve".to_string(),
-        "--no-context-files".to_string(),
-        "--no-skills".to_string(),
-        "--no-prompt-templates".to_string(),
-        "--tui-mode".to_string(),
-        "regular".to_string(),
-        "--model".to_string(),
-        request.model.to_string(),
-        "--thinking".to_string(),
-        request.effort.as_str().to_string(),
-        "--system-prompt".to_string(),
+    ];
+    if let Some(model) = request.model {
+        argv.push("--model".to_string());
+        argv.push(model.to_string());
+    }
+    if let Some(effort) = request.effort {
+        argv.push("--thinking".to_string());
+        argv.push(effort.as_str().to_string());
+    }
+    argv.extend([
+        "--append-system-prompt".to_string(),
         request.system_prompt.to_string(),
-        "--tools".to_string(),
-        tools.into_iter().collect::<Vec<_>>().join(","),
         "--session-dir".to_string(),
         request.session_dir.to_string_lossy().into_owned(),
-    ];
+    ]);
     // The shared lifecycle materializer always revalidates resume root/path/header.
     // Keep the pure argv builder usable before a fixture root is materialized, while
     // refusing a missing exact file once the recorded path's parent exists.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.69",
+  "version": "0.5.71",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.69",
-    "@team-agent/cli-darwin-x64": "0.5.69",
-    "@team-agent/cli-linux-x64": "0.5.69"
+    "@team-agent/cli-darwin-arm64": "0.5.71",
+    "@team-agent/cli-darwin-x64": "0.5.71",
+    "@team-agent/cli-linux-x64": "0.5.71"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/skills/team-agent/SKILL.md

@@ -2,7 +2,7 @@
 name: team-agent
 description: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.
 requires_team_agent: ">=0.5.0"
-last_verified_against: "0.5.66"
+last_verified_against: "0.5.71"
 ---
 
 # Team Agent
@@ -42,6 +42,12 @@ Grok / `cursor_agent` have no JSONL turn-state reader (classify → Unknown).
 
 ## Provider Prep
 
+### Pi TeamMate roles
+
+Use the standard role schema with `provider: pi`, a block-style `tools` list containing `mcp_team`, and the required boolean `dangerously_skip_permissions`. That role boolean is the only bypass setting; `TEAM.md` `dangerous_auto_approve` is compatibility input, not a second user-facing switch.
+
+Pi TeamMates keep the same login, model, extensions/plugins, skills, context files, project trust, and tools as a direct `pi` run on that machine. Team Agent only appends the role contract, a per-seat Team MCP registration, and per-seat session storage; do not duplicate those direct Pi settings in the role. `model` and `effort` remain optional compatibility overrides, and explicit values are passed through.
+
 ### Cursor provider notes
 
 Frontmatter: `provider: cursor_agent` (not `cursor`; launcher verb is `team-agent cursor`), `auth_mode: subscription`, `name:` required (omit → `missing front matter field name`). Also required: `role:`, `tools:`, `dangerously_skip_permissions:` (bool). Subscription needs no `profile`.