@team-agent/installer 0.5.75 → 0.5.78

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

@@ -65,10 +65,11 @@ use crate::provider::wire::{parse_provider, provider_wire};
 use crate::transport::{
     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,
+    tmux_spawn_argv, AttachOutcome, BackendKind, BusySignalKind, CaptureRange,
+    CaptureSampleOutcome, CapturedText, InjectPayload, InjectReport, InjectStage,
+    InjectVerification, InputSurfaceProbe, Key, PaneField, PaneId, PaneInfo, PaneMode,
+    QueryOutcome, SessionName, SetEnvOutcome, SpawnResult, SubmitAttemptObservation,
+    SubmitConsumptionReason, SubmitDiagnostics, SubmitObserver, SubmitVerification, Target,
     Transport, TransportError, TurnVerification, WindowName,
 };
 
@@ -242,8 +243,6 @@ impl TmuxSocketEndpoint {
 pub(crate) enum RuntimeTmuxEndpointSource {
     StateTmuxEndpoint,
     StateTmuxSocket,
-    LeaderReceiverTmuxEndpoint,
-    LeaderReceiverTmuxSocket,
     WorkspaceFallback,
 }
 
@@ -257,8 +256,6 @@ impl RuntimeTmuxEndpointSource {
         match self {
             Self::StateTmuxEndpoint => "state.tmux_endpoint",
             Self::StateTmuxSocket => "state.tmux_socket",
-            Self::LeaderReceiverTmuxEndpoint => "leader_receiver.tmux_endpoint",
-            Self::LeaderReceiverTmuxSocket => "leader_receiver.tmux_socket",
             Self::WorkspaceFallback => "workspace_fallback",
         }
     }
@@ -671,50 +668,6 @@ fn runtime_tmux_endpoint_from_state(
     })
 }
 
-/// ---
-/// purpose: 读取 selected team's persisted leader receiver endpoint
-/// params:
-///   state: 运行期全量或 selected-team 投影 JSON
-/// returns: nested selected receiver 优先，其次投影顶层 receiver；二者都缺则 None
-/// boundary: 只读 owning receiver，不读取普通 tmux_endpoint，不探活
-/// ---
-pub(crate) fn owning_tmux_endpoint_from_state(
-    state: &serde_json::Value,
-) -> Option<(&str, RuntimeTmuxEndpointSource)> {
-    fn receiver_endpoint(state: &serde_json::Value) -> Option<(&str, RuntimeTmuxEndpointSource)> {
-        state
-            .pointer("/leader_receiver/tmux_endpoint")
-            .and_then(serde_json::Value::as_str)
-            .filter(|endpoint| !endpoint.is_empty())
-            .map(|endpoint| {
-                (
-                    endpoint,
-                    RuntimeTmuxEndpointSource::LeaderReceiverTmuxEndpoint,
-                )
-            })
-            .or_else(|| {
-                state
-                    .pointer("/leader_receiver/tmux_socket")
-                    .and_then(serde_json::Value::as_str)
-                    .filter(|endpoint| !endpoint.is_empty())
-                    .map(|endpoint| {
-                        (
-                            endpoint,
-                            RuntimeTmuxEndpointSource::LeaderReceiverTmuxSocket,
-                        )
-                    })
-            })
-    }
-
-    state
-        .get("active_team_key")
-        .and_then(serde_json::Value::as_str)
-        .filter(|team_key| !team_key.is_empty())
-        .and_then(|team_key| state.get("teams").and_then(|teams| teams.get(team_key)))
-        .and_then(receiver_endpoint)
-        .or_else(|| receiver_endpoint(state))
-}
-
 /// CP-1 socket name: SHORT + DETERMINISTIC per canonical workspace path. `ta-` + 12 hex chars of a
 /// stable FNV-1a hash over the canonicalized path. AF_UNIX `sun_path` is ~104 chars and the socket
 /// lives at `/tmp/tmux-<uid>/<name>`, so we must NOT use the (~88-char) session name. §10: a
