@team-agent/installer 0.5.66 → 0.5.69

package/crates/team-agent/src/messaging/tests/e23.rs

@@ -18,6 +18,15 @@ fn e23_fallback_pane_has_single_shared_noisy_surface() {
                 .unwrap(),
         "primary-ok guard must run before any fallback audit/inject attempt"
     );
+    let already = leader_receiver
+        .split("fn message_already_delivered")
+        .nth(1)
+        .unwrap_or("");
+    assert!(
+        already.contains("submitted_pending_acceptance")
+            && already.contains("injected_awaiting_receipt"),
+        "fallback already-delivered set must include the live post-submit statuses, not only the dead string submitted"
+    );
 }
 
 #[test]

package/crates/team-agent/src/messaging/tests/leader_inject_acceptance.rs

@@ -99,6 +99,72 @@ fn attached_leader_mailbox_is_rechecked_by_the_normal_delivery_tick() {
     assert!(case.events().contains("leader_receiver.mailbox_requeued"));
 }
 
+#[test]
+fn claimed_leader_delivery_revalidates_a_stale_unattached_snapshot() {
+    let workspace = tmp_ws("leader-inject-acceptance-stale-attach");
+    let rollout = workspace.join("leader.jsonl");
+    std::fs::write(&rollout, "").unwrap();
+    let current_state = serde_json::json!({
+        "active_team_key": "acceptance-team",
+        "session_name": "team-acceptance",
+        "leader_receiver": {
+            "pane_id": "%leader",
+            "status": "attached",
+            "provider": "claude",
+            "rollout_path": rollout,
+        },
+        "teams": {
+            "acceptance-team": {
+                "session_name": "team-acceptance",
+            }
+        }
+    });
+    crate::state::persist::save_runtime_state(&workspace, &current_state).unwrap();
+    let store = MessageStore::open(&workspace).unwrap();
+    let event_log = EventLog::new(&workspace);
+    let message_id = store
+        .create_message(
+            None,
+            "worker",
+            "leader",
+            "stale attach canary",
+            None,
+            false,
+            Some("acceptance-team"),
+        )
+        .unwrap();
+    let stale_state = serde_json::json!({
+        "active_team_key": "acceptance-team",
+        "teams": {
+            "acceptance-team": {
+                "session_name": "team-acceptance"
+            }
+        }
+    });
+    let transport = RecordingTransport::new("");
+
+    let outcome = deliver_pending_message(
+        &workspace,
+        &store,
+        &transport,
+        &message_id,
+        &event_log,
+        &stale_state,
+    )
+    .expect("delivery from stale coordinator snapshot");
+
+    assert_ne!(
+        outcome.reason,
+        Some(DeliveryRefusal::LeaderNotAttached),
+        "a claim made after attach must revalidate durable state before writing leader_not_attached"
+    );
+    assert_ne!(
+        outcome.message_status.0, "failed",
+        "a stale pre-attach snapshot must not strand the requeued row"
+    );
+    assert_eq!(transport.inject_count(), 1);
+}
+
 #[test]
 fn leader_submit_without_receipt_source_cannot_park_forever_without_a_completion_writer() {
     let case = Case::new_without_rollout("missing-receipt-source");

package/crates/team-agent/src/messaging/tests/mod.rs

@@ -296,6 +296,7 @@ impl Drop for EnvGuardMsg {
 }
 
 mod basic;
+mod dup_inject;
 mod e23;
 mod leader_channel;
 mod leader_inject_acceptance;

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

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::model::enums::Provider;
 use crate::model::ids::{LeaderSessionUuid, OwnerEpoch, TaskId, TeamKey};
-use crate::transport::PaneId;
+use crate::transport::{PaneId, TurnVerification};
 
 use super::helpers::MessageStatusShadow;
 
@@ -308,6 +308,9 @@ pub struct DeliveryOutcome {
     pub reason: Option<DeliveryRefusal>,
     /// fallback / broadcast / fanout 等通道标注 (`channel` 字段)。
     pub channel: Option<String>,
+    /// 入箱 vs 开跑。None = 本路径没观测（JSON 必须落成 not_yet_observed，不得报开跑）。
+    /// Gap42：只是 metadata，不是投递闸门。
+    pub turn_verification: Option<TurnVerification>,
 }
 
 /// trust retry payload (card §45;`delivery.py:273` scheduled_events.payload_json 的 typed 视图)。

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

@@ -21,6 +21,14 @@ pub enum Provider {
     /// AGENTS.md + `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` env(B2 灵魂件降级,§C2)。
     Copilot,
     GeminiCli,
+    /// Grok CLI (0.5.67 provider-adapter). Append system prompt via `--rules`,
+    /// bypass `--always-approve`, session `--session-id`.
+    Grok,
+    /// 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,
 }
 
@@ -33,7 +41,8 @@ pub enum Provider {
 /// Provider support:
 ///   - claude / claude_code: low|medium|high|xhigh|max → `--effort <level>`
 ///   - codex: low|medium|high|xhigh (NOT max) → `-c model_reasoning_effort=<level>`
-///   - copilot / gemini_cli / fake: unsupported — warning event, no flag
+///   - grok: low|medium|high|xhigh (NOT max) → `--effort <level>`
+///   - copilot / gemini_cli / cursor_agent / fake: unsupported — warning event, no flag
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum ProviderEffort {
     #[serde(rename = "low")]
@@ -78,13 +87,15 @@ impl ProviderEffort {
     }
 
     /// True when the given provider supports this effort level. `max` is
-    /// Claude-only; other levels are supported by Claude and Codex, ignored
-    /// by Copilot/Gemini/Fake (warning emitted at runtime).
+    /// Claude-only; other levels are supported by Claude, Codex, and Grok.
+    /// 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::Codex => !self.is_claude_only(),
-            Provider::Copilot | Provider::GeminiCli | Provider::Fake => false,
+            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

@@ -189,6 +189,9 @@ fn provider_enforcement(provider: Provider, tool: Tool) -> Enforcement {
             FsRead | FsWrite | FsList | ExecuteBash | GitDiff | ProviderBuiltin => Hard,
         },
         Provider::Fake => Hard,
+        // 0.5.67: grok/cursor_agent 无 deny-kind 概念 (同 codex 精神), 诚实
+        // prompt_only, 不替 provider 决。
+        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/os_probe.rs

@@ -1,10 +1,31 @@
+//! ---
+//! purpose: 为运行时提供有界的进程输出读取与前台进程组探测
+//! contract:
+//!   provides:
+//!     - name: bounded_command_output_with_probe
+//!       what: 在固定超时内执行命令并读取 stdout，超时后终止子进程
+//!     - name: pane_foreground_and_root_pgrp
+//!       what: 读取 pane PID 的前台与根进程组 ID，无法判定时返回 None
+//!   depends:
+//!     - std
+//! boundary:
+//!   - 只负责有界探测、临时 stdout 文件的独占创建与清理
+//!   - 不决定 shutdown 状态，不重试探测，不修改调用方行为
+//! arch:
+//!   allowed_dependencies:
+//!     - std
+//! maturity: wired
+//! ---
+
 use std::cell::RefCell;
 use std::fs::OpenOptions;
 use std::io::{self, Read};
 use std::process::{Command, ExitStatus, Stdio};
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 const DEFAULT_TIMEOUT: Duration = Duration::from_millis(900);
+static NEXT_TEMP_OUTPUT_ID: AtomicU64 = AtomicU64::new(0);
 
 thread_local! {
     static PROBE_TIMEOUT: RefCell<Option<ProbeTimeout>> = const { RefCell::new(None) };
@@ -23,19 +44,31 @@ pub(crate) struct BoundedCommandOutput {
     pub(crate) stdout: Vec<u8>,
 }
 
+/// ---
+/// purpose: 清除当前线程记录的探测超时
+/// ---
 pub(crate) fn clear_probe_timeout() {
     PROBE_TIMEOUT.with(|timeout| *timeout.borrow_mut() = None);
 }
 
+/// ---
+/// purpose: 判断当前线程是否记录了探测超时
+/// ---
 pub(crate) fn probe_timed_out() -> bool {
     PROBE_TIMEOUT.with(|timeout| timeout.borrow().is_some())
 }
 
+/// ---
+/// purpose: 获取当前线程记录的探测超时详情
+/// ---
 pub(crate) fn probe_timeout() -> Option<ProbeTimeout> {
     PROBE_TIMEOUT.with(|timeout| timeout.borrow().clone())
 }
 
 #[cfg(test)]
+/// ---
+/// purpose: 为单元测试设置探测超时详情
+/// ---
 pub(crate) fn set_probe_timeout_for_test(probe: &'static str, pid: Option<u32>, timeout_ms: u64) {
     PROBE_TIMEOUT.with(|current| {
         *current.borrow_mut() = Some(ProbeTimeout {
@@ -46,6 +79,9 @@ pub(crate) fn set_probe_timeout_for_test(probe: &'static str, pid: Option<u32>,
     });
 }
 
+/// ---
+/// purpose: 执行一个带默认超时与探测标识的命令并读取 stdout
+/// ---
 pub(crate) fn bounded_command_output_with_probe(
     command: &mut Command,
     probe: &'static str,
@@ -114,9 +150,14 @@ fn temp_output_path(kind: &str) -> std::path::PathBuf {
         .duration_since(UNIX_EPOCH)
         .map(|duration| duration.as_nanos())
         .unwrap_or(0);
+    temp_output_path_with_nanos(kind, nanos)
+}
+
+fn temp_output_path_with_nanos(kind: &str, nanos: u128) -> std::path::PathBuf {
+    let unique_id = NEXT_TEMP_OUTPUT_ID.fetch_add(1, Ordering::Relaxed);
     std::env::temp_dir().join(format!(
-        "team-agent-os-probe-{}-{nanos}.{kind}",
-        std::process::id()
+        "team-agent-os-probe-{}-{nanos}-{unique_id}.{kind}",
+        std::process::id(),
     ))
 }
 
@@ -146,6 +187,9 @@ fn read_and_remove(path: &std::path::Path) -> Vec<u8> {
 ///
 /// Bounded via [`run_bounded_command`] so a wedged ps cannot stall the
 /// coordinator tick.
+/// ---
+/// purpose: 读取 pane PID 的前台与根进程组 ID，无法判定时返回 None
+/// ---
 pub(crate) fn pane_foreground_and_root_pgrp(pane_pid: u32) -> io::Result<Option<(u32, u32)>> {
     let mut command = Command::new("ps");
     command.args(["-o", "tpgid=,pgid=", "-p", &pane_pid.to_string()]);
@@ -206,4 +250,31 @@ mod fg_pgrp_tests {
             pane_foreground_and_root_pgrp(0xFFFF_FFFE).expect("must not error on missing pid");
         assert!(result.is_none(), "missing pid → None");
     }
+
+    #[test]
+    fn temp_output_create_new_requires_atomic_discriminator() {
+        let fixed_nanos = 0x5eed_u128;
+        let first_path = temp_output_path_with_nanos("stdout", fixed_nanos);
+        let second_path = temp_output_path_with_nanos("stdout", fixed_nanos);
+        let _ = std::fs::remove_file(&first_path);
+        let _ = std::fs::remove_file(&second_path);
+
+        let first = OpenOptions::new()
+            .create_new(true)
+            .read(true)
+            .write(true)
+            .open(&first_path)
+            .expect("first atomic path create");
+        let second = OpenOptions::new()
+            .create_new(true)
+            .read(true)
+            .write(true)
+            .open(&second_path)
+            .expect("second atomic path create");
+        assert_ne!(first_path, second_path, "atomic discriminator must advance");
+        drop(first);
+        drop(second);
+        let _ = std::fs::remove_file(first_path);
+        let _ = std::fs::remove_file(second_path);
+    }
 }

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

@@ -342,6 +342,28 @@ impl ProviderAdapter for BasicProviderAdapter {
                 native_mcp_config: false,
                 writes_global_settings: true,
             },
+            // Grok: --resume/--fork-session 齐全 → resume/fork true; 无原生
+            // --mcp-config flag → native_mcp_config false (MCP 走 .grok/config.toml)。
+            Provider::Grok => ProviderCaps {
+                resume: true,
+                fork: true,
+                native_mcp_config: false,
+                writes_global_settings: false,
+            },
+            // Cursor agent: --resume [chatId] 有 → resume true; 无 fork flag →
+            // fork false; 无 --mcp-config → native_mcp_config false。
+            Provider::CursorAgent => ProviderCaps {
+                resume: true,
+                fork: false,
+                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,
@@ -389,6 +411,10 @@ impl ProviderAdapter for BasicProviderAdapter {
             // 标"weak / no auth-status command available";Compatible/Official 走 BYOK
             // 路径,有 COPILOT_PROVIDER_BASE_URL 时已脱离 GitHub 登录通道。
             Provider::Copilot => copilot_auth_hint(auth_mode),
+            // 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,
@@ -454,6 +480,27 @@ impl ProviderAdapter for BasicProviderAdapter {
                 }
                 Ok(argv)
             }
+            Provider::Grok => Ok(grok_launch_command(
+                self,
+                auth_mode,
+                mcp_config,
+                system_prompt,
+                model,
+                tools,
+            )?),
+            Provider::CursorAgent => Ok(cursor_agent_base_command(
+                self,
+                auth_mode,
+                mcp_config,
+                system_prompt,
+                model,
+                tools,
+                false,
+                None,
+            )?),
+            Provider::Pi => Err(ProviderError::Command(
+                "Pi commands require the shared lifecycle materializer".to_string(),
+            )),
             Provider::Fake => Ok(fake_worker_command()),
         }
     }
@@ -543,6 +590,32 @@ impl ProviderAdapter for BasicProviderAdapter {
             //   * `-C <workspace>`(双保险,即便 spawn cwd 漂移也能锚定)
             // mcp_config inline 形态由 build_command 写入,launch 路径会用
             // point_native_mcp_config_at_file 重写为 @<file> 形(§C1 note)。
+            Provider::Grok => {
+                // Align with Claude/Copilot: the UUID on `--session-id` is
+                // also the capture hint. `CommandPlan::argv_only` used to
+                // drop expected_session_id, so `_pending_session_id` was
+                // never written and restart could not resume.
+                let expected = next_session_token();
+                let mut argv = grok_base_command(
+                    self,
+                    ctx.auth_mode,
+                    ctx.mcp_config,
+                    ctx.system_prompt,
+                    ctx.model,
+                    ctx.tools,
+                    ctx.profile_launch
+                        .is_some_and(|profile| profile.managed_mcp_config),
+                    ctx.effort,
+                )?;
+                argv.push("--session-id".to_string());
+                argv.push(expected.clone());
+                Ok(CommandPlan {
+                    argv,
+                    expected_session_id: Some(SessionId::new(expected)),
+                    provider_projects_root: None,
+                    managed_mcp_config: false,
+                })
+            }
             Provider::Copilot => {
                 let expected = next_session_token();
                 let mut argv = copilot_base_command(
@@ -561,6 +634,30 @@ impl ProviderAdapter for BasicProviderAdapter {
                     managed_mcp_config: false,
                 })
             }
+            Provider::CursorAgent => {
+                // U-01 create-chat 无登录超时；禁止发明 --session-id。
+                // pending 只能是 CLI chatId，本拍不造假 uuid。
+                let argv = cursor_agent_base_command(
+                    self,
+                    ctx.auth_mode,
+                    ctx.mcp_config,
+                    ctx.system_prompt,
+                    ctx.model,
+                    ctx.tools,
+                    ctx.profile_launch
+                        .is_some_and(|profile| profile.managed_mcp_config),
+                    ctx.effort,
+                )?;
+                Ok(CommandPlan {
+                    argv,
+                    expected_session_id: None,
+                    provider_projects_root: None,
+                    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,
@@ -725,6 +822,43 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.push(session_id.as_str().to_string());
                 Ok(argv)
             }
+            // Grok resume: base + `--resume <id>` (grok -r/--resume 接受 id|title)。
+            Provider::Grok => {
+                let mut argv = grok_base_command(
+                    self,
+                    auth_mode,
+                    mcp_config,
+                    system_prompt,
+                    model,
+                    tools,
+                    false,
+                    None,
+                )?;
+                argv.push("--resume".to_string());
+                argv.push(session_id.as_str().to_string());
+                Ok(argv)
+            }
+            // Cursor resume: base + `--resume <chatId>`。
+            Provider::CursorAgent => {
+                let mut argv = cursor_agent_base_command(
+                    self,
+                    auth_mode,
+                    mcp_config,
+                    system_prompt,
+                    model,
+                    tools,
+                    false,
+                    None,
+                )?;
+                // Put --resume immediately after `agent` so the CLI treats it as
+                // the session mode rather than a trailing flag after --workspace.
+                argv.insert(1, "--resume".to_string());
+                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)
@@ -801,6 +935,54 @@ impl ProviderAdapter for BasicProviderAdapter {
                 argv.push(session_id.as_str().to_string());
                 Ok(CommandPlan::argv_only(argv))
             }
+            Provider::Grok => {
+                let Some(session_id) = session_id else {
+                    return Err(ProviderError::ResumeUnavailable(
+                        "resume requires session_id".to_string(),
+                    ));
+                };
+                let mut argv = grok_base_command(
+                    self,
+                    ctx.auth_mode,
+                    ctx.mcp_config,
+                    ctx.system_prompt,
+                    ctx.model,
+                    ctx.tools,
+                    ctx.profile_launch
+                        .is_some_and(|profile| profile.managed_mcp_config),
+                    ctx.effort,
+                )?;
+                argv.push("--resume".to_string());
+                argv.push(session_id.as_str().to_string());
+                Ok(CommandPlan::argv_only(argv))
+            }
+            Provider::CursorAgent => {
+                let Some(session_id) = session_id else {
+                    return Err(ProviderError::ResumeUnavailable(
+                        "cursor_agent resume requires chatId; empty --resume is forbidden (picker)".to_string(),
+                    ));
+                };
+                let raw = session_id.as_str();
+                if raw.is_empty() || raw.contains('/') || raw.contains('\\') || raw.contains('\0') {
+                    return Err(ProviderError::ResumeUnavailable(
+                        "cursor_agent resume rejected forged or empty chatId".to_string(),
+                    ));
+                }
+                let mut argv = cursor_agent_base_command(
+                    self,
+                    ctx.auth_mode,
+                    ctx.mcp_config,
+                    ctx.system_prompt,
+                    ctx.model,
+                    ctx.tools,
+                    ctx.profile_launch
+                        .is_some_and(|profile| profile.managed_mcp_config),
+                    ctx.effort,
+                )?;
+                argv.push("--resume".to_string());
+                argv.push(raw.to_string());
+                Ok(CommandPlan::argv_only(argv))
+            }
             _ => self
                 .build_resume_command_with_context(
                     session_id,
@@ -882,7 +1064,27 @@ impl ProviderAdapter for BasicProviderAdapter {
             Provider::Copilot => Err(ProviderError::CapabilityUnsupported(
                 "copilot CLI 无 fork 旗标,session-store 不支持 branched continuation".to_string(),
             )),
-            Provider::GeminiCli | Provider::Fake => {
+            // Grok fork: base + 新 `--session-id` + `--resume <src>` + `--fork-session`
+            // (grok help: --fork-session 需配合 --resume/--continue)。
+            Provider::Grok => {
+                let mut argv = grok_base_command(
+                    self,
+                    auth_mode,
+                    mcp_config,
+                    system_prompt,
+                    model,
+                    tools,
+                    false,
+                    None,
+                )?;
+                argv.push("--session-id".to_string());
+                argv.push(next_session_token());
+                argv.push("--resume".to_string());
+                argv.push(session_id.as_str().to_string());
+                argv.push("--fork-session".to_string());
+                Ok(argv)
+            }
+            Provider::Pi | Provider::CursorAgent | Provider::GeminiCli | Provider::Fake => {
                 Err(ProviderError::CapabilityUnsupported(format!(
                     "{} does not support native session fork",
                     provider_wire(self.provider)
@@ -1006,6 +1208,30 @@ impl ProviderAdapter for BasicProviderAdapter {
                     managed_mcp_config: profile.managed_mcp_config,
                 })
             }
+            Provider::Grok => {
+                let Some(session_id) = session_id else {
+                    return Err(ProviderError::ResumeUnavailable(
+                        "fork requires session_id".to_string(),
+                    ));
+                };
+                let mut argv = grok_base_command(
+                    self,
+                    ctx.auth_mode,
+                    ctx.mcp_config,
+                    ctx.system_prompt,
+                    ctx.model,
+                    ctx.tools,
+                    ctx.profile_launch
+                        .is_some_and(|profile| profile.managed_mcp_config),
+                    ctx.effort,
+                )?;
+                argv.push("--session-id".to_string());
+                argv.push(next_session_token());
+                argv.push("--resume".to_string());
+                argv.push(session_id.as_str().to_string());
+                argv.push("--fork-session".to_string());
+                Ok(CommandPlan::argv_only(argv))
+            }
             _ => self
                 .fork_with_context(
                     session_id,
@@ -1061,14 +1287,32 @@ impl ProviderAdapter for BasicProviderAdapter {
                 r"working|processing",
                 r"Error|panic",
             ),
-            Provider::GeminiCli | Provider::Fake => {
+            // 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")
             }
+            // Cursor: U-15 未过前不得用 generic `>` 单独判已证实 idle。
+            // 字面量 `cursor-idle-unset-until-u15` 不会出现在屏上。
+            Provider::CursorAgent => patterns(
+                r"cursor-idle-unset-until-u15",
+                r"cursor-busy-unset-until-u15",
+                r"Error|Traceback",
+            ),
         }
     }
 
-    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())
     }
 }
 
@@ -1164,7 +1408,9 @@ pub(crate) fn json_inline(value: &serde_json::Value) -> String {
 use super::adapters::claude::{claude_base_command, claude_launch_command};
 use super::adapters::codex::codex_base_command;
 use super::adapters::copilot::{copilot_base_command, copilot_base_command_resume};
+use super::adapters::cursor_agent::cursor_agent_base_command;
 use super::adapters::fake::fake_worker_command;
+use super::adapters::grok::{grok_base_command, grok_launch_command};
 
 /// Contract C / MUST-8: the per-worker Team Agent MCP server config used by Claude
 /// (`--mcp-config`) and Codex (`-c mcp_servers.*` injection). Placeholders
@@ -1249,9 +1495,16 @@ pub(crate) fn next_session_token() -> String {
 #[cfg(test)]
 mod fork_materialization_source_guard {
     #[test]
-    fn lifecycle_uses_provider_neutral_fork_materialization_dispatch() {
+    fn lifecycle_uses_in_window_fork_not_session_file_materialization() {
         let source = include_str!("../lifecycle/launch/fork_agent.rs");
-        assert!(source.contains(".materialize_fork_backing("));
+        assert!(
+            source.contains("in_window_fork(") && source.contains("inject_clean_command"),
+            "fork must stay on the shared in-window inject path"
+        );
+        assert!(
+            !source.contains(".materialize_fork_backing("),
+            "session-file fork materialization must stay gone"
+        );
         assert!(!source.contains("materialize_codex_fork"));
         assert!(!source.contains("codex_fork"));
     }