@team-agent/installer 0.3.23 → 0.3.25

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,303 @@ 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
+        );
+    }
+
+    // ═════════════════════════════════════════════════════════════════════════════
+    // E46 0.3.24 task#327 P0 — submit verification false-positive / false-negative.
+    //
+    // Architect + Workflow C1: do NOT flip `EnterSentWithoutPlaceholderCheck =>
+    // false` (breaks MUST-10 in provider_submit_verification_red.rs:113-159).
+    // Instead introduce SubmitConsumptionUnverified and only emit it from the
+    // bracketed-paste / Enter path when post-Enter input consumption is NOT
+    // observed within a bounded resend cap.
+    //
+    // Real-machine truth source (macmini): a fresh claude TUI's bracketed
+    // paste swallows the framework's Enter as paste content; the framework
+    // must (a) send Escape first to exit the paste bracket and (b) verify
+    // post-Enter consumption by structural input-empty probe (token marker
+    // no longer in the bottom 5 lines of the pane = composer cleared).
+    // ═════════════════════════════════════════════════════════════════════════════
+
+    /// **E46 RED-1 (核心假阳)**: token-bearing Text + Enter + bracketed paste.
+    /// Token is visible in the pane after submit AND remains in the bottom of
+    /// the pane (input region — consumption was NOT observed). Submit must
+    /// report `SubmitConsumptionUnverified`, NOT
+    /// `EnterSentWithoutPlaceholderCheck`. Otherwise delivery emits delivered
+    /// + message.delivered (假阳) even though the worker never consumed it.
+    #[test]
+    fn e46_inject_text_with_token_unconsumed_in_tail_reports_submit_consumption_unverified() {
+        // Mock always returns the token in the captured tail — simulates the
+        // macmini fresh claude TUI where the paste lands but the input never
+        // clears (Enter swallowed by bracketed-paste).
+        let token_text = "Team Agent message from leader:\n\nhi\n\n[team-agent-token:msg_red1]";
+        let (be, _rec) = backend_with(MockResp::Out(ok(token_text)), vec![]);
+        let report = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::Text(token_text.to_string()),
+                Key::Enter,
+                true,
+            )
+            .expect("inject runs");
+        assert_eq!(
+            report.submit_verification,
+            SubmitVerification::SubmitConsumptionUnverified,
+            "E46 RED-1: when token remains in the pane input region after \
+             Enter + resend cap, transport must report SubmitConsumptionUnverified \
+             (not EnterSentWithoutPlaceholderCheck which delivery treats as \
+             delivered). Got {:?}",
+            report.submit_verification
+        );
+        // turn_verification stays NotYetObserved (Gap42: metadata only).
+        assert_eq!(report.turn_verification, TurnVerification::NotYetObserved);
+    }
+
+    /// **E46 RED-2 (正向消费确认 → delivered)**: token-bearing Text + Enter +
+    /// bracketed paste. Token VISIBLE on first capture (pre/post-submit token
+    /// readback) BUT then GONE from the post-submit input-consumption probe
+    /// (composer cleared after Enter). Submit must report
+    /// `EnterSentWithoutPlaceholderCheck` (MUST-10 path) — delivery proceeds
+    /// to delivered. Guards against regression on crd's existing-worker path.
+    #[test]
+    fn e46_inject_text_with_token_consumed_after_enter_keeps_enter_sent_without_placeholder_check() {
+        let token_text = "Team Agent message from leader:\n\nhi\n\n[team-agent-token:msg_red2]";
+        // First captures (token visibility probes pre/post-Enter) return text
+        // with token; the LAST capture (consumption probe) returns text WITHOUT
+        // the token in the tail (composer cleared). MockCommandRunner drains
+        // `queued` first then defaults — we queue the early "token visible"
+        // captures, then drop to the empty default for the consumption probe.
+        let visible = ok(token_text);
+        let queued = vec![
+            MockResp::Out(ok("")),                // set-buffer
+            MockResp::Out(ok("")),                // paste-buffer
+            MockResp::Out(ok("")),                // delete-buffer
+            MockResp::Out(visible.clone()),        // pasted-content prompt poll: none → continue
+            MockResp::Out(visible.clone()),        // pre-submit token visibility: visible
+            MockResp::Out(ok("")),                // Escape send-keys (no stdout needed)
+            MockResp::Out(ok("")),                // Enter send-keys
+            // From here on, the default response is `ok("")` (empty pane tail) so
+            // post-Enter consumption probe sees no token in tail → consumed=true.
+        ];
+        let (be, _rec) = backend_with(MockResp::Out(ok("")), queued);
+        let report = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::Text(token_text.to_string()),
+                Key::Enter,
+                true,
+            )
+            .expect("inject runs");
+        assert_eq!(
+            report.submit_verification,
+            SubmitVerification::EnterSentWithoutPlaceholderCheck,
+            "E46 RED-2: when post-Enter consumption is observed (token gone \
+             from input region tail), submit must report the canonical \
+             EnterSentWithoutPlaceholderCheck so MUST-10 delivery semantics \
+             hold (provider_submit_verification_red.rs:113-159). Got {:?}",
+            report.submit_verification
+        );
+    }
+
+    /// **E46 RED-3 (resend-to-cap, no double-submit)**: when the FIRST Enter
+    /// landed on the composer but our readback was slow, the re-check BEFORE
+    /// resend must observe the now-empty input and STOP — must NOT fire a
+    /// second Enter into an empty composer (would open an empty turn).
+    #[test]
+    fn e46_inject_text_resend_rechecks_input_before_resending_to_avoid_double_submit() {
+        // Same mock as RED-2: post-Enter consumption probe sees empty tail.
+        // The implementation should issue only ONE Enter (no resend) once
+        // consumption is observed.
+        let token_text = "Team Agent message from leader:\n\nhi\n\n[team-agent-token:msg_red3]";
+        let queued = vec![
+            MockResp::Out(ok("")),                // set-buffer
+            MockResp::Out(ok("")),                // paste-buffer
+            MockResp::Out(ok("")),                // delete-buffer
+            MockResp::Out(ok(token_text)),         // pasted-content prompt: not matched
+            MockResp::Out(ok(token_text)),         // pre-submit token visibility
+            MockResp::Out(ok("")),                // Escape
+            MockResp::Out(ok("")),                // Enter
+        ];
+        let (be, rec) = backend_with(MockResp::Out(ok("")), queued);
+        let _report = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::Text(token_text.to_string()),
+                Key::Enter,
+                true,
+            )
+            .expect("inject runs");
+        let calls = rec.lock().unwrap().clone();
+        // Count `send-keys ... Enter` invocations. There must be EXACTLY ONE
+        // (the canonical submit). A second one indicates the resend loop
+        // didn't honour C3 (re-check input before resend).
+        let enter_count = calls
+            .iter()
+            .filter(|argv| {
+                argv.get(1).map(String::as_str) == Some("send-keys")
+                    && argv.contains(&"Enter".to_string())
+            })
+            .count();
+        assert_eq!(
+            enter_count, 1,
+            "E46 RED-3: when consumption is observed (or already happened \
+             between Enter and probe), the resend loop must STOP and NOT \
+             issue a second Enter. Got {enter_count} Enter sends. \
+             calls={calls:?}"
+        );
+    }
+
+    /// **E46 RED-5 (provider-agnostic detector)**: the consumption probe must
+    /// NOT hard-code provider UI strings (claude `>`, codex `╰`, ...). It uses
+    /// the token marker absence in the bottom of the pane — works for any
+    /// provider. Here we run a non-claude-shaped pane (no claude markers) and
+    /// confirm the same delivered semantics when consumption happens.
+    #[test]
+    fn e46_consumption_detector_works_on_codex_shaped_pane_without_provider_strings() {
+        // Codex-shaped fake: prompt looks like `codex>` with no claude markers.
+        // After Enter, the composer clears (empty default returns ok("")).
+        let token_text =
+            "Team Agent message from leader:\n\ncodex msg\n\n[team-agent-token:msg_red5]";
+        let queued = vec![
+            MockResp::Out(ok("")),                // set-buffer
+            MockResp::Out(ok("")),                // paste-buffer
+            MockResp::Out(ok("")),                // delete-buffer
+            MockResp::Out(ok("codex>\n")),         // pasted-content prompt: no match
+            MockResp::Out(ok(token_text)),         // pre-submit token visibility
+            MockResp::Out(ok("")),                // Escape
+            MockResp::Out(ok("")),                // Enter
+            // post-Enter: default returns ok("") (composer cleared) → token gone
+        ];
+        let (be, _rec) = backend_with(MockResp::Out(ok("")), queued);
+        let report = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::Text(token_text.to_string()),
+                Key::Enter,
+                true,
+            )
+            .expect("inject runs");
+        assert_eq!(
+            report.submit_verification,
+            SubmitVerification::EnterSentWithoutPlaceholderCheck,
+            "E46 RED-5: provider-agnostic detector — codex-shaped pane (no \
+             claude UI string) where composer clears post-Enter must still \
+             report EnterSentWithoutPlaceholderCheck via structural \
+             input-empty check. Got {:?}",
+            report.submit_verification
+        );
+    }
+
+    /// **E46 Escape pre-Enter**: when bracketed=true + Text payload + submit=Enter,
+    /// the inject must send Escape BEFORE the Enter (exits bracketed-paste
+    /// mode on stuck composer). Non-Enter submits (e.g. Key::Down for codex
+    /// menu) must NOT receive the Escape pre-step.
+    #[test]
+    fn e46_inject_text_enter_emits_escape_before_enter_on_bracketed_paste() {
+        let token_text = "Team Agent message from leader:\n\nhi\n\n[team-agent-token:msg_esc]";
+        let (be, rec) = backend_with(MockResp::Out(ok("")), vec![]);
+        let _report = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::Text(token_text.to_string()),
+                Key::Enter,
+                true,
+            )
+            .expect("inject runs");
+        let calls = rec.lock().unwrap().clone();
+        let escape_idx = calls.iter().position(|argv| {
+            argv.get(1).map(String::as_str) == Some("send-keys")
+                && argv.contains(&"Escape".to_string())
+        });
+        let enter_idx = calls.iter().position(|argv| {
+            argv.get(1).map(String::as_str) == Some("send-keys")
+                && argv.contains(&"Enter".to_string())
+        });
+        let escape_idx = escape_idx.expect("E46: bracketed text + Enter must send Escape pre-step");
+        let enter_idx = enter_idx.expect("E46: must still send the final Enter");
+        assert!(
+            escape_idx < enter_idx,
+            "E46: Escape must be sent BEFORE Enter (closes bracketed-paste \
+             so Enter is interpreted as submit). escape_idx={escape_idx} \
+             enter_idx={enter_idx} calls={calls:?}"
+        );
+    }
+
+    /// **E46 regression guard**: non-Enter submit (codex menu navigation,
+    /// `Key::Down`) does NOT trigger the Escape pre-step (would interfere
+    /// with the menu).
+    #[test]
+    fn e46_inject_text_non_enter_submit_does_not_emit_escape_prestep() {
+        let token_text = "menu interaction\n[team-agent-token:msg_down]";
+        let (be, rec) = backend_with(MockResp::Out(ok("")), vec![]);
+        let _report = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::Text(token_text.to_string()),
+                Key::Down,
+                true,
+            )
+            .expect("inject runs");
+        let calls = rec.lock().unwrap().clone();
+        let escape_count = calls
+            .iter()
+            .filter(|argv| {
+                argv.get(1).map(String::as_str) == Some("send-keys")
+                    && argv.contains(&"Escape".to_string())
+            })
+            .count();
+        assert_eq!(
+            escape_count, 0,
+            "E46 regression guard: Key::Down submits (codex menu navigation) \
+             must NOT receive Escape pre-step. Got {escape_count}. \
+             calls={calls:?}"
+        );
+    }
+
     #[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;
