@team-agent/installer 0.5.102 → 0.5.104

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

@@ -15,11 +15,8 @@
 //! comparing byte-for-byte to Python golden. The absolute `workspace` path (env-
 //! dependent) is templated to `__WS__` on both sides so every other byte is pinned.
 //!
-//! SCOPE (this wave): no-profile `subscription` role docs only. The `.env`
-//! profile machinery (`profiles/`, `_profile_model`/`load_profile`) and the
-//! `rust_core` inline-secret *detection* (`contains_inline_secret` / the secret-
-//! lint rejection test) are DEFERRED to a follow-on — the compile path here only
-//! needs `contains_inline_secret` to return `false` for clean (non-secret) input.
+//! Profile references are carried as role metadata; profile files and secrets are
+//! handled by lifecycle/profile_launch, not loaded or inspected by this compiler.
 //!
 //! §10: pure lib layer — no panic on malformed input; every parse/validate path
 //! returns `Result<_, ModelError>` (mirrors Python `ValidationError`).
@@ -31,10 +28,7 @@ use crate::communication_mode::CommunicationMode;
 use crate::model::enums::{Provider, ProviderEffort};
 use crate::model::yaml::Value;
 use crate::model::{paths, spec, yaml, ModelError};
-use crate::provider::wire::{
-    builtin_provider_model as wire_builtin_provider_model, parse_canonical_provider,
-    provider_model_keys,
-};
+use crate::provider::wire::parse_canonical_provider;
 
 pub const IGNORED_OWNER_TEAM_ID_FIELD: &str = "owner_team_id";
 
@@ -494,18 +488,12 @@ fn compile_role_agent_with_mode(
     let provider = string_field(&meta, "provider")
         .filter(|provider| !provider.trim().is_empty())
         .unwrap_or_else(|| "pi".to_string());
-    require_explicit_grok_role_model(&meta, role_path, &provider)?;
-    require_explicit_cursor_role_model(&meta, role_path, &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_else(|| Value::Str("openai-codex/gpt-6-luna".to_string()))
-    } else {
-        resolve_model(&meta, team_meta, &provider)
-    };
+    validate_pi_role_fields(&meta, role_path, &provider)?;
+    let model = string_field(&meta, "model")
+        .filter(|value| !value.trim().is_empty())
+        .map(Value::Str)
+        .unwrap_or(Value::Null);
     let auth_mode = string_field(&meta, "auth_mode")
         .or_else(|| string_field(team_meta, "default_auth_mode"))
         .unwrap_or_else(|| "subscription".to_string());
@@ -557,15 +545,11 @@ fn compile_role_agent_with_mode(
             ]),
         ),
     ];
-    if let Some(label) = string_field(&meta, "label") {
-        agent_items.insert(1, ("label", Value::Str(label)));
-    }
     if let Some(profile) = string_field(&meta, "profile") {
         agent_items.push(("profile", Value::Str(profile)));
     }
-    // 0.4.x provider effort MVP step 3: resolve effort with role > team > none
-    // (Pi uses only explicit role effort). Validate syntax and provider support
-    // here so unsupported combinations fail at compile, not at runtime.
+    // Role effort wins; Pi uses only an explicit role value. Other providers may
+    // inherit TEAM provider_effort for Issue #238 compatibility.
     let role_effort = match string_field(&meta, "effort") {
         Some(raw) if !raw.trim().is_empty() => {
             let value = raw.trim();
@@ -577,7 +561,6 @@ fn compile_role_agent_with_mode(
             })?;
             Some(parsed)
         }
