@team-agent/installer 0.5.118 → 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.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>
     {

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

@@ -0,0 +1,166 @@
+//! Independent watchdog receipts. Registration is unconditional; key authority is not.
+
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+use crate::model::enums::Provider;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EnterRescueContext {
+    pub message_id: String,
+    pub owner_team_id: String,
+    pub recipient: String,
+    pub payload_sha256: String,
+    pub target: Option<EnterRescueTarget>,
+    pub proof: Option<EnterRescueProof>,
+}
+
+impl EnterRescueContext {
+    pub fn marker(&self) -> String {
+        format!("[team-agent-token:{}]", self.message_id)
+    }
+
+    /// Binds an opaque-paste receipt to this message and this original carrier.
+    pub fn scope_sha256(&self) -> Option<String> {
+        let bytes = serde_json::to_vec(&(
+            &self.message_id,
+            &self.owner_team_id,
+            &self.recipient,
+            &self.payload_sha256,
+            &self.target,
+        ))
+        .ok()?;
+        Some(format!("{:x}", Sha256::digest(bytes)))
+    }
+
+    pub fn valid_proof(&self) -> bool {
+        self.proof.as_ref().is_some_and(|proof| {
+            proof.valid()
+                && proof.owned_capsule.as_ref().is_none_or(|capsule| {
+                    capsule.valid() && self.scope_sha256().as_ref() == Some(&capsule.scope_sha256)
+                })
+        })
+    }
+
+    pub fn valid_message(&self) -> bool {
+        self.message_id.starts_with("msg_")
+            && self
+                .message_id
+                .bytes()
+                .all(|b| b.is_ascii_alphanumeric() || b == b'_')
+            && !self.owner_team_id.is_empty()
+            && !self.recipient.is_empty()
+            && self.recipient != "leader"
+            && valid_digest(&self.payload_sha256)
+    }
+}
+
+/// `selected` records canonical original routing, not a late adoption of a pane.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EnterRescueTarget {
+    pub provider: Provider,
+    pub endpoint: String,
+    pub pane_id: String,
+    pub pane_pid: u32,
+    pub pane_height: u32,
+    pub carrier_birth: String,
+    pub binding_nonce: String,
+    pub session: String,
+    pub window: String,
+}
+
+impl EnterRescueTarget {
+    pub fn selected(
+        provider: Provider,
+        pane_id: String,
+        pane_pid: u32,
+        session: String,
+        window: String,
+    ) -> Self {
+        Self {
+            provider,
+            pane_id,
+            pane_pid,
+            session,
+            window,
+            endpoint: String::new(),
+            pane_height: 0,
+            carrier_birth: String::new(),
+            binding_nonce: String::new(),
+        }
+    }
+
+    pub fn same_selection(&self, other: &Self) -> bool {
+        self.provider == other.provider
+            && self.pane_id == other.pane_id
+            && self.pane_pid == other.pane_pid
+            && self.session == other.session
+            && self.window == other.window
+    }
+
+    pub fn bound(&self) -> bool {
+        std::path::Path::new(&self.endpoint).is_absolute()
+            && self.pane_id.starts_with('%')
+            && self.pane_pid > 1
+            && self.pane_height >= 10
+            && !self.carrier_birth.is_empty()
+            && !self.binding_nonce.is_empty()
+            && !self.session.is_empty()
+            && !self.window.is_empty()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EnterRescueProof {
+    pub ui_identity: String,
+    pub footer_sha256: String,
+    pub visible_marker: bool,
+    pub transcript_marker_absent: bool,
+    pub owned_capsule: Option<OwnedCapsule>,
+}
+
+impl EnterRescueProof {
+    pub fn valid(&self) -> bool {
+        !self.ui_identity.is_empty()
+            && valid_digest(&self.footer_sha256)
+            && (self.visible_marker || self.owned_capsule.as_ref().is_some_and(OwnedCapsule::valid))
+    }
+}
+
+/// Only a prior empty-baseline/single-owned-paste transition may create this.
+/// Snapshotting a visible capsule label alone never creates ownership.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct OwnedCapsule {
+    pub scope_sha256: String,
+    pub label: String,
+    pub baseline_sha256: String,
+    pub baseline_capsules: Vec<String>,
+    pub observed_after_owned_paste: bool,
+}
+
+impl OwnedCapsule {
+    pub fn valid(&self) -> bool {
+        self.observed_after_owned_paste
+            && valid_digest(&self.scope_sha256)
+            && !self.label.is_empty()
+            && self.label.len() <= 80
+            && valid_digest(&self.baseline_sha256)
+            && !self.baseline_capsules.contains(&self.label)
+    }
+}
+
+fn valid_digest(value: &str) -> bool {
+    value.len() == 64 && value.bytes().all(|b| b.is_ascii_hexdigit())
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EnterRescueOutcome {
+    Consumed,
+    NoEffect {
+        reason: &'static str,
+        reobserve: bool,
+    },
+    Entered {
+        accepted: bool,
+    },
+}

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

@@ -131,7 +131,7 @@ pub(crate) fn record_evidence(evidence: &NativeInputEvidence) {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct InputFrame {
+pub struct InputFrame {
     pub composer: String,
     pub transcript: String,
     pub identity: String,
@@ -195,6 +195,10 @@ fn input_digest(text: &str) -> String {
     format!("{:x}", Sha256::digest(text.as_bytes()))
 }
 
+pub(crate) fn supports_input_observation(provider: Provider) -> bool {
+    matches!(provider, Provider::Pi | Provider::CursorAgent)
+}
+
 pub(crate) fn inspect_input(
     provider: Provider,
     text: &str,