@team-agent/installer 0.4.8 → 0.4.9

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.4.8"
+version = "0.4.9"
 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.9"
 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/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());
     }

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

@@ -415,7 +415,14 @@ fn provider_env_exports(
     exports
 }
 
-fn provider_env_unsets(provider: Provider, auth_mode: AuthMode) -> BTreeSet<String> {
+/// 0.4.x (CR C-1): exposed as `pub(crate)` so the leader launcher
+/// (leader/start.rs) can reuse the SAME Claude/Codex/Copilot env-unset set
+/// used by worker spawn. Single source of truth — adding a new provider env
+/// var to clean up means changing this one function. Audit grep guard in
+/// `crates/team-agent/src/leader/start.rs::leader_env_unset_for_provider`
+/// confirms the leader path imports from here and does not maintain its own
+/// duplicate list.
+pub(crate) fn provider_env_unsets(provider: Provider, auth_mode: AuthMode) -> BTreeSet<String> {
     let mut unsets = BTreeSet::new();
     match provider {
         Provider::Claude | Provider::ClaudeCode => {

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

@@ -636,7 +636,21 @@ impl TmuxBackend {
         first: bool,
     ) -> Result<SpawnResult, TransportError> {
         let command = shell_command(argv, cwd, env, env_unset);
-        let spawn_argv = tmux_spawn_argv(session, window, &command, first);
+        self.spawn_with_command(session, window, &command, first)
+    }
+
+    /// 0.4.x (CR C-2): spawn variant that takes a pre-built shell command
+    /// (used by `spawn_first_with_leader_shell_wrapper` /
+    /// `spawn_into_with_leader_shell_wrapper` to inject the leader wrapper
+    /// shape without going through `shell_command`'s `exec`-only template).
+    fn spawn_with_command(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        command: &str,
+        first: bool,
+    ) -> Result<SpawnResult, TransportError> {
+        let spawn_argv = tmux_spawn_argv(session, window, command, first);
         self.run_spawn(&spawn_argv)?;
         let pane_argv = vec![
             "tmux".to_string(),
@@ -1327,6 +1341,75 @@ fn shell_command(
     parts.join(" ")
 }
 
+/// 0.4.x (CR R6): single-source marker prefix. The exit marker emitted by
+/// `leader_shell_wrapper_command` and the substring detected by
+/// `leader_provider_health` MUST share this prefix exactly. Format:
+/// `"[team-agent] {provider_label} exited with {rc}"`.
+pub const LEADER_PROVIDER_EXIT_MARKER_PREFIX: &str = "[team-agent]";
+pub const LEADER_PROVIDER_EXIT_MARKER_SUFFIX: &str = "exited with";
+
+/// 0.4.x (CR R6): build the leader exit marker text for `provider_label`.
+/// Used by both the shell wrapper (printf source) and the health check
+/// (capture substring) so they cannot drift.
+pub fn leader_provider_exit_marker(provider_label: &str) -> String {
+    format!(
+        "{LEADER_PROVIDER_EXIT_MARKER_PREFIX} {provider_label} {LEADER_PROVIDER_EXIT_MARKER_SUFFIX}"
+    )
+}
+
+/// 0.4.x (CR C-2): leader shell wrapper — provider runs as a CHILD of a
+/// long-lived shell, not as the pane's primary process. When the provider
+/// exits, the pane returns to an interactive shell with an explicit exit
+/// marker, matching manual `tmux new-session` then `claude` behaviour.
+///
+/// Four required envelope sections (CR C-2):
+///   1. cd <cwd>                    — same as `shell_command`
+///   2. unset <KEY> ...             — provider env_unset block
+///   3. KEY=val ... <provider>      — env exports + provider invocation
+///                                    (NO `exec` — runs as child)
+///   4. printf exit marker; exec shell -l
+///
+/// `provider_label` is a human-readable provider name (e.g. "claude",
+/// "codex") embedded in the exit marker for diagnostics.
+pub fn leader_shell_wrapper_command(
+    argv: &[String],
+    cwd: &Path,
+    env: &BTreeMap<String, String>,
+    env_unset: &[String],
+    provider_label: &str,
+) -> String {
+    let mut parts = Vec::new();
+    // 1. cd
+    parts.push("cd".to_string());
+    parts.push(shell_quote(&cwd.to_string_lossy()));
+    parts.push("&&".to_string());
+    // 2. unset
+    for key in env_unset {
+        parts.push("unset".to_string());
+        parts.push(key.clone());
+        parts.push("&&".to_string());
+    }
+    // 3. env exports + provider (NO `exec` so the provider is a child)
+    for (key, value) in env {
+        parts.push(format!("{key}={}", shell_quote(value)));
+    }
+    parts.extend(argv.iter().map(|arg| shell_quote(arg)));
+    parts.push(";".to_string());
+    // 4. exit marker + fall back to interactive shell
+    parts.push("rc=$?;".to_string());
+    parts.push("printf".to_string());
+    // CR R6: marker text comes from single-source `leader_provider_exit_marker`.
+    parts.push(shell_quote(&format!(
+        "\n{} %s\n",
+        leader_provider_exit_marker(provider_label)
+    )));
+    parts.push("\"$rc\";".to_string());
+    parts.push("exec".to_string());
+    parts.push("\"${SHELL:-/bin/zsh}\"".to_string());
+    parts.push("-l".to_string());
+    parts.join(" ")
+}
+
 fn shell_quote(raw: &str) -> String {
     if raw.is_empty() {
         return "''".to_string();
@@ -1422,6 +1505,38 @@ impl Transport for TmuxBackend {
         self.spawn_split(session, window, argv, cwd, env, env_unset)
     }
 
+    /// 0.4.x (CR C-2): TmuxBackend override of the leader-shell-wrapper
+    /// variant. Builds the wrapper shell line via
+    /// `leader_shell_wrapper_command` and runs it through
+    /// `spawn_with_command` (bypassing the default `exec <cmd>` shape).
+    fn spawn_first_with_leader_shell_wrapper(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+        provider_label: &str,
+    ) -> Result<SpawnResult, TransportError> {
+        let command = leader_shell_wrapper_command(argv, cwd, env, env_unset, provider_label);
+        self.spawn_with_command(session, window, &command, true)
+    }
+
+    fn spawn_into_with_leader_shell_wrapper(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+        provider_label: &str,
+    ) -> Result<SpawnResult, TransportError> {
+        let command = leader_shell_wrapper_command(argv, cwd, env, env_unset, provider_label);
+        self.spawn_with_command(session, window, &command, false)
+    }
+
     fn inject(
         &self,
         target: &Target,

package/crates/team-agent/src/transport/test_support.rs

@@ -50,6 +50,9 @@ struct OfflineState {
     /// U1-C Tail-peek contract: every `capture()` call records its `CaptureRange`,
     /// in order, so a test can prove the delivery peek site narrowed Full → Tail(80).
     capture_ranges: Vec<CaptureRange>,
+    /// 0.4.x (CR C-3 / CR C-5): pre-staged `query(PaneField::PaneCurrentCommand)`
+    /// answer keyed by pane id. Used by leader provider health tests.
+    pane_current_commands: BTreeMap<String, String>,
 }
 
 impl Default for OfflineState {
@@ -73,6 +76,7 @@ impl Default for OfflineState {
             list_targets_error: None,
             capture_text: BTreeMap::new(),
             capture_ranges: Vec::new(),
+            pane_current_commands: BTreeMap::new(),
         }
     }
 }
@@ -163,6 +167,52 @@ impl OfflineTransport {
         self
     }
 
+    /// 0.4.x (CR C-3 / CR C-5): pre-stage a `pane_current_command` answer
+    /// for `query(PaneField::PaneCurrentCommand)`. Used by leader provider
+    /// health tests to simulate "pane is now in a shell" vs
+    /// "pane is running the provider".
+    pub fn with_pane_current_command(
+        self,
+        pane_id: impl Into<String>,
+        command: impl Into<String>,
+    ) -> Self {
+        self.with_state(|state| {
+            state.pane_current_commands.insert(pane_id.into(), command.into());
+        });
+        self
+    }
+
+    /// 0.4.x (CR C-3 / CR C-5): mutable setters for fluent test seeding
+    /// (alternative to builder chain when the transport already exists).
+    pub fn set_pane_addressable(&self, pane: &PaneId, addressable: bool) {
+        self.with_state(|state| {
+            state.liveness.insert(
+                pane.as_str().to_string(),
+                if addressable {
+                    PaneLiveness::Live
+                } else {
+                    PaneLiveness::Dead
+                },
+            );
+        });
+    }
+
+    pub fn set_pane_current_command(&self, pane: &PaneId, command: &str) {
+        self.with_state(|state| {
+            state
+                .pane_current_commands
+                .insert(pane.as_str().to_string(), command.to_string());
+        });
+    }
+
+    pub fn set_pane_capture(&self, pane: &PaneId, text: &str) {
+        self.with_state(|state| {
+            state
+                .capture_text
+                .insert(pane.as_str().to_string(), text.to_string());
+        });
+    }
+
     /// Pre-stage `capture()` output for a `Target::SessionWindow{session,window}` key.
     pub fn with_capture_for_session_window(
         self,
@@ -378,11 +428,20 @@ impl Transport for OfflineTransport {
 
     fn query(
         &self,
-        _target: &Target,
-        _field: PaneField,
+        target: &Target,
+        field: PaneField,
     ) -> Result<Option<String>, TransportError> {
         self.record("query");
-        Ok(None)
+        if !matches!(field, PaneField::PaneCurrentCommand) {
+            return Ok(None);
+        }
+        let pane_id = match target {
+            Target::Pane(p) => p.as_str().to_string(),
+            Target::SessionWindow { .. } => return Ok(None),
+        };
+        Ok(self.with_state(|state| {
+            state.pane_current_commands.get(&pane_id).cloned()
+        }))
     }
 
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {

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

@@ -584,6 +584,44 @@ pub trait Transport: Send + Sync {
         self.spawn_into(session, window, argv, cwd, env)
     }
 
+    /// 0.4.x (CR C-2): leader-specific spawn variant. Instead of `exec <cmd>`
+    /// (which makes the provider the pane's primary process and turns the
+    /// pane into `[exited]` when the provider exits), build a shell line
+    /// that runs the provider as a CHILD of a long-lived shell:
+    /// `cd ... && unset ... && KEY=val ... <cmd>; rc=$?; printf '\n[team-agent] <provider> exited with %s\n' "$rc"; exec "${SHELL:-/bin/zsh}" -l`.
+    /// When the provider exits, the pane returns to an interactive shell with
+    /// an explicit exit marker — matching manual `tmux new-session` then
+    /// `claude` behaviour. Default falls back to plain `spawn_first_with_env_unset`
+    /// for backends that have no shell layer (test-only `OfflineTransport`).
+    fn spawn_first_with_leader_shell_wrapper(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+        provider_label: &str,
+    ) -> Result<SpawnResult, TransportError> {
+        let _ = provider_label;
+        self.spawn_first_with_env_unset(session, window, argv, cwd, env, env_unset)
+    }
+
+    /// 同 [`Transport::spawn_first_with_leader_shell_wrapper`],对应 `spawn_into`。
+    fn spawn_into_with_leader_shell_wrapper(
+        &self,
+        session: &SessionName,
+        window: &WindowName,
+        argv: &[String],
+        cwd: &Path,
+        env: &BTreeMap<String, String>,
+        env_unset: &[String],
+        provider_label: &str,
+    ) -> Result<SpawnResult, TransportError> {
+        let _ = provider_label;
+        self.spawn_into_with_env_unset(session, window, argv, cwd, env, env_unset)
+    }
+
     // —— INJECT / CAPTURE / QUERY(RIE):按稳定 Target 寻址 ——
 
     /// 归并 set/load-buffer + paste-buffer + send submit;空文本走纯 send-keys

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "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.8",
-    "@team-agent/cli-darwin-x64": "0.4.8",
-    "@team-agent/cli-linux-x64": "0.4.8"
+    "@team-agent/cli-darwin-arm64": "0.4.9",
+    "@team-agent/cli-darwin-x64": "0.4.9",
+    "@team-agent/cli-linux-x64": "0.4.9"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",