-        _ if is_pi => Some(ProviderEffort::Max),
         _ => None,
     };
     let team_effort = match string_field(team_meta, "provider_effort") {
@@ -674,54 +657,6 @@ fn string_field(meta: &Value, key: &str) -> Option<String> {
         .map(ToString::to_string)
 }
 
-/// 缺 model 时框架会填内建默认（grok 上是 grok-4），席位因此静默拿到
-/// 与角色文件无关的模型和上下文窗口，而 argv 看起来完全正常。
-/// 角色文件必须自己写死；内建默认、team 级默认、CLI 全局默认都是隐式来源。
-fn require_explicit_grok_role_model(
-    meta: &Value,
-    path: &Path,
-    provider: &str,
-) -> Result<(), ModelError> {
-    if parse_canonical_provider(provider) != Some(Provider::Grok) {
-        return Ok(());
-    }
-    if string_field(meta, "model").is_some_and(|value| !value.trim().is_empty()) {
-        return Ok(());
-    }
-    Err(ModelError::Validation(format!(
-        "{}: missing front matter field model. \
-Without an explicit model the framework fills a built-in default (grok-4 for grok), \
-so the seat silently gets a model and context window that are not in the role file, \
-while argv still looks normal. The role file must name the model itself; \
-built-in defaults, team-level defaults, and the Grok CLI global default are all implicit sources. Example:\n\
-model: grok-4.6",
-        path.display()
-    )))
-}
-
-/// 缺 model 时框架曾填 builtin `sonnet-4-thinking`，本机 shim 还会剥掉该默认。
-/// 角色必须自己写死；内建默认、team 级默认、CLI 全局默认都是隐式来源。
-fn require_explicit_cursor_role_model(
-    meta: &Value,
-    path: &Path,
-    provider: &str,
-) -> Result<(), ModelError> {
-    if parse_canonical_provider(provider) != Some(Provider::CursorAgent) {
-        return Ok(());
-    }
-    if string_field(meta, "model").is_some_and(|value| !value.trim().is_empty()) {
-        return Ok(());
-    }
-    Err(ModelError::Validation(format!(
-        "{}: missing front matter field model. \
-Without an explicit model the framework fills a built-in default (sonnet-4-thinking for cursor_agent), \
-so the seat silently gets a model that is not in the role file, while argv still looks normal. \
-The role file must name the model itself; built-in defaults, team-level defaults, and the Cursor CLI default are all implicit sources. Example:\n\
-model: sonnet-4-thinking",
-        path.display()
-    )))
-}
-
 fn validate_pi_role_fields(meta: &Value, path: &Path, provider: &str) -> Result<(), ModelError> {
     if parse_canonical_provider(provider) != Some(Provider::Pi) {
         return Ok(());
@@ -746,7 +681,7 @@ fn validate_pi_role_fields(meta: &Value, path: &Path, provider: &str) -> Result<
 fn optional_dangerously_skip_permissions(meta: &Value) -> bool {
     match meta.get("dangerously_skip_permissions") {
         Some(Value::Bool(value)) => *value,
-        _ => true,
+        _ => false,
     }
 }
 
@@ -830,35 +765,6 @@ fn py_int_value(value: &Value) -> Option<i64> {
     }
 }
 
-fn resolve_model(role_meta: &Value, team_meta: &Value, provider: &str) -> Value {
-    if let Some(model) = string_field(role_meta, "model") {
-        return Value::Str(model);
-    }
-    if let Some(model) =
-        provider_model(team_meta, provider).or_else(|| string_field(team_meta, "default_model"))
-    {
-        return Value::Str(model);
-    }
-    if role_meta.get("profile").is_some() {
-        return Value::Null;
-    }
-    builtin_provider_model(provider)
-        .map(|m| Value::Str(m.to_string()))
-        .unwrap_or(Value::Null)
-}
-
-fn provider_model(team_meta: &Value, provider: &str) -> Option<String> {
-    let models = team_meta.get("provider_models")?;
-    let provider = parse_canonical_provider(provider)?;
-    provider_model_keys(provider)
-        .iter()
-        .find_map(|key| string_field(models, key))
-}
-
-fn builtin_provider_model(provider: &str) -> Option<&'static str> {
-    parse_canonical_provider(provider).and_then(wire_builtin_provider_model)
-}
-
 fn non_empty_trimmed(text: &str) -> Option<String> {
     let trimmed = text.trim();
     if trimmed.is_empty() {

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

@@ -390,7 +390,8 @@ fn starting_agent_entry(
     let provider = meta
         .get("provider")
         .and_then(Value::as_str)
-        .unwrap_or("codex");
+        .filter(|provider| !provider.trim().is_empty())
+        .unwrap_or("pi");
     let auth_mode = meta
         .get("auth_mode")
         .and_then(Value::as_str)
@@ -438,8 +439,9 @@ fn starting_agent_entry(
         let meta_provider = meta
             .get("provider")
             .and_then(Value::as_str)
+            .filter(|provider| !provider.trim().is_empty())
             .and_then(crate::provider::wire::parse_provider)
-            .unwrap_or(Provider::Codex);
+            .unwrap_or(Provider::Pi);
         persist_effective_approval_policy_from_yaml_agent(obj, meta, meta_provider);
     }
     entry

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

@@ -59,12 +59,9 @@ pub fn clone_agent(
         source_agent_id,
         as_agent_id,
         label,
-        None,
     )?;
-    // The materialized role carries the source role's DECLARED tools verbatim —
-    // a clone must preserve the source seat's full tools set (add-agent does
-    // the same; no leader-ceiling clamp). See role_source.rs for the removed
-    // clamp_materialized_role_to_leader.
+    // Materialization preserves the role body and legacy metadata; the compiler
+    // only maps supported fields, so ignored header keys remain behaviorally inert.
     let added = add_agent(
         &selected.run_workspace,
         as_agent_id,

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

@@ -168,25 +168,21 @@ pub(crate) fn provider_effort_event_payload(
 }
 
 /// ---
-/// purpose: 对 claude 系 provider 兜底确保 CLAUDE_EFFORT 进入待清除环境变量表
+/// purpose: 仅在存在显式 effort override 时清除继承的 CLAUDE_EFFORT
 /// params:
 ///   base: 已有的待清除变量名列表
-/// returns: 非 claude 系原样返回；claude 系在缺失时补上 CLAUDE_EFFORT
-/// ---
-/// 0.4.x provider effort MVP step 9: defensive guarantee that `CLAUDE_EFFORT`
-/// is unset in the Claude/ClaudeCode worker spawn env. As of the
-/// `profile_launch::provider_env_unsets` update, the base list already
-/// includes `CLAUDE_EFFORT` for Claude — so this function is idempotent
-/// (returns input unchanged). Kept as a belt-and-braces guard so a future
-/// refactor that bypasses provider_env_unsets cannot silently drop the
-/// scrub. The structural win is in `tmux_backend::shell_command` which now
-/// filters env exports by env_unset (preventing inherited values from
-/// re-introducing keys we just unset).
+///   has_effort_override: 本次启动是否实际施加 effort
+/// returns: 无显式 override 或非 claude 系时原样返回
+/// ---
+/// Preserve provider-native `CLAUDE_EFFORT` unless a supported explicit role
+/// effort is applied; in that case prevent the inherited environment from
+/// overriding the requested value.
 pub(crate) fn extend_worker_env_unset_for_effort(
     base: Vec<String>,
     provider: Provider,
+    has_effort_override: bool,
 ) -> Vec<String> {
-    if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
+    if !has_effort_override || !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         return base;
     }
     let mut out = base;

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

@@ -15,14 +15,13 @@
 
 use std::collections::BTreeSet;
 use std::fs::OpenOptions;
-use std::io::{Read, Write};
+use std::io::Write;
 #[cfg(test)]
 use std::cell::RefCell;
 use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-use std::sync::mpsc;
-use std::time::{Duration, Instant};
+use std::process::Command;
+use std::time::Duration;
 
 use sha2::{Digest, Sha256};
 
@@ -132,62 +131,9 @@ pub(crate) fn new_pi_session_id() -> SessionId {
 /// errors: 非 UTF-8、header/row 异常、重复或空 catalog 时返回 ProviderError
 /// ---
 pub(crate) fn parse_pi_list_models_table(bytes: &[u8]) -> Result<Vec<String>, ProviderError> {
-    let text = std::str::from_utf8(bytes).map_err(|error| {
-        ProviderError::Command(format!("Pi model catalog is not UTF-8: {error}"))
-    })?;
-    let mut lines = text.lines();
-    let header = lines
-        .next()
-        .ok_or_else(|| ProviderError::Command("Pi model catalog is empty".to_string()))?;
-    let header_columns = header.split_whitespace().collect::<Vec<_>>();
-    if header_columns.get(0) != Some(&"provider") || header_columns.get(1) != Some(&"model") {
-        return Err(ProviderError::Command(
-            "Pi model catalog has an unexpected header".to_string(),
-        ));
-    }
-    let mut seen = BTreeSet::new();
-    let mut models = Vec::new();
-    for (index, line) in lines.enumerate() {
-        if line.trim().is_empty() {
-            continue;
-        }
-        let malformed = || {
-            ProviderError::Command(format!(
-                "Pi model catalog row {} is malformed",
-                index + 2
-            ))
-        };
-        let (provider, model) = line
-            .trim()
-            .split_once(char::is_whitespace)
-            .ok_or_else(malformed)?;
-        let mut model = model.trim();
-        // Pi prints the raw model id, which may contain spaces. Only the
-        // capability columns following it are single whitespace-free values.
-        for _ in 2..header_columns.len() {
-            model = model
-                .rsplit_once(char::is_whitespace)
-                .ok_or_else(malformed)?
-                .0
-                .trim_end();
-        }
-        if model.is_empty() {
-            return Err(malformed());
-        }
-        let exact = format!("{provider}/{model}");
-        if !seen.insert(exact.clone()) {
-            return Err(ProviderError::Command(format!(
-                "Pi model catalog contains duplicate exact id {exact:?}"
-            )));
-        }
-        models.push(exact);
-    }
-    if models.is_empty() {
-        return Err(ProviderError::Command(
-            "Pi model catalog contains no models".to_string(),
-        ));
-    }
-    Ok(models)
+    crate::provider::model_catalog::parse_pi_catalog(bytes)
+        .map(|records| records.into_iter().map(|record| record.id).collect())
+        .map_err(|error| ProviderError::Command(error.pi_legacy_message()))
 }
 
 /// ---
@@ -658,43 +604,6 @@ fn observe_pi_catalog_test(f: impl FnOnce(&mut PiCatalogTestContext)) {
     });
 }
 
-fn spawn_catalog_reader(
-    stdout: std::process::ChildStdout,
-    max_bytes: u64,
-) -> mpsc::Receiver<(std::io::Result<usize>, Vec<u8>)> {
-    let (sender, receiver) = mpsc::channel();
-    std::thread::spawn(move || {
-        let mut bytes = Vec::new();
-        let result = stdout.take(max_bytes + 1).read_to_end(&mut bytes);
-        let _ = sender.send((result, bytes));
-    });
-    receiver
-}
-
-fn finish_catalog_reader(
-    receiver: mpsc::Receiver<(std::io::Result<usize>, Vec<u8>)>,
-    status: std::process::ExitStatus,
-    timeout: Duration,
-    max_bytes: u64,
-) -> Result<Vec<u8>, String> {
-    let (result, bytes) = match receiver.recv_timeout(timeout) {
-        Ok(value) => value,
-        Err(_) => {
-            #[cfg(test)]
-            observe_pi_catalog_test(|context| context.observation.reader_timeout = true);
-            return Err("Pi model catalog command timed out".to_string());
-        }
-    };
-    if !status.success() {
-        return Err("Pi model catalog command failed".into());
-    }
-    result.map_err(|_| "Pi model catalog could not be read".to_string())?;
-    if bytes.len() as u64 > max_bytes {
-        return Err("Pi model catalog exceeds the bounded output limit".into());
-    }
-    Ok(bytes)
-}
-
 #[cfg(test)]
 pub(crate) fn run_pi_catalog_after_parent_exit_for_test(
     stdout: std::process::ChildStdout,
@@ -708,86 +617,53 @@ pub(crate) fn run_pi_catalog_after_parent_exit_for_test(
         context.observation.parent_exit_success = Some(status.success());
         context.observation.parent_exit_code = status.code();
     });
-    finish_catalog_reader(
-        spawn_catalog_reader(stdout, max_bytes),
-        status,
-        timeout,
-        max_bytes,
+    crate::provider::model_catalog::finish_stdout_after_exit(
+        stdout, status, timeout, max_bytes, &mut PiCatalogObserver,
     )
+    .map_err(|error| error.pi_legacy_message())
 }
 
-/// Discover candidates with one PATH-first catalog observation. This deliberately
-/// does not resolve adapters or scan wrapper chains; callers use it only for
-/// rejecting an unqualified role model before lifecycle mutation.
+/// Shared bounded native-command runner; launch preflight keeps its exact model gate.
 pub(crate) fn run_pi_catalog(
     executable: &Path,
     timeout: Duration,
     max_bytes: u64,
 ) -> Result<Vec<u8>, String> {
-    let mut command = Command::new(executable);
-    command.arg("--list-models");
+    let mut extra_env = Vec::new();
     #[cfg(test)]
     observe_pi_catalog_test(|context| {
         context.observation.spawn_count += 1;
         context.observation.argv.push("--list-models".to_string());
-        command.env("TEAM_AGENT_MODELS_TIMEOUT_RECEIPT", &context.receipt);
+        extra_env.push(("TEAM_AGENT_MODELS_TIMEOUT_RECEIPT".into(), context.receipt.as_os_str().into()));
         if let Some(mode) = context.helper_mode.as_deref() {
-            command.env("TEAM_AGENT_MODELS_TIMEOUT_MODE", mode);
+            extra_env.push(("TEAM_AGENT_MODELS_TIMEOUT_MODE".into(), mode.into()));
         }
     });
-    let mut child = command
-        .stdin(Stdio::null())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::null())
-        .spawn()
-        .map_err(|error| {
-            #[cfg(test)]
-            {
-                eprintln!(
-                    "run_pi_catalog spawn failed kind={:?} raw_os_error={:?}",
-                    error.kind(),
-                    error.raw_os_error()
-                );
-            }
-            let _ = error;
-            "Pi executable is unavailable on PATH".to_string()
-        })?;
+    crate::provider::model_catalog::run_command(
+        executable, &["--list-models"], None, None, &[], &extra_env, timeout, max_bytes,
+        &mut PiCatalogObserver,
+    )
+    .map_err(|error| error.pi_legacy_message())
+}
+
+struct PiCatalogObserver;
+impl crate::provider::model_catalog::CatalogObserver for PiCatalogObserver {
     #[cfg(test)]
-    observe_pi_catalog_test(|context| context.observation.parent_pid = Some(child.id()));
-    let stdout = child.stdout.take().ok_or_else(|| {
-        let _ = child.kill();
-        let _ = child.wait();
-        "Pi model catalog output unavailable".to_string()
-    })?;
-    let receiver = spawn_catalog_reader(stdout, max_bytes);
-    let start = Instant::now();
-    loop {
-        match child.try_wait() {
-            Ok(Some(status)) => {
-                #[cfg(test)]
-                observe_pi_catalog_test(|context| {
-                    context.observation.parent_exit_success = Some(status.success());
-                    context.observation.parent_exit_code = status.code();
-                });
-                return finish_catalog_reader(
-                    receiver,
-                    status,
-                    timeout.saturating_sub(start.elapsed()),
-                    max_bytes,
-                );
-            }
-            Ok(None) if start.elapsed() < timeout => std::thread::sleep(Duration::from_millis(20)),
-            Ok(None) => {
-                let _ = child.kill();
-                let _ = child.wait();
-                return Err("Pi model catalog command timed out".into());
-            }
-            Err(_) => {
-                let _ = child.kill();
-                let _ = child.wait();
-                return Err("Pi model catalog command could not be observed".into());
-            }
-        }
+    fn spawned(&mut self, pid: u32) {
+        observe_pi_catalog_test(|context| context.observation.parent_pid = Some(pid));
+    }
+
+    #[cfg(test)]
+    fn exited(&mut self, status: &std::process::ExitStatus) {
+        observe_pi_catalog_test(|context| {
+            context.observation.parent_exit_success = Some(status.success());
+            context.observation.parent_exit_code = status.code();
+        });
+    }
+
+    #[cfg(test)]
+    fn output_timeout(&mut self) {
+        observe_pi_catalog_test(|context| context.observation.reader_timeout = true);
     }
 }
 

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

@@ -132,9 +132,8 @@ impl Drop for MaterializedRole {
 ///   state: 用于找源席的 dynamic_role_file，找不到时退到 team 目录下的同名 md
 ///   as_agent_id: 新席位名，写进 front matter 的 name
 ///   label: 非空时覆盖 front matter 的 role
-///   agent_label: 非空时写入 front matter 的 label
 /// returns: 物化结果，未调用 keep 时 Drop 会删掉该文件
-/// errors: 源文件缺失、未声明 name 或声明与源席不符时返回 Compile；目标已存在返回 RequirementUnmet；建目录或写盘失败返回 StatePersist
+/// errors: 源文件缺失时返回 Compile；目标已存在返回 RequirementUnmet；建目录或写盘失败返回 StatePersist
 /// ---
 pub(crate) fn materialize_latest_role(
     run_workspace: &Path,
@@ -143,27 +142,10 @@ pub(crate) fn materialize_latest_role(
     source_agent_id: &AgentId,
     as_agent_id: &AgentId,
     label: Option<&str>,
-    agent_label: Option<&str>,
 ) -> Result<MaterializedRole, LifecycleError> {
     let source_path = resolve_role_source(run_workspace, team_dir, state, source_agent_id)?;
     let (mut meta, body) = crate::compiler::read_front_matter(&source_path)
         .map_err(|error| LifecycleError::Compile(error.to_string()))?;
-    let declared = meta
-        .get("name")
-        .and_then(Value::as_str)
-        .filter(|name| !name.is_empty())
-        .ok_or_else(|| {
-            LifecycleError::Compile(format!(
-                "source role file does not declare name: {}",
-                source_path.display()
-            ))
-        })?;
-    if declared != source_agent_id.as_str() {
-        return Err(LifecycleError::Compile(format!(
-            "source role file declares name '{}' but source agent is '{}'",
-            declared, source_agent_id
-        )));
-    }
     set_yaml_map_value(
         &mut meta,
         "name",
@@ -175,12 +157,6 @@ pub(crate) fn materialize_latest_role(
     {
         set_yaml_map_value(&mut meta, "role", Value::Str(label.to_string()))?;
     }
-    if let Some(agent_label) = agent_label
-        .map(strip_label_quotes)
-        .filter(|value| !value.is_empty())
-    {
-        set_yaml_map_value(&mut meta, "label", Value::Str(agent_label.to_string()))?;
-    }
     if let Some(role) = meta.get("role").and_then(Value::as_str).map(str::to_string) {
         let role_without_quotes = strip_label_quotes(&role);
         if !role_without_quotes.is_empty() && role_without_quotes != role {

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

@@ -255,6 +255,7 @@ pub(super) fn spawn_agents(
             extend_worker_env_unset_for_effort(
                 profile_launch.env_unset.iter().cloned().collect(),
                 provider,
+                agent_effort.is_some(),
             ),
         );
         // The provider is the final typed value after profile overlays. Keep it

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

@@ -578,18 +578,6 @@ pub(crate) fn provider_env_unsets(provider: Provider, auth_mode: AuthMode) -> BT
             unsets.insert("CLAUDE_CODE_ENTRYPOINT".to_string());
             unsets.insert("CLAUDE_CODE_EXECPATH".to_string());
             unsets.insert("CLAUDECODE".to_string());
-            // 0.4.x provider effort MVP step 9: CLAUDE_EFFORT carried from the
-            // launching shell would silently override the framework's effort
-            // decision (or, when no spec effort is configured, override the
-            // documented "provider default"). Scrubbing here is the single
-            // source — `extend_worker_env_unset_for_effort` is a thin alias
-            // that calls into this list. Applies to BOTH worker spawn AND
-            // leader spawn (leader_env_unset_for_provider also reads this).
-            // MVP scope: leader-effort is not configured yet, but if a
-            // launching shell already carries CLAUDE_EFFORT, the leader
-            // inheriting it would conflict with future leader-effort
-            // semantics. Scrub uniformly for predictability.
-            unsets.insert("CLAUDE_EFFORT".to_string());
             if auth_mode == AuthMode::CompatibleApi {
                 unsets.insert("ANTHROPIC_API_KEY".to_string());
             }

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

@@ -315,7 +315,6 @@ pub(crate) fn fork_pi_new_seat_locked(
             source_agent_id,
             target_agent_id,
             label,
-            Some(target_agent_id.as_str()),
         )?;
         role = Some(target_role);
         let target_role_path = role

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

@@ -510,6 +510,7 @@ pub(super) fn spawn_agent_window(
         crate::lifecycle::launch::extend_worker_env_unset_for_effort(
             profile_launch.env_unset.iter().cloned().collect(),
             provider,
+            restart_effort.is_some(),
         ),
     );
     // Keep the launcher-known typed provider independent from inherited
@@ -748,7 +749,6 @@ fn merge_command_context_fields(
         "auth_mode",
         "effort",
         "profile",
-        "permission_mode",
         // 0.5.66 bypass 单源:rehydrate 同步合入,restart 的 safety 构造读到新值。
         "dangerously_skip_permissions",
     ] {

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

@@ -31,35 +31,23 @@ use team_agent::transport::test_support::OfflineTransport;
 
 #[test]
 #[serial(env)]
-fn cursor_role_missing_model_refuses_to_start() {
+fn cursor_role_missing_model_uses_provider_default() {
     let ws = tmp_dir("cursor-no-model");
     let team = write_role_team(&ws, "cursortm", "cursor_writer", None, None);
     let transport = OfflineTransport::new();
-    let result = quick_start_with_transport_in_workspace(
+    quick_start_with_transport_in_workspace(
         &ws,
         &team,
         None,
         true,
         Some("cursortm"),
         &transport,
-    );
-    let err = match result {
-        Ok(report) => panic!("cursor role without model must refuse; report={report:?}"),
-        Err(error) => error.to_string(),
-    };
-    let lower = err.to_ascii_lowercase();
-    assert!(
-        lower.contains("model"),
-        "error must name the missing field; err={err}"
-    );
-    assert!(
-        lower.contains("built-in") || lower.contains("builtin") || err.contains("内建"),
-        "error must name the built-in default; err={err}"
-    );
+    )
+    .expect("Cursor may use its provider-native model default");
+    let argv = first_spawn_argv(&transport);
     assert!(
-        transport.spawn_records().is_empty(),
-        "refusal must happen before spawn; records={:?}",
-        transport.spawn_records()
+        !argv.iter().any(|arg| arg == "--model"),
+        "an omitted model must not fabricate a --model argument: {argv:?}"
     );
 }