@team-agent/installer 0.5.68 → 0.5.70

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

@@ -0,0 +1,216 @@
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::time::Duration;
+
+use crate::lifecycle::launch::pi_mcp::pi_seat_paths;
+use crate::messaging::delivery::{
+    paste_to_submit_floor_for_recipient, recipient_allows_explicit_queue_flush, recipient_is_busy,
+    recipient_requires_single_enter,
+};
+use crate::model::enums::{Provider, ProviderEffort};
+use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiSessionSelector};
+use crate::provider::session_scan::{scan_session_candidates_once, CaptureSessionContext};
+use crate::provider::{get_adapter, AuthMode, ProviderError, SessionId};
+
+static NEXT_ROOT: AtomicU32 = AtomicU32::new(0);
+
+fn temp_root(label: &str) -> PathBuf {
+    let seq = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
+    let root = std::env::temp_dir().join(format!(
+        "team-agent-pi-{label}-{}-{seq}",
+        std::process::id()
+    ));
+    std::fs::create_dir_all(&root).expect("create fixture root");
+    root
+}
+
+fn write_header(path: &Path, id: &str, cwd: &Path, timestamp: &str) {
+    std::fs::create_dir_all(path.parent().expect("session parent")).expect("create session parent");
+    let header = serde_json::json!({
+        "type": "session",
+        "version": 3,
+        "id": id,
+        "cwd": cwd,
+        "timestamp": timestamp,
+    });
+    std::fs::write(
+        path,
+        format!("{header}\nsecret conversation body must not be read\n"),
+    )
+    .expect("write session fixture");
+}
+
+fn scan_context(cwd: &Path, root: &Path, id: &str, generation: &str) -> CaptureSessionContext {
+    CaptureSessionContext {
+        agent_id: "worker-a".to_string(),
+        spawn_cwd: cwd.to_path_buf(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: Some(generation.to_string()),
+        expected_session_id: Some(SessionId::new(id)),
+        provider_projects_root: Some(root.to_path_buf()),
+    }
+}
+
+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: 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"),
+        session: PiSessionSelector::Resume { path },
+        agent_id: "worker-a",
+    })
+}
+
+#[test]
+fn pi_session_capture_requires_header_id_cwd_generation_and_unique_claim() {
+    let root = temp_root("session-capture");
+    let cwd = root.join("workspace");
+    let sessions = root.join("seat/sessions");
+    std::fs::create_dir_all(&cwd).expect("create cwd");
+    let id = "652756ea-aaee-4437-a30f-40c5606826d5";
+    let generation = "2026-08-29T10:00:00Z";
+    let session_timestamp = "2026-08-29T10:00:01Z";
+    let expected_path = sessions.join("2026/08/29/session.jsonl");
+    write_header(&expected_path, id, &cwd, session_timestamp);
+
+    let context = scan_context(&cwd, &sessions, id, generation);
+    let candidates = scan_session_candidates_once(Provider::Pi, &context).expect("Pi scan");
+    assert_eq!(candidates.len(), 1);
+    assert_eq!(
+        candidates[0]
+            .captured
+            .session_id
+            .as_ref()
+            .map(SessionId::as_str),
+        Some(id)
+    );
+    assert_eq!(
+        candidates[0]
+            .captured
+            .rollout_path
+            .as_ref()
+            .map(|path| path.as_path()),
+        Some(expected_path.as_path())
+    );
+
+    for (label, header_id, header_cwd, header_timestamp) in [
+        ("wrong-id", "wrong-id", cwd.as_path(), session_timestamp),
+        ("wrong-cwd", id, root.as_path(), session_timestamp),
+        (
+            "wrong-generation",
+            id,
+            cwd.as_path(),
+            "2026-08-29T09:00:00+00:00",
+        ),
+    ] {
+        let case_root = root.join(label);
+        let case_path = case_root.join(format!("{id}.jsonl"));
+        write_header(&case_path, header_id, header_cwd, header_timestamp);
+        let case_context = scan_context(&cwd, &case_root, id, generation);
+        assert!(
+            scan_session_candidates_once(Provider::Pi, &case_context)
+                .expect("negative scan")
+                .is_empty(),
+            "filename or mtime must not override a mismatched header: {label}"
+        );
+    }
+
+    let second = sessions.join("duplicate/session.jsonl");
+    write_header(&second, id, &cwd, session_timestamp);
+    assert_eq!(
+        scan_session_candidates_once(Provider::Pi, &context)
+            .expect("ambiguous scan")
+            .len(),
+        2,
+        "multiple exact candidates must remain ambiguous for the shared allocator"
+    );
+
+    std::fs::remove_dir_all(root).expect("remove session fixture");
+}
+
+#[test]
+fn pi_restart_uses_exact_path_and_refuses_missing_backing() {
+    let root = temp_root("resume");
+    let cwd = root.join("workspace");
+    let sessions = root.join("seat/sessions");
+    std::fs::create_dir_all(&cwd).expect("create cwd");
+    let id = "cc09d133-878f-4241-920f-f7ebfefc2a9e";
+    let generation = "2026-08-29T10:00:00Z";
+    let exact = sessions.join("nested/exact.jsonl");
+    write_header(&exact, id, &cwd, "2026-08-29T10:00:01Z");
+
+    let candidates =
+        scan_session_candidates_once(Provider::Pi, &scan_context(&cwd, &sessions, id, generation))
+            .expect("resume preflight scan");
+    assert_eq!(
+        candidates.len(),
+        1,
+        "exact backing must revalidate before restart"
+    );
+
+    let argv = resume_argv(&exact).expect("resume exact path");
+    assert!(argv
+        .windows(2)
+        .any(|pair| { pair[0] == "--session" && pair[1] == exact.to_string_lossy().as_ref() }));
+    assert!(!argv.iter().any(|arg| {
+        matches!(
+            arg.as_str(),
+            "--session-id" | "-c" | "--continue" | "-r" | "--resume"
+        )
+    }));
+
+    std::fs::remove_file(&exact).expect("remove backing tooth");
+    let missing = resume_argv(&exact);
+    assert!(
+        matches!(missing, Err(ProviderError::ResumeUnavailable(_))),
+        "missing exact backing must refuse rather than create a new session: {missing:?}"
+    );
+    std::fs::remove_dir_all(root).expect("remove resume fixture");
+}
+
+#[test]
+fn pi_delivery_submits_one_enter_and_never_flushes_or_retries() {
+    let idle = serde_json::json!({
+        "agents": {
+            "worker-a": {"provider": "pi", "status": "running"}
+        }
+    });
+    assert!(recipient_requires_single_enter(&idle, "worker-a"));
+    assert!(!recipient_allows_explicit_queue_flush(&idle, "worker-a"));
+    assert_eq!(
+        paste_to_submit_floor_for_recipient(&idle, "worker-a"),
+        Duration::ZERO
+    );
+    assert!(!recipient_is_busy(&idle, "worker-a"));
+
+    let busy = serde_json::json!({
+        "agents": {
+            "worker-a": {"provider": "pi", "status": "busy"}
+        }
+    });
+    assert!(
+        recipient_is_busy(&busy, "worker-a"),
+        "known busy must take the existing send.deferred_busy path before paste"
+    );
+    assert!(recipient_requires_single_enter(&busy, "worker-a"));
+    assert!(!recipient_allows_explicit_queue_flush(&busy, "worker-a"));
+}
+
+#[test]
+fn pi_clone_is_fresh_and_fork_is_not_clone() {
+    let workspace = Path::new("/workspace");
+    let source_paths = pi_seat_paths(workspace, "team-a", "source");
+    let clone_paths = pi_seat_paths(workspace, "team-a", "clone");
+    assert_ne!(source_paths.runtime_root, clone_paths.runtime_root);
+    assert_ne!(source_paths.wrapper, clone_paths.wrapper);
+    assert_ne!(source_paths.sessions, clone_paths.sessions);
+
+    let source_session = SessionId::new("652756ea-aaee-4437-a30f-40c5606826d5");
+    let fork = get_adapter(Provider::Pi).fork(Some(&source_session), AuthMode::Subscription, None);
+    assert!(matches!(fork, Err(ProviderError::CapabilityUnsupported(_))));
+}

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

