@team-agent/installer 0.3.23 → 0.3.24

package/crates/team-agent/src/state/projection.rs

@@ -298,6 +298,11 @@ pub fn project_top_level_view(state: &Value, team_key: &str) -> Value {
         team_entry_from_state(state, team_key).and_then(Value::as_object).cloned().unwrap_or_default();
     let mut p = entry_obj.clone(); // projection = deepcopy(entry)
     // setdefault session_name/team_dir ← entry.get(...)(缺则插,值可为 null)。
+    // **0.3.24 excision** (U1-A real-machine RED v2): the ff38ab9 root-state
+    // `or_else` fallback was reverted along with the wave-2 U1-A drift fallback,
+    // since this projection change had no other consumer. v0.3.25 will re-introduce
+    // this together with the writer-shape + rediscover-writer fix — see
+    // `.team/artifacts/u1-a-realmachine-v2-fix-or-excise.md`.
     if !p.contains_key("session_name") {
         p.insert("session_name".to_string(), entry_obj.get("session_name").cloned().unwrap_or(Value::Null));
     }

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

@@ -526,6 +526,52 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
         );
     }
 
+    #[test]
+    fn inject_waits_for_token_visibility_before_enter() {
+        let text = "hello [team-agent-token:e31]".to_string();
+        let marker_visible = format!("{text}\n");
+        let (be, rec) = backend_with(
+            MockResp::Out(ok("")),
+            vec![
+                MockResp::Out(ok("")), // set-buffer
+                MockResp::Out(ok("")), // paste-buffer
+                MockResp::Out(ok("")), // delete-buffer
+                MockResp::Out(ok("")), // pasted-content prompt poll 1
+                MockResp::Out(ok("")), // pasted-content prompt poll 2
+                MockResp::Out(ok("")), // pasted-content prompt poll 3
+                MockResp::Out(ok("")), // pasted-content prompt poll 4
+                MockResp::Out(ok("")), // pasted-content prompt poll 5
+                MockResp::Out(ok("")), // token gate: not visible yet
+                MockResp::Out(ok("")), // token gate: still not visible
+                MockResp::Out(ok(&marker_visible)), // token gate: visible, Enter may fire
+                MockResp::Out(ok("")), // send-keys Enter
+            ],
+        );
+
+        let report = be
+            .inject(&Target::Pane(PaneId::new("%7")), &InjectPayload::Text(text), Key::Enter, true)
+            .expect("inject");
+        let calls = rec.lock().unwrap().clone();
+        let submit_index = calls
+            .iter()
+            .position(|argv| argv.get(1).map(String::as_str) == Some("send-keys"))
+            .expect("inject must eventually send Enter");
+        let captures_before_submit = calls[..submit_index]
+            .iter()
+            .filter(|argv| argv.get(1).map(String::as_str) == Some("capture-pane"))
+            .count();
+
+        assert!(
+            captures_before_submit >= super::PASTED_CONTENT_APPEAR_POLLS as usize + 3,
+            "Enter must wait until the pasted token is visible; calls={calls:?}"
+        );
+        assert_eq!(report.inject_verification, InjectVerification::CaptureContainsToken);
+        assert_eq!(
+            report.submit_verification,
+            SubmitVerification::EnterSentWithoutPlaceholderCheck
+        );
+    }
+
     #[test]
     fn send_keys_cancel_mode_queries_mode_and_dispatches_cancel_argv() {
         let (be, rec) = backend_with(

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

@@ -845,16 +845,28 @@ fn token_visible_in_capture(
     }
 }
 
-/// U1 #7: capture the pane just before submit and report whether the just-pasted
-/// token marker is actually visible. `Ok(None)` for non-token payloads (nothing to
-/// check). `Ok(Some(false))` means the paste silently dropped — a false-positive that
-/// the static `inject_verification_for_payload` would have reported as success.
+/// U1 #7 / E31: wait briefly for the just-pasted token marker before submitting.
+/// `Ok(None)` for non-token payloads (nothing to check). `Ok(Some(false))` means the
+/// paste did not become visible before the Python-parity fallback delay.
 fn pre_submit_token_visible(
     backend: &TmuxBackend,
     target: &Target,
     payload: &InjectPayload,
 ) -> Result<Option<bool>, TransportError> {
-    token_visible_in_capture(backend, target, payload)
+    if payload_token_marker(payload).is_none() {
+        return Ok(None);
+    }
+    for attempt in 0..PASTED_CONTENT_APPEAR_POLLS {
+        if let Some(true) = token_visible_in_capture(backend, target, payload)? {
+            return Ok(Some(true));
+        }
+        if attempt + 1 < PASTED_CONTENT_APPEAR_POLLS {
+            std::thread::sleep(Duration::from_millis(25));
+        }
+    }
+    // Python waits 250ms between paste-buffer and Enter to let bracketed paste settle.
+    std::thread::sleep(Duration::from_millis(250));
+    Ok(Some(false))
 }
 
 const TOKEN_POST_SUBMIT_READBACK_POLLS: u32 = 5;

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

@@ -37,6 +37,18 @@ struct OfflineState {
     inject_targets: Vec<Target>,
     inject_payloads: Vec<String>,
     tmux_endpoint: Option<String>,
+    /// U1-B contract: when set, `list_targets()` returns `TransportError::MuxUnavailable`
+    /// — used to model tmux server jitter (subprocess-fork-failed level). The whole
+    /// resolve must DEFER, not silently coerce to an empty vec.
+    list_targets_error: Option<String>,
+    /// U1-C / general: pre-staged `capture()` payload, keyed by target stringification.
+    /// `Target::Pane(p)` keys as `p.as_str()`; `Target::SessionWindow{session,window}`
+    /// keys as `format!("{session}:{window}")`. A miss returns empty text (current
+    /// default behaviour).
+    capture_text: BTreeMap<String, String>,
+    /// U1-C Tail-peek contract: every `capture()` call records its `CaptureRange`,
+    /// in order, so a test can prove the delivery peek site narrowed Full → Tail(80).
+    capture_ranges: Vec<CaptureRange>,
 }
 
 impl Default for OfflineState {
@@ -57,6 +69,9 @@ impl Default for OfflineState {
             inject_targets: Vec::new(),
             inject_payloads: Vec::new(),
             tmux_endpoint: None,
+            list_targets_error: None,
+            capture_text: BTreeMap::new(),
+            capture_ranges: Vec::new(),
         }
     }
 }
