@team-agent/installer 0.5.73 → 0.5.75

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

@@ -61,13 +61,15 @@ use std::process::Stdio;
 use std::time::{Duration, Instant};
 
 use crate::model::enums::PaneLiveness;
+use crate::provider::wire::{parse_provider, provider_wire};
 use crate::transport::{
-    normalize_capture, tmux_capture_argv, tmux_empty_inject_argv, tmux_inject_text_argv,
-    tmux_query_argv, tmux_send_keys_argv, tmux_send_submit_argv, tmux_spawn_argv, AttachOutcome,
-    BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport, InjectStage,
-    InjectVerification, Key, PaneField, PaneId, PaneInfo, PaneMode, SessionName, SetEnvOutcome,
-    SpawnResult, SubmitAttemptObservation, SubmitObserver, SubmitVerification, Target, Transport,
-    TransportError, TurnVerification, WindowName,
+    command_basename, normalize_capture, tmux_capture_argv, tmux_empty_inject_argv,
+    tmux_inject_text_argv, tmux_query_argv, tmux_send_keys_argv, tmux_send_submit_argv,
+    tmux_spawn_argv, AttachOutcome, BackendKind, CaptureRange, CaptureSampleOutcome, CapturedText,
+    InjectPayload, InjectReport, InjectStage, InjectVerification, InputSurfaceProbe, Key,
+    PaneField, PaneId, PaneInfo, PaneMode, QueryOutcome, SessionName, SetEnvOutcome, SpawnResult,
+    SubmitAttemptObservation, SubmitDiagnostics, SubmitObserver, SubmitVerification, Target,
+    Transport, TransportError, TurnVerification, WindowName,
 };
 
 pub const PANE_BINDING_NONCE_METADATA_KEY: &str = "TEAM_AGENT_PANE_BINDING_NONCE";
@@ -378,6 +380,63 @@ impl TmuxBackend {
         self.run_ok(&argv)
     }
 
+    /// Set the pane-instance nonce only when the pane option is unset. tmux
+    /// serializes commands at the server, so concurrent first claims have one
+    /// winner; losers read back that winner instead of persisting a stale nonce.
+    pub(crate) fn set_pane_binding_nonce_if_unset(
+        &self,
+        pane: &PaneId,
+        nonce: &str,
+    ) -> Result<String, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "set-option".to_string(),
+            "-p".to_string(),
+            "-o".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            TMUX_PANE_BINDING_NONCE_OPTION.to_string(),
+            nonce.to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if output.success {
+            return Ok(nonce.to_string());
+        }
+        if output
+            .stderr
+            .to_ascii_lowercase()
+            .contains("already set")
+        {
+            return self.read_pane_binding_nonce(pane);
+        }
+        Err(subprocess_error(argv, output))
+    }
+
+    fn read_pane_binding_nonce(&self, pane: &PaneId) -> Result<String, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "show-options".to_string(),
+            "-p".to_string(),
+            "-v".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            TMUX_PANE_BINDING_NONCE_OPTION.to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if !output.success {
+            return Err(subprocess_error(argv, output));
+        }
+        let nonce = output.stdout.trim();
+        if nonce.is_empty() {
+            return Err(TransportError::Subprocess {
+                argv,
+                code: output.code,
+                stderr: "pane binding nonce remained unset after conditional write".to_string(),
+            });
+        }
+        Ok(nonce.to_string())
+    }
+
     /// Backend with an injected runner (tests: canned/recording tmux output). Shared default socket.
     /// ---
     /// purpose: 用注入的 runner 构造后端(测试用录制/罐装 tmux 输出),绑共享默认 socket
@@ -1389,6 +1448,107 @@ fn pane_from_target(target: &Target) -> PaneId {
     }
 }
 
