@team-agent/installer 0.5.117 → 0.5.119

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

@@ -0,0 +1,432 @@
+#![allow(clippy::unwrap_used, clippy::panic)]
+use super::*;
+use crate::model::enums::Provider;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone, Copy)]
+enum Mode {
+    Normal,
+    Busy,
+    Unknown,
+    Capsule,
+    History,
+    Changed,
+    UnknownAfterEnter,
+    UnknownWithReplacement,
+}
+struct State {
+    mode: Mode,
+    nonce: String,
+    endpoint: String,
+    pid: u32,
+    captures: usize,
+    entered: usize,
+    calls: Vec<Vec<String>>,
+}
+struct Runner(Arc<Mutex<State>>);
+fn pi(composer: &str, history: &str, busy: bool) -> String {
+    format!("{history}\n{}\n{composer}\n────────────────────────\ngpt-6-luna · max · 0%/272k · 0% · $0.00\n",if busy{"── ⠋ Working ──────────────────"}else{"────────────────────"})
+}
+impl CommandRunner for Runner {
+    fn run(&self, argv: &[String]) -> Result<CommandOutput, std::io::Error> {
+        let mut s = self.0.lock().unwrap();
+        s.calls.push(argv.to_vec());
+        let stdout = if argv.iter().any(|a| a == "display-message") {
+            let format = argv.last().unwrap();
+            if format.contains("socket_path") {
+                let nonce = if (matches!(s.mode, Mode::UnknownAfterEnter) && s.entered > 0)
+                    || (matches!(s.mode, Mode::UnknownWithReplacement) && s.captures > 0)
+                {
+                    "replaced"
+                } else {
+                    &s.nonce
+                };
+                format!("{}|%1|{}|session|worker|{nonce}|0|120\n", s.endpoint, s.pid)
+            } else if format == "#{pane_height}" {
+                "120\n".into()
+            } else if format == "#{pane_pid}" {
+                format!("{}\n", s.pid)
+            } else {
+                "0\n".into()
+            }
+        } else if argv.iter().any(|a| a == "set-option") {
+            assert!(s.nonce.is_empty());
+            assert!(argv.iter().any(|a| a == "-o"));
+            s.nonce = argv.last().unwrap().clone();
+            String::new()
+        } else if argv.iter().any(|a| a == "show-options") {
+            format!("{}\n", s.nonce)
+        } else if argv.iter().any(|a| a == "capture-pane") {
+            s.captures += 1;
+            let marker = "[team-agent-token:msg_one]";
+            match s.mode {
+                Mode::Unknown | Mode::UnknownWithReplacement => "unknown native screen".into(),
+                Mode::Capsule => pi("[paste #1 +30 lines]", "", false),
+                Mode::History => pi("", marker, false),
+                Mode::Changed if s.captures >= 3 => pi("different draft", "", false),
+                Mode::Busy => pi(marker, "", true),
+                _ if s.entered > 0 => pi("", marker, false),
+                _ => pi(marker, "", false),
+            }
+        } else if argv.iter().any(|a| a == "send-keys") {
+            assert_eq!(argv.last().unwrap(), "Enter");
+            s.entered += 1;
+            String::new()
+        } else {
+            panic!("unexpected transport operation {argv:?}")
+        };
+        Ok(CommandOutput {
+            success: true,
+            code: Some(0),
+            stdout,
+            stderr: String::new(),
+        })
+    }
+}
+struct Fixture {
+    path: std::path::PathBuf,
+    backend: TmuxBackend,
+    state: Arc<Mutex<State>>,
+}
+impl Fixture {
+    fn new(mode: Mode) -> Self {
+        static NEXT: AtomicUsize = AtomicUsize::new(0);
+        let path = std::env::temp_dir().join(format!(
+            "ta-independent-rescue-backend-{}-{}",
+            std::process::id(),
+            NEXT.fetch_add(1, Ordering::SeqCst)
+        ));
+        std::fs::create_dir(&path).unwrap();
+        let state = Arc::new(Mutex::new(State {
+            mode,
+            nonce: "original-nonce".into(),
+            endpoint: "/tmp/owned.sock".into(),
+            pid: std::process::id(),
+            captures: 0,
+            entered: 0,
+            calls: vec![],
+        }));
+        let backend =
+            TmuxBackend::with_runner_for_workspace(Box::new(Runner(state.clone())), &path);
+        Self {
+            path,
+            backend,
+            state,
+        }
+    }
+    fn context(&self) -> EnterRescueContext {
+        EnterRescueContext {
+            message_id: "msg_one".into(),
+            owner_team_id: "team".into(),
+            recipient: "worker".into(),
+            payload_sha256: digest("rendered payload"),
+            target: Some(EnterRescueTarget::selected(
+                Provider::Pi,
+                "%1".into(),
+                std::process::id(),
+                "session".into(),
+                "worker".into(),
+            )),
+            proof: None,
+        }
+    }
+    fn snapshot(&self) -> EnterRescueContext {
+        self.backend
+            .snapshot_rescue_context(
+                &Target::Pane(PaneId::new("%1")),
+                &self.context(),
+                "rendered payload",
+            )
+            .unwrap()
+    }
+    fn entered(&self) -> usize {
+        self.state.lock().unwrap().entered
+    }
+}
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.path);
+    }
+}
+
+#[test]
+fn original_boundary_snapshot_records_only_exact_visible_current_marker() {
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    assert!(c.target.as_ref().unwrap().bound());
+    let proof = c.proof.unwrap();
+    assert!(proof.visible_marker && proof.transcript_marker_absent);
+    assert!(proof.owned_capsule.is_none());
+    assert_eq!(f.entered(), 0);
+    for mode in [Mode::Unknown, Mode::Capsule, Mode::History] {
+        let f = Fixture::new(mode);
+        let c = f.snapshot();
+        assert!(c.proof.is_none());
+        assert_eq!(f.entered(), 0);
+    }
+}
+
+#[test]
+fn snapshot_rejects_wrong_payload_or_selected_carrier_and_creates_nonce_only_when_owned() {
+    let f = Fixture::new(Mode::Normal);
+    let c = f.context();
+    let t = Target::Pane(PaneId::new("%1"));
+    assert!(f
+        .backend
+        .snapshot_rescue_context(&t, &c, "edited")
+        .unwrap()
+        .proof
+        .is_none());
+    assert!(f.state.lock().unwrap().calls.is_empty());
+    let mut c = f.context();
+    c.target.as_mut().unwrap().pane_pid += 1;
+    assert!(f
+        .backend
+        .snapshot_rescue_context(&t, &c, "rendered payload")
+        .unwrap()
+        .proof
+        .is_none());
+    let f = Fixture::new(Mode::Capsule);
+    f.state.lock().unwrap().nonce.clear();
+    assert!(f.snapshot().proof.is_none());
+    assert!(f.state.lock().unwrap().nonce.is_empty());
+    let f = Fixture::new(Mode::Normal);
+    f.state.lock().unwrap().nonce.clear();
+    assert!(f.snapshot().target.unwrap().bound());
+    assert!(!f.state.lock().unwrap().nonce.is_empty());
+    assert_eq!(f.entered(), 0);
+}
+
+#[test]
+fn watchdog_rechecks_carrier_and_never_adopts_replacement_or_missing_receipt() {
+    for changed in ["endpoint", "nonce", "birth", "pid"] {
+        let f = Fixture::new(Mode::Normal);
+        let mut c = f.snapshot();
+        match changed {
+            "endpoint" => f.state.lock().unwrap().endpoint = "/tmp/other.sock".into(),
+            "nonce" => f.state.lock().unwrap().nonce = "other".into(),
+            "birth" => c.target.as_mut().unwrap().carrier_birth = "reused".into(),
+            _ => c.target.as_mut().unwrap().pane_pid += 1,
+        };
+        let _ = f.backend.rescue_guarded_enter(&c, &|| true, None);
+        assert_eq!(f.entered(), 0, "{changed}");
+    }
+    let f = Fixture::new(Mode::Normal);
+    assert!(matches!(
+        f.backend
+            .rescue_guarded_enter(&f.context(), &|| true, None)
+            .unwrap(),
+        EnterRescueOutcome::NoEffect { .. }
+    ));
+    assert_eq!(f.entered(), 0);
+}
+
+#[test]
+fn busy_unstable_unknown_or_final_authorization_failure_sends_no_key() {
+    for mode in [Mode::Busy, Mode::Changed] {
+        let f = Fixture::new(mode);
+        let c = f.snapshot();
+        assert!(matches!(
+            f.backend.rescue_guarded_enter(&c, &|| true, None).unwrap(),
+            EnterRescueOutcome::NoEffect { .. }
+        ));
+        assert_eq!(f.entered(), 0);
+    }
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    f.state.lock().unwrap().mode = Mode::Unknown;
+    assert_eq!(
+        f.backend.rescue_guarded_enter(&c, &|| true, None).unwrap(),
+        no_effect("surface_unknown", true)
+    );
+    assert_eq!(f.entered(), 0);
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    assert!(matches!(
+        f.backend.rescue_guarded_enter(&c, &|| false, None).unwrap(),
+        EnterRescueOutcome::NoEffect { .. }
+    ));
+    assert_eq!(f.entered(), 0);
+}
+
+#[test]
+fn unknown_observation_still_checks_original_carrier_before_zero_effect_refusal() {
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    {
+        let mut state = f.state.lock().unwrap();
+        state.mode = Mode::UnknownWithReplacement;
+        state.captures = 0;
+    }
+    assert!(matches!(
+        f.backend.rescue_guarded_enter(&c, &|| true, None),
+        Err(TransportError::NativeInputNotReady { reason }) if reason == "rescue_binding_changed"
+    ));
+    assert_eq!(f.entered(), 0);
+}
+
+#[test]
+fn required_input_lock_cannot_be_omitted_or_bypassed() {
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    let _lock = acquire_required(PaneInputLockRequest {
+        workspace: Some(&f.path),
+        target_key: "%1",
+        operation: "fixture-held",
+    })
+    .unwrap();
+    assert_eq!(
+        f.backend.rescue_guarded_enter(&c, &|| true, None).unwrap(),
+        no_effect("input_lock", true)
+    );
+    assert_eq!(f.entered(), 0);
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    let backend = TmuxBackend::with_runner(Box::new(Runner(f.state.clone())));
+    assert_eq!(
+        backend.rescue_guarded_enter(&c, &|| true, None).unwrap(),
+        no_effect("input_lock", true)
+    );
+    assert_eq!(f.entered(), 0);
+}
+
+struct Observer(AtomicUsize);
+impl SubmitObserver for Observer {
+    fn after_physical_submit(&self) {
+        self.0.fetch_add(1, Ordering::SeqCst);
+    }
+}
+#[test]
+fn one_logical_enter_notifies_before_verification_and_never_pastes() {
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    let observer = Observer(AtomicUsize::new(0));
+    assert_eq!(
+        f.backend
+            .rescue_guarded_enter(&c, &|| true, Some(&observer))
+            .unwrap(),
+        EnterRescueOutcome::Entered { accepted: true }
+    );
+    assert_eq!(f.entered(), 1);
+    assert_eq!(observer.0.load(Ordering::SeqCst), 1);
+    let s = f.state.lock().unwrap();
+    assert!(!s
+        .calls
+        .iter()
+        .flatten()
+        .any(|a| matches!(a.as_str(), "paste-buffer" | "load-buffer" | "set-buffer")));
+}
+
+#[test]
+fn already_consumed_transition_never_sends_another_enter_or_fakes_observer() {
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    f.state.lock().unwrap().mode = Mode::History;
+    let observer = Observer(AtomicUsize::new(0));
+    assert_eq!(
+        f.backend
+            .rescue_guarded_enter(&c, &|| true, Some(&observer))
+            .unwrap(),
+        EnterRescueOutcome::Consumed
+    );
+    assert_eq!(f.entered(), 0);
+    assert_eq!(observer.0.load(Ordering::SeqCst), 0);
+}
+
+#[test]
+fn foreign_token_or_bare_capsule_is_not_current_message_key_authority() {
+    let f = Fixture::new(Mode::Normal);
+    let mut c = f.snapshot();
+    let mut frame = f
+        .backend
+        .rescue_frame(c.target.as_ref().unwrap())
+        .unwrap()
+        .unwrap();
+    frame.composer.push_str("\n[team-agent-token:msg_foreign]");
+    assert!(!pending(&c, &frame));
+    frame.composer = "[paste #1 +30 lines]".into();
+    frame.capsule = Some(frame.composer.clone());
+    assert!(!pending(&c, &frame));
+    let scope_sha256 = c.scope_sha256().unwrap();
+    let proof = c.proof.as_mut().unwrap();
+    proof.visible_marker = false;
+    proof.owned_capsule = Some(crate::transport::enter_rescue::OwnedCapsule {
+        scope_sha256,
+        label: frame.composer.clone(),
+        baseline_sha256: digest("original baseline"),
+        baseline_capsules: vec![],
+        observed_after_owned_paste: true,
+    });
+    assert!(pending(&c, &frame));
+    for field in [
+        "message",
+        "payload",
+        "owner",
+        "recipient",
+        "nonce",
+        "birth",
+        "endpoint",
+    ] {
+        let mut reassigned = c.clone();
+        match field {
+            "message" => reassigned.message_id = "msg_other".into(),
+            "payload" => reassigned.payload_sha256 = digest("other payload"),
+            "owner" => reassigned.owner_team_id = "other".into(),
+            "recipient" => reassigned.recipient = "other".into(),
+            "nonce" => reassigned.target.as_mut().unwrap().binding_nonce = "other".into(),
+            "birth" => reassigned.target.as_mut().unwrap().carrier_birth = "other".into(),
+            _ => reassigned.target.as_mut().unwrap().endpoint = "/tmp/other.sock".into(),
+        }
+        assert!(!pending(&reassigned, &frame), "{field}");
+    }
+    c.proof
+        .as_mut()
+        .unwrap()
+        .owned_capsule
+        .as_mut()
+        .unwrap()
+        .baseline_capsules
+        .push(frame.composer.clone());
+    assert!(!pending(&c, &frame));
+}
+
+#[test]
+fn unknown_after_enter_is_terminal_uncertainty_not_no_effect() {
+    let f = Fixture::new(Mode::UnknownAfterEnter);
+    let c = f.snapshot();
+    let observer = Observer(AtomicUsize::new(0));
+    assert_eq!(
+        f.backend
+            .rescue_guarded_enter(&c, &|| true, Some(&observer))
+            .unwrap(),
+        EnterRescueOutcome::Entered { accepted: false }
+    );
+    assert_eq!(f.entered(), 1);
+    assert_eq!(observer.0.load(Ordering::SeqCst), 1);
+}
+
+#[test]
+fn transcript_transfer_requires_empty_not_whitespace_composer_and_unique_marker() {
+    let f = Fixture::new(Mode::Normal);
+    let c = f.snapshot();
+    let proof = c.proof.as_ref().unwrap();
+    let mut frame = InputFrame {
+        composer: "".into(),
+        transcript: c.marker(),
+        identity: proof.ui_identity.clone(),
+        footer: "changed while working".into(),
+        busy: true,
+        capsule: None,
+    };
+    assert!(accepted(&c, &frame));
+    frame.composer = " ".into();
+    assert!(!accepted(&c, &frame));
+    frame.composer.clear();
+    frame.transcript = format!("{}{}", c.marker(), c.marker());
+    assert!(!accepted(&c, &frame));
+    frame.transcript = c.marker();
+    let mut c = c;
+    c.proof.as_mut().unwrap().transcript_marker_absent = false;
+    assert!(!accepted(&c, &frame));
+}

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

