@team-agent/installer 0.4.9 → 0.4.10

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.4.9"
+version = "0.4.10"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.4.9"
+version = "0.4.10"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -743,7 +743,10 @@ use rusqlite::params;
             return json!({});
         };
         let mut out = Map::new();
-        for key in ["status", "provider", "activity", "last_output_at"] {
+        // 0.4.x Phase 1: add `worker_state` (canonical 5-state product
+        // surface). `activity` is preserved alongside as the deprecated
+        // legacy classifier output (CR R3 same-source contract).
+        for key in ["status", "provider", "worker_state", "activity", "last_output_at"] {
             if let Some(value) = input.get(key) {
                 out.insert(key.to_string(), value.clone());
             }

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

@@ -26,6 +26,7 @@
 use std::fs;
 use std::path::Path;
 
+use crate::model::enums::{Provider, ProviderEffort};
 use crate::model::yaml::Value;
 use crate::model::{paths, spec, yaml, ModelError};
 
@@ -182,17 +183,35 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
         })
         .collect::<Vec<_>>();
 
+    // 0.4.x provider effort MVP step 2: validate TEAM.md provider_effort early
+    // (unknown literal rejects compile). Empty/absent → no team-level effort.
+    let team_provider_effort = match string_field(&team_meta, "provider_effort") {
+        Some(raw) if !raw.trim().is_empty() => {
+            let value = raw.trim();
+            let parsed = ProviderEffort::parse(value).ok_or_else(|| {
+                ModelError::Validation(format!(
+                    "{}: unknown provider_effort '{value}' (allowed: low|medium|high|xhigh|max)",
+                    team_md.display()
+                ))
+            })?;
+            Some(parsed)
+        }
+        _ => None,
+    };
+
+    let mut team_fields: Vec<(&str, Value)> = vec![
+        ("name", Value::Str(team_name.clone())),
+        ("mode", Value::Str("supervisor_worker".to_string())),
+        ("objective", Value::Str(objective)),
+        ("workspace", Value::Str(workspace_s)),
+    ];
+    if let Some(effort) = team_provider_effort {
+        team_fields.push(("provider_effort", Value::Str(effort.as_str().to_string())));
+    }
+
     let spec = map(vec![
         ("version", Value::Int(1)),
-        (
-            "team",
-            map(vec![
-                ("name", Value::Str(team_name.clone())),
-                ("mode", Value::Str("supervisor_worker".to_string())),
-                ("objective", Value::Str(objective)),
-                ("workspace", Value::Str(workspace_s)),
-            ]),
-        ),
+        ("team", map(team_fields)),
         (
             "leader",
             map(vec![
@@ -366,6 +385,56 @@ pub fn compile_role_agent(
     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.
+    // Validate (unknown literal) AND check provider/effort compatibility
+    // (max is Claude-only; emit hard error for max + non-Claude here so
+    // unsupported combinations fail at compile, not at runtime).
+    let role_effort = match string_field(&meta, "effort") {
+        Some(raw) if !raw.trim().is_empty() => {
+            let value = raw.trim();
+            let parsed = ProviderEffort::parse(value).ok_or_else(|| {
+                ModelError::Validation(format!(
+                    "{}: unknown effort '{value}' (allowed: low|medium|high|xhigh|max)",
+                    role_path.display()
+                ))
+            })?;
+            Some(parsed)
+        }
+        _ => None,
+    };
+    let team_effort = match string_field(team_meta, "provider_effort") {
+        Some(raw) if !raw.trim().is_empty() => ProviderEffort::parse(raw.trim()),
+        _ => None,
+    };
+    let resolved_effort = role_effort.or(team_effort);
+    if let Some(effort) = resolved_effort {
+        // Reject max + non-Claude at compile time.
+        let provider_str = agent_items
+            .iter()
+            .find(|(k, _)| *k == "provider")
+            .and_then(|(_, v)| match v {
+                Value::Str(s) => Some(s.as_str()),
+                _ => None,
+            })
+            .unwrap_or("");
+        let provider_enum = match provider_str {
+            "claude" => Provider::Claude,
+            "claude_code" => Provider::ClaudeCode,
+            "codex" => Provider::Codex,
+            "copilot" => Provider::Copilot,
+            "gemini_cli" => Provider::GeminiCli,
+            "fake" => Provider::Fake,
+            _ => Provider::Codex, // unknown providers caught elsewhere
+        };
+        if effort.is_claude_only() && !matches!(provider_enum, Provider::Claude | Provider::ClaudeCode) {
+            return Err(ModelError::Validation(format!(
+                "{}: effort '{}' is only supported by claude/claude_code (provider: {provider_str})",
+                role_path.display(),
+                effort.as_str()
+            )));
+        }
+        agent_items.push(("effort", Value::Str(effort.as_str().to_string())));
+    }
     Ok(CompiledRole {
         id,
         role,

package/crates/team-agent/src/coordinator/tick.rs

@@ -3103,6 +3103,11 @@ fn write_activity(
         .get("last_output_at")
         .and_then(Value::as_str)
         .map(str::to_string);
+    // 0.4.x Phase 1: resolve the 5-state worker runtime state alongside the
+    // legacy `activity` write. CR R3: activity field is preserved as the
+    // deprecated surface; worker_state is the new canonical surface.
+    let worker_state =
+        resolve_worker_runtime_state_with_fg_pgrp(agent, Some(activity));
     let Some(agent_obj) = agent.as_object_mut() else {
         return previous_last_output;
     };
@@ -3115,6 +3120,10 @@ fn write_activity(
             "rationale": activity.rationale,
         }),
     );
+    agent_obj.insert(
+        "worker_state".to_string(),
+        serde_json::json!(worker_state.as_wire()),
+    );
     if output_advanced {
         let last_output_at = chrono::Utc::now().to_rfc3339();
         agent_obj.insert(
@@ -3126,6 +3135,83 @@ fn write_activity(
     previous_last_output
 }
 
+/// 0.4.x Phase 1 worker-runtime-state resolver.
+///
+/// Pure resolution from (agent JSON, optional activity classifier output).
+/// Reads `agent.pane_id`, `agent.pane_pid`, `agent.awaiting_human_confirm`,
+/// and the trust/startup approval flags. Uses
+/// `os_probe::pane_foreground_and_root_pgrp` to detect a child process
+/// occupying the terminal foreground.
+///
+/// Precedence (matches Phase 1 plan §4):
+///   1. Dead         — pane_pid exists but `getpgid` returns no process,
+///                     OR foreground probe explicitly reports the PID gone.
+///   2. Blocked      — agent.awaiting_human_confirm / startup-trust flags.
+///   3. Busy         — fg_pgrp != root_pgrp (child occupies terminal) OR
+///                     JSONL classifier reports Working.
+///   4. ProbablyIdle — JSONL classifier reports Idle AND no fg-pgrp
+///                     conflict (or probe unavailable + activity idle).
+///   5. Unknown      — missing pane_pid, probe error, or no decisive
+///                     signal. Iron law: never silently Idle.
+pub(crate) fn resolve_worker_runtime_state_with_fg_pgrp(
+    agent: &Value,
+    activity: Option<&crate::messaging::AgentActivity>,
+) -> crate::messaging::WorkerRuntimeState {
+    use crate::messaging::{ActivityStatus, WorkerRuntimeState};
+
+    // §4.2 Blocked: trust prompt / awaiting human confirm.
+    let blocked = agent
+        .get("awaiting_human_confirm")
+        .and_then(Value::as_bool)
+        .unwrap_or(false)
+        || agent
+            .get("approval")
+            .and_then(Value::as_str)
+            .is_some_and(|s| s == "pending" || s == "awaiting_trust_prompt")
+        || agent
+            .get("approval_status")
+            .and_then(Value::as_str)
+            .is_some_and(|s| s == "pending" || s == "awaiting_trust_prompt");
+    if blocked {
+        return WorkerRuntimeState::Blocked;
+    }
+
+    // §4.3 Busy via fg-pgrp probe (when pane_pid is available).
+    let pane_pid = agent.get("pane_pid").and_then(Value::as_u64).map(|p| p as u32);
+    if let Some(pid) = pane_pid {
+        match crate::os_probe::pane_foreground_and_root_pgrp(pid) {
+            Ok(Some((tpgid, pgid))) => {
+                if tpgid != pgid {
+                    return WorkerRuntimeState::Busy;
+                }
+                // Same pgrp — pane process owns foreground. Defer to
+                // JSONL/activity for finer state.
+            }
+            Ok(None) => {
+                // Probe could not read: missing PID, no controlling
+                // terminal, ps unavailable. Fall through to activity
+                // classifier; if that's also missing/uncertain, the
+                // function returns Unknown.
+            }
+            Err(_) => {
+                // Subprocess error — degrade to Unknown unless activity
+                // is decisive.
+            }
+        }
+    }
+
+    // §4.4/4.5 Activity-derived classification.
+    if let Some(activity) = activity {
+        return match activity.status {
+            ActivityStatus::Working => WorkerRuntimeState::Busy,
+            ActivityStatus::Idle => WorkerRuntimeState::ProbablyIdle,
+            ActivityStatus::Stuck | ActivityStatus::Uncertain => WorkerRuntimeState::Unknown,
+        };
+    }
+
+    WorkerRuntimeState::Unknown
+}
+
 fn activity_status_wire(status: crate::messaging::ActivityStatus) -> &'static str {
     match status {
         crate::messaging::ActivityStatus::Idle => "idle",
@@ -3144,6 +3230,16 @@ fn agent_health_status_wire(status: crate::messaging::ActivityStatus) -> &'stati
     }
 }
 
+/// 0.4.x Phase 1: read the worker_state wire string that `write_activity`
+/// persisted alongside the legacy activity. Returns None when no worker_state
+/// has been written yet (older state row pre-upgrade).
+pub(crate) fn agent_worker_state(agent: &Value) -> Option<crate::messaging::WorkerRuntimeState> {
+    agent
+        .get("worker_state")
+        .and_then(Value::as_str)
+        .map(crate::messaging::WorkerRuntimeState::parse_wire)
+}
+
 fn write_agent_health(
     store: &crate::message_store::MessageStore,
     team: &str,

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

@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use crate::model::enums::{AuthMode, DisplayBackend, PaneLiveness, Provider};
+use crate::model::enums::{AuthMode, DisplayBackend, PaneLiveness, Provider, ProviderEffort};
 use crate::model::ids::AgentId;
 use crate::model::permissions::{self, AgentPermissionInput};
 use crate::model::yaml::{self, Value};
@@ -243,6 +243,16 @@ fn spawn_agents(
                 Some(&mcp_config),
             )?;
         let command_model = profile_launch.command_overrides.model.as_deref().or(model);
+        // 0.4.x provider effort MVP step 4 + 7: resolve effort and emit
+        // unsupported warning event when the spec asked for an effort the
+        // provider can't satisfy.
+        let agent_effort = provider_effort_for_spawn(agent, provider);
+        if let Some(event_value) =
+            provider_effort_event_if_dropped(agent, provider, agent_id_raw)
+        {
+            let _ = crate::event_log::EventLog::new(workspace)
+                .write("provider.effort_unsupported", event_value);
+        }
         let mut plan = adapter
             .build_command_plan(crate::provider::ProviderCommandContext {
                 auth_mode,
@@ -256,6 +266,7 @@ fn spawn_agents(
                 // adapters can pass `--name <agent_id>`. Codex has no
                 // equivalent flag and ignores the hint.
                 agent_id_hint: Some(agent_id_raw),
+                effort: agent_effort,
             })
             .map_err(|e| LifecycleError::Provider(e.to_string()))?;
         if !plan.managed_mcp_config && !profile_launch.managed_mcp_config {
@@ -320,7 +331,10 @@ fn spawn_agents(
         apply_mcp_auto_approval_env(&mut env, &safety);
         // Python providers.py:145 + launch/core.py:253 — fresh launch runs the worker
         // with cwd=workspace, same as the RS fork/add and restart paths.
-        let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
+        let env_unset: Vec<String> = extend_worker_env_unset_for_effort(
+            profile_launch.env_unset.iter().cloned().collect(),
+            provider,
+        );
         // BUG / C-1-2 / C-6-1 cr verdict — Copilot system_prompt 走 spawn env overlay +
         // per-worker AGENTS.md(B2 灵魂件降级):写
         //   <workspace>/.team/runtime/copilot-instructions/<agent_id>/AGENTS.md
@@ -1721,6 +1735,13 @@ fn running_agent_state(
         model.map_or(serde_json::Value::Null, |m| serde_json::json!(m)),
     );
     state.insert("auth_mode".to_string(), serde_json::json!(auth_mode));
+    // 0.4.x provider effort MVP step 8: persist resolved effort so restart
+    // / resume reads the same value (no re-resolution from role/team).
+    if let Some(effort_str) = agent.get("effort").and_then(Value::as_str) {
+        if !effort_str.is_empty() {
+            state.insert("effort".to_string(), serde_json::json!(effort_str));
+        }
+    }
     state.insert("profile".to_string(), profile);
     if agent.get("profile").is_some() {
         if let Some(profile_dir) = profile_dir {
@@ -2466,6 +2487,112 @@ fn parse_auth_mode(raw: &str) -> Option<AuthMode> {
     }
 }
 
+/// 0.4.x provider effort MVP step 4: low-level from a raw string. Returns
+/// `Some(effort)` when the level parses AND the provider supports it.
+pub(crate) fn provider_effort_from_raw(
+    raw: Option<&str>,
+    provider: Provider,
+) -> Option<ProviderEffort> {
+    let raw = raw?.trim();
+    if raw.is_empty() {
+        return None;
+    }
+    let effort = ProviderEffort::parse(raw)?;
+    if effort.is_supported_by(provider) {
+        Some(effort)
+    } else {
+        None
+    }
+}
+
+/// 0.4.x provider effort MVP step 7: warning event payload when the spec
+/// requested an effort level the provider does not support.
+pub(crate) fn provider_effort_event_payload(
+    raw: Option<&str>,
+    provider: Provider,
+    agent_id: &str,
+) -> Option<serde_json::Value> {
+    let raw = raw?.trim();
+    if raw.is_empty() {
+        return None;
+    }
+    let effort = ProviderEffort::parse(raw)?;
+    if effort.is_supported_by(provider) {
+        return None;
+    }
+    Some(serde_json::json!({
+        "agent_id": agent_id,
+        "provider": format!("{provider:?}").to_lowercase(),
+        "effort": effort.as_str(),
+        "action": "ignored",
+        "reason": "provider does not support 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).
+pub(crate) fn extend_worker_env_unset_for_effort(
+    base: Vec<String>,
+    provider: Provider,
+) -> Vec<String> {
+    if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
+        return base;
+    }
+    let mut out = base;
+    if !out.iter().any(|k| k == "CLAUDE_EFFORT") {
+        out.push("CLAUDE_EFFORT".to_string());
+    }
+    out
+}
+
+/// Convenience: resolve effort for a yaml::Value agent (spec / compiled).
+pub(crate) fn provider_effort_for_spawn(
+    agent: &crate::model::yaml::Value,
+    provider: Provider,
+) -> Option<ProviderEffort> {
+    provider_effort_from_raw(agent.get("effort").and_then(|v| v.as_str()), provider)
+}
+
+pub(crate) fn provider_effort_event_if_dropped(
+    agent: &crate::model::yaml::Value,
+    provider: Provider,
+    agent_id: &str,
+) -> Option<serde_json::Value> {
+    provider_effort_event_payload(
+        agent.get("effort").and_then(|v| v.as_str()),
+        provider,
+        agent_id,
+    )
+}
+
+/// Same as [`provider_effort_for_spawn`] but for serde_json state values
+/// (used by restart paths reading from `state.agents[id]`).
+pub(crate) fn provider_effort_for_spawn_json(
+    agent: &serde_json::Value,
+    provider: Provider,
+) -> Option<ProviderEffort> {
+    provider_effort_from_raw(agent.get("effort").and_then(serde_json::Value::as_str), provider)
+}
+
+pub(crate) fn provider_effort_event_if_dropped_json(
+    agent: &serde_json::Value,
+    provider: Provider,
+    agent_id: &str,
+) -> Option<serde_json::Value> {
+    provider_effort_event_payload(
+        agent.get("effort").and_then(serde_json::Value::as_str),
+        provider,
+        agent_id,
+    )
+}
+
 fn quick_start_requested_team_key<'a>(
     team_id: Option<&'a str>,
     name: Option<&'a str>,
@@ -3786,6 +3913,16 @@ fn upsert_agent_state_from_role(
             }
         }
     }
+    // 0.4.x provider effort MVP step 8 (dynamic add-agent): persist effort
+    // from the role doc front matter (compiler.rs validates syntax/semantics
+    // at compile; add-agent path validates here too in case of direct YAML).
+    if let Some(effort_str) = meta.get("effort").and_then(Value::as_str) {
+        if !effort_str.is_empty() {
+            if let Some(obj) = entry.as_object_mut() {
+                obj.insert("effort".to_string(), serde_json::json!(effort_str));
+            }
+        }
+    }
     if let Some(obj) = entry.as_object_mut() {
         persist_effective_approval_policy(obj, safety);
     }
@@ -4075,6 +4212,15 @@ pub fn fork_agent_with_transport(
             Some(&mcp_config),
         )?;
     let command_model = profile_launch.command_overrides.model.as_deref().or(model);
+    // 0.4.x provider effort MVP: fork inherits effort from the new agent JSON
+    // (compiler.rs propagated the role/team effort into the agent at fork-spawn).
+    let fork_effort = provider_effort_for_spawn(new_agent, provider);
+    if let Some(event_value) =
+        provider_effort_event_if_dropped(new_agent, provider, as_agent_id.as_str())
+    {
+        let _ = crate::event_log::EventLog::new(&workspace)
+            .write("provider.effort_unsupported", event_value);
+    }
     let mut plan = adapter
         .fork_plan(
             Some(&session_id),
@@ -4086,6 +4232,7 @@ pub fn fork_agent_with_transport(
                 tools: &resolved_tool_refs,
                 profile_launch: Some(&profile_launch),
                 agent_id_hint: Some(as_agent_id.as_str()),
+                effort: fork_effort,
             },
         )
         .map_err(|e| {
@@ -4111,7 +4258,10 @@ pub fn fork_agent_with_transport(
     // _tmux_session_exists — an ABSENT session => new-session (spawn_first), present => new-window
     // (spawn_into). The Rust restart seam (restart.rs spawn_agent_window) uses the same branch.
     let session_live = transport.has_session(&session_name).unwrap_or(false);
-    let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
+    let env_unset: Vec<String> = extend_worker_env_unset_for_effort(
+        profile_launch.env_unset.iter().cloned().collect(),
+        provider,
+    );
     let spawn_result = if session_live {
         transport.spawn_into_with_env_unset(
             &session_name,
@@ -4495,6 +4645,8 @@ fn upsert_forked_agent_state(
         "profile",
         "_profile_dir",
         "role",
+        // 0.4.x provider effort MVP step 8: fork inherits compiled effort.
+        "effort",
     ] {
         if let Some(value) = spec_agent.get(key) {
             entry.insert(key.to_string(), yaml_value_to_json(value));

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

@@ -450,6 +450,18 @@ 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/agent.rs

@@ -1058,6 +1058,15 @@ fn write_start_agent_start_event(
         .model
         .as_deref()
         .or(model);
+    // 0.4.x provider effort MVP: start_agent path preserves effort from the
+    // persisted agent JSON.
+    let start_agent_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(&agent, provider);
+    if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
+        &agent, provider, agent_id.as_str(),
+    ) {
+        let _ = crate::event_log::EventLog::new(workspace)
+            .write("provider.effort_unsupported", event_value);
+    }
     let context = crate::provider::ProviderCommandContext {
         auth_mode,
         mcp_config: Some(&mcp_config),
@@ -1066,6 +1075,7 @@ fn write_start_agent_start_event(
         tools: &resolved_tool_refs,
         profile_launch: Some(&profile_launch),
         agent_id_hint: Some(agent_id.as_str()),
+        effort: start_agent_effort,
     };
     let mut plan = match session_id {
         Some(session_id) => adapter

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

@@ -114,6 +114,15 @@ pub(super) fn spawn_agent_window(
             Some(&mcp_config),
         )?;
     let command_model = profile_launch.command_overrides.model.as_deref().or(model);
+    // 0.4.x provider effort MVP: restart/resume preserves effort from the
+    // persisted agent JSON (state's agent["effort"] field, set by launch).
+    let restart_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(agent, provider);
+    if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
+        agent, provider, agent_id.as_str(),
+    ) {
+        let _ = crate::event_log::EventLog::new(workspace)
+            .write("provider.effort_unsupported", event_value);
+    }
     let context = crate::provider::ProviderCommandContext {
         auth_mode,
         mcp_config: Some(&mcp_config),
@@ -122,6 +131,7 @@ pub(super) fn spawn_agent_window(
         tools: &resolved_tool_refs,
         profile_launch: Some(&profile_launch),
         agent_id_hint: Some(agent_id.as_str()),
+        effort: restart_effort,
     };
     let mut plan = match resume_session_id {
         Some(session_id) => adapter
@@ -167,7 +177,13 @@ pub(super) fn spawn_agent_window(
     // a per-agent YAML `spawn_cwd` field if one is set. Until then, override
     // > workspace; state-based override is silently dropped.
     let spawn_cwd = spawn_cwd_override.unwrap_or(workspace);
-    let env_unset: Vec<String> = profile_launch.env_unset.iter().cloned().collect();
+    // 0.4.x provider effort MVP step 9: scrub CLAUDE_EFFORT for Claude
+    // worker spawn so a parent shell env cannot silently override the
+    // framework's effort decision.
+    let env_unset: Vec<String> = crate::lifecycle::launch::extend_worker_env_unset_for_effort(
+        profile_launch.env_unset.iter().cloned().collect(),
+        provider,
+    );
 
     // 0.4.6 Stage 2: write actual spawn plan event BEFORE invoking the
     // transport spawn. Mirrors `launch.rs:359-380` (the reference impl)

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

@@ -102,7 +102,8 @@ pub use types::{
     CheckKind, CheckStatus, ContractSuiteCheck, DeliveryOutcome, DeliveryRefusal, DeliveryStage,
     DeliveryStatus, IdleEvaluation, LeaderNotificationKey, LeaderReceiver, PaneWidthQuery,
     ProviderSdkCalls, ReceiverMode, ScheduledKind, SelftestCheck, SelftestReport, SendEventPayload,
-    TrustRetryPayload, WatcherNotice, RESULT_DELIVERY_MAX_ATTEMPTS, SEND_RETRY_MAX_ATTEMPTS,
+    TrustRetryPayload, WatcherNotice, WorkerRuntimeState,
+    RESULT_DELIVERY_MAX_ATTEMPTS, SEND_RETRY_MAX_ATTEMPTS,
     TRUST_RETRY_BACKOFF_SECONDS, TRUST_RETRY_MAX_ATTEMPTS,
 };
 pub use watchers::{

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

@@ -126,6 +126,92 @@ impl ActivityStatus {
     }
 }
 
+/// 0.4.x Phase 1 worker runtime-state (fg-pgrp + 5-state plan, CR APPROVED).
+///
+/// Canonical runtime-state enum surfaced by `team-agent status` and consumed
+/// by automatic-dispatch / idle-gate predicates. Distinct from
+/// [`ActivityStatus`] (which remains the internal classifier output for
+/// backwards compatibility) and from lifecycle `agents.<id>.status` (which
+/// remains launch/stop-owned: `running`/`paused`/`stopped`/etc.).
+///
+/// Rules:
+///   * `Busy` when `foreground_pgrp != agent_root_pgrp` (a child process
+///     occupies the terminal — provider is not at idle prompt).
+///   * `Unknown` is NEVER idle-eligible and must be treated as busy by
+///     automatic-dispatch / idle-gate predicates.
+///   * `ProbablyIdle` is a weak conclusion, not proof of idleness.
+///   * `Dead` when the pane is missing or the root process is gone.
+///   * `Blocked` when the worker is awaiting human confirmation (trust
+///     prompt, startup approval).
+///
+/// CR R4: deserialise with `#[serde(other)]` so a future variant added by
+/// a newer build does not crash an older reader (rolling upgrade safe).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum WorkerRuntimeState {
+    Dead,
+    Busy,
+    Blocked,
+    ProbablyIdle,
+    /// Default fallback. CR R4: also catches unknown wire strings via
+    /// `#[serde(other)]`.
+    #[serde(other)]
+    Unknown,
+}
+
+impl WorkerRuntimeState {
+    /// Wire string used by status/diagnose JSON.
+    pub fn as_wire(self) -> &'static str {
+        match self {
+            Self::Dead => "DEAD",
+            Self::Busy => "BUSY",
+            Self::Blocked => "BLOCKED",
+            Self::ProbablyIdle => "PROBABLY_IDLE",
+            Self::Unknown => "UNKNOWN",
+        }
+    }
+
+    /// Parse from wire string. Returns `Self::Unknown` for unknown literals
+    /// (defence-in-depth alongside `#[serde(other)]`).
+    pub fn parse_wire(value: &str) -> Self {
+        match value.trim() {
+            "DEAD" => Self::Dead,
+            "BUSY" => Self::Busy,
+            "BLOCKED" => Self::Blocked,
+            "PROBABLY_IDLE" => Self::ProbablyIdle,
+            _ => Self::Unknown,
+        }
+    }
+
+    /// True for states that MUST NOT receive automatic dispatch:
+    /// `Dead | Busy | Blocked | Unknown`. Only `ProbablyIdle` is safe.
+    /// CR R3 + Phase 1 §8 dispatch boundary.
+    pub fn blocks_automatic_dispatch(self) -> bool {
+        !matches!(self, Self::ProbablyIdle)
+    }
+
+    /// True only for `ProbablyIdle` — the sole idle candidate. `Unknown` is
+    /// NEVER idle (Iron Law: bug-071/077/085).
+    pub fn is_idle_candidate(self) -> bool {
+        matches!(self, Self::ProbablyIdle)
+    }
+
+    /// Map from the legacy [`ActivityStatus`] for backward-compat. Used by
+    /// status/diagnose code paths that have an old AgentActivity in hand
+    /// and need a runtime-state surface for the product enum.
+    ///   Working   → Busy
+    ///   Idle      → ProbablyIdle
+    ///   Stuck     → Unknown (CR rule: stale signals are never idle)
+    ///   Uncertain → Unknown
+    pub fn from_activity(activity: ActivityStatus) -> Self {
+        match activity {
+            ActivityStatus::Working => Self::Busy,
+            ActivityStatus::Idle => Self::ProbablyIdle,
+            ActivityStatus::Stuck | ActivityStatus::Uncertain => Self::Unknown,
+        }
+    }
+}
+
 /// 告警类型 (card §49;`scheduler.py:38` `_ALERT_TYPES`)。`stuck_cancel` 还接 `all` (展开全集)。
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]

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

@@ -23,6 +23,71 @@ pub enum Provider {
     Fake,
 }
 
+/// 0.4.x Provider effort MVP: reasoning effort level passed to the provider.
+/// Configuration sources (resolution order):
+///   1. role doc front matter `effort: low|medium|high|xhigh|max`
+///   2. TEAM.md front matter `provider_effort: low|medium|high|xhigh|max`
+///   3. provider default (framework passes no flag)
+///
+/// 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
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum ProviderEffort {
+    #[serde(rename = "low")]
+    Low,
+    #[serde(rename = "medium")]
+    Medium,
+    #[serde(rename = "high")]
+    High,
+    #[serde(rename = "xhigh")]
+    XHigh,
+    #[serde(rename = "max")]
+    Max,
+}
+
+impl ProviderEffort {
+    /// Parse from a wire string. Returns None on unknown literal.
+    pub fn parse(value: &str) -> Option<Self> {
+        match value.trim() {
+            "low" => Some(Self::Low),
+            "medium" => Some(Self::Medium),
+            "high" => Some(Self::High),
+            "xhigh" => Some(Self::XHigh),
+            "max" => Some(Self::Max),
+            _ => None,
+        }
+    }
+
+    /// Wire string used by both CLI argv and state serialization.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Low => "low",
+            Self::Medium => "medium",
+            Self::High => "high",
+            Self::XHigh => "xhigh",
+            Self::Max => "max",
+        }
+    }
+
+    /// Effort levels Claude-only (Codex / others must reject `max`).
+    pub fn is_claude_only(self) -> bool {
+        matches!(self, Self::Max)
+    }
+
+    /// 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).
+    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,
+        }
+    }
+}
+
 /// auth 模式(`AUTH_MODES` `profiles/constants.py:6`)。
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]

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

@@ -250,8 +250,19 @@ fn basic_schema_errors(spec: &Yaml) -> Vec<String> {
     if !matches!(spec.get("version"), Some(Yaml::Int(1))) {
         e.push("/version: must equal 1".to_string());
     }
-    let team_keys = &["name", "mode", "objective", "workspace"];
-    check_keys_y(spec.get("team"), "/team", team_keys, team_keys, &mut e);
+    // 0.4.x provider effort MVP step 3: provider_effort is allowed but not required.
+    let team_required = &["name", "mode", "objective", "workspace"];
+    let team_allowed = &["name", "mode", "objective", "workspace", "provider_effort"];
+    check_keys_y(spec.get("team"), "/team", team_required, team_allowed, &mut e);
+    if let Some(team) = spec.get("team") {
+        if let Some(raw) = team.get("provider_effort").and_then(Yaml::as_str) {
+            if crate::model::enums::ProviderEffort::parse(raw).is_none() {
+                e.push(format!(
+                    "/team/provider_effort: unknown effort '{raw}' (allowed: low|medium|high|xhigh|max)"
+                ));
+            }
+        }
+    }
     let mode = spec.get("team").and_then(|t| t.get("mode")).and_then(Yaml::as_str);
     if !matches!(mode, Some("supervisor_worker" | "swarm_limited")) {
         e.push("/team/mode: invalid mode".to_string());
@@ -298,11 +309,32 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
         "id", "role", "provider", "model", "working_directory", "system_prompt", "tools",
         "permission_mode", "preferred_for", "avoid_for", "output_contract", "paused", "auth_mode",
         "profile", "credential_ref", "forked_from",
+        // 0.4.x provider effort MVP step 3: per-agent effort override (resolved at compile).
+        "effort",
     ];
     check_keys_y(Some(agent), path, req, allowed, errors);
     if !agent.is_map() {
         return;
     }
+    // 0.4.x provider effort MVP step 3: effort syntactic + semantic validation.
+    if let Some(raw) = agent.get("effort").and_then(Yaml::as_str) {
+        match crate::model::enums::ProviderEffort::parse(raw) {
+            None => {
+                errors.push(format!(
+                    "{path}/effort: unknown effort '{raw}' (allowed: low|medium|high|xhigh|max)"
+                ));
+            }
+            Some(effort) if effort.is_claude_only() => {
+                let provider = agent.get("provider").and_then(Yaml::as_str).unwrap_or("");
+                if !matches!(provider, "claude" | "claude_code") {
+                    errors.push(format!(
+                        "{path}/effort: effort '{raw}' is only supported by claude/claude_code (provider: {provider})"
+                    ));
+                }
+            }
+            Some(_) => {}
+        }
+    }
     check_keys_y(agent.get("system_prompt"), &format!("{path}/system_prompt"), &["inline", "file"], &["inline", "file"], errors);
     check_list_y(agent.get("tools"), &format!("{path}/tools"), errors);
     check_list_y(agent.get("preferred_for"), &format!("{path}/preferred_for"), errors);

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

@@ -128,3 +128,82 @@ fn read_and_remove(path: &std::path::Path) -> Vec<u8> {
     let _ = std::fs::remove_file(path);
     stdout
 }
+
+/// 0.4.x Phase 1 (fg-pgrp): terminal foreground process-group probe.
+///
+/// macOS probe confirmed (2026-06-29, .team/artifacts/fg-pgrp-probe.md):
+/// `TIOCGPGRP` ioctl returns Errno 25 on tmux slave PTYs opened from a
+/// non-controlling process. We use `ps -o tpgid,pgid -p <pid>` instead —
+/// reliable on macOS AND Linux, no platform-specific cfg needed.
+///
+/// Returns `Ok(Some((tpgid, pgid)))` on success, `Ok(None)` when the PID
+/// is gone / ps returned no row / values unparseable. The caller maps
+/// `None` to `WorkerRuntimeState::Unknown` (never to idle — Iron Law).
+///
+/// `tpgid` = terminal foreground process group ID.
+/// `pgid`  = the agent root's own process group ID.
+/// `tpgid != pgid` means a child process owns the foreground (BUSY signal).
+///
+/// Bounded via [`run_bounded_command`] so a wedged ps cannot stall the
+/// coordinator tick.
+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()]);
+    let output = bounded_command_output_with_probe(
+        &mut command,
+        "pane_foreground_and_root_pgrp",
+        Some(pane_pid),
+    )?;
+    if probe_timed_out() {
+        return Ok(None);
+    }
+    if !output.status.success() {
+        return Ok(None);
+    }
+    let text = String::from_utf8_lossy(&output.stdout);
+    let first_line = text.lines().next().unwrap_or("").trim();
+    if first_line.is_empty() {
+        return Ok(None);
+    }
+    let parts: Vec<&str> = first_line.split_whitespace().collect();
+    if parts.len() < 2 {
+        return Ok(None);
+    }
+    let tpgid = parts[0].parse::<i64>().ok();
+    let pgid = parts[1].parse::<i64>().ok();
+    match (tpgid, pgid) {
+        // ps prints `-1` for tpgid when there is no controlling terminal —
+        // treat as unknown rather than fabricating a u32.
+        (Some(t), Some(p)) if t > 0 && p > 0 => Ok(Some((t as u32, p as u32))),
+        _ => Ok(None),
+    }
+}
+
+#[cfg(test)]
+mod fg_pgrp_tests {
+    use super::*;
+
+    #[test]
+    fn pane_foreground_and_root_pgrp_self_returns_some_or_none() {
+        // The current test process is not necessarily attached to a
+        // controlling terminal (CI runs detached), so we accept Some OR
+        // None. The contract is: never panic, return io::Result.
+        let pid = std::process::id();
+        match pane_foreground_and_root_pgrp(pid) {
+            Ok(Some((tpgid, pgid))) => {
+                assert!(tpgid > 0 && pgid > 0, "positive pgid/tpgid");
+            }
+            Ok(None) => {} // headless / no tty — acceptable
+            Err(e) => panic!("probe must not error in normal env: {e}"),
+        }
+    }
+
+    #[test]
+    fn pane_foreground_and_root_pgrp_missing_pid_returns_none() {
+        // PID 1 is init/launchd — exists but we read fields; non-existent
+        // PIDs return Ok(None) (ps exits non-zero).
+        let result =
+            pane_foreground_and_root_pgrp(0xFFFF_FFFE).expect("must not error on missing pid");
+        assert!(result.is_none(), "missing pid → None");
+    }
+}

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

@@ -410,7 +410,7 @@ impl ProviderAdapter for BasicProviderAdapter {
             Provider::Claude | Provider::ClaudeCode => {
                 Ok(claude_launch_command(self, auth_mode, mcp_config, system_prompt, model, tools)?)
             }
-            Provider::Codex => Ok(codex_base_command(None, auth_mode, mcp_config, system_prompt, model, tools, None)),
+            Provider::Codex => Ok(codex_base_command(None, auth_mode, mcp_config, system_prompt, model, tools, None, None)),
             // §C1 worker argv 形态 + C-1/C-5/C-6 cr verdict:
             //   copilot --no-color --no-auto-update [<dangerous|granular>] [--model]
             //          --additional-mcp-config <inline json> --session-id <expected_uuid> -C <cwd>
@@ -469,6 +469,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                     model,
                     ctx.tools,
                     managed,
+                    ctx.effort,
                 )?;
                 argv.push("--session-id".to_string());
                 argv.push(expected.clone());
@@ -507,6 +508,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                 ctx.model,
                 ctx.tools,
                 ctx.profile_launch.map(|profile| &profile.command_overrides),
+                ctx.effort,
             ))),
             // §C1 + §C4 cr verdict — copilot plan 端预定 UUID + workspace `-C` 双保险:
             //   * `--session-id <uuid>`(claude 同法,捕获免目录扫描,sqlite 仅校验)
@@ -638,13 +640,14 @@ impl ProviderAdapter for BasicProviderAdapter {
                     model,
                     tools,
                     None,
+                    None,
                 );
                 argv.push(session_id.as_str().to_string());
                 Ok(argv)
             }
             Provider::Claude | Provider::ClaudeCode => {
                 let mut argv =
-                    claude_base_command(self, auth_mode, mcp_config, system_prompt, model, tools, false)?;
+                    claude_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)
@@ -686,6 +689,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                     model,
                     ctx.tools,
                     managed,
+                    ctx.effort,
                 )?;
                 argv.push("--resume".to_string());
                 argv.push(session_id.as_str().to_string());
@@ -725,6 +729,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                     ctx.model,
                     ctx.tools,
                     ctx.profile_launch.map(|profile| &profile.command_overrides),
+                    ctx.effort,
                 );
                 argv.push(session_id.as_str().to_string());
                 Ok(CommandPlan::argv_only(argv))
@@ -779,13 +784,14 @@ impl ProviderAdapter for BasicProviderAdapter {
                     model,
                     tools,
                     None,
+                    None,
                 );
                 argv.push(session_id.as_str().to_string());
                 Ok(argv)
             }
             Provider::Claude | Provider::ClaudeCode => {
                 let mut argv =
-                    claude_base_command(self, auth_mode, mcp_config, system_prompt, model, tools, false)?;
+                    claude_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());
@@ -837,6 +843,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                     model,
                     ctx.tools,
                     managed,
+                    ctx.effort,
                 )?;
                 argv.push("--session-id".to_string());
                 argv.push(expected.clone());
@@ -870,6 +877,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                     ctx.model,
                     ctx.tools,
                     ctx.profile_launch.map(|profile| &profile.command_overrides),
+                    ctx.effort,
                 );
                 argv.push(session_id.as_str().to_string());
                 Ok(CommandPlan::argv_only(argv))

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

@@ -34,6 +34,7 @@ pub(crate) fn claude_launch_command(
         model,
         tools,
         false,
+        None,
     )?;
     argv.push("--session-id".to_string());
     argv.push(next_session_token());
@@ -48,6 +49,9 @@ pub(crate) fn claude_base_command(
     model: Option<&str>,
     tools: &[&str],
     managed_mcp_config: bool,
+    // 0.4.x provider effort MVP step 5: when Some, inject `--effort <level>`
+    // immediately after the model (before prompt/MCP).
+    effort: Option<crate::model::enums::ProviderEffort>,
 ) -> Result<Vec<String>, ProviderError> {
     let mut argv = vec!["claude".to_string()];
     if claude_dangerous_auto_approve(tools) {
@@ -60,6 +64,10 @@ pub(crate) fn claude_base_command(
         argv.push("--model".to_string());
         argv.push(model.to_string());
     }
+    if let Some(effort) = effort {
+        argv.push("--effort".to_string());
+        argv.push(effort.as_str().to_string());
+    }
     if let Some(prompt) = system_prompt {
         argv.push("--append-system-prompt".to_string());
         argv.push(prompt.to_string());

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

@@ -17,6 +17,12 @@ pub(crate) fn codex_base_command(
     model: Option<&str>,
     tools: &[&str],
     overrides: Option<&ProviderCommandOverrides>,
+    // 0.4.x provider effort MVP step 6: when Some, inject
+    // `-c model_reasoning_effort=<level>` AFTER existing profile
+    // codex_config overrides — explicit launch effort wins over profile.
+    // Codex does not support `max`; the caller filters that case via
+    // `ProviderEffort::is_supported_by` before reaching this point.
+    effort: Option<crate::model::enums::ProviderEffort>,
 ) -> Vec<String> {
     let mut argv = vec!["codex".to_string()];
     if let Some(subcommand) = subcommand {
@@ -51,6 +57,10 @@ pub(crate) fn codex_base_command(
             argv.push(config.clone());
         }
     }
+    if let Some(effort) = effort {
+        argv.push("-c".to_string());
+        argv.push(format!("model_reasoning_effort={}", effort.as_str()));
+    }
     if let Some(prompt) = system_prompt {
         // codex.py:120 — escape order matters: backslash first, then quote, then newline.
         let escaped = prompt

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

@@ -347,6 +347,14 @@ pub struct ProviderCommandContext<'a> {
     /// no `--name` CLI flag (probe verdict 2026-06-22) and ignores this
     /// field. None = legacy callers (the field is purely additive).
     pub agent_id_hint: Option<&'a str>,
+    /// 0.4.x provider effort MVP step 4: reasoning effort level resolved
+    /// from role doc / TEAM.md / provider default. `None` means the
+    /// framework passes no effort flag (provider default).
+    ///   - Claude / ClaudeCode: low|medium|high|xhigh|max → `--effort <level>`
+    ///   - Codex: low|medium|high|xhigh → `-c model_reasoning_effort=<level>`
+    ///   - Copilot / Gemini / Fake: ignored, warning event emitted at the
+    ///     caller (lifecycle/launch.rs / lifecycle/restart) before construct.
+    pub effort: Option<crate::model::enums::ProviderEffort>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

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

@@ -1321,6 +1321,8 @@ fn shell_command(
     env: &BTreeMap<String, String>,
     env_unset: &[String],
 ) -> String {
+    let unset_set: std::collections::BTreeSet<&str> =
+        env_unset.iter().map(String::as_str).collect();
     let mut parts = Vec::new();
     parts.push("cd".to_string());
     parts.push(shell_quote(&cwd.to_string_lossy()));
@@ -1333,7 +1335,16 @@ fn shell_command(
         parts.push(key.clone());
         parts.push("&&".to_string());
     }
+    // 0.4.x ordering fix (env-leak symptom #3): KEY=val exports must NOT
+    // re-introduce any key that was just unset. Filter env entries whose key
+    // appears in env_unset so the unset wins on the final shell line. This
+    // matters when inherited env (worker_spawn_env / apply_profile_launch_env)
+    // contains the very keys we want to scrub (e.g. CLAUDE_EFFORT carried
+    // forward from the launching shell into the env map).
     for (key, value) in env {
+        if unset_set.contains(key.as_str()) {
+            continue;
+        }
         parts.push(format!("{key}={}", shell_quote(value)));
     }
     parts.push("exec".to_string());
@@ -1378,6 +1389,8 @@ pub fn leader_shell_wrapper_command(
     env_unset: &[String],
     provider_label: &str,
 ) -> String {
+    let unset_set: std::collections::BTreeSet<&str> =
+        env_unset.iter().map(String::as_str).collect();
     let mut parts = Vec::new();
     // 1. cd
     parts.push("cd".to_string());
@@ -1389,8 +1402,13 @@ pub fn leader_shell_wrapper_command(
         parts.push(key.clone());
         parts.push("&&".to_string());
     }
-    // 3. env exports + provider (NO `exec` so the provider is a child)
+    // 3. env exports + provider (NO `exec` so the provider is a child).
+    // 0.4.x ordering fix: skip keys present in env_unset so KEY=val does not
+    // re-introduce a just-unset variable from the inherited env map.
     for (key, value) in env {
+        if unset_set.contains(key.as_str()) {
+            continue;
+        }
         parts.push(format!("{key}={}", shell_quote(value)));
     }
     parts.extend(argv.iter().map(|arg| shell_quote(arg)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.4.9",
-    "@team-agent/cli-darwin-x64": "0.4.9",
-    "@team-agent/cli-linux-x64": "0.4.9"
+    "@team-agent/cli-darwin-arm64": "0.4.10",
+    "@team-agent/cli-darwin-x64": "0.4.10",
+    "@team-agent/cli-linux-x64": "0.4.10"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",