@@ -758,10 +711,6 @@ pub fn runtime_tmux_endpoint_from_state_pub(
         let src = match source {
             RuntimeTmuxEndpointSource::StateTmuxEndpoint => "state.tmux_endpoint",
             RuntimeTmuxEndpointSource::StateTmuxSocket => "state.tmux_socket",
-            RuntimeTmuxEndpointSource::LeaderReceiverTmuxEndpoint => {
-                "leader_receiver.tmux_endpoint"
-            }
-            RuntimeTmuxEndpointSource::LeaderReceiverTmuxSocket => "leader_receiver.tmux_socket",
             RuntimeTmuxEndpointSource::WorkspaceFallback => "workspace_fallback",
         };
         (endpoint.to_string(), src)
@@ -1530,6 +1479,14 @@ fn submit_diagnostics_for_inject(
     surface: InjectTargetSurface,
 ) -> SubmitDiagnostics {
     SubmitDiagnostics {
+        consumption_reason: SubmitConsumptionReason::Unknown,
+        // No pre-paste capture exists on this path; keep the diagnostic null.
+        before_busy_signal_kind: None,
+        busy_signal_kind: None,
+        busy_line_from_bottom: None,
+        current_marker_in_bottom_15: None,
+        paste_identity_in_composer: None,
+        consumption_from_capture_result: None,
         appear_gate_elapsed_ms: 0,
         appear_gate_matched: false,
         total_elapsed_ms,
@@ -2118,6 +2075,56 @@ pub(crate) fn consumption_from_capture(
     }
 }
 
+#[derive(Debug, Clone, Copy, Default)]
+struct ConsumptionCaptureObservation {
+    busy: Option<BusySignalMatch>,
+    marker_in_bottom_15: Option<bool>,
+    paste_identity_in_composer: Option<bool>,
+    consumption_from_capture_result: Option<bool>,
+}
+
+fn consumption_capture_observation(
+    text: &str,
+    marker: Option<&str>,
+    token_ever_visible: bool,
+    tracked: Option<PasteLatch>,
+) -> ConsumptionCaptureObservation {
+    let Some(marker) = marker else {
+        return ConsumptionCaptureObservation::default();
+    };
+    ConsumptionCaptureObservation {
+        busy: provider_busy_signal_match(text),
+        marker_in_bottom_15: Some(token_in_bottom_n(text, marker, 15)),
+        paste_identity_in_composer: tracked
+            .map(|tracked| this_paste_identity_in_composer(text, marker, Some(tracked))),
+        consumption_from_capture_result: consumption_from_capture(
+            text,
+            marker,
+            token_ever_visible,
+            tracked,
+        ),
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+struct ConsumptionDiagnostics {
+    busy_signal_kind: Option<BusySignalKind>,
+    busy_line_from_bottom: Option<u8>,
+    current_marker_in_bottom_15: Option<bool>,
+    paste_identity_in_composer: Option<bool>,
+    consumption_from_capture_result: Option<bool>,
+}
+
+impl ConsumptionDiagnostics {
+    fn record(&mut self, observation: ConsumptionCaptureObservation) {
+        self.busy_signal_kind = observation.busy.map(|match_| match_.kind);
+        self.busy_line_from_bottom = observation.busy.map(|match_| match_.line_from_bottom);
+        self.current_marker_in_bottom_15 = observation.marker_in_bottom_15;
+        self.paste_identity_in_composer = observation.paste_identity_in_composer;
+        self.consumption_from_capture_result = observation.consumption_from_capture_result;
+    }
+}
+
 /// ---
 /// purpose: Gone 分支在判已消费前复核 composer 占位符（PasteLatch 身份）
 /// contract: 锁定身份仍在，或未锁定但 grok `[Pasted: …]` 仍在 ⇒ Some(false)
@@ -2147,37 +2154,67 @@ fn marker_position_from_bottom(text: &str, marker: &str) -> Option<u32> {
     None
 }
 
-fn provider_busy_signal_in_tail(text: &str) -> bool {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct BusySignalMatch {
+    kind: BusySignalKind,
+    line_from_bottom: u8,
+}
+
+fn busy_signal_kind_in_line(line: &str) -> Option<BusySignalKind> {
+    let lower = line.to_ascii_lowercase();
+    if lower.contains("working") {
+        return Some(BusySignalKind::Working);
+    }
+    if lower.contains("thinking") {
+        return Some(BusySignalKind::Thinking);
+    }
+    if lower.contains("processing") {
+        return Some(BusySignalKind::Processing);
+    }
+    if lower.contains("esc to interrupt") {
+        return Some(BusySignalKind::EscToInterrupt);
+    }
+    if line.contains('●')
+        || line.contains('⏳')
+        || line.contains('⠋')
+        || line.contains('⠙')
+        || line.contains('⠹')
+        || line.contains('⠸')
+        || line.contains('⠼')
+        || line.contains('⠴')
+        || line.contains('⠦')
+        || line.contains('⠧')
+        || line.contains('⠇')
+        || line.contains('⠏')
+        || line.contains('✶')
+        || line.contains('✢')
+        || line.contains('✻')
+        || line.contains('✽')
+        || line.contains('✳')
+    {
+        return Some(BusySignalKind::SpinnerGlyph);
+    }
+    None
+}
+
+fn provider_busy_signal_match(text: &str) -> Option<BusySignalMatch> {
     text.lines()
         .rev()
         .filter(|line| !line.trim().is_empty())
         .take(15)
-        .any(|line| {
-            let lower = line.to_ascii_lowercase();
-            lower.contains("working")
-                || lower.contains("thinking")
-                || lower.contains("processing")
-                || lower.contains("esc to interrupt")
-                || line.contains('●')
-                || line.contains('⏳')
-                || line.contains('⠋')
-                || line.contains('⠙')
-                || line.contains('⠹')
-                || line.contains('⠸')
-                || line.contains('⠼')
-                || line.contains('⠴')
-                || line.contains('⠦')
-                || line.contains('⠧')
-                || line.contains('⠇')
-                || line.contains('⠏')
-                || line.contains('✶')
-                || line.contains('✢')
-                || line.contains('✻')
-                || line.contains('✽')
-                || line.contains('✳')
+        .enumerate()
+        .find_map(|(line_from_bottom, line)| {
+            busy_signal_kind_in_line(line).map(|kind| BusySignalMatch {
+                kind,
+                line_from_bottom: line_from_bottom as u8,
+            })
         })
 }
 
+fn provider_busy_signal_in_tail(text: &str) -> bool {
+    provider_busy_signal_match(text).is_some()
+}
+
 /// ---
 /// purpose: 入箱 vs 开跑（G4）。给定最近一次 pane 尾，回答席位是否因此开跑。
 /// params:
@@ -3227,6 +3264,8 @@ impl Transport for TmuxBackend {
                 let mut consumption_attempts: u32 = 0;
                 let mut capture_retries: u32 = 0;
                 let mut consumed: Option<bool> = None;
+                let mut consumption_reason = SubmitConsumptionReason::Unknown;
+                let mut consumption_diagnostics = ConsumptionDiagnostics::default();
                 let mut attempts_detail: Vec<SubmitAttemptObservation> = Vec::new();
                 let mut any_attempt_matched = false;
 
@@ -3267,6 +3306,13 @@ impl Transport for TmuxBackend {
                                     token_seen_after_enter = Some(false);
                                 }
                                 tracked_paste = latch_paste(&cap.text, tracked_paste);
+                                let observation = consumption_capture_observation(
+                                    &cap.text,
+                                    marker,
+                                    token_ever_visible,
+                                    tracked_paste,
+                                );
+                                consumption_diagnostics.record(observation);
                                 let obs = submit_attempt_observation(
                                     attempt_index,
                                     &cap,
@@ -3279,18 +3325,16 @@ impl Transport for TmuxBackend {
                                 attempts_detail.push(obs);
                                 // NeverSeen 不得把 token 缺席写成 consumed；
                                 // 见过再消失，或本次占位符身份离开 composer，才停手。
-                                if consumption_from_capture(
-                                    &cap.text,
-                                    m,
-                                    token_ever_visible,
-                                    tracked_paste,
-                                ) == Some(true)
-                                {
+                                if observation.consumption_from_capture_result == Some(true) {
+                                    consumption_reason =
+                                        SubmitConsumptionReason::ConsumptionFromCapture;
                                     consumed = Some(true);
                                     break;
                                 }
                                 if cursor_single_enter_enabled() {
-                                    if provider_busy_signal_in_tail(&cap.text) {
+                                    if observation.busy.is_some() {
+                                        consumption_reason =
+                                            SubmitConsumptionReason::CursorPollingBusy;
                                         consumed = Some(true);
                                         break;
                                     }
@@ -3375,6 +3419,13 @@ impl Transport for TmuxBackend {
                                         token_seen_after_enter = Some(false);
                                     }
                                     tracked_paste = latch_paste(&cap.text, tracked_paste);
+                                    let observation = consumption_capture_observation(
+                                        &cap.text,
+                                        marker,
+                                        token_ever_visible,
+                                        tracked_paste,
+                                    );
+                                    consumption_diagnostics.record(observation);
                                     let obs = submit_attempt_observation(
                                         attempt_index,
                                         &cap,
@@ -3385,24 +3436,22 @@ impl Transport for TmuxBackend {
                                         any_attempt_matched = true;
                                     }
                                     attempts_detail.push(obs);
-                                    if consumption_from_capture(
-                                        &cap.text,
-                                        m,
-                                        token_ever_visible,
-                                        tracked_paste,
-                                    ) == Some(true)
-                                    {
+                                    if observation.consumption_from_capture_result == Some(true) {
+                                        consumption_reason =
+                                            SubmitConsumptionReason::ConsumptionFromCapture;
                                         found_consumed = true;
                                         break;
                                     }
-                                    if cursor_single_enter_enabled()
-                                        && provider_busy_signal_in_tail(&cap.text)
-                                    {
+                                    if cursor_single_enter_enabled() && observation.busy.is_some() {
+                                        consumption_reason =
+                                            SubmitConsumptionReason::CursorPollingBusy;
                                         found_consumed = true;
                                         break;
                                     }
                                 }
                                 Err(_) => {
+                                    consumption_diagnostics
+                                        .record(ConsumptionCaptureObservation::default());
                                     capture_tally.record_err();
                                     capture_retries = capture_retries.saturating_add(1);
                                     consecutive_capture_failures =
@@ -3426,7 +3475,8 @@ impl Transport for TmuxBackend {
                         }
                     } else {
                         // Non-token payload: single Enter, no consumption check
-                        // (0.3.27). Not 「没能判断」— 本门不覆盖无 token 路径。
+                        // (0.3.27). Keep the explicit no-marker reason.
+                        consumption_reason = SubmitConsumptionReason::NoMarker;
                         consumed = Some(true);
                         break;
                     }
@@ -3451,21 +3501,38 @@ impl Transport for TmuxBackend {
                     Some(false) => match self.capture(target, CaptureRange::Tail(15)) {
                         Ok(cap) => {
                             last_turn_text = Some(cap.text.clone());
+                            let observation = consumption_capture_observation(
+                                &cap.text,
+                                marker,
+                                token_ever_visible,
+                                tracked_paste,
+                            );
+                            consumption_diagnostics.record(observation);
                             attempts_detail.push(submit_attempt_observation(
                                 consumption_attempts.max(1),
                                 &cap,
                                 marker,
                                 inject_start.elapsed().as_millis() as u64,
                             ));
-                            if provider_busy_signal_in_tail(&cap.text) {
+                            if observation.busy.is_some() {
+                                consumption_reason = SubmitConsumptionReason::FallbackBusy;
                                 SubmitVerification::EnterSentWithoutPlaceholderCheck
                             } else {
+                                consumption_reason = SubmitConsumptionReason::Unverified;
                                 SubmitVerification::SubmitConsumptionUnverified
                             }
                         }
-                        Err(_) => SubmitVerification::SubmitConsumptionUnverified,
+                        Err(_) => {
+                            consumption_diagnostics
+                                .record(ConsumptionCaptureObservation::default());
+                            consumption_reason = SubmitConsumptionReason::Unverified;
+                            SubmitVerification::SubmitConsumptionUnverified
+                        }
                     },
-                    None => SubmitVerification::SubmitConsumptionUnverified,
+                    None => {
+                        consumption_reason = SubmitConsumptionReason::Unverified;
+                        SubmitVerification::SubmitConsumptionUnverified
+                    }
                 };
                 // Unverified + 折行缺口：只补一颗 C-m。A 的 should_resubmit_enter
                 // 已为真（latch/底15 token，含打满 cap）时 B 不介入。身份拿不到
@@ -3511,6 +3578,13 @@ impl Transport for TmuxBackend {
                                             token_seen_after_enter = Some(false);
                                         }
                                         tracked_paste = latch_paste(&cap.text, tracked_paste);
+                                        let observation = consumption_capture_observation(
+                                            &cap.text,
+                                            marker,
+                                            token_ever_visible,
+                                            tracked_paste,
+                                        );
+                                        consumption_diagnostics.record(observation);
                                         let obs = submit_attempt_observation(
                                             consumption_attempts.max(1),
                                             &cap,
@@ -3519,20 +3593,22 @@ impl Transport for TmuxBackend {
                                         );
                                         attempts_detail.push(obs);
                                         last_turn_text = Some(cap.text.clone());
-                                        if consumption_from_capture(
-                                            &cap.text,
-                                            m,
-                                            token_ever_visible,
-                                            tracked_paste,
-                                        ) == Some(true)
-                                            || provider_busy_signal_in_tail(&cap.text)
-                                        {
+                                        let capture_consumed = observation
+                                            .consumption_from_capture_result
+                                            == Some(true);
+                                        let busy = observation.busy.is_some();
+                                        if capture_consumed || busy {
                                             // Gone+无 latch 会把折行 token 写成已消费；身份仍在则不算。
                                             if !this_paste_identity_in_composer(
                                                 &cap.text,
                                                 m,
                                                 tracked_paste,
                                             ) {
+                                                consumption_reason = if capture_consumed {
+                                                    SubmitConsumptionReason::ConsumptionFromCapture
+                                                } else {
+                                                    SubmitConsumptionReason::FallbackBusy
+                                                };
                                                 found_consumed = true;
                                                 break;
                                             }
@@ -3542,11 +3618,14 @@ impl Transport for TmuxBackend {
                                             m,
                                             tracked_paste,
                                         ) {
+                                            consumption_reason = SubmitConsumptionReason::Unknown;
                                             found_consumed = true;
                                             break;
                                         }
                                     }
                                     Err(_) => {
+                                        consumption_diagnostics
+                                            .record(ConsumptionCaptureObservation::default());
                                         capture_tally.record_err();
                                         break;
                                     }
@@ -3562,6 +3641,24 @@ impl Transport for TmuxBackend {
                 }
                 let total_elapsed_ms = inject_start.elapsed().as_millis() as u64;
                 let surface = probe_inject_target_surface(self, target);
+                let mut submit_diagnostics = submit_diagnostics_for_inject(
+                    total_elapsed_ms,
+                    attempts_detail,
+                    &capture_tally,
+                    token_seen_after_paste,
+                    token_seen_after_enter,
+                    surface,
+                );
+                submit_diagnostics.consumption_reason = consumption_reason;
+                submit_diagnostics.busy_signal_kind = consumption_diagnostics.busy_signal_kind;
+                submit_diagnostics.busy_line_from_bottom =
+                    consumption_diagnostics.busy_line_from_bottom;
+                submit_diagnostics.current_marker_in_bottom_15 =
+                    consumption_diagnostics.current_marker_in_bottom_15;
+                submit_diagnostics.paste_identity_in_composer =
+                    consumption_diagnostics.paste_identity_in_composer;
+                submit_diagnostics.consumption_from_capture_result =
+                    consumption_diagnostics.consumption_from_capture_result;
                 return Ok(InjectReport {
                     stage_reached: InjectStage::Submit,
                     inject_verification: inject_verification_after_readback(
@@ -3574,14 +3671,7 @@ impl Transport for TmuxBackend {
                         last_turn_text.as_deref(),
                     ),
                     attempts: consumption_attempts.saturating_add(capture_retries),
-                    submit_diagnostics: Some(submit_diagnostics_for_inject(
-                        total_elapsed_ms,
-                        attempts_detail,
-                        &capture_tally,
-                        token_seen_after_paste,
-                        token_seen_after_enter,
-                        surface,
-                    )),
+                    submit_diagnostics: Some(submit_diagnostics),
                 });
             }
         }

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

@@ -467,6 +467,21 @@ pub struct InjectReport {
 /// pasted-prompt branch + (informational) for the appear-gate poll.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct SubmitDiagnostics {
+    /// The concrete branch that produced the post-Enter consumption outcome.
+    /// Unknown is retained for paths that do not expose a branch reason.
+    pub consumption_reason: SubmitConsumptionReason,
+    /// Reserved for a pre-paste baseline; this path has no such capture and emits null.
+    pub before_busy_signal_kind: Option<BusySignalKind>,
+    /// Structured busy predicate category for the accepted/current capture.
+    pub busy_signal_kind: Option<BusySignalKind>,
+    /// Bottom-relative non-empty line index of the busy match.
+    pub busy_line_from_bottom: Option<u8>,
+    /// Whether this message marker is in the bottom 15 non-empty lines.
+    pub current_marker_in_bottom_15: Option<bool>,
+    /// Whether the tracked paste identity is still in the composer.
+    pub paste_identity_in_composer: Option<bool>,
+    /// Result of the structural consumption predicate on the current capture.
+    pub consumption_from_capture_result: Option<bool>,
     /// Time spent in the appear-gate (poll for the pasted-content placeholder
     /// before Enter). When `saw_pasted_prompt == false` this is the time we
     /// spent polling before falling through to the E46 token path.
@@ -505,6 +520,63 @@ pub struct SubmitDiagnostics {
     pub target_pane_query_matched: Option<bool>,
 }
 
+/// Structured category returned by the provider-busy predicate.
+///
+/// This is diagnostic metadata only; it does not change delivery semantics.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BusySignalKind {
+    Working,
+    Thinking,
+    Processing,
+    EscToInterrupt,
+    SpinnerGlyph,
+}
+
+impl BusySignalKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Working => "working",
+            Self::Thinking => "thinking",
+            Self::Processing => "processing",
+            Self::EscToInterrupt => "esc_to_interrupt",
+            Self::SpinnerGlyph => "spinner_glyph",
+        }
+    }
+}
+
+/// Structured reason for the post-Enter consumption observation.
+///
+/// This is diagnostic metadata only; it does not change delivery semantics.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum SubmitConsumptionReason {
+    /// The token/input identity disappeared in the consumption capture.
+    ConsumptionFromCapture,
+    /// Cursor's bounded polling observed a provider-busy signal.
+    CursorPollingBusy,
+    /// The final fallback capture observed a provider-busy signal.
+    FallbackBusy,
+    /// The payload had no token marker, so no structural consumption probe ran.
+    NoMarker,
+    /// The bounded probe did not establish consumption.
+    Unverified,
+    /// An older or otherwise uncovered path did not provide a reason.
+    #[default]
+    Unknown,
+}
+
+impl SubmitConsumptionReason {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::ConsumptionFromCapture => "consumption_from_capture",
+            Self::CursorPollingBusy => "cursor_poll_busy",
+            Self::FallbackBusy => "fallback_busy",
+            Self::NoMarker => "no_marker",
+            Self::Unverified => "unverified",
+            Self::Unknown => "unknown",
+        }
+    }
+}
+
 /// 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)]

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

@@ -51,6 +51,59 @@ use crate::conpty::ConPtyBackend;
 use crate::tmux_backend::TmuxBackend;
 use crate::transport::{BackendKind, Transport};
 
+#[cfg(test)]
+thread_local! {
+    static LEADER_ENDPOINT_TRANSPORT_OVERRIDE: std::cell::RefCell<
+        Option<(String, crate::transport::test_support::OfflineTransport)>,
+    > = std::cell::RefCell::new(None);
+}
+
+/// Production live-probe transport for a recorded leader endpoint.
+/// `classify_leader_binding`, restart `transport_for_receiver`, and
+/// `attach_leader_targets` all go through this function.
+pub fn leader_endpoint_transport(endpoint: &str) -> Box<dyn Transport> {
+    #[cfg(test)]
+    if let Some(injected) = LEADER_ENDPOINT_TRANSPORT_OVERRIDE.with(|slot| {
+        slot.borrow().as_ref().and_then(|(expected, transport)| {
+            (expected == endpoint).then(|| Box::new(transport.clone()) as Box<dyn Transport>)
+        })
+    }) {
+        return injected;
+    }
+    if endpoint.is_empty() || endpoint == "default" {
+        Box::new(tmux_default_transport())
+    } else {
+        Box::new(tmux_endpoint_transport(endpoint))
+    }
+}
+
+#[cfg(test)]
+struct LeaderEndpointTransportGuard {
+    previous: Option<(String, crate::transport::test_support::OfflineTransport)>,
+}
+
+#[cfg(test)]
+impl Drop for LeaderEndpointTransportGuard {
+    fn drop(&mut self) {
+        LEADER_ENDPOINT_TRANSPORT_OVERRIDE.with(|slot| {
+            *slot.borrow_mut() = self.previous.take();
+        });
+    }
+}
+
+#[cfg(test)]
+pub fn with_leader_endpoint_transport<T>(
+    endpoint: &str,
+    transport: crate::transport::test_support::OfflineTransport,
+    f: impl FnOnce() -> T,
+) -> T {
+    let previous = LEADER_ENDPOINT_TRANSPORT_OVERRIDE.with(|slot| {
+        slot.replace(Some((endpoint.to_string(), transport)))
+    });
+    let _guard = LeaderEndpointTransportGuard { previous };
+    f()
+}
+
 /// User-visible backend selector on the CLI (`--backend tmux|conpty`).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RequestedTransportBackend {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.75",
+  "version": "0.5.78",
   "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.75",
-    "@team-agent/cli-darwin-x64": "0.5.75",
-    "@team-agent/cli-linux-x64": "0.5.75"
+    "@team-agent/cli-darwin-arm64": "0.5.78",
+    "@team-agent/cli-darwin-x64": "0.5.78",
+    "@team-agent/cli-linux-x64": "0.5.78"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",
@@ -33,7 +33,6 @@
   "files": [
     "npm/bincheck.mjs",
     "npm/install.mjs",
-    "npm/check-skill-links.mjs",
     "skills",
     "templates",
     "examples",