@@ -127,6 +142,40 @@ impl OfflineTransport {
         self
     }
 
+    /// U1-B: stage a `list_targets()` error to model tmux server jitter. While set,
+    /// every call returns `Err(TransportError::MuxUnavailable{detail})`. Pass an
+    /// empty string to clear via re-builder if needed.
+    pub fn with_list_targets_error(self, detail: impl Into<String>) -> Self {
+        self.with_state(|state| state.list_targets_error = Some(detail.into()));
+        self
+    }
+
+    /// Pre-stage `capture()` output for a `Target::Pane(pane_id)` key.
+    pub fn with_capture_for_pane(
+        self,
+        pane_id: impl Into<String>,
+        text: impl Into<String>,
+    ) -> Self {
+        self.with_state(|state| {
+            state.capture_text.insert(pane_id.into(), text.into());
+        });
+        self
+    }
+
+    /// Pre-stage `capture()` output for a `Target::SessionWindow{session,window}` key.
+    pub fn with_capture_for_session_window(
+        self,
+        session: impl Into<String>,
+        window: impl Into<String>,
+        text: impl Into<String>,
+    ) -> Self {
+        let key = format!("{}:{}", session.into(), window.into());
+        self.with_state(|state| {
+            state.capture_text.insert(key, text.into());
+        });
+        self
+    }
+
     pub fn calls(&self) -> Vec<&'static str> {
         self.with_state(|state| state.calls.clone())
     }
@@ -163,6 +212,12 @@ impl OfflineTransport {
         self.with_state(|state| state.inject_payloads.clone())
     }
 
+    /// All `capture()` ranges observed, in call order. Used by U1-C Tail-peek
+    /// contracts to prove the delivery peek site requested Tail rather than Full.
+    pub fn capture_ranges(&self) -> Vec<CaptureRange> {
+        self.with_state(|state| state.capture_ranges.clone())
+    }
+
     fn record(&self, call: &'static str) {
         self.with_state(|state| state.calls.push(call));
     }
@@ -294,11 +349,21 @@ impl Transport for OfflineTransport {
 
     fn capture(
         &self,
-        _target: &Target,
+        target: &Target,
         range: CaptureRange,
     ) -> Result<CapturedText, TransportError> {
-        self.record("capture");
-        Ok(CapturedText { text: String::new(), range })
+        let key = match target {
+            Target::Pane(p) => p.as_str().to_string(),
+            Target::SessionWindow { session, window } => {
+                format!("{}:{}", session.as_str(), window.as_str())
+            }
+        };
+        let text = self.with_state(|state| {
+            state.calls.push("capture");
+            state.capture_ranges.push(range);
+            state.capture_text.get(&key).cloned().unwrap_or_default()
+        });
+        Ok(CapturedText { text, range })
     }
 
     fn query(
@@ -329,10 +394,18 @@ impl Transport for OfflineTransport {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(self.with_state(|state| {
+        // U1-B: when `with_list_targets_error` is set, return a real Err so the
+        // caller sees server jitter rather than a coerced empty vec.
+        if let Some(detail) = self.with_state(|state| {
             state.calls.push("list_targets");
-            state.targets.clone()
-        }))
+            state.list_targets_error.clone()
+        }) {
+            return Err(TransportError::MuxUnavailable {
+                backend: BackendKind::Tmux,
+                detail,
+            });
+        }
+        Ok(self.with_state(|state| state.targets.clone()))
     }
 
     fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {

package/package.json

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