@@ -38,6 +38,25 @@ pub(crate) fn digest(text: &str) -> String {
 }
 
 impl TmuxBackend {
+    pub(super) fn observe_current_native_input(
+        &self,
+        target: &Target,
+        provider: Provider,
+    ) -> Result<Option<InputFrame>, TransportError> {
+        if !crate::transport::native_input::supports_input_observation(provider) {
+            return Ok(None);
+        }
+        // Pure observation: no nonce initialization, paste, or key.
+        let binding = self.query_native_binding(target, true)?;
+        let capture = self.capture(target, CaptureRange::Tail(200))?;
+        let frame = inspect_input(provider, &capture.text, binding.pane_height)
+            .ok_or_else(|| refused("native_surface_unknown"))?;
+        if self.query_native_binding(target, true)? != binding {
+            return Err(refused("binding_changed"));
+        }
+        Ok(Some(frame))
+    }
+
     fn native_binding(&self, target: &Target) -> Result<NativeInputBinding, TransportError> {
         self.query_native_binding(target, false)
     }

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

@@ -20,6 +20,12 @@ enum Mode {
     R6IdleNotice,
     PiFolded,
     PiFoldedUnstable,
+    CursorFollowup,
+    CursorHeaderEvicted,
+    CursorHistoryOnly,
+    CursorLongHistory,
+    CursorExpanded,
+    CursorExpandedDirty,
 }
 struct State {
     mode: Mode,
@@ -53,7 +59,13 @@ impl CommandRunner for Runner {
             };
             let height = if matches!(
                 state.mode,
-                Mode::R6IdleNotice | Mode::PiFolded | Mode::PiFoldedUnstable
+                Mode::R6IdleNotice
+                    | Mode::PiFolded
+                    | Mode::PiFoldedUnstable
+                    | Mode::CursorHistoryOnly
+                    | Mode::CursorLongHistory
+                    | Mode::CursorExpanded
+                    | Mode::CursorExpandedDirty
             ) {
                 24
             } else {
@@ -168,14 +180,58 @@ impl CommandRunner for Runner {
         let stdout = if state.provider == Provider::CursorAgent
             && argv.iter().any(|arg| arg == "capture-pane")
         {
+            let followup = matches!(
+                state.mode,
+                Mode::CursorFollowup
+                    | Mode::CursorHeaderEvicted
+                    | Mode::CursorHistoryOnly
+                    | Mode::CursorLongHistory
+                    | Mode::CursorExpanded
+                    | Mode::CursorExpandedDirty
+            );
+            let placeholder = if followup {
+                "Add a follow-up"
+            } else {
+                "Plan, search, build anything"
+            };
+            let header = if matches!(state.mode, Mode::CursorFollowup)
+                || (matches!(state.mode, Mode::CursorHeaderEvicted) && state.pasted > 0)
+            {
+                ""
+            } else {
+                "Cursor Agent\nv2026.10.01-e373342\n"
+            };
             let (composer, history) = if state.entered > 0 {
-                ("Plan, search, build anything", "[Pasted text #2 +25 lines]")
+                (placeholder, "[Pasted text #2 +25 lines]")
             } else if state.pasted > 0 {
                 ("[Pasted text #2 +25 lines]", "[Pasted text #1 +25 lines]")
             } else {
-                ("Plan, search, build anything", "[Pasted text #1 +25 lines]")
+                (placeholder, "[Pasted text #1 +25 lines]")
+            };
+            let padding = if matches!(state.mode, Mode::CursorLongHistory) {
+                "historical transcript row\n".repeat(70)
+            } else {
+                String::new()
             };
-            format!("Cursor Agent\nv2026.10.01-e373342\n{history}\n→ {composer}\nGrok 4.7 High Run Everything\n/owned/project\n")
+            let frame = format!(
+                "{header}{history}\n{padding}→ {composer}\nGrok 4.7 High Run Everything\n/owned/project\n"
+            );
+            if matches!(state.mode, Mode::CursorExpanded | Mode::CursorExpandedDirty) {
+                let expanded = include_str!("../../tests/fixtures/cursor-followup-expanded.txt");
+                if matches!(state.mode, Mode::CursorExpandedDirty)
+                    || state.pasted > 0 && state.entered == 0
+                {
+                    format!("[Pasted text #1 +30 lines]\n{expanded}")
+                } else if state.entered > 0 {
+                    format!("{marker}\n→ Add a follow-up\nGrok 4.7 256K High · 8.6% Run Everything\n/owned/project\n")
+                } else {
+                    "[Pasted text #1 +30 lines]\n→ Add a follow-up\nGrok 4.7 256K High · 8.6% Run Everything\n/owned/project\n".into()
+                }
+            } else if matches!(state.mode, Mode::CursorHistoryOnly) {
+                format!("{frame}{}", "unknown current row\n".repeat(24))
+            } else {
+                frame
+            }
         } else {
             stdout
         };
@@ -703,6 +759,87 @@ fn native_input_cursor_owned_new_capsule_transfers_to_transcript_without_token_c
     assert_eq!(state.entered, 1);
 }
 
+#[test]
+fn native_input_cursor_clean_followup_uses_one_paste_one_enter_across_banner_eviction() {
+    for mode in [
+        Mode::CursorFollowup,
+        Mode::CursorHeaderEvicted,
+        Mode::CursorLongHistory,
+    ] {
+        let f = Fixture::new(mode);
+        f.state.lock().unwrap().provider = Provider::CursorAgent;
+        let (report, evidence) = f.inject();
+        let report = report.unwrap();
+        assert_eq!(
+            report.submit_verification,
+            SubmitVerification::EnterSentWithoutPlaceholderCheck
+        );
+        let evidence = evidence.unwrap();
+        assert_eq!(evidence.phase, NativeInputPhase::Accepted);
+        assert_eq!(
+            evidence.capsule.as_deref(),
+            Some("[Pasted text #2 +25 lines]")
+        );
+        let state = f.state.lock().unwrap();
+        assert_eq!((state.pasted, state.entered), (1, 1));
+    }
+}
+
+#[test]
+fn native_input_cursor_expanded_followup_reaches_seen_then_one_enter() {
+    let f = Fixture::new(Mode::CursorExpanded);
+    f.state.lock().unwrap().provider = Provider::CursorAgent;
+    let text = "For a harmless terminal-scroll fixture, reply with exactly 240 numbered lines, one per line, from 001 through 240, each formatted `NNN: amber`; do not use tools or change any files. Then wait.\n\n[team-agent-token:msg_one]";
+    let (report, evidence) = with_native_input(Some(f.request()), || {
+        f.backend.inject(
+            &Target::Pane(PaneId::new("%1")),
+            &InjectPayload::Text(text.into()),
+            Key::Enter,
+            true,
+        )
+    });
+    let report = report.unwrap();
+    assert_eq!(
+        report.submit_verification,
+        SubmitVerification::EnterSentWithoutPlaceholderCheck
+    );
+    assert_eq!(
+        report.inject_verification,
+        InjectVerification::CaptureContainsToken
+    );
+    let evidence = evidence.unwrap();
+    assert_eq!(evidence.phase, NativeInputPhase::Accepted);
+    assert!(evidence.capsule.is_none());
+    assert_eq!(evidence.baseline_capsules, ["[Pasted text #1 +30 lines]"]);
+    let state = f.state.lock().unwrap();
+    assert_eq!((state.pasted, state.entered), (1, 1));
+    assert!(state.stage_captures[1] >= 2);
+}
+
+#[test]
+fn native_input_cursor_foreign_expanded_followup_is_zero_effect() {
+    let f = Fixture::new(Mode::CursorExpandedDirty);
+    f.state.lock().unwrap().provider = Provider::CursorAgent;
+    let (report, _) = f.inject();
+    assert!(report.is_err());
+    let state = f.state.lock().unwrap();
+    assert_eq!((state.pasted, state.entered), (0, 0));
+}
+
+#[test]
+fn native_input_cursor_history_only_composer_cannot_authorize_paste_or_enter() {
+    let f = Fixture::new(Mode::CursorHistoryOnly);
+    f.state.lock().unwrap().provider = Provider::CursorAgent;
+    let (result, _) = f.inject();
+    let state = f.state.lock().unwrap();
+    assert_eq!(
+        (state.pasted, state.entered),
+        (0, 0),
+        "old history is not current composer authority"
+    );
+    assert!(result.is_err());
+}
+
 #[test]
 fn native_input_buffer_uses_authoritative_message_not_first_quoted_marker() {
     let f = Fixture::new(Mode::Normal);

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

@@ -73,6 +73,7 @@ use crate::transport::{
     SubmitVerification, Target, Transport, TransportError, TurnVerification, WindowName,
 };
 
+mod enter_rescue;
 mod native_input;
 
 pub const PANE_BINDING_NONCE_METADATA_KEY: &str = "TEAM_AGENT_PANE_BINDING_NONCE";
@@ -3848,6 +3849,32 @@ impl Transport for TmuxBackend {
         })
     }
 
+    fn observe_native_input(
+        &self,
+        target: &Target,
+        provider: crate::model::enums::Provider,
+    ) -> Result<Option<crate::transport::native_input::InputFrame>, TransportError> {
+        self.observe_current_native_input(target, provider)
+    }
+
+    fn snapshot_enter_rescue(
+        &self,
+        target: &Target,
+        context: &crate::transport::enter_rescue::EnterRescueContext,
+        rendered_payload: &str,
+    ) -> Result<crate::transport::enter_rescue::EnterRescueContext, TransportError> {
+        self.snapshot_rescue_context(target, context, rendered_payload)
+    }
+
+    fn rescue_enter_guarded(
+        &self,
+        context: &crate::transport::enter_rescue::EnterRescueContext,
+        authorize: &dyn Fn() -> bool,
+        observer: Option<&dyn SubmitObserver>,
+    ) -> Result<crate::transport::enter_rescue::EnterRescueOutcome, TransportError> {
+        self.rescue_guarded_enter(context, authorize, observer)
+    }
+
     fn rescue_enter(&self, evidence: &crate::transport::native_input::NativeInputEvidence, authorize: &dyn Fn() -> bool, observer: Option<&dyn SubmitObserver>)
         -> Result<crate::transport::native_input::EnterRescueOutcome, TransportError>
     {