@team-agent/installer 0.4.8 → 0.4.10

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.4.8"
+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.8"
+version = "0.4.10"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -33,6 +33,39 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
             "issue": "leader_not_attached",
             "action": "attach or claim a leader receiver before sending work",
         }));
+    } else {
+        // 0.4.x (CR R2 P0): leader provider health reconciliation. The
+        // leader_receiver may be marked `attached` (pane addressable) but the
+        // provider process has exited — pane fell back to shell with the exit
+        // marker. Distinguish `leader_provider_exited` from `attached` so
+        // status/diagnose surfaces the real state.
+        if let Some((pane_id, provider_label)) = leader_pane_and_provider(state) {
+            let health = crate::leader::leader_provider_health(
+                backend,
+                &crate::transport::PaneId::new(pane_id),
+                &provider_label,
+            );
+            match health {
+                crate::leader::LeaderProviderHealth::ProviderExited => {
+                    issues.push(json!("leader_provider_exited"));
+                    repairs.push(json!({
+                        "issue": "leader_provider_exited",
+                        "action": format!(
+                            "leader pane fell back to shell — provider `{provider_label}` exited; \
+                             relaunch with `team-agent {provider_label}` to restart the provider"
+                        ),
+                    }));
+                }
+                crate::leader::LeaderProviderHealth::Unreachable => {
+                    issues.push(json!("leader_provider_unreachable"));
+                    repairs.push(json!({
+                        "issue": "leader_provider_unreachable",
+                        "action": "leader pane is dead — relaunch the leader",
+                    }));
+                }
+                crate::leader::LeaderProviderHealth::Alive => {}
+            }
+        }
     }
 
     if let Some(session_name) = state.get("session_name").and_then(Value::as_str).filter(|s| !s.is_empty()) {
@@ -62,6 +95,25 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
     (Value::Array(issues), Value::Array(repairs))
 }
 
+/// 0.4.x (CR R2): pull (pane_id, provider_label) from leader_receiver. Used
+/// by `leader_provider_health` reconcile in diagnose. Returns None when the
+/// leader is not attached or any field is missing.
+fn leader_pane_and_provider(state: &Value) -> Option<(String, String)> {
+    let receiver = state.get("leader_receiver")?;
+    let pane_id = receiver
+        .get("pane_id")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())?
+        .to_string();
+    let provider = receiver
+        .get("provider")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .unwrap_or("claude")
+        .to_string();
+    Some((pane_id, provider))
+}
+
 fn leader_receiver_attached(state: &Value) -> bool {
     let Some(receiver) = state.get("leader_receiver") else {
         return false;

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

@@ -1685,6 +1685,16 @@ pub mod lifecycle_port {
     /// matching cannot reap the leader — including when ANOTHER team's bare shutdown
     /// runs, where the leader is never in the invoker's ancestry.
     ///
+    /// 0.4.x (CR R3): leader shell wrapper interaction. The leader pane's
+    /// controlling process is the `sh -lc "...; exec ${SHELL} -l"` that
+    /// runs Claude as a CHILD. When Claude exits and the shell wrapper falls
+    /// back via `exec ${SHELL} -l`, the controlling PID is REPLACED in-place
+    /// by the interactive shell (same pane_pid). Because this function
+    /// protects by `pane.pane_pid` (Source 1 & 2), the fallback interactive
+    /// shell is already covered by the same protection set — shutdown will
+    /// NOT treat the fallback shell as a stray process. Verified by the
+    /// `leader_fallback_shell_protected_when_provider_exited` test.
+    ///
     /// Two leader-pane sources(N39 双来源,真机 grounded):
     /// 1. **Session prefix**: tmux session starts with `team-agent-leader-`(契约 grounded;
     ///    覆盖 LeaderStartMode::NewTmuxSession / AttachExisting).

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/leader/start.rs

@@ -448,16 +448,57 @@ fn ensure_managed_leader_pane(
                 });
             }
         }
+        // 0.4.x (CR C-1 + C-2): leader env_unset reuses the worker
+        // provider_env_unsets (single source of truth) + spawn through the
+        // leader shell wrapper so provider exit returns to a shell, not
+        // `[exited]`.
+        let env_unset = leader_env_unset_for_provider(plan.provider);
+        let provider_label = provider_command_name(plan.provider);
         transport
