@team-agent/installer 0.5.117 → 0.5.119

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,
@@ -202,16 +206,27 @@ pub(crate) fn inspect_input(
 ) -> Option<InputFrame> {
     match provider {
         Provider::Pi => pi_input(text, pane_height),
-        Provider::CursorAgent => cursor_input(text),
+        Provider::CursorAgent => cursor_input(text, pane_height),
         _ => None,
     }
 }
 
-fn cursor_input(text: &str) -> Option<InputFrame> {
+fn cursor_input(text: &str, pane_height: u32) -> Option<InputFrame> {
     use team_agent_contract::contract::delivery::InputSurface;
+    if pane_height == 0 {
+        return None;
+    }
+    let text_rows: Vec<_> = text.lines().collect();
+    // Only the current viewport authorizes input; retain full history below
+    // solely for same-message transcript correlation.
+    let viewport_start = text_rows.len().saturating_sub(pane_height as usize);
+    let viewport = text_rows[viewport_start..].join("\n");
     let (surface, rows, capsule, busy) =
-        team_agent_contract::providers::cursor::interaction::inspect_composer(text)?;
-    let first = rows.first()?.strip_prefix("→ ")?;
+        team_agent_contract::providers::cursor::interaction::inspect_legacy_composer(&viewport)?;
+    let first = match *rows.first()? {
+        "→" => "",
+        row => row.strip_prefix("→ ")?,
+    };
     let footer = rows.iter().rposition(|row| {
         row.strip_suffix("Run Everything").is_some_and(|prefix| {
             !prefix.trim().is_empty() && !prefix.trim_start().starts_with("→ ")
@@ -228,9 +243,13 @@ fn cursor_input(text: &str) -> Option<InputFrame> {
     if tail.is_empty() {
         return None;
     }
-    let header: Vec<_> = text.lines().map(str::trim).collect();
-    let version = header.windows(2).find(|pair| pair[0] == "Cursor Agent")?[1];
-    let identity = format!("{version}:{}", input_digest(&tail.join("\n")));
+    // Startup history can leave Tail(200) between Ready/Pasted/Accepted. The
+    // immutable carrier birth/nonce remains in NativeInputBinding; this UI
+    // context is the current native cwd/footer tail, not a version attestation.
+    let identity = format!(
+        "cursor-current-composer-v1:{}",
+        input_digest(&tail.join("\n"))
+    );
     let footer_row = rows[footer]
         .split_whitespace()
         .collect::<Vec<_>>()
@@ -247,10 +266,9 @@ fn cursor_input(text: &str) -> Option<InputFrame> {
             .collect::<Vec<_>>()
             .join("\n")
     };
-    let text_rows: Vec<_> = text.lines().collect();
     let arrow = text_rows
         .iter()
-        .rposition(|line| line.trim().starts_with("→ "))?;
+        .rposition(|line| line.trim() == "→" || line.trim().starts_with("→ "))?;
     Some(InputFrame {
         composer,
         transcript: text.lines().take(arrow).collect::<Vec<_>>().join("\n"),
@@ -544,6 +562,114 @@ mod tests {
         }
     }
 
+    // Native Issue #328 current-composer rows; transcript removed and private
+    // cwd replaced with /owned/project. Startup banner is genuinely absent
+    // from the owned pane's Tail(200), not a fabricated invalid version.
+    const CURSOR_FOLLOWUP: &str =
+        include_str!("../../tests/fixtures/cursor-followup-headerless.txt");
+
+    #[test]
+    fn native_input_cursor_clean_followup_does_not_require_scrolled_startup_banner() {
+        let ready = inspect_input(Provider::CursorAgent, CURSOR_FOLLOWUP).unwrap();
+        assert!(ready.empty());
+        assert!(!ready.busy);
+        assert!(ready.capsule.is_none());
+        let header = format!("Cursor Agent\nv2026.10.14-0f9edde\n{CURSOR_FOLLOWUP}");
+        let with_header = inspect_input(Provider::CursorAgent, &header).unwrap();
+        assert!(with_header.empty() && !with_header.busy);
+        assert_eq!(ready.footer, with_header.footer);
+        assert_eq!(
+            ready.identity, with_header.identity,
+            "startup history is not a new UI identity"
+        );
+    }
+
+    #[test]
+    fn native_input_cursor_headerless_followup_retains_draft_busy_and_footer_fences() {
+        let label = "[Pasted text #2 +25 lines]";
+        let folded = CURSOR_FOLLOWUP.replace("Add a follow-up", label);
+        let draft = inspect_input(Provider::CursorAgent, &folded).unwrap();
+        assert!(!draft.empty());
+        assert_eq!(draft.capsule.as_deref(), Some(label));
+        let dirty = CURSOR_FOLLOWUP.replace("Add a follow-up", "Add a follow-up draft");
+        assert!(!inspect_input(Provider::CursorAgent, &dirty)
+            .unwrap()
+            .empty());
+        for dirty in [
+            CURSOR_FOLLOWUP.replace("Add a follow-up", "Add a follow-up\nforeign draft"),
+            CURSOR_FOLLOWUP.replace("Add a follow-up", &format!("{label}\nforeign draft")),
+        ] {
+            assert!(inspect_input(Provider::CursorAgent, &dirty).is_none());
+        }
+        let busy = CURSOR_FOLLOWUP.replace("Add a follow-up", "Add a follow-up ctrl+c to stop");
+        assert!(inspect_input(Provider::CursorAgent, &busy).unwrap().busy);
+        let working = format!("⠘⠆ Working\n{CURSOR_FOLLOWUP}");
+        assert!(inspect_input(Provider::CursorAgent, &working).unwrap().busy);
+        for unknown in [
+            "→ Add a follow-up\n".to_string(),
+            CURSOR_FOLLOWUP.replace("Run Everything", "unknown footer"),
+            CURSOR_FOLLOWUP.replace("  /owned/project\n", ""),
+        ] {
+            assert!(inspect_input(Provider::CursorAgent, &unknown).is_none());
+        }
+    }
+
+    #[test]
+    fn native_input_cursor_real_expanded_followup_is_nonempty_current_marker_not_capsule() {
+        let expanded = include_str!("../../tests/fixtures/cursor-followup-expanded.txt");
+        let marker = "[team-agent-token:msg_one]";
+        for prefix in [
+            "".to_string(),
+            format!("Cursor Agent\nv2026.10.14-0f9edde\n{CURSOR_FOLLOWUP}"),
+        ] {
+            let text = format!("{prefix}{expanded}");
+            let frame = inspect_input(Provider::CursorAgent, &text).unwrap();
+            assert!(!frame.empty() && !frame.busy);
+            assert!(frame.has_marker(marker));
+            assert!(frame.capsule.is_none());
+            assert!(!frame.transcript.contains(marker));
+            let changed = text.replace("/owned/project", "/different/project");
+            assert_ne!(
+                frame.identity,
+                inspect_input(Provider::CursorAgent, &changed)
+                    .unwrap()
+                    .identity
+            );
+        }
+        let duplicate = expanded.replace(marker, &format!("{marker}\n{marker}"));
+        assert!(!inspect_input(Provider::CursorAgent, &duplicate)
+            .unwrap()
+            .has_marker(marker));
+        let busy = expanded.replace("  →", "⠘⠆ Working\n  →");
+        assert!(inspect_input(Provider::CursorAgent, &busy).unwrap().busy);
+        for unknown in [
+            "→\nGrok 4.7 High Run Everything\n/owned/project\n".to_string(),
+            "→\nforeign draft\n→ Add a follow-up\nGrok 4.7 High Run Everything\n/owned/project\n"
+                .to_string(),
+            expanded.replace("Run Everything", "unknown footer"),
+            expanded.replace("  /owned/project\n", ""),
+            format!("{expanded}{}", "unknown current row\n".repeat(24)),
+        ] {
+            assert!(super::inspect_input(Provider::CursorAgent, &unknown, 24).is_none());
+        }
+    }
+
+    #[test]
+    fn native_input_cursor_requires_composer_in_current_viewport_not_old_history() {
+        for header in ["", "Cursor Agent\nv2026.10.14-0f9edde\n"] {
+            let hidden = format!(
+                "{header}{CURSOR_FOLLOWUP}{}",
+                "unknown current row\n".repeat(24)
+            );
+            assert!(super::inspect_input(Provider::CursorAgent, &hidden, 24).is_none());
+        }
+        assert!(super::inspect_input(Provider::CursorAgent, CURSOR_FOLLOWUP, 0).is_none());
+        let current = super::inspect_input(Provider::CursorAgent, CURSOR_FOLLOWUP, 24).unwrap();
+        let changed = CURSOR_FOLLOWUP.replace("/owned/project", "/different/project");
+        let changed = super::inspect_input(Provider::CursorAgent, &changed, 24).unwrap();
+        assert_ne!(current.identity, changed.identity);
+    }
+
     #[test]
     fn native_input_cursor_separates_folded_draft_from_history_and_busy() {
         let capsule = "[Pasted text #1 +25 lines]";

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

@@ -57,6 +57,8 @@ struct OfflineState {
     /// answer keyed by pane id. Used by leader provider health tests.
     pane_current_commands: BTreeMap<String, String>,
     session_owner: Option<super::SessionOwner>,
+    native_input_observation: Option<super::native_input::InputFrame>,
+    native_input_error: Option<String>,
 }
 
 impl Default for OfflineState {
@@ -85,6 +87,8 @@ impl Default for OfflineState {
             capture_ranges: Vec::new(),
             pane_current_commands: BTreeMap::new(),
             session_owner: None,
+            native_input_observation: None,
+            native_input_error: None,
         }
     }
 }
@@ -95,6 +99,16 @@ pub struct OfflineTransport {
 }
 
 impl OfflineTransport {
+    pub fn with_native_input_observation(self, frame: super::native_input::InputFrame) -> Self {
+        self.with_state(|state| state.native_input_observation = Some(frame));
+        self
+    }
+
+    pub fn with_native_input_error(self, reason: &str) -> Self {
+        self.with_state(|state| state.native_input_error = Some(reason.into()));
+        self
+    }
+
     pub fn new() -> Self {
         Self::default()
     }
@@ -434,6 +448,17 @@ impl OfflineTransport {
 }
 
 impl Transport for OfflineTransport {
+    fn observe_native_input(
+        &self,
+        _target: &Target,
+        _provider: crate::model::enums::Provider,
+    ) -> Result<Option<super::native_input::InputFrame>, TransportError> {
+        self.with_state(|state| match &state.native_input_error {
+            Some(reason) => Err(TransportError::NativeInputNotReady { reason: reason.clone() }),
+            None => Ok(state.native_input_observation.clone()),
+        })
+    }
+
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
     }

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

@@ -67,6 +67,7 @@ use std::path::{Path, PathBuf};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
+pub mod enter_rescue;
 pub mod native_input;
 
 #[cfg(test)]
@@ -989,6 +990,39 @@ pub trait Transport: Send + Sync {
         Ok(report)
     }
 
+    /// Observation only; None means this backend/provider has no native parser.
+    /// An implemented parser with an incomplete frame returns an error, not absence.
+    fn observe_native_input(
+        &self,
+        _target: &Target,
+        _provider: crate::model::enums::Provider,
+    ) -> Result<Option<native_input::InputFrame>, TransportError> {
+        Ok(None)
+    }
+
+    /// Snapshot the original attempted target without submitting or adopting a capsule.
+    fn snapshot_enter_rescue(
+        &self,
+        _target: &Target,
+        context: &enter_rescue::EnterRescueContext,
+        _rendered_payload: &str,
+    ) -> Result<enter_rescue::EnterRescueContext, TransportError> {
+        Ok(context.clone())
+    }
+
+    /// Independent delayed Enter-only watchdog, not native-input admission.
+    fn rescue_enter_guarded(
+        &self,
+        _context: &enter_rescue::EnterRescueContext,
+        _authorize: &dyn Fn() -> bool,
+        _observer: Option<&dyn SubmitObserver>,
+    ) -> Result<enter_rescue::EnterRescueOutcome, TransportError> {
+        Ok(enter_rescue::EnterRescueOutcome::NoEffect {
+            reason: "unsupported_backend",
+            reobserve: false,
+        })
+    }
+
     /// Enter-only recovery; unsupported backends have an explicit zero-effect refusal.
     fn rescue_enter(&self, _evidence: &native_input::NativeInputEvidence, _authorize: &dyn Fn() -> bool, _observer: Option<&dyn SubmitObserver>)
         -> Result<native_input::EnterRescueOutcome, TransportError>

package/package.json

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