@@ -1068,6 +1068,7 @@ fn provider_name(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini",
         Provider::Grok => "grok",
         Provider::CursorAgent => "cursor_agent",
+        Provider::Pi => "pi",
         Provider::Fake => "fake",
     }
 }

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

@@ -79,6 +79,13 @@ mod main_preserved;
 mod mcp_tool_name_format_red;
 mod phase_b_contracts;
 mod phase_golden;
+mod pi_catalog_red;
+mod pi_command_red;
+mod pi_compiler_red;
+mod pi_dual_entry_red;
+mod pi_executable_mcp_red;
+mod pi_lifecycle_doctor_red;
+mod pi_session_delivery_red;
 mod quick_start_worker_readiness_red;
 mod realmachine_clusters_1_6_red;
 mod realmachine_residual_g1_g4_red;

package/crates/team-agent/src/lifecycle/worker_command_context.rs

@@ -209,11 +209,25 @@ pub(crate) fn compile_worker_system_prompt(
     // C-1 cr verdict / B2 灵魂件 — identity 必须 FIRST(MUST-4 行为层守:空白上下文问
     // "你是谁"必须先答 Team Agent worker 身份)。runtime contract 跟后。
     let send_message = mcp_tool_name(agent.provider, "team_orchestrator", "send_message");
-    let report_result = mcp_tool_name(agent.provider, "team_orchestrator", "report_result");
+    let report_result = if agent.provider == Provider::Pi {
+        r#"mcp({tool:"team_orchestrator_report_result", args:{summary:"..."}})"#.to_string()
+    } else {
+        mcp_tool_name(agent.provider, "team_orchestrator", "report_result")
+    };
+    let runtime_contract = if agent.provider == Provider::Pi {
+        pi_runtime_contract_section()
+    } else {
+        runtime_contract_section(&send_message, &report_result)
+    };
+    let communication_contract = if agent.provider == Provider::Pi {
+        pi_communication_contract(agent.communication_mode)
+    } else {
+        agent.communication_mode.runtime_contract(&send_message)
+    };
     let mut chunks = vec![
         identity_section(agent),
-        runtime_contract_section(&send_message, &report_result),
-        agent.communication_mode.runtime_contract(&send_message),
+        runtime_contract,
+        communication_contract,
         role_body(agent)?,
     ];
     if let Some(contract) = output_contract(agent, &report_result) {
@@ -229,6 +243,17 @@ pub(crate) fn compile_worker_system_prompt(
         .join("\n\n"))
 }
 
+pub(crate) fn compile_pi_leader_system_prompt() -> String {
+    r#"You are the Team Agent leader for this workspace. Coordinate work through the existing Team Agent MCP server.
+
+Use the Pi MCP proxy call form with server-prefixed tool names, for example:
+mcp({tool:"team_orchestrator_get_team_status", args:{}})
+mcp({tool:"team_orchestrator_send_message", args:{to:"<agent_id>", content:"..."}})
+
+Do not invent a second team protocol or assume that a configured lazy MCP server is connected before a call returns."#
+        .to_string()
+}
+
 /// ---
 /// purpose: 解析该 agent 最终生效的工具串
 /// params:
@@ -249,7 +274,7 @@ pub(crate) fn resolved_tool_strings_for_command(
     // 不再收 team/runtime/leader argv 派生的 `DangerousApproval`。true → 加
     // `dangerous_auto_approve` 哨兵(adapter 消费点不变);provider 无 bypass
     // argv 定义 → fail-loud,不静默 fallback。
-    if agent.dangerously_skip_permissions {
+    if agent.dangerously_skip_permissions && provider != Provider::Pi {
         let flag = crate::provider::bypass_flags::provider_bypass_flag(provider).ok_or_else(
             || {
                 LifecycleError::RequirementUnmet(format!(
@@ -272,6 +297,7 @@ fn mcp_tool_name(provider: Provider, server: &str, tool: &str) -> String {
     match provider {
         Provider::Claude | Provider::ClaudeCode => format!("mcp__{server}__{tool}"),
         Provider::Grok => format!("{server}__{tool}"),
+        Provider::Pi => format!("{server}_{tool}"),
         // CursorAgent / Codex / Copilot / GeminiCli / Fake: 未验证，沿用现状点号。
         // CursorAgent 不可与 grok 同臂：仓库里没有活转录，`{server}__{tool}` 是推断。
         Provider::CursorAgent
@@ -291,6 +317,7 @@ fn provider_display_name(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini_cli",
         Provider::Grok => "grok",
         Provider::CursorAgent => "cursor_agent",
+        Provider::Pi => "pi",
         Provider::Fake => "fake",
     }
 }
@@ -314,6 +341,36 @@ fn runtime_contract_section(send_message: &str, report_result: &str) -> String {
         .replace("{report_result}", report_result)
 }
 
+fn pi_runtime_contract_section() -> String {
+    RUNTIME_CONTRACT_SECTION
+        .replace(
+            "{send_message}(to='<agent_id>', content='...')",
+            r#"mcp({tool:"team_orchestrator_send_message", args:{to:"<agent_id>", content:"..."}})"#,
+        )
+        .replace(
+            "{send_message}(to='*', content='...')",
+            r#"mcp({tool:"team_orchestrator_send_message", args:{to:"*", content:"..."}})"#,
+        )
+        .replace(
+            "{report_result}(summary='...')",
+            r#"mcp({tool:"team_orchestrator_report_result", args:{summary:"..."}})"#,
+        )
+}
+
+fn pi_communication_contract(mode: CommunicationMode) -> String {
+    match mode {
+        CommunicationMode::LeaderCentric => r#"# Team Agent communication contract: leader_centric
+
+- Progress, blockers, questions: mcp({tool:"team_orchestrator_send_message", args:{to:"leader", content:"..."}})
+
+When you receive a message from the leader or a teammate, you MUST respond
+through MCP tools. Writing a reply in your terminal does nothing — the sender
+will never see it."#
+            .to_string(),
+        CommunicationMode::Orchestrated => mode.runtime_contract("mcp"),
+    }
+}
+
 fn communication_mode(value: Option<&str>) -> Result<CommunicationMode, LifecycleError> {
     let Some(value) = value else {
         return Ok(CommunicationMode::default());

package/crates/team-agent/src/messaging/delivery.rs

@@ -572,11 +572,11 @@ pub fn deliver_pending_message(
         canonical_owner_team_id.as_deref(),
         resolved.metadata.as_ref(),
     );
-    let recipient_cursor = recipient_is_cursor_agent(state, &message.recipient);
+    let recipient_single_enter = recipient_requires_single_enter(state, &message.recipient);
     let inject_attempt = crate::tmux_backend::with_paste_to_submit_floor(
         paste_to_submit_floor_for_recipient(state, &message.recipient),
         || {
-            crate::tmux_backend::with_cursor_single_enter(recipient_cursor, || {
+            crate::tmux_backend::with_cursor_single_enter(recipient_single_enter, || {
                 transport.inject_with_submit_observer(
                     &target,
                     &payload,
@@ -592,7 +592,9 @@ pub fn deliver_pending_message(
             // grok 忙时第一次回车只入显式队列。默认 send-now：只重按回车顶出去。
             // 无 `Enter:send now` 时零次额外按键，claude/codex 行为不变。
             // cursor：第二下 Enter 打断进行中回合，不走 flush。
-            if !crate::provider::submit_now::keep_provider_queue_requested() && !recipient_cursor {
+            if !crate::provider::submit_now::keep_provider_queue_requested()
+                && recipient_allows_explicit_queue_flush(state, &message.recipient)
+            {
                 match crate::provider::submit_now::flush_explicit_queue(transport, &target) {
                     Ok(flush) if flush.extra_enters > 0 => {
                         let _ = event_log.write(
@@ -2221,7 +2223,11 @@ fn recipient_pane_has_actionable_startup_prompt(
             crate::provider::classify_copilot_startup_screen(&captured),
             crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
         ),
-        Provider::Grok | Provider::CursorAgent | Provider::GeminiCli | Provider::Fake => false,
+        Provider::Pi
+        | Provider::Grok
+        | Provider::CursorAgent
+        | Provider::GeminiCli
+        | Provider::Fake => false,
     }
 }
 
@@ -2235,13 +2241,6 @@ fn recipient_provider(state: &serde_json::Value, recipient: &str) -> Option<Prov
         .and_then(parse_canonical_provider)
 }
 
-fn recipient_is_cursor_agent(state: &serde_json::Value, recipient: &str) -> bool {
-    matches!(
-        recipient_provider(state, recipient),
-        Some(Provider::CursorAgent)
-    )
-}
-
 /// ---
 /// purpose: paste→Enter 地板按收件人 provider 选择
 /// contract: CursorAgent 与 Grok 为 1s；其余（含 claude）为 ZERO
@@ -2259,7 +2258,32 @@ pub(crate) fn paste_to_submit_floor_for_recipient(
     }
 }
 
-fn recipient_is_busy(state: &serde_json::Value, recipient: &str) -> bool {
+/// ---
+/// purpose: 判断收件 provider 是否必须禁止 submit observer 重按 Enter
+/// returns: CursorAgent 与 Pi 为 true，其余为 false
+/// ---
+pub(crate) fn recipient_requires_single_enter(state: &serde_json::Value, recipient: &str) -> bool {
+    matches!(
+        recipient_provider(state, recipient),
+        Some(Provider::CursorAgent | Provider::Pi)
+    )
+}
+
+/// ---
+/// purpose: 判断收件 provider 是否允许 Grok send-now 显式队列 flush
+/// returns: CursorAgent 与 Pi 为 false，其余为 true
+/// ---
+pub(crate) fn recipient_allows_explicit_queue_flush(
+    state: &serde_json::Value,
+    recipient: &str,
+) -> bool {
+    !matches!(
+        recipient_provider(state, recipient),
+        Some(Provider::CursorAgent | Provider::Pi)
+    )
+}
+
+pub(crate) fn recipient_is_busy(state: &serde_json::Value, recipient: &str) -> bool {
     state
         .get("agents")
         .and_then(serde_json::Value::as_object)

package/crates/team-agent/src/model/enums.rs

@@ -27,6 +27,8 @@ pub enum Provider {
     /// Cursor `agent` CLI (0.5.67 provider-adapter). Append system prompt via
     /// workspace `.cursor/rules/*.mdc` (方案 1 变体), bypass `--force`.
     CursorAgent,
+    /// Pi coding agent CLI. Models are selected from its live catalog.
+    Pi,
     Fake,
 }
 
@@ -89,7 +91,7 @@ impl ProviderEffort {
     /// Copilot/Gemini/CursorAgent/Fake ignore the field (warning at runtime).
     pub fn is_supported_by(self, provider: Provider) -> bool {
         match provider {
-            Provider::Claude | Provider::ClaudeCode => true,
+            Provider::Claude | Provider::ClaudeCode | Provider::Pi => true,
             Provider::Codex | Provider::Grok => !self.is_claude_only(),
             Provider::Copilot | Provider::GeminiCli | Provider::CursorAgent | Provider::Fake => {
                 false

package/crates/team-agent/src/model/permissions.rs

@@ -191,7 +191,7 @@ fn provider_enforcement(provider: Provider, tool: Tool) -> Enforcement {
         Provider::Fake => Hard,
         // 0.5.67: grok/cursor_agent 无 deny-kind 概念 (同 codex 精神), 诚实
         // prompt_only, 不替 provider 决。
-        Provider::Grok | Provider::CursorAgent => PromptOnly,
+        Provider::Grok | Provider::CursorAgent | Provider::Pi => PromptOnly,
         // Copilot(C-2-1 cr verdict):execute_bash/fs_write/network/mcp_team = hard,
         // fs_read/fs_list/git_diff/provider_builtin = prompt_only(诚实:copilot 无
         // 对应 deny kind,framework 不替决,留给 provider prompt 控制;MUST-NOT-13)。

package/crates/team-agent/src/provider/adapter.rs

@@ -358,6 +358,12 @@ impl ProviderAdapter for BasicProviderAdapter {
                 native_mcp_config: false,
                 writes_global_settings: false,
             },
+            Provider::Pi => ProviderCaps {
+                resume: true,
+                fork: false,
+                native_mcp_config: false,
+                writes_global_settings: false,
+            },
             Provider::Fake => ProviderCaps {
                 resume: false,
                 fork: false,
@@ -408,6 +414,7 @@ impl ProviderAdapter for BasicProviderAdapter {
             // Cursor: 登录探测未接。U-17 前不得把未观测写成 Present（shim 对
             // `cursor-agent status` 会假绿 Logged in）。缺键 ≠ 已知未登录，故不用 Missing。
             Provider::CursorAgent => AuthHintStatus::Unknown,
+            Provider::Pi => AuthHintStatus::Unknown,
             _ => match auth_mode {
                 AuthMode::Subscription => AuthHintStatus::Present,
                 AuthMode::OfficialApi | AuthMode::CompatibleApi => AuthHintStatus::MissingOrUnknown,
@@ -491,6 +498,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                 false,
                 None,
             )?),
+            Provider::Pi => Err(ProviderError::Command(
+                "Pi commands require the shared lifecycle materializer".to_string(),
+            )),
             Provider::Fake => Ok(fake_worker_command()),
         }
     }
@@ -645,6 +655,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                     managed_mcp_config: false,
                 })
             }
+            Provider::Pi => Err(ProviderError::Command(
+                "Pi commands require the shared lifecycle materializer".to_string(),
+            )),
             _ => self
                 .build_command_with_tools(
                     ctx.auth_mode,
@@ -843,6 +856,9 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.insert(2, session_id.as_str().to_string());
                 Ok(argv)
             }
+            Provider::Pi => Err(ProviderError::ResumeUnavailable(
+                "pi resume requires the captured exact session path".to_string(),
+            )),
             Provider::GeminiCli | Provider::Fake => Err(ProviderError::ResumeUnavailable(format!(
                 "{} resume requires session_id",
                 provider_wire(self.provider)
@@ -1068,7 +1084,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.push("--fork-session".to_string());
                 Ok(argv)
             }
-            Provider::CursorAgent | Provider::GeminiCli | Provider::Fake => {
+            Provider::Pi | Provider::CursorAgent | Provider::GeminiCli | Provider::Fake => {
                 Err(ProviderError::CapabilityUnsupported(format!(
                     "{} does not support native session fork",
                     provider_wire(self.provider)
@@ -1271,6 +1287,12 @@ impl ProviderAdapter for BasicProviderAdapter {
                 r"working|processing",
                 r"Error|panic",
             ),
+            // Pi: 无已验证 turn-state 检测；占位串不会匹配真实 pane chrome。
+            Provider::Pi => patterns(
+                r"pi-idle-unset-until-turn-state",
+                r"pi-busy-unset-until-turn-state",
+                r"pi-error-unset-until-turn-state",
+            ),
             // Grok: 暂无专有 status 正则, 沿用 generic。
             Provider::Grok | Provider::GeminiCli | Provider::Fake => {
                 patterns(r">", r"working|processing", r"Error|Traceback")
@@ -1285,8 +1307,12 @@ impl ProviderAdapter for BasicProviderAdapter {
         }
     }
 
-    fn validate_model(&self, _model: &str) -> Result<bool, ProviderError> {
-        Ok(true)
+    fn validate_model(&self, model: &str) -> Result<bool, ProviderError> {
+        if self.provider != Provider::Pi {
+            return Ok(true);
+        }
+        let (_, catalog) = crate::lifecycle::launch::pi_mcp::resolve_pi_executable_chain()?;
+        Ok(crate::lifecycle::launch::pi_mcp::select_exact_pi_model(&catalog, model).is_ok())
     }
 }
 

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

@@ -15,8 +15,10 @@
 //! `.team/scripts/cursor_seat.sh` 实测一致：
 //!   `--trust --sandbox disabled --workspace <物理路径> [--force] [--model]`
 //! Role 不入 argv，写 `<workspace>/.cursor/rules/*.mdc` + `alwaysApply: true`。
-//! MCP 无 `--mcp-config`；身份必须写进 `.cursor/mcp.json` 的 env 表
+//! MCP 无 `--mcp-config`；身份必须写进 per-seat
+//! `provider-config/<id>/cursor/.cursor/mcp.json` 的 env 表
 //! （cursor 不把父进程 TEAM_AGENT_* 传给 MCP 子进程）。
+//! spawn 把 `--workspace` 指到该工程根，并用 `--add-dir` 挂上真 workspace。
 //!
 //! 隐藏 flag `--system-prompt` / `--allowed-tools` 实测存在但 help 未列，
 //! 随时可能消失。可以在注释里记录，代码里不许调。
@@ -73,7 +75,8 @@ pub(crate) fn cursor_agent_base_command(
     let _ = effort;
     // system_prompt 不入 argv（help 无 --rules / --append-system-prompt）。
     // launch 写 `<workspace>/.cursor/rules/team-agent-role-<agent_id>.mdc`。
-    // mcp_config 也不入 argv（无 --mcp-config）。launch 写 `.cursor/mcp.json`
+    // mcp_config 也不入 argv（无 --mcp-config）。launch 写
+    // `.team/runtime/provider-config/<id>/cursor/.cursor/mcp.json`
     // 并 `agent mcp enable team_orchestrator`。这里收下以免静默丢弃。
     let _ = (adapter, auth_mode, mcp_config, managed_mcp_config, system_prompt);
     argv.push("--workspace".to_string());

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

@@ -30,3 +30,4 @@ pub(crate) mod copilot_fork;
 pub(crate) mod fake;
 pub(crate) mod grok;
 pub(crate) mod cursor_agent;
+pub(crate) mod pi;