-            .spawn_into(session, window, &plan.provider_argv, workspace, &plan.leader_env)
+            .spawn_into_with_leader_shell_wrapper(
+                session,
+                window,
+                &plan.provider_argv,
+                workspace,
+                &plan.leader_env,
+                &env_unset,
+                provider_label,
+            )
             .map_err(|error| LeaderError::Start(error.to_string()))
     } else {
+        let env_unset = leader_env_unset_for_provider(plan.provider);
+        let provider_label = provider_command_name(plan.provider);
         transport
-            .spawn_first(session, window, &plan.provider_argv, workspace, &plan.leader_env)
+            .spawn_first_with_leader_shell_wrapper(
+                session,
+                window,
+                &plan.provider_argv,
+                workspace,
+                &plan.leader_env,
+                &env_unset,
+                provider_label,
+            )
             .map_err(|error| LeaderError::Start(error.to_string()))
     }
 }
 
+/// 0.4.x (CR C-1): leader provider env-unset list — SINGLE SOURCE OF TRUTH
+/// reused from worker spawn (`profile_launch::provider_env_unsets`).
+/// Audit grep guard: this function MUST be the only place in
+/// `crates/team-agent/src/leader/` that constructs a Claude/Codex/Copilot
+/// env-unset list. Any new code path that needs it must call this function
+/// or the underlying `provider_env_unsets`. Use `AuthMode::Subscription` —
+/// the leader is the user's interactive provider, never CompatibleApi/
+/// OfficialApi which are worker-only auth modes today.
+pub fn leader_env_unset_for_provider(provider: Provider) -> Vec<String> {
+    crate::lifecycle::profile_launch::provider_env_unsets(
+        provider,
+        crate::model::enums::AuthMode::Subscription,
+    )
+    .into_iter()
+    .collect()
+}
+
 fn ensure_managed_provider_live_after_attach(
     transport: &dyn Transport,
     spawned: &SpawnResult,
@@ -478,6 +519,117 @@ fn ensure_managed_provider_live_after_attach(
     )))
 }
 
+/// 0.4.x (CR C-3 P0): leader provider health reconciliation. The default
+/// `liveness()` check only proves the pane is ADDRESSABLE via tmux — it
+/// returns `Live` even when the provider has exited and the wrapper shell
+/// fell back to an interactive shell. This function distinguishes
+/// `provider_alive` from `provider_exited` by:
+///   1. Reading `pane_current_command` (tmux `#{pane_current_command}`).
+///   2. If the current command matches the expected provider binary (or
+///      one of its known aliases), report `Alive`.
+///   3. If the current command is an interactive shell AND the pane
+///      content contains the exit marker `[team-agent] <provider> exited`
+///      (emitted by `leader_shell_wrapper_command`), report
+///      `ProviderExited`.
+///   4. Otherwise (Unknown shell, no marker), report `Alive` as the
+///      conservative default — avoid false-positive exit alarms.
+///
+/// Note: when the leader shell wrapper is used (CR C-2), a provider exit
+/// leaves the pane as `<SHELL:-/bin/zsh>` with the exit marker in
+/// scrollback. Pre-wrapper code that hit `exec claude` would have left the
+/// pane as `[exited]` and `liveness()` would have returned `Dead`. The new
+/// failure mode requires this richer health check to surface
+/// `leader_provider_exited` as a distinct status.
+pub fn leader_provider_health(
+    transport: &dyn Transport,
+    pane_id: &PaneId,
+    expected_provider_label: &str,
+) -> LeaderProviderHealth {
+    use crate::transport::{CaptureRange, PaneField, Target};
+    let liveness = transport.liveness(pane_id).ok();
+    if matches!(liveness, Some(PaneLiveness::Dead)) {
+        return LeaderProviderHealth::Unreachable;
+    }
+    let target = Target::Pane(pane_id.clone());
+    let current_command = transport
+        .query(&target, PaneField::PaneCurrentCommand)
+        .ok()
+        .flatten()
+        .map(|s| s.trim().to_lowercase())
+        .unwrap_or_default();
+    if !current_command.is_empty()
+        && (current_command == expected_provider_label
+            || current_command.contains(expected_provider_label))
+    {
+        return LeaderProviderHealth::Alive;
+    }
+    // Current command is NOT the provider — likely fell back to shell.
+    let is_shell = is_interactive_shell_basename(&current_command);
+    if is_shell {
+        // CR R6: marker text from single-source `leader_provider_exit_marker`
+        // so the wrapper printf and the health-check substring cannot drift.
+        let exit_marker_substr =
+            crate::tmux_backend::leader_provider_exit_marker(expected_provider_label);
+        if let Ok(cap) = transport.capture(&target, CaptureRange::Tail(200)) {
+            if cap.text.contains(&exit_marker_substr) {
+                return LeaderProviderHealth::ProviderExited;
+            }
+        }
+    }
+    // Conservative default — pane addressable, but couldn't positively
+    // confirm provider exit. Treat as Alive.
+    LeaderProviderHealth::Alive
+}
+
+/// Health status reported by [`leader_provider_health`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LeaderProviderHealth {
+    /// Provider process appears to be the pane's current command.
+    Alive,
+    /// Pane has fallen back to a shell with the exit marker present —
+    /// provider has exited.
+    ProviderExited,
+    /// Pane is dead / unaddressable.
+    Unreachable,
+}
+
+/// 0.4.x (CR R6 + R3): single-source interactive-shell detection.
+/// Used by:
+///   - `leader_provider_health` to decide "pane fell back to shell"
+///   - shutdown logic to recognise a leader pane in fallback-shell mode
+///     as still owned by the leader (not stray).
+///
+/// Matches by basename (case-insensitive) — `pane_current_command` returns
+/// the basename of the running binary. Conservative whitelist of POSIX +
+/// common interactive shells; missing entries here are false negatives
+/// (shell looks like provider absent → health says Alive) which is the
+/// safe default per the CR R6 conservative-Alive rule.
+pub fn is_interactive_shell_basename(name: &str) -> bool {
+    let trimmed = name.trim().to_ascii_lowercase();
+    let basename = std::path::Path::new(&trimmed)
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or(&trimmed);
+    matches!(
+        basename,
+        "zsh"
+            | "bash"
+            | "sh"
+            | "fish"
+            | "dash"
+            | "ksh"
+            | "tcsh"
+            | "csh"
+            | "ash"
+            | "mksh"
+            | "yash"
+            | "elvish"
+            | "nu"
+            | "nushell"
+            | "xonsh"
+    )
+}
+
 fn managed_spawned_pane_in_targets(transport: &dyn Transport, spawned: &SpawnResult) -> bool {
     transport
         .list_targets()
@@ -785,13 +937,35 @@ fn run_leader_argv(
             "leader launch argv is empty".to_string(),
         ));
     };