+#[derive(Default)]
+struct CaptureTally {
+    ok: u32,
+    err: u32,
+    last: CaptureSampleOutcome,
+}
+
+impl CaptureTally {
+    fn record_ok(&mut self, text: &str, marker: Option<&str>) {
+        self.ok = self.ok.saturating_add(1);
+        self.last = if marker.is_some_and(|token| text.contains(token)) {
+            CaptureSampleOutcome::OkTokenSeen
+        } else {
+            CaptureSampleOutcome::OkTokenMissing
+        };
+    }
+
+    fn record_err(&mut self) {
+        self.err = self.err.saturating_add(1);
+        self.last = CaptureSampleOutcome::Failed;
+    }
+
+    fn seen_after_ok_samples(&self, visible: bool) -> Option<bool> {
+        if self.ok == 0 {
+            None
+        } else {
+            Some(visible)
+        }
+    }
+}
+
+struct InjectTargetSurface {
+    pane_command_basename: Option<String>,
+    pane_command_query: QueryOutcome,
+    input_surface: InputSurfaceProbe,
+    target_pane_id: String,
+    target_pane_query_matched: Option<bool>,
+}
+
+fn probe_inject_target_surface(backend: &TmuxBackend, target: &Target) -> InjectTargetSurface {
+    let pane = pane_from_target(target);
+    let (pane_command_basename, pane_command_query) =
+        match backend.query(target, PaneField::PaneCurrentCommand) {
+            Ok(Some(raw)) => match command_basename(&raw) {
+                Some(name) => (Some(name), QueryOutcome::Observed),
+                None => (None, QueryOutcome::Unavailable),
+            },
+            _ => (None, QueryOutcome::Unavailable),
+        };
+    let input_surface = match backend.query(target, PaneField::PaneMode) {
+        Ok(Some(raw)) => match pane_mode_from_raw(Some(raw)) {
+            None => InputSurfaceProbe::Input,
+            Some(PaneMode::Copy) => InputSurfaceProbe::Copy,
+            Some(PaneMode::Tree) => InputSurfaceProbe::Tree,
+            Some(PaneMode::View) => InputSurfaceProbe::View,
+            Some(PaneMode::Client) => InputSurfaceProbe::Client,
+            Some(PaneMode::Unknown) => InputSurfaceProbe::UnknownMode,
+        },
+        _ => InputSurfaceProbe::Unavailable,
+    };
+    let target_pane_query_matched = match backend.query(target, PaneField::PaneId) {
+        Ok(Some(id)) if !id.is_empty() => Some(id == pane.as_str()),
+        _ => None,
+    };
+    InjectTargetSurface {
+        pane_command_basename,
+        pane_command_query,
+        input_surface,
+        target_pane_id: pane.as_str().to_string(),
+        target_pane_query_matched,
+    }
+}
+
+fn submit_diagnostics_for_inject(
+    total_elapsed_ms: u64,
+    attempts_detail: Vec<SubmitAttemptObservation>,
+    tally: &CaptureTally,
+    token_seen_after_paste: Option<bool>,
+    token_seen_after_enter: Option<bool>,
+    surface: InjectTargetSurface,
+) -> SubmitDiagnostics {
+    SubmitDiagnostics {
+        appear_gate_elapsed_ms: 0,
+        appear_gate_matched: false,
+        total_elapsed_ms,
+        attempts_detail,
+        token_seen_before_paste: None,
+        token_seen_after_paste,
+        token_seen_after_enter,
+        capture_ok_count: tally.ok,
+        capture_err_count: tally.err,
+        capture_sample_count: tally.ok.saturating_add(tally.err),
+        last_capture_outcome: tally.last,
+        pane_command_basename: surface.pane_command_basename,
+        pane_command_query: surface.pane_command_query,
+        input_surface: surface.input_surface,
+        target_pane_id: Some(surface.target_pane_id),
+        target_pane_query_matched: surface.target_pane_query_matched,
+    }
+}
+
 fn target_name(target: &Target) -> String {
     match target {
         Target::Pane(pane) => pane.as_str().to_string(),
@@ -1590,13 +1750,23 @@ fn post_submit_token_visible(
     backend: &TmuxBackend,
     target: &Target,
     payload: &InjectPayload,
+    tally: &mut CaptureTally,
 ) -> Result<Option<bool>, TransportError> {
-    if payload_token_marker(payload).is_none() {
+    let Some(marker) = payload_token_marker(payload) else {
         return Ok(None);
-    }
+    };
     for attempt in 0..TOKEN_POST_SUBMIT_READBACK_POLLS {
-        if let Some(true) = token_visible_in_capture(backend, target, payload)? {
-            return Ok(Some(true));
+        match backend.capture(target, CaptureRange::Tail(80)) {
+            Ok(cap) => {
+                tally.record_ok(&cap.text, Some(marker));
+                if cap.text.contains(marker) {
+                    return Ok(Some(true));
+                }
+            }
+            Err(_) => {
+                tally.record_err();
+                return Ok(None);
+            }
         }
         if attempt + 1 < TOKEN_POST_SUBMIT_READBACK_POLLS {
             std::thread::sleep(Duration::from_millis(25));
@@ -2388,6 +2558,7 @@ fn shell_command(
 ) -> String {
     let unset_set: std::collections::BTreeSet<&str> =
         env_unset.iter().map(String::as_str).collect();
+    let caller_provider = caller_provider_for_invocation(env);
     let mut parts = Vec::new();
     parts.push("cd".to_string());
     parts.push(shell_quote(&cwd.to_string_lossy()));
@@ -2407,16 +2578,47 @@ fn shell_command(
     // 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()) {
+        if unset_set.contains(key.as_str())
+            || key.starts_with(crate::layout::worker_env::CALLER_CONTEXT_PREFIX)
+        {
             continue;
         }
         parts.push(format!("{key}={}", shell_quote(value)));
     }
+    append_caller_context_assignments(&mut parts, caller_provider);
     parts.push("exec".to_string());
     parts.extend(argv.iter().map(|arg| shell_quote(arg)));
     parts.join(" ")
 }
 
+fn caller_provider_for_invocation(env: &BTreeMap<String, String>) -> Option<&'static str> {
+    env.get(crate::layout::worker_env::CALLER_PROVIDER_ENV)
+        .and_then(|value| parse_provider(value))
+        .map(provider_wire)
+}
+
+fn append_caller_context_assignments(parts: &mut Vec<String>, provider: Option<&str>) {
+    let Some(provider) = provider else {
+        return;
+    };
+    parts.push(format!(
+        "{}={}",
+        crate::layout::worker_env::CALLER_PROVIDER_ENV,
+        shell_quote(provider)
+    ));
+    // These are expanded by the shell created inside the target pane. They are
+    // assignments on the provider command only, so the exit marker/inert tail
+    // cannot retain a usable caller context.
+    parts.push(format!(
+        "{}=\"${{TMUX_PANE-}}\"",
+        crate::layout::worker_env::CALLER_PANE_ENV
+    ));
+    parts.push(format!(
+        "{}=\"${{TMUX%%,*}}\"",
+        crate::layout::worker_env::CALLER_ENDPOINT_ENV
+    ));
+}
+
 /// 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:
@@ -2586,6 +2788,7 @@ pub fn worker_shell_wrapper_command(
 ) -> String {
     let unset_set: std::collections::BTreeSet<&str> =
         env_unset.iter().map(String::as_str).collect();
+    let caller_provider = caller_provider_for_invocation(env);
     let mut parts = Vec::new();
     parts.push("cd".to_string());
     parts.push(shell_quote(&cwd.to_string_lossy()));
@@ -2596,11 +2799,14 @@ pub fn worker_shell_wrapper_command(
         parts.push("&&".to_string());
     }
     for (key, value) in env {
-        if unset_set.contains(key.as_str()) {
+        if unset_set.contains(key.as_str())
+            || key.starts_with(crate::layout::worker_env::CALLER_CONTEXT_PREFIX)
+        {
             continue;
         }
         parts.push(format!("{key}={}", shell_quote(value)));
     }
+    append_caller_context_assignments(&mut parts, caller_provider);
     parts.extend(argv.iter().map(|arg| shell_quote(arg)));
     parts.push(";".to_string());
     parts.push("rc=$?;".to_string());
@@ -2945,11 +3151,15 @@ impl Transport for TmuxBackend {
                 let poll_start = std::time::Instant::now();
                 let mut token_ever_visible = false;
                 let mut tracked_paste: Option<PasteLatch> = None;
+                let mut capture_tally = CaptureTally::default();
+                let mut token_seen_after_paste = None;
+                let mut token_seen_after_enter = None;
                 token_visible_for_report = if let Some(m) = payload_token_marker(payload) {
                     let mut visible = false;
                     while poll_start.elapsed().as_millis() < token_poll_timeout_ms as u128 {
                         match self.capture(target, CaptureRange::Tail(80)) {
                             Ok(cap) => {
+                                capture_tally.record_ok(&cap.text, Some(m));
                                 tracked_paste = latch_paste(&cap.text, tracked_paste);
                                 if cap.text.contains(m) {
                                     visible = true;
@@ -2960,10 +3170,14 @@ impl Transport for TmuxBackend {
                                     break;
                                 }
                             }
-                            Err(_) => break, // tmux unavailable, skip poll
+                            Err(_) => {
+                                capture_tally.record_err();
+                                break; // tmux unavailable, skip poll
+                            }
                         }
                         std::thread::sleep(Duration::from_millis(50));
                     }
+                    token_seen_after_paste = capture_tally.seen_after_ok_samples(visible);
                     Some(visible)
                 } else {
                     None
@@ -2985,6 +3199,7 @@ impl Transport for TmuxBackend {
                     self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
                     notify_submit_observer(observer);
                     let total_elapsed_ms = inject_start.elapsed().as_millis() as u64;
+                    let surface = probe_inject_target_surface(self, target);
                     return Ok(InjectReport {
                         stage_reached: InjectStage::Submit,
                         inject_verification: inject_verification_after_readback(
@@ -2994,12 +3209,14 @@ impl Transport for TmuxBackend {
                         submit_verification: submit_verification_for_key(submit),
                         turn_verification: TurnVerification::NotYetObserved,
                         attempts: 1,
-                        submit_diagnostics: Some(crate::transport::SubmitDiagnostics {
-                            appear_gate_elapsed_ms: 0,
-                            appear_gate_matched: false,
+                        submit_diagnostics: Some(submit_diagnostics_for_inject(
                             total_elapsed_ms,
-                            attempts_detail: Vec::new(),
-                        }),
+                            Vec::new(),
+                            &capture_tally,
+                            token_seen_after_paste,
+                            None,
+                            surface,
+                        )),
                     });
                 }
 
@@ -3042,8 +3259,12 @@ impl Transport for TmuxBackend {
                     if attempt > 0 {
                         if let Some(m) = marker {
                             if let Ok(cap) = self.capture(target, CaptureRange::Tail(40)) {
+                                capture_tally.record_ok(&cap.text, Some(m));
                                 if cap.text.contains(m) {
                                     token_ever_visible = true;
+                                    token_seen_after_enter = Some(true);
+                                } else if token_seen_after_enter.is_none() {
+                                    token_seen_after_enter = Some(false);
                                 }
                                 tracked_paste = latch_paste(&cap.text, tracked_paste);
                                 let obs = submit_attempt_observation(
@@ -3115,10 +3336,22 @@ impl Transport for TmuxBackend {
                     // Post-submit token readback (U1 #7 parity: check token
                     // visible after Enter for no-echo panes).
                     if attempt == 0 && matches!(token_visible_for_report, Some(false)) {
-                        token_visible_for_report =
-                            post_submit_token_visible(self, target, payload).unwrap_or(Some(false));
-                        if token_visible_for_report == Some(true) {
+                        let post = post_submit_token_visible(
+                            self,
+                            target,
+                            payload,
+                            &mut capture_tally,
+                        )
+                        .unwrap_or(None);
+                        if post == Some(true) {
+                            token_visible_for_report = Some(true);
                             token_ever_visible = true;
+                            token_seen_after_enter = Some(true);
+                        } else {
+                            token_visible_for_report = Some(false);
+                            if post == Some(false) {
+                                token_seen_after_enter = Some(false);
+                            }
                         }
                     }
 
@@ -3132,10 +3365,14 @@ impl Transport for TmuxBackend {
                             std::thread::sleep(Duration::from_millis(100));
                             match self.capture(target, CaptureRange::Tail(40)) {
                                 Ok(cap) => {
+                                    capture_tally.record_ok(&cap.text, Some(m));
                                     consecutive_capture_failures = 0;
                                     saw_capture = true;
                                     if cap.text.contains(m) {
                                         token_ever_visible = true;
+                                        token_seen_after_enter = Some(true);
+                                    } else if token_seen_after_enter.is_none() {
+                                        token_seen_after_enter = Some(false);
                                     }
                                     tracked_paste = latch_paste(&cap.text, tracked_paste);
                                     let obs = submit_attempt_observation(
@@ -3166,6 +3403,7 @@ impl Transport for TmuxBackend {
                                     }
                                 }
                                 Err(_) => {
+                                    capture_tally.record_err();
                                     capture_retries = capture_retries.saturating_add(1);
                                     consecutive_capture_failures =
                                         consecutive_capture_failures.saturating_add(1);
@@ -3265,8 +3503,12 @@ impl Transport for TmuxBackend {
                                 std::thread::sleep(Duration::from_millis(100));
                                 match self.capture(target, CaptureRange::Tail(40)) {
                                     Ok(cap) => {
+                                        capture_tally.record_ok(&cap.text, Some(m));
                                         if cap.text.contains(m) {
                                             token_ever_visible = true;
+                                            token_seen_after_enter = Some(true);
+                                        } else if token_seen_after_enter.is_none() {
+                                            token_seen_after_enter = Some(false);
                                         }
                                         tracked_paste = latch_paste(&cap.text, tracked_paste);
                                         let obs = submit_attempt_observation(
@@ -3304,7 +3546,10 @@ impl Transport for TmuxBackend {
                                             break;
                                         }
                                     }
-                                    Err(_) => break,
+                                    Err(_) => {
+                                        capture_tally.record_err();
+                                        break;
+                                    }
                                 }
                             }
                             if found_consumed {
@@ -3316,6 +3561,7 @@ impl Transport for TmuxBackend {
                     }
                 }
                 let total_elapsed_ms = inject_start.elapsed().as_millis() as u64;
+                let surface = probe_inject_target_surface(self, target);
                 return Ok(InjectReport {
                     stage_reached: InjectStage::Submit,
                     inject_verification: inject_verification_after_readback(
@@ -3328,12 +3574,14 @@ impl Transport for TmuxBackend {
                         last_turn_text.as_deref(),
                     ),
                     attempts: consumption_attempts.saturating_add(capture_retries),
-                    submit_diagnostics: Some(crate::transport::SubmitDiagnostics {
-                        appear_gate_elapsed_ms: 0,
-                        appear_gate_matched: false,
+                    submit_diagnostics: Some(submit_diagnostics_for_inject(
                         total_elapsed_ms,
                         attempts_detail,
-                    }),
+                        &capture_tally,
+                        token_seen_after_paste,
+                        token_seen_after_enter,
+                        surface,
+                    )),
                 });
             }
         }

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

@@ -1,7 +1,7 @@
 //! 测试默认零真-spawn、零真-tmux:lifecycle/CLI spawn 路径必经 *_with_transport 注入离线
 //! mock;确需真 tmux 者必须 provider:fake + RAII kill_server 守卫 + #[ignore=real-machine].
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, VecDeque};
 use std::path::Path;
 use std::sync::{Arc, Mutex};
 
@@ -26,6 +26,7 @@ struct OfflineState {
     session_present: bool,
     session_absent_after_spawn_first: bool,
     targets: Vec<PaneInfo>,
+    target_snapshots: VecDeque<Vec<PaneInfo>>,
     windows: Vec<WindowName>,
     pane_presence: BTreeMap<String, bool>,
     spawn_failures: BTreeMap<String, String>,
@@ -62,6 +63,7 @@ impl Default for OfflineState {
             session_present: false,
             session_absent_after_spawn_first: false,
             targets: Vec::new(),
+            target_snapshots: VecDeque::new(),
             windows: Vec::new(),
             pane_presence: BTreeMap::new(),
             spawn_failures: BTreeMap::new(),
@@ -104,7 +106,15 @@ impl OfflineTransport {
     }
 
     pub fn with_targets(self, targets: Vec<PaneInfo>) -> Self {
-        self.with_state(|state| state.targets = targets);
+        self.with_state(|state| {
+            state.targets = targets;
+            state.target_snapshots.clear();
+        });
+        self
+    }
+
+    pub fn with_target_snapshots(self, snapshots: Vec<Vec<PaneInfo>>) -> Self {
+        self.with_state(|state| state.target_snapshots = snapshots.into());
         self
     }
 
@@ -507,7 +517,12 @@ impl Transport for OfflineTransport {
                 detail,
             });
         }
-        Ok(self.with_state(|state| state.targets.clone()))
+        Ok(self.with_state(|state| {
+            state
+                .target_snapshots
+                .pop_front()
+                .unwrap_or_else(|| state.targets.clone())
+        }))
     }
 
     fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {

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

@@ -483,6 +483,105 @@ pub struct SubmitDiagnostics {
     /// prompt loop. Empty when `saw_pasted_prompt == false` and the inject
     /// went through the E46 token path.
     pub attempts_detail: Vec<SubmitAttemptObservation>,
+    /// Token visibility before paste. `None` means this inject did not sample
+    /// (honest unknown). Never inferred from later captures.
+    pub token_seen_before_paste: Option<bool>,
+    /// Token visibility from successful post-paste captures. `None` if every
+    /// post-paste capture failed or none ran.
+    pub token_seen_after_paste: Option<bool>,
+    /// Token visibility from successful post-Enter captures. `None` if none ran
+    /// or all failed.
+    pub token_seen_after_enter: Option<bool>,
+    pub capture_ok_count: u32,
+    pub capture_err_count: u32,
+    pub capture_sample_count: u32,
+    pub last_capture_outcome: CaptureSampleOutcome,
+    /// Basename only of `#{pane_current_command}` at inject; never argv.
+    pub pane_command_basename: Option<String>,
+    pub pane_command_query: QueryOutcome,
+    pub input_surface: InputSurfaceProbe,
+    pub target_pane_id: Option<String>,
+    /// Inject target pane id vs `#{pane_id}` queried on that same target.
+    pub target_pane_query_matched: Option<bool>,
+}
+
+/// Last capture sample of the inject token path. Distinguishes "read failed"
+/// from "read succeeded and token was absent". Does not change delivery gates.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum CaptureSampleOutcome {
+    #[default]
+    NotAttempted,
+    OkTokenSeen,
+    OkTokenMissing,
+    Failed,
+}
+
+impl CaptureSampleOutcome {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::NotAttempted => "not_attempted",
+            Self::OkTokenSeen => "ok_token_seen",
+            Self::OkTokenMissing => "ok_token_missing",
+            Self::Failed => "failed",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum QueryOutcome {
+    #[default]
+    Unavailable,
+    Observed,
+}
+
+impl QueryOutcome {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Unavailable => "unavailable",
+            Self::Observed => "observed",
+        }
+    }
+}
+
+/// Typed pane input surface from existing `pane_mode` probe. `Unavailable`
+/// means the query failed; it is not a pass.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum InputSurfaceProbe {
+    #[default]
+    Unavailable,
+    Input,
+    Copy,
+    Tree,
+    View,
+    Client,
+    UnknownMode,
+}
+
+impl InputSurfaceProbe {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Unavailable => "unavailable",
+            Self::Input => "input",
+            Self::Copy => "copy",
+            Self::Tree => "tree",
+            Self::View => "view",
+            Self::Client => "client",
+            Self::UnknownMode => "unknown_mode",
+        }
+    }
+}
+
+/// First token of a pane command, basename only. Empty/missing → `None`.
+pub(crate) fn command_basename(raw: &str) -> Option<String> {
+    let first = raw.split_whitespace().next()?.trim();
+    if first.is_empty() {
+        return None;
+    }
+    std::path::Path::new(first)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .filter(|name| !name.is_empty())
+        .map(str::to_string)
 }
 
 /// E50 PR-1 single attempt observation (one Enter + one capture). All fields

package/package.json

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

package/skills/team-agent/SKILL.md

@@ -27,10 +27,13 @@ For a Pi worker, use this existing three-step flow:
 
 Pi roles preserve the direct Pi login, model defaults, extensions/plugins, skills, context, trust, and tools. Team Agent adds only per-seat identity/session isolation. `model` and `effort` are optional explicit pass-throughs. Use the shared role schema, a block-style `tools` list containing `mcp_team`, and the required boolean `dangerously_skip_permissions`.
 
+Pi tool contract: use only `mcp_team`, `fs_read`, `fs_list`, `fs_write`, and `execute_bash`. Do not copy `provider_builtin`, `git_diff`, or `network` from a generic Codex role; Pi cannot map those categories. `compile`/`validate` rejects unsupported Pi categories before quick-start persists runtime state.
+
 ## Operate
 
 - Send: `team-agent send TO MESSAGE` using an in-team short name or fully qualified `<workspace>::<team>/<agent>`; these are co-equal positional TO forms. For example, `team-agent send reviewer "..."` uses an in-team short name. Do not poll after success.
 - Inspect: `team-agent status` or `team-agent status --json`; `ok: true` with `ready: false` is not a crash.
+- `quick-start` / `restart` / `claim-leader` JSON is compact by default (`ok`, `status`/`reason`, next action, attach/send, and `readiness.all_workers_spawned`); pass `--detail` only for internal diagnostics.
 - On a structured failure with an `action`, run that action first, then stop. Never guess flags.
 - Never rewrite a user-supplied model id or read `.env` files.