@@ -915,6 +927,51 @@ fn capture_has_pasted_content_prompt(text: &str) -> bool {
 const PASTED_CONTENT_APPEAR_POLLS: u32 = 5;
 const PASTED_CONTENT_SUBMIT_ATTEMPTS: u32 = 3;
 
+/// E46 (0.3.24 bug#5): bounded resend cap for post-Enter consumption probe.
+/// Mirrors PASTED_CONTENT_SUBMIT_ATTEMPTS shape: try Enter then bounded
+/// re-checks of the pane's input region. Each iteration first re-checks that
+/// the input still has content before resending Enter — guards against double
+/// submission when the first Enter was consumed but our readback was slow.
+const POST_SUBMIT_CONSUMPTION_ATTEMPTS: u32 = 3;
+const POST_SUBMIT_CONSUMPTION_POLL_MS: u64 = 60;
+
+/// E46 (0.3.24 bug#5, C5 provider-agnostic detector): the pane's input region
+/// is "consumed" when the token text that was just visible BEFORE the Enter
+/// is no longer present in the captured tail. Structural signal — no
+/// provider-specific UI string. Works across claude / codex / copilot because
+/// every provider's composer clears the input area after a successful submit
+/// (the content scrolls into history, leaving the prompt empty).
+///
+/// Returns:
+///   * `Some(true)`  — token was visible BEFORE submit and is GONE from
+///     the visible input area now → consumption confirmed.
+///   * `Some(false)` — token still visible (or other reason to think not yet
+///     consumed).
+///   * `None` — payload has no token marker (peer message without token,
+///     empty payload) so we can't structurally check; caller treats this as
+///     non-blocking (the pre-existing `EnterSentWithoutPlaceholderCheck`
+///     path).
+fn post_submit_input_consumed(
+    backend: &TmuxBackend,
+    target: &Target,
+    payload: &InjectPayload,
+) -> Result<Option<bool>, TransportError> {
+    let Some(marker) = payload_token_marker(payload) else {
+        return Ok(None);
+    };
+    let captured = backend.capture(target, CaptureRange::Tail(30))?;
+    // The token may legitimately appear in scrollback (a successful submit
+    // pushes it into history). We only treat the BOTTOM-of-pane region (last
+    // few lines, where the input area lives) as the consumption signal. Tail
+    // 30 lines is small enough that the input area still dominates if the
+    // submit didn't go through, while a successful submit has pushed the
+    // token marker out of the bottom 5 lines by the time the response
+    // composer redraws.
+    let tail_lines: Vec<&str> = captured.text.lines().rev().take(5).collect();
+    let token_in_tail = tail_lines.iter().any(|line| line.contains(marker));
+    Ok(Some(!token_in_tail))
+}
+
 fn shell_command(
     argv: &[String],
     cwd: &Path,
@@ -1105,11 +1162,94 @@ impl Transport for TmuxBackend {
                 // downgrade to CaptureMissingToken.
                 token_visible_for_report =
                     pre_submit_token_visible(self, target, payload).unwrap_or(None);
+                // E46 (0.3.24 bug#5, demo-director卡 bracketed paste root cause):
+                // bracketed-paste-mode on a fresh provider TUI swallows the framework's
+                // Enter as paste content. Send `Escape` first to exit the paste bracket
+                // so the subsequent Enter is interpreted as submit. Safe across
+                // claude/codex/copilot: Escape on an empty composer is a no-op
+                // (cancel any pending mode), it only matters when bracketed-paste is
+                // actually open. Architect-approved + macmini real-machine verified.
+                // Only Enter benefits — explicit menu navigation (Key::Down etc.)
+                // should not pre-cancel mode.
+                if bracketed
+                    && matches!(payload, InjectPayload::Text(_))
+                    && matches!(submit, Key::Enter)
+                {
+                    let escape_argv = tmux_send_keys_argv(&pane, &[Key::Escape]);
+                    // We don't fail the whole inject on Escape error — Escape failure
+                    // would surface downstream as the same SubmitConsumptionUnverified
+                    // when post-Enter probe still sees the token in the input region.
+                    let _ = self.run_inject_stage(&escape_argv, InjectStage::Submit);
+                }
                 self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
                 if matches!(token_visible_for_report, Some(false)) {
                     token_visible_for_report =
                         post_submit_token_visible(self, target, payload).unwrap_or(Some(false));
                 }
+                // E46 C2 + C3: post-Enter consumption gate with bounded resend cap.
+                // Only fires for:
+                //   - submit key == Enter (other keys like Down/Up are explicit
+                //     menu navigation; codex uses `Down Enter` to dismiss a
+                //     prompt — those carry their own verification semantics
+                //     via KeySentAfterVisibleToken),
+                //   - token-bearing Text payloads (the structural input-empty
+                //     signal needs a token marker to anchor on).
+                // Each iteration RE-CHECKS that the input still contains the
+                // token BEFORE resending Enter — guards against the C3
+                // double-submit hazard when the first Enter was consumed but
+                // our readback was slow to catch the empty-input state.
+                let mut consumption_attempts: u32 = 1;
+                let mut consumed = if matches!(submit, Key::Enter) {
+                    post_submit_input_consumed(self, target, payload).unwrap_or(None)
+                } else {
+                    None
+                };
+                if matches!(consumed, Some(false)) {
+                    for _ in 1..POST_SUBMIT_CONSUMPTION_ATTEMPTS {
+                        std::thread::sleep(Duration::from_millis(
+                            POST_SUBMIT_CONSUMPTION_POLL_MS,
+                        ));
+                        // C3 critical: re-check BEFORE resending. If the input
+                        // is now empty (= first Enter actually consumed, just
+                        // observable now), DO NOT resend — bumping a spurious
+                        // empty Enter would open an empty turn.
+                        consumed = post_submit_input_consumed(self, target, payload)
+                            .unwrap_or(None);
+                        if !matches!(consumed, Some(false)) {
+                            break;
+                        }
+                        consumption_attempts += 1;
+                        let _ = self.run_inject_stage(&submit_argv, InjectStage::Submit);
+                    }
+                }
+                let submit_verification = match consumed {
+                    // Consumption confirmed → MUST-10 path: keep the canonical
+                    // EnterSentWithoutPlaceholderCheck so the existing
+                    // provider_submit_verification_red contract holds.
+                    Some(true) => SubmitVerification::EnterSentWithoutPlaceholderCheck,
+                    // Consumption explicitly NOT observed (token still in tail
+                    // after resend cap) → E46's new variant. Delivery treats
+                    // as not delivered.
+                    Some(false) => SubmitVerification::SubmitConsumptionUnverified,
+                    // No structural anchor (non-token payload) → preserve the
+                    // historic non-checked variant; the pre-existing
+                    // pre/post-submit token readback + U1 #7 cover the other
+                    // false-positive (silent paste drop).
+                    None => submit_verification_for_key(submit),
+                };
+                return Ok(InjectReport {
+                    stage_reached: InjectStage::Submit,
+                    inject_verification: inject_verification_after_readback(
+                        payload,
+                        token_visible_for_report,
+                    ),
+                    submit_verification,
+                    turn_verification: match payload {
+                        InjectPayload::Empty => TurnVerification::NotRequired,
+                        InjectPayload::Text(_) => TurnVerification::NotYetObserved,
+                    },
+                    attempts: consumption_attempts,
+                });
             }
         }
         Ok(InjectReport {

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> {