@team-agent/installer 0.5.69 → 0.5.71

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.69"
+version = "0.5.71"
 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.71"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/mod.rs

@@ -3393,6 +3393,40 @@ pub mod lifecycle_port {
                 Some(crate::cli::QUICK_START_REMINDER)
             );
         }
+
+        #[test]
+        fn spawn_failure_without_session_does_not_claim_a_worker_pane_exists() {
+            let value = restart_value(
+                crate::lifecycle::RestartReport::Failed {
+                    session_name: crate::transport::SessionName::new("team-current"),
+                    failed_agents: vec![crate::lifecycle::RestartFailedAgent {
+                        agent_id: crate::model::ids::AgentId::new("coder"),
+                        restart_mode: crate::lifecycle::StartMode::Fresh,
+                        decision: crate::lifecycle::ResumeDecision::FreshStart,
+                        session_id: None,
+                        phase: "spawn".to_string(),
+                        error: "provider io error".to_string(),
+                    }],
+                    next_actions: Vec::new(),
+                    attach_commands: Vec::new(),
+                },
+                None,
+            );
+            let action = value
+                .pointer("/failed_agents/0/action")
+                .and_then(Value::as_str)
+                .expect("spawn failure action");
+
+            assert!(
+                action.contains("before a pane was created"),
+                "action={action}"
+            );
+            assert!(
+                !action.contains("inspect worker coder output"),
+                "action={action}"
+            );
+            assert!(!action.contains("restart-agent"), "action={action}");
+        }
     }
 
     fn restart_value(report: crate::lifecycle::RestartReport, team: Option<&str>) -> Value {
@@ -3436,10 +3470,10 @@ pub mod lifecycle_port {
                     "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
                     "phase": failure.phase,
                     "error": failure.error,
-                    "action": format!(
-                        "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                        failure.agent_id,
-                        failure.agent_id
+                    "action": crate::lifecycle::restart_failure_action(
+                        &failure.agent_id,
+                        &failure.phase,
+                        failure.session_id.as_ref(),
                     ),
                     "log": format!(
                         ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
@@ -3470,10 +3504,10 @@ pub mod lifecycle_port {
                     "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
                     "phase": failure.phase,
                     "error": failure.error,
-                    "action": format!(
-                        "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                        failure.agent_id,
-                        failure.agent_id
+                    "action": crate::lifecycle::restart_failure_action(
+                        &failure.agent_id,
+                        &failure.phase,
+                        failure.session_id.as_ref(),
                     ),
                     "log": format!(
                         ".team/logs/coordinator.log and .team/runtime/state.json agent={}",

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,66 +383,91 @@ 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
 /// ---
 pub(crate) fn write_pi_wrapper(request: PiWrapperRequest<'_>) -> Result<PathBuf, ProviderError> {
+    write_pi_wrapper_with_publish(request, |from, to| std::fs::rename(from, to))
+}
+
+pub(crate) fn write_pi_wrapper_with_publish(
+    request: PiWrapperRequest<'_>,
+    publish: impl FnOnce(&Path, &Path) -> std::io::Result<()>,
+) -> Result<PathBuf, ProviderError> {
     let source = render_pi_wrapper(&request)?;
     validate_pi_wrapper_source(&source, request.adapter, request.candidate_executable)?;
     let parent = request.destination.parent().ok_or_else(|| {
         ProviderError::Io("Pi wrapper destination has no parent directory".to_string())
     })?;
-    std::fs::create_dir_all(parent)
-        .map_err(|error| ProviderError::Io(format!("{}: {error}", parent.display())))?;
+    std::fs::create_dir_all(parent).map_err(|error| {
+        ProviderError::Io(format!(
+            "Pi wrapper atomic write stage=create_parent path={}: {error}",
+            parent.display()
+        ))
+    })?;
     let temp = parent.join(format!(".team-mcp.ts.{}.tmp", std::process::id()));
     let write_result = (|| {
         let mut file = OpenOptions::new()
@@ -456,22 +475,38 @@ pub(crate) fn write_pi_wrapper(request: PiWrapperRequest<'_>) -> Result<PathBuf,
             .write(true)
             .mode(0o600)
             .open(&temp)
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", temp.display())))?;
-        file.write_all(source.as_bytes())
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", temp.display())))?;
-        file.sync_all()
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", temp.display())))?;
-        std::fs::rename(&temp, request.destination).map_err(|error| {
+            .map_err(|error| {
+                ProviderError::Io(format!(
+                    "Pi wrapper atomic write stage=open_temp path={}: {error}",
+                    temp.display()
+                ))
+            })?;
+        file.write_all(source.as_bytes()).map_err(|error| {
             ProviderError::Io(format!(
-                "rename {} to {}: {error}",
-                temp.display(),
-                request.destination.display()
+                "Pi wrapper atomic write stage=write_temp path={}: {error}",
+                temp.display()
             ))
         })?;
-        std::fs::set_permissions(request.destination, std::fs::Permissions::from_mode(0o600))
+        file.set_permissions(std::fs::Permissions::from_mode(0o600))
             .map_err(|error| {
-                ProviderError::Io(format!("{}: {error}", request.destination.display()))
+                ProviderError::Io(format!(
+                    "Pi wrapper atomic write stage=chmod_temp_fd path={}: {error}",
+                    temp.display()
+                ))
             })?;
+        file.sync_all().map_err(|error| {
+            ProviderError::Io(format!(
+                "Pi wrapper atomic write stage=fsync_temp path={}: {error}",
+                temp.display()
+            ))
+        })?;
+        publish(&temp, request.destination).map_err(|error| {
+            ProviderError::Io(format!(
+                "Pi wrapper atomic write stage=rename_publish from={} to={}: {error}",
+                temp.display(),
+                request.destination.display()
+            ))
+        })?;
         Ok(request.destination.to_path_buf())
     })();
     if write_result.is_err() {
@@ -482,14 +517,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 +554,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 +626,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 +688,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 +705,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 +746,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 +784,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 +830,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 +844,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"],