@team-agent/installer 0.5.69 → 0.5.70

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.69"
+version = "0.5.70"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.69"
+version = "0.5.70"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/compiler.rs

@@ -392,12 +392,20 @@ fn compile_role_agent_with_mode(
     let provider = required_string(&meta, role_path, "provider")?;
     require_explicit_grok_role_model(&meta, role_path, &provider)?;
     require_explicit_cursor_role_model(&meta, role_path, &provider)?;
-    require_explicit_pi_role_fields(&meta, role_path, &provider)?;
-    let model = resolve_model(&meta, team_meta, &provider);
+    validate_pi_role_fields(&meta, role_path, &provider)?;
+    let is_pi = parse_canonical_provider(&provider) == Some(Provider::Pi);
+    let model = if is_pi {
+        string_field(&meta, "model")
+            .filter(|value| !value.trim().is_empty())
+            .map(Value::Str)
+            .unwrap_or(Value::Null)
+    } else {
+        resolve_model(&meta, team_meta, &provider)
+    };
     let auth_mode = string_field(&meta, "auth_mode")
         .or_else(|| string_field(team_meta, "default_auth_mode"))
         .unwrap_or_else(|| "subscription".to_string());
-    if parse_canonical_provider(&provider) == Some(Provider::Pi) && auth_mode != "subscription" {
+    if is_pi && auth_mode != "subscription" {
         return Err(ModelError::Validation(format!(
             "{}: Pi roles support subscription auth_mode only",
             role_path.display()
@@ -473,7 +481,11 @@ fn compile_role_agent_with_mode(
         Some(raw) if !raw.trim().is_empty() => ProviderEffort::parse(raw.trim()),
         _ => None,
     };
-    let resolved_effort = role_effort.or(team_effort);
+    let resolved_effort = if is_pi {
+        role_effort
+    } else {
+        role_effort.or(team_effort)
+    };
     if let Some(effort) = resolved_effort {
         // Reject max + non-Claude at compile time.
         let provider_str = agent_items
@@ -619,39 +631,23 @@ model: sonnet-4-thinking",
     )))
 }
 
-fn require_explicit_pi_role_fields(
-    meta: &Value,
-    path: &Path,
-    provider: &str,
-) -> Result<(), ModelError> {
+fn validate_pi_role_fields(meta: &Value, path: &Path, provider: &str) -> Result<(), ModelError> {
     if parse_canonical_provider(provider) != Some(Provider::Pi) {
         return Ok(());
     }
-    let model = string_field(meta, "model")
-        .filter(|value| !value.trim().is_empty())
-        .ok_or_else(|| {
+    if let Some(model) = string_field(meta, "model").filter(|value| !value.trim().is_empty()) {
+        let (catalog, name) = model.trim().split_once('/').ok_or_else(|| {
             ModelError::Validation(format!(
-                "{}: Pi roles require an explicit qualified exact model",
+                "{}: Pi roles require a qualified exact model such as provider/model",
                 path.display()
             ))
         })?;
-    let (catalog, name) = model.trim().split_once('/').ok_or_else(|| {
-        ModelError::Validation(format!(
-            "{}: Pi roles require a qualified exact model such as provider/model",
-            path.display()
-        ))
-    })?;
-    if catalog.is_empty() || name.is_empty() || model.contains('*') {
-        return Err(ModelError::Validation(format!(
-            "{}: Pi roles require a qualified exact model",
-            path.display()
-        )));
-    }
-    if !string_field(meta, "effort").is_some_and(|value| !value.trim().is_empty()) {
-        return Err(ModelError::Validation(format!(
-            "{}: Pi roles require explicit effort",
-            path.display()
-        )));
+        if catalog.is_empty() || name.is_empty() || model.contains('*') {
+            return Err(ModelError::Validation(format!(
+                "{}: Pi roles require a qualified exact model",
+                path.display()
+            )));
+        }
     }
     let tools = required_tools(meta, path)?;
     if !tools.iter().any(|tool| tool == "mcp_team") {
@@ -660,13 +656,7 @@ fn require_explicit_pi_role_fields(
             path.display()
         )));
     }
-    match meta.get("dangerously_skip_permissions") {
-        Some(Value::Bool(true)) => Ok(()),
-        _ => Err(ModelError::Validation(format!(
-            "{}: Pi roles require dangerously_skip_permissions: true",
-            path.display()
-        ))),
-    }
+    Ok(())
 }
 
 /// 0.5.66 bypass 单源:角色 md 的 `dangerously_skip_permissions` 必填 bool。

package/crates/team-agent/src/leader/start.rs

@@ -318,7 +318,7 @@ fn leader_start_plan_with_ambient_authority(
                 workspace,
                 team_id: identity.team_id.as_str(),
                 agent_id: "leader",
-                model: &parsed.model,
+                model: parsed.model.as_deref(),
                 effort: parsed.effort,
                 system_prompt: &prompt,
                 tool_categories: &tools,

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

@@ -5,7 +5,7 @@
 //!     - name: materialize_pi_plan
 //!       what: 为 leader 与 TeamMate 生成同一来源的 Pi CommandPlan
 //!     - name: write_pi_wrapper
-//!       what: 原子写入 0600 isolated lazy MCP wrapper
+//!       what: 原子写入 0600 per-seat runtime MCP registration extension
 //! boundary:
 //!   - 不枚举 Pi session；resume 只重验调用方给出的 exact backing
 //!   - 不投递消息、不执行 cleanup 或 doctor 判定
@@ -270,7 +270,10 @@ pub(crate) fn validate_pi_executable_chain(chain: &PiExecutableChain) -> Result<
     if !chain.path_entry.is_absolute()
         || !chain.launch_executable.is_absolute()
         || !chain.real_binary.is_absolute()
-        || chain.path_entry_type != PiExecutableFileType::Wrapper
+        || !matches!(
+            chain.path_entry_type,
+            PiExecutableFileType::Wrapper | PiExecutableFileType::Symlink
+        )
         || chain.launch_executable != chain.path_entry
         || chain.real_binary == chain.launch_executable
         || chain.catalog_sha256.len() != 64
@@ -349,15 +352,6 @@ fn render_pi_wrapper(request: &PiWrapperRequest<'_>) -> Result<String, ProviderE
         "command".to_string(),
         serde_json::Value::String(expected.to_string_lossy().into_owned()),
     );
-    server.insert(
-        "lifecycle".to_string(),
-        serde_json::Value::String("lazy".to_string()),
-    );
-    server.insert("directTools".to_string(), serde_json::Value::Bool(false));
-    server.insert(
-        "toolPrefix".to_string(),
-        serde_json::Value::String("server".to_string()),
-    );
     server.insert(
         "includeTools".to_string(),
         serde_json::Value::Array(
@@ -389,55 +383,69 @@ fn render_pi_wrapper(request: &PiWrapperRequest<'_>) -> Result<String, ProviderE
         "TEAM_AGENT_OWNER_TEAM_ID".to_string(),
         serde_json::Value::String(request.team_id.to_string()),
     );
-    let config = serde_json::json!({
-        "mcpServers": {
-            "team_orchestrator": serde_json::Value::Object(server)
-        }
-    });
-    let import = serde_json::to_string(&request.adapter.index_ts)
-        .map_err(|error| ProviderError::Command(format!("serialize Pi adapter path: {error}")))?;
-    let config = serde_json::to_string_pretty(&config)
-        .map_err(|error| ProviderError::Command(format!("serialize Pi MCP config: {error}")))?;
+    let definition = serde_json::to_string_pretty(&serde_json::Value::Object(server))
+        .map_err(|error| ProviderError::Command(format!("serialize Pi MCP server: {error}")))?;
     Ok(format!(
-        "import {{ createMcpAdapter }} from {import};\n\nexport default createMcpAdapter({{ config: {config} }});\n"
+        r#"const MCP_RUNTIME_REGISTER_EVENT = "pi-mcp-adapter:runtime-register:v1";
+
+export default function teamAgentMcp(pi: any) {{
+  let registration: {{ dispose(): Promise<void> }} | undefined;
+
+  pi.on("session_start", () => {{
+    if (registration) return;
+    const request: any = {{
+      version: 1,
+      name: "team_orchestrator",
+      definition: {definition},
+    }};
+    pi.events.emit(MCP_RUNTIME_REGISTER_EVENT, request);
+    if (!request.result) throw new Error("pi-mcp-adapter is not enabled");
+    if (!request.result.ok) throw request.result.error;
+    registration = request.result.registration;
+  }});
+
+  pi.on("session_shutdown", async () => {{
+    const current = registration;
+    registration = undefined;
+    await current?.dispose();
+  }});
+}}
+"#
     ))
 }
 
 /// ---
-/// purpose: 静态核对 wrapper 的 exact import、candidate 与 lazy isolation 字段
-/// returns: wrapper 保持冻结隔离合同则成功
-/// errors: identity 缺失或出现 mcp-config fallback 时返回 ProviderError
+/// purpose: 静态核对 wrapper 只做 per-seat runtime MCP registration
+/// returns: wrapper 保留 direct Pi 配置且冻结 seat identity 时成功
+/// errors: identity、runtime registration 或 candidate 缺失时返回 ProviderError
 /// ---
 pub(crate) fn validate_pi_wrapper_source(
     source: &str,
     adapter: &PiAdapterIdentity,
     candidate_executable: &Path,
 ) -> Result<(), ProviderError> {
-    let adapter_path = adapter.index_ts.to_string_lossy();
+    validate_pi_adapter_identity(adapter)?;
     let candidate = candidate_executable.to_string_lossy();
-    if !source.contains(adapter_path.as_ref())
-        || !source.contains(candidate.as_ref())
-        || !source.contains("createMcpAdapter")
-        || !source.contains("mcpServers")
+    if !source.contains(candidate.as_ref())
+        || !source.contains("pi-mcp-adapter:runtime-register:v1")
+        || !source.contains("session_start")
+        || !source.contains("session_shutdown")
         || !source.contains("team_orchestrator")
-        || !source.contains("lazy")
-        || !source.contains("directTools")
-        || !source.contains("false")
-        || !source.contains("toolPrefix")
-        || !source.contains("server")
         || !source.contains("includeTools")
+        || source.contains("createMcpAdapter")
+        || source.contains("directTools")
+        || source.contains("toolPrefix")
         || source.contains("--mcp-config")
     {
         return Err(ProviderError::Command(
-            "Pi wrapper source does not preserve the isolated adapter/candidate contract"
-                .to_string(),
+            "Pi wrapper source does not preserve direct Pi plus per-seat runtime MCP".to_string(),
         ));
     }
     Ok(())
 }
 
 /// ---
-/// purpose: 在 seat root 原子写入 mode 0600 的 isolated lazy MCP wrapper
+/// purpose: 在 seat root 原子写入 mode 0600 的 runtime MCP registration extension
 /// returns: 最终 wrapper 路径
 /// errors: identity、序列化、目录、写盘或 rename 失败时返回 ProviderError
 /// ---
@@ -482,14 +490,14 @@ pub(crate) fn write_pi_wrapper(request: PiWrapperRequest<'_>) -> Result<PathBuf,
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct PiLeaderArgs {
-    pub model: String,
-    pub effort: ProviderEffort,
+    pub model: Option<String>,
+    pub effort: Option<ProviderEffort>,
 }
 
 /// ---
 /// purpose: 解析 Pi leader 唯一允许的 model/thinking 输入
-/// returns: 显式 qualified model 与 effort
-/// errors: 缺失、重复、未知或 materializer-owned flag 时返回 ProviderError
+/// returns: 仅保留调用方显式给出的 qualified model 与 effort
+/// errors: 重复、未知或 materializer-owned flag 时返回 ProviderError
 /// ---
 pub(crate) fn parse_pi_leader_args(args: &[String]) -> Result<PiLeaderArgs, ProviderError> {
     let args = args.strip_prefix(&["--".to_string()]).unwrap_or(args);
@@ -519,24 +527,17 @@ pub(crate) fn parse_pi_leader_args(args: &[String]) -> Result<PiLeaderArgs, Prov
         }
         index += 2;
     }
-    let model = model.ok_or_else(|| {
-        ProviderError::Command("Pi leader requires an explicit --model".to_string())
-    })?;
-    if model.contains('*')
-        || !model
-            .split_once('/')
-            .is_some_and(|(provider, name)| !provider.is_empty() && !name.is_empty())
-    {
+    if model.as_ref().is_some_and(|model| {
+        model.contains('*')
+            || !model
+                .split_once('/')
+                .is_some_and(|(provider, name)| !provider.is_empty() && !name.is_empty())
+    }) {
         return Err(ProviderError::Command(
             "Pi leader --model must be a qualified exact id".to_string(),
         ));
     }
-    Ok(PiLeaderArgs {
-        model,
-        effort: effort.ok_or_else(|| {
-            ProviderError::Command("Pi leader requires an explicit --thinking".to_string())
-        })?,
-    })
+    Ok(PiLeaderArgs { model, effort })
 }
 
 fn sha256(bytes: &[u8]) -> String {
@@ -598,7 +599,7 @@ fn command_stdout(executable: &Path, args: &[&str]) -> Result<Vec<u8>, ProviderE
 }
 
 fn discover_pi_adapter(launch_executable: &Path) -> Result<PiAdapterIdentity, ProviderError> {
-    let listing = command_stdout(launch_executable, &["list", "--no-approve"])?;
+    let listing = command_stdout(launch_executable, &["list"])?;
     let listing = std::str::from_utf8(&listing).map_err(|error| {
         ProviderError::Command(format!("Pi package list is not UTF-8: {error}"))
     })?;
@@ -660,16 +661,16 @@ fn discover_pi_adapter(launch_executable: &Path) -> Result<PiAdapterIdentity, Pr
 pub(crate) fn resolve_pi_executable_chain(
 ) -> Result<(PiExecutableChain, Vec<String>), ProviderError> {
     let path_entries = pi_path_entries()?;
-    let path_entry = path_entries
-        .iter()
-        .find_map(|candidate| {
-            (executable_file_type(candidate).ok()? == PiExecutableFileType::Wrapper)
-                .then(|| candidate.clone())
-        })
-        .ok_or_else(|| {
-            ProviderError::Command("Pi PATH has no verified wrapper launch executable".to_string())
-        })?;
-    let path_entry_type = PiExecutableFileType::Wrapper;
+    let path_entry = path_entries[0].clone();
+    let path_entry_type = executable_file_type(&path_entry)?;
+    if !matches!(
+        path_entry_type,
+        PiExecutableFileType::Wrapper | PiExecutableFileType::Symlink
+    ) {
+        return Err(ProviderError::Command(
+            "the direct Pi PATH entry is not a verified wrapper or npm symlink".to_string(),
+        ));
+    }
     let version =
         String::from_utf8(command_stdout(&path_entry, &["--version"])?).map_err(|error| {
             ProviderError::Command(format!("Pi version output is not UTF-8: {error}"))
@@ -677,17 +678,21 @@ pub(crate) fn resolve_pi_executable_chain(
     let version = version.trim().to_string();
     let launch_identity = std::fs::canonicalize(&path_entry)
         .map_err(|error| ProviderError::Io(format!("{}: {error}", path_entry.display())))?;
-    let real_binary = path_entries
-        .iter()
-        .find_map(|candidate| {
-            let real = std::fs::canonicalize(candidate).ok()?;
-            (real != launch_identity).then_some(real)
-        })
-        .ok_or_else(|| {
-            ProviderError::Command(
-                "Pi PATH wrapper has no independently resolved real executable".to_string(),
-            )
-        })?;
+    let real_binary = if path_entry_type == PiExecutableFileType::Symlink {
+        launch_identity
+    } else {
+        path_entries
+            .iter()
+            .find_map(|candidate| {
+                let real = std::fs::canonicalize(candidate).ok()?;
+                (real != launch_identity).then_some(real)
+            })
+            .ok_or_else(|| {
+                ProviderError::Command(
+                    "Pi PATH wrapper has no independently resolved real executable".to_string(),
+                )
+            })?
+    };
     let _real_version =
         String::from_utf8(command_stdout(&real_binary, &["--version"])?).map_err(|error| {
             ProviderError::Command(format!(
@@ -714,8 +719,8 @@ pub(crate) struct PiMaterializeRequest<'a> {
     pub workspace: &'a Path,
     pub team_id: &'a str,
     pub agent_id: &'a str,
-    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 team_mcp_tools: &'a [&'a str],
@@ -752,7 +757,10 @@ fn materialize_pi_plan_with_session(
     resume: Option<(&SessionId, &Path, &Path)>,
 ) -> Result<CommandPlan, ProviderError> {
     let (chain, catalog) = resolve_pi_executable_chain()?;
-    let model = select_exact_pi_model(&catalog, request.model)?;
+    let model = request
+        .model
+        .map(|model| select_exact_pi_model(&catalog, model))
+        .transpose()?;
     let paths = pi_seat_paths(request.workspace, request.team_id, request.agent_id);
     let resume = if let Some((session_id, session_path, spawn_cwd)) = resume {
         let session_root = std::fs::canonicalize(&paths.sessions).map_err(|error| {
@@ -795,7 +803,7 @@ fn materialize_pi_plan_with_session(
         let argv = build_pi_command_argv(PiCommandRequest {
             executable: &chain.launch_executable,
             extension: &wrapper,
-            model: &model,
+            model: model.as_deref(),
             effort: request.effort,
             system_prompt: request.system_prompt,
             tool_categories: request.tool_categories,
@@ -809,7 +817,7 @@ fn materialize_pi_plan_with_session(
         let argv = build_pi_command_argv(PiCommandRequest {
             executable: &chain.launch_executable,
             extension: &wrapper,
-            model: &model,
+            model: model.as_deref(),
             effort: request.effort,
             system_prompt: request.system_prompt,
             tool_categories: request.tool_categories,

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

@@ -178,23 +178,13 @@ pub(super) fn spawn_agents(
             effort: agent_effort,
         };
         let mut plan = if provider == Provider::Pi {
-            let model = command_model.ok_or_else(|| {
-                LifecycleError::RequirementUnmet(
-                    "Pi launch requires an explicit qualified model".to_string(),
-                )
-            })?;
-            let effort = agent_effort.ok_or_else(|| {
-                LifecycleError::RequirementUnmet(
-                    "Pi launch requires an explicit thinking effort".to_string(),
-                )
-            })?;
             crate::lifecycle::launch::pi_mcp::materialize_pi_plan(
                 crate::lifecycle::launch::pi_mcp::PiMaterializeRequest {
                     workspace,
                     team_id: &mcp_team_id,
                     agent_id: agent_id_raw,
-                    model,
-                    effort,
+                    model: command_model,
+                    effort: agent_effort,
                     system_prompt: &system_prompt,
                     tool_categories: &resolved_tool_refs,
                     team_mcp_tools: &["send_message", "report_result"],

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

@@ -392,22 +392,12 @@ pub(super) fn spawn_agent_window(
         .or(pi_spawn_cwd.as_deref())
         .unwrap_or(workspace);
     let mut plan = if provider == Provider::Pi {
-        let model = command_model.ok_or_else(|| {
-            LifecycleError::RequirementUnmet(
-                "Pi restart requires an explicit qualified model".to_string(),
-            )
-        })?;
-        let effort = restart_effort.ok_or_else(|| {
-            LifecycleError::RequirementUnmet(
-                "Pi restart requires an explicit thinking effort".to_string(),
-            )
-        })?;
         let request = crate::lifecycle::launch::pi_mcp::PiMaterializeRequest {
             workspace,
             team_id: team_id.as_deref().unwrap_or(""),
             agent_id: agent_id.as_str(),
-            model,
-            effort,
+            model: command_model,
+            effort: restart_effort,
             system_prompt: &system_prompt,
             tool_categories: &resolved_tool_refs,
             team_mcp_tools: &["send_message", "report_result"],

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

@@ -18,8 +18,8 @@ fn command_for_model(model: &str) -> Vec<String> {
     build_pi_command_argv(PiCommandRequest {
         executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/t1/w1/team-mcp.ts"),
-        model,
-        effort: ProviderEffort::Medium,
+        model: Some(model),
+        effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
         session_dir: Path::new("/workspace/.team/runtime/pi/t1/w1/sessions"),

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

@@ -7,8 +7,8 @@ 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: "team-agent/qwen3.8-27b",
-        effort: ProviderEffort::High,
+        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"),
@@ -18,7 +18,20 @@ fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
 }
 
 #[test]
-fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
+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",
     }))
@@ -27,23 +40,14 @@ fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
         fresh,
         [
             "/verified/pi",
-            "--no-extensions",
             "-e",
             "/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts",
-            "--no-approve",
-            "--no-context-files",
-            "--no-skills",
-            "--no-prompt-templates",
-            "--tui-mode",
-            "regular",
             "--model",
             "team-agent/qwen3.8-27b",
             "--thinking",
             "high",
-            "--system-prompt",
+            "--append-system-prompt",
             "frozen worker prompt",
-            "--tools",
-            "bash,edit,mcp,read,write",
             "--session-dir",
             "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
             "--session-id",
@@ -88,6 +92,14 @@ fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
             "--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),
@@ -98,23 +110,26 @@ fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
 }
 
 #[test]
-fn pi_command_uses_no_context_no_extensions_no_approve() {
+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 required in [
+    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() == required).count(),
-            1,
-            "required isolation flag must occur once: {required}; argv={argv:?}"
+            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| {
@@ -124,5 +139,7 @@ fn pi_command_uses_no_context_no_extensions_no_approve() {
         ]
     }));
     assert_eq!(argv.iter().filter(|arg| arg.as_str() == "-e").count(), 1);
-    assert!(!argv.iter().any(|arg| arg == "--approve"));
+    assert!(argv
+        .windows(2)
+        .any(|pair| pair == ["--append-system-prompt", "frozen worker prompt"]));
 }

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

@@ -14,6 +14,13 @@ 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}",
@@ -26,7 +33,7 @@ fn compile_pi_role(front_matter: &str) -> Result<CompiledRole, ModelError> {
         format!("---\n{front_matter}\n---\nPi worker contract.\n"),
     )
     .expect("write role fixture");
-    let result = compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace");
+    let result = compile_role_agent(&role, team_meta, "/workspace");
     std::fs::remove_dir_all(root).expect("remove role fixture root");
     result
 }
@@ -48,8 +55,8 @@ fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<St
     build_pi_command_argv(PiCommandRequest {
         executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/team-mcp.ts"),
-        model,
-        effort,
+        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"),
@@ -62,19 +69,15 @@ fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<St
 }
 
 #[test]
-fn pi_role_requires_qualified_model_explicit_effort_and_mcp_team() {
+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_model = valid_role_with("").replace("model: team-agent/qwen3.8-27b\n", "");
-    let missing_effort = valid_role_with("").replace("effort: medium\n", "");
     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 [
-        ("model", missing_model),
-        ("effort", missing_effort),
         ("mcp_team", missing_mcp),
         ("qualified exact model", unqualified),
     ] {
@@ -85,13 +88,45 @@ fn pi_role_requires_qualified_model_explicit_effort_and_mcp_team() {
         );
     }
 
+    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_requires_intrinsic_unrestricted_ack_true() {
+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"),
@@ -122,10 +157,16 @@ fn pi_role_requires_intrinsic_unrestricted_ack_true() {
         "dangerously_skip_permissions: true",
         "dangerously_skip_permissions: false",
     );
-    let error = compile_error(compile_pi_role(&false_ack));
-    let text = error.to_string();
+    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("dangerously_skip_permissions") && text.contains("true"),
+        text.contains("missing front matter field dangerously_skip_permissions"),
         "got {text}"
     );
 }
@@ -153,7 +194,7 @@ fn pi_max_effort_is_supported_without_model_suffix() {
 }
 
 #[test]
-fn pi_tools_allowlist_keeps_mcp_and_rejects_unknown_categories() {
+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"),
@@ -194,14 +235,9 @@ fn pi_tools_allowlist_keeps_mcp_and_rejects_unknown_categories() {
         ProviderEffort::Medium,
         "team-agent/qwen3.8-27b",
     )
-    .expect("known allowlist");
-    let tools = argv
-        .windows(2)
-        .find(|pair| pair[0] == "--tools")
-        .map(|pair| pair[1].as_str())
-        .expect("--tools value");
-    assert_eq!(
-        tools, "bash,edit,find,grep,ls,mcp,read,write",
-        "tools must be sorted and deduplicated"
+    .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:?}"
     );
 }

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

@@ -224,12 +224,27 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
     );
     let leader = parse_pi_leader_args(&leader_argv[2..])
         .expect("leader exact model and effort must compile into the shared plan input");
-    assert_eq!(leader.model, "team-agent/qwen3.8-27b");
-    assert_eq!(leader.effort, ProviderEffort::Max);
+    assert_eq!(leader.model.as_deref(), Some("team-agent/qwen3.8-27b"));
+    assert_eq!(leader.effort, Some(ProviderEffort::Max));
+
+    let defaults = parse_pi_leader_args(&[]).expect("leader provider defaults");
+    assert_eq!(defaults.model, None);
+    assert_eq!(defaults.effort, None);
+    assert_eq!(
+        parse_pi_leader_args(&["--thinking".to_string(), "medium".to_string()])
+            .expect("explicit thinking only")
+            .effort,
+        Some(ProviderEffort::Medium)
+    );
+    assert_eq!(
+        parse_pi_leader_args(&["--model".to_string(), "team-agent/qwen3.8-27b".to_string(),])
+            .expect("explicit model only")
+            .model
+            .as_deref(),
+        Some("team-agent/qwen3.8-27b")
+    );
 
     for invalid in [
-        vec!["--thinking".to_string(), "medium".to_string()],
-        vec!["--model".to_string(), "team-agent/qwen3.8-27b".to_string()],
         vec![
             "--model".to_string(),
             "qwen3.8-27b".to_string(),
@@ -247,7 +262,7 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
     ] {
         assert!(
             parse_pi_leader_args(&invalid).is_err(),
-            "leader input must refuse missing, ambiguous, or materializer-owned fields: {invalid:?}"
+            "leader input must refuse ambiguous or materializer-owned fields: {invalid:?}"
         );
     }
 
@@ -267,12 +282,15 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
 
     std::fs::write(
         &role,
-        "---\nname: worker-a\nrole: developer\nprovider: pi\nauth_mode: subscription\neffort: max\ntools:\n  - mcp_team\ndangerously_skip_permissions: true\n---\nworker contract\n",
+        "---\nname: worker-a\nrole: developer\nprovider: pi\nauth_mode: subscription\ntools:\n  - mcp_team\ndangerously_skip_permissions: true\n---\nworker contract\n",
     )
-    .expect("write missing-model teammate role");
+    .expect("write provider-default teammate role");
+    let defaults = compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace")
+        .expect("provider: pi teammate may use Pi model and effort defaults");
+    assert_eq!(defaults.agent.get("model"), Some(&Value::Null));
     assert!(
-        compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace").is_err(),
-        "provider: pi teammate without an exact model must refuse"
+        defaults.agent.get("effort").is_none(),
+        "omitted Pi model and effort must remain absent"
     );
     std::fs::remove_dir_all(root).expect("remove role fixture");
 

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

@@ -3,9 +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,
-    PiExecutableFileType, PiWrapperRequest,
+    parse_pi_list_models_table, resolve_pi_executable_chain, validate_pi_adapter_identity,
+    validate_pi_executable_chain, validate_pi_wrapper_source, write_pi_wrapper, PiAdapterIdentity,
+    PiExecutableChain, PiExecutableFileType, PiWrapperRequest,
 };
 use crate::provider::McpConfig;
 
@@ -18,15 +18,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 +170,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 +293,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 +337,8 @@ 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_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 +371,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.70",
   "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.70",
+    "@team-agent/cli-darwin-x64": "0.5.70",
+    "@team-agent/cli-linux-x64": "0.5.70"
   },
   "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.70"
 ---
 
 # 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`.