-    let mut child = Command::new(program)
+    // 0.4.x regression fix (env-leak scenario 1, in-tmux ExecProvider path):
+    // the managed-tmux path got the provider env-unset block via the shell
+    // wrapper (cb9c217), but the ExecProvider in-tmux path here is a direct
+    // Command::spawn().wait() — it inherits the parent process's full env
+    // including any CLAUDE_CODE_SESSION_ID / CLAUDE_CODE_CHILD_SESSION /
+    // CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS / CLAUDE_CODE_ENTRYPOINT /
+    // CLAUDE_CODE_EXECPATH / CLAUDECODE that the launching shell carries.
+    // Apply the SAME env-unset list used by the managed path (CR R6 single
+    // source: profile_launch::provider_env_unsets via
+    // leader_env_unset_for_provider).
+    let env_unset = leader_env_unset_for_provider(plan.provider);
+    let mut command = Command::new(program);
+    command
         .args(argv.iter().skip(1))
-        .envs(env)
         .stdin(Stdio::inherit())
         .stdout(Stdio::inherit())
-        .stderr(Stdio::inherit())
-        .spawn()?;
+        .stderr(Stdio::inherit());
+    // 0.4.x order fix: env_remove MUST run AFTER envs(). The `env` map comes
+    // from `merged_exec_env` which seeds with `std::env::vars().collect()` —
+    // calling `.envs(env)` re-adds every inherited CLAUDE_CODE_* the launching
+    // shell carried, overwriting any prior env_remove. By removing AFTER the
+    // bulk envs() call, the final Command env table has the leak keys
+    // structurally absent. Verified by the regression grep guard that the
+    // env_remove call appears AFTER `command.envs(env)`.
+    command.envs(env);
+    for key in &env_unset {
+        command.env_remove(key);
+    }
+    let mut child = command.spawn()?;
     if plan.mode == LeaderStartMode::ExecProvider {
         spawn_exec_provider_startup_prompt_handler(plan.provider, workspace.to_path_buf());
     }