@team-agent/installer 0.3.25 → 0.3.27

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

@@ -642,9 +642,15 @@ impl TmuxBackend {
     ) -> Result<SpawnResult, TransportError> {
         let command = shell_command(argv, cwd, env, env_unset);
         let target = format!("{}:{}", session.as_str(), window.as_str());
+        // E53 (0.3.26, adaptive layout same-session tabs): `-d` prevents the
+        // new split pane from stealing focus from the leader's active pane.
+        // Same rationale as the `-d` on `new-window` in transport.rs; for
+        // adaptive layout the leader and all workers share the same tmux
+        // session, and every focus-stealing spawn is a disruption.
         let split_argv = vec![
             "tmux".to_string(),
             "split-window".to_string(),
+            "-d".to_string(),
             "-t".to_string(),
             target.clone(),
             "-h".to_string(),
@@ -920,8 +926,227 @@ fn submit_verification_for_key(key: Key) -> SubmitVerification {
 }
 
 fn capture_has_pasted_content_prompt(text: &str) -> bool {
+    pasted_prompt_match(text).is_some()
+}
+
+/// 0.3.27: check if a token marker is present in the bottom N non-empty lines.
+/// Used by the unified submit_and_verify to detect whether the provider consumed
+/// the pasted message (token scrolls out of composer region on successful submit).
+fn token_in_bottom_n(text: &str, marker: &str, n: usize) -> bool {
+    text.lines()
+        .rev()
+        .filter(|line| !line.trim().is_empty())
+        .take(n)
+        .any(|line| line.contains(marker))
+}
+
+/// 0.3.27: check if a pasted-content prompt literal (`pasted content` / `pasted text`)
+/// appears in the bottom N non-empty lines. Narrower than the full-Tail(80) check
+/// that caused scrollback ghost matches (E50 defect B).
+fn pasted_prompt_in_bottom(text: &str, n: usize) -> bool {
+    text.lines()
+        .rev()
+        .filter(|line| !line.trim().is_empty())
+        .take(n)
+        .any(|line| {
+            let lower = line.to_ascii_lowercase();
+            lower.contains("pasted content") || lower.contains("pasted text")
+        })
+}
+
+/// E50 PR-1 (0.3.24 P0, pasted-prompt 假阴诊断): factor `capture_has_pasted_content_prompt`
+/// so the diagnostic layer can recover the MATCHED LITERAL and its position
+/// in the tail. Returns `(literal, line_index_from_bottom)` on a match.
+/// Byte-identical match semantics — `capture_has_pasted_content_prompt`'s
+/// `bool` wrapper preserves the legacy `true/false` contract for the three
+/// existing callers (the appear-gate poll at :1122-1128 + the legacy submit
+/// loop matcher at :1138 + post-flip clearer at :1138).
+///
+/// **Where-in-tail rationale**: a `pasted content` literal that lives in
+/// the SCROLLBACK (line 6+ from bottom) is NOT the live composer
+/// placeholder — codex's successful submit scrolls the block into history
+/// where it remains in the last 80 lines. The current matcher cannot
+/// distinguish that from a live placeholder; this fn surfaces the data
+/// the operator needs to see (PR-2 will USE it to fix the criterion).
+pub(crate) fn pasted_prompt_match(text: &str) -> Option<(&'static str, u32)> {
     let lower = text.to_ascii_lowercase();
-    lower.contains("pasted content") || lower.contains("pasted text")
+    let lit = if lower.contains("pasted content") {
+        "pasted content"
+    } else if lower.contains("pasted text") {
+        "pasted text"
+    } else {
+        return None;
+    };
+    // Distance from the bottom of the tail in non-empty lines.
+    let non_empty: Vec<&str> = text.lines().filter(|line| !line.trim().is_empty()).collect();
+    let mut from_bottom: u32 = 0;
+    for line in non_empty.iter().rev() {
+        if line.to_ascii_lowercase().contains(lit) {
+            return Some((lit, from_bottom));
+        }
+        from_bottom = from_bottom.saturating_add(1);
+    }
+    // Literal appeared only in trimmed-away whitespace lines — treat as
+    // bottom (defensive; rare).
+    Some((lit, 0))
+}
+
+/// E50 PR-1 (0.3.24 P0): scrub a pane capture for safe inclusion in
+/// `events.jsonl`. Steps:
+///   1. Strip CSI / OSC ANSI escapes.
+///   2. Take the bottom `tail_lines` of non-empty lines.
+///   3. Redact common secret shapes (sk-, ghp_, AKIA, Bearer ..., 32+ hex).
+///   4. Cap at ~1200 bytes (UTF-8 safe truncation).
+/// Returns `(excerpt, line_count)`. Designed to be CHEAP — no regex crate
+/// dependency, simple byte scanning.
+pub(crate) fn scrub_pane_excerpt(raw: &str, tail_lines: usize) -> (String, u32) {
+    let stripped = strip_ansi_escapes_inplace(raw);
+    let lines: Vec<&str> = stripped
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .collect();
+    let tail = if lines.len() > tail_lines {
+        &lines[lines.len() - tail_lines..]
+    } else {
+        &lines[..]
+    };
+    let mut out = tail
+        .iter()
+        .map(|line| scrub_secrets(line))
+        .collect::<Vec<_>>()
+        .join("\n");
+    if out.len() > 1200 {
+        // Truncate at UTF-8 char boundary.
+        let mut cut = 1200;
+        while cut > 0 && !out.is_char_boundary(cut) {
+            cut -= 1;
+        }
+        out.truncate(cut);
+        out.push_str("…[truncated]");
+    }
+    (out, tail.len() as u32)
+}
+
+fn strip_ansi_escapes_inplace(input: &str) -> String {
+    let mut out = String::with_capacity(input.len());
+    let bytes = input.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == 0x1b && i + 1 < bytes.len() {
+            // CSI: ESC [ ... <final byte 0x40-0x7e>
+            if bytes[i + 1] == b'[' {
+                let mut j = i + 2;
+                while j < bytes.len() && !(0x40..=0x7e).contains(&bytes[j]) {
+                    j += 1;
+                }
+                i = j.saturating_add(1).min(bytes.len());
+                continue;
+            }
+            // OSC: ESC ] ... BEL or ESC \
+            if bytes[i + 1] == b']' {
+                let mut j = i + 2;
+                while j < bytes.len() {
+                    if bytes[j] == 0x07 {
+                        j += 1;
+                        break;
+                    }
+                    if bytes[j] == 0x1b && j + 1 < bytes.len() && bytes[j + 1] == b'\\' {
+                        j += 2;
+                        break;
+                    }
+                    j += 1;
+                }
+                i = j.min(bytes.len());
+                continue;
+            }
+            // Other single-char ESC sequence — skip ESC + next byte.
+            i += 2;
+            continue;
+        }
+        let ch = bytes[i];
+        out.push(ch as char);
+        i += 1;
+    }
+    // Re-decode from bytes to recover UTF-8 (since we pushed bytes as chars,
+    // multi-byte UTF-8 is preserved correctly because we only skip on the
+    // single-byte ESC start). For pane text this is good enough; pathological
+    // UTF-8 inside CSI parameter bytes is invalid anyway.
+    out
+}
+
+fn scrub_secrets(line: &str) -> String {
+    // Five shapes: sk-XXXX, ghp_XXXX, AKIAXXXX (16-char uppercase id), Bearer XXXX,
+    // 32+ hex (token).
+    let mut out = String::with_capacity(line.len());
+    let bytes = line.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        // sk- / ghp_ / AKIA prefixes: detect and redact through end-of-token.
+        if matches_prefix(bytes, i, b"sk-") || matches_prefix(bytes, i, b"ghp_") {
+            let prefix_len = if bytes[i] == b's' { 3 } else { 4 };
+            let token_end = scan_token_end(bytes, i + prefix_len);
+            out.push_str(&line[i..i + prefix_len]);
+            out.push_str("REDACTED");
+            i = token_end;
+            continue;
+        }
+        if matches_prefix(bytes, i, b"AKIA") {
+            let token_end = scan_token_end(bytes, i + 4);
+            out.push_str("AKIA");
+            out.push_str("REDACTED");
+            i = token_end;
+            continue;
+        }
+        if matches_prefix_case_insensitive(bytes, i, b"Bearer ") {
+            let token_end = scan_token_end(bytes, i + 7);
+            out.push_str(&line[i..i + 7]);
+            out.push_str("REDACTED");
+            i = token_end;
+            continue;
+        }
+        // 32+ hex run.
+        if is_hex_byte(bytes[i]) {
+            let mut j = i;
+            while j < bytes.len() && is_hex_byte(bytes[j]) {
+                j += 1;
+            }
+            if j - i >= 32 {
+                out.push_str("REDACTED_HEX");
+                i = j;
+                continue;
+            }
+        }
+        // Default: passthrough byte.
+        out.push(bytes[i] as char);
+        i += 1;
+    }
+    out
+}
+
+fn matches_prefix(bytes: &[u8], i: usize, prefix: &[u8]) -> bool {
+    bytes.get(i..i + prefix.len()).is_some_and(|s| s == prefix)
+}
+
+fn matches_prefix_case_insensitive(bytes: &[u8], i: usize, prefix: &[u8]) -> bool {
+    bytes
+        .get(i..i + prefix.len())
+        .is_some_and(|s| s.eq_ignore_ascii_case(prefix))
+}
+
+fn scan_token_end(bytes: &[u8], start: usize) -> usize {
+    let mut j = start;
+    while j < bytes.len() && is_token_byte(bytes[j]) {
+        j += 1;
+    }
+    j
+}
+
+fn is_token_byte(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || b == b'-' || b == b'_'
+}
+
+fn is_hex_byte(b: u8) -> bool {
+    b.is_ascii_hexdigit()
 }
 
 const PASTED_CONTENT_APPEAR_POLLS: u32 = 5;
@@ -1118,125 +1343,195 @@ impl Transport for TmuxBackend {
                         self.run_inject_stage(&argv, stage)?;
                     }
                 }
-                let mut saw_pasted_prompt = false;
-                for _ in 0..PASTED_CONTENT_APPEAR_POLLS {
-                    let captured = self.capture(target, CaptureRange::Tail(80))?;
-                    if capture_has_pasted_content_prompt(&captured.text) {
-                        saw_pasted_prompt = true;
-                        break;
-                    }
-                    std::thread::sleep(Duration::from_millis(25));
-                }
+                // ═══════════════════════════════════════════════════════════
+                // 0.3.27 UNIFIED submit_and_verify
+                //
+                // Replaces the dual-branch split (saw_pasted_prompt weak loop
+                // + E46 token consumption gate) with a single pipeline:
+                //
+                //   Phase 1 — token visibility poll (dynamic timeout based on
+                //     payload size, 50ms interval, replaces the fixed 125ms
+                //     appear_gate)
+                //   Phase 2 — Escape (if bracketed+Text+Enter) + Enter + poll
+                //     token disappeared from bottom 3 lines. On failure:
+                //     re-check → Escape+Enter → poll. Up to 3 attempts.
+                //
+                // Design truth source: .team/artifacts/E55-delivery-architecture-design.html
+                // Python parity: dynamic timeout max(2s, bytes/25000), poll 50ms.
+                // ═══════════════════════════════════════════════════════════
+                let inject_start = std::time::Instant::now();
                 let submit_argv = tmux_send_keys_argv(&pane, &[submit]);
-                if saw_pasted_prompt {
-                    let mut attempts = 0;
-                    let mut cleared = false;
-                    for _ in 0..PASTED_CONTENT_SUBMIT_ATTEMPTS {
-                        attempts += 1;
-                        self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
-                        let captured = self.capture(target, CaptureRange::Tail(80))?;
-                        if !capture_has_pasted_content_prompt(&captured.text) {
-                            cleared = true;
-                            break;
+
+                // Phase 1: token visibility poll — wait for the pasted text to
+                // become visible in the pane before submitting. Dynamic timeout
+                // based on payload size (large codex pastes can take seconds to
+                // render the bracketed-paste block).
+                let token_poll_timeout_ms = {
+                    let size_based = (text.len() as u64) / 25;
+                    size_based.max(2000)
+                };
+                let poll_start = std::time::Instant::now();
+                token_visible_for_report =
+                    if payload_token_marker(payload).is_some() {
+                        let mut visible = false;
+                        while poll_start.elapsed().as_millis() < token_poll_timeout_ms as u128 {
+                            match token_visible_in_capture(self, target, payload) {
+                                Ok(Some(true)) => { visible = true; break; }
+                                Err(_) => break, // tmux unavailable, skip poll
+                                _ => {}
+                            }
+                            std::thread::sleep(Duration::from_millis(50));
                         }
-                    }
+                        Some(visible)
+                    } else {
+                        None
+                    };
+
+                // Phase 2: submit_and_verify — unified Escape+Enter+poll loop.
+                let use_escape = bracketed
+                    && matches!(payload, InjectPayload::Text(_))
+                    && matches!(submit, Key::Enter);
+                let escape_argv = if use_escape {
+                    Some(tmux_send_keys_argv(&pane, &[Key::Escape]))
+                } else {
+                    None
+                };
+                // Non-Enter submit keys (Key::Down for codex menu, etc.) skip
+                // the entire submit_and_verify loop — single send, no consumption
+                // check, KeySentAfterVisibleToken verification.
+                if !matches!(submit, Key::Enter) {
+                    self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
+                    let total_elapsed_ms = inject_start.elapsed().as_millis() as u64;
                     return Ok(InjectReport {
                         stage_reached: InjectStage::Submit,
-                        inject_verification:
-                            InjectVerification::CaptureContainsNewPastedContentPrompt,
-                        submit_verification: if cleared {
-                            SubmitVerification::PastedContentPromptAbsentAfterSubmit
-                        } else {
-                            SubmitVerification::PastedContentPromptStillPresentAfterSubmit
-                        },
+                        inject_verification: inject_verification_after_readback(
+                            payload,
+                            token_visible_for_report,
+                        ),
+                        submit_verification: submit_verification_for_key(submit),
                         turn_verification: TurnVerification::NotYetObserved,
-                        attempts,
+                        attempts: 1,
+                        submit_diagnostics: Some(crate::transport::SubmitDiagnostics {
+                            appear_gate_elapsed_ms: 0,
+                            appear_gate_matched: false,
+                            total_elapsed_ms,
+                            attempts_detail: Vec::new(),
+                        }),
                     });
                 }
-                // U1 #7 (efd189b redo, canonical-native): around the final submit, read
-                // back the pane and confirm the just-pasted token is actually visible.
-                // The static `inject_verification_for_payload` returns CaptureContainsToken
-                // for any token payload WITHOUT checking the pane — a false positive when
-                // the paste silently dropped. A no-echo pane may only render after Enter,
-                // so a pre-submit miss gets one bounded post-submit readback before we
-                // 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)) {
+
+                let marker = payload_token_marker(payload);
+                let max_submit_attempts: u32 = 3;
+                let mut consumption_attempts: u32 = 0;
+                let mut consumed: Option<bool> = None;
+
+                for attempt in 0..max_submit_attempts {
+                    // Before resending (attempt > 0), re-check if the token
+                    // already disappeared — guards against double-submit (C3).
+                    // Capture failures are non-fatal (tmux may not be running
+                    // in MCP sim / test env).
+                    if attempt > 0 {
+                        if let Some(m) = marker {
+                            if let Ok(cap) = self.capture(target, CaptureRange::Tail(30)) {
+                                if !token_in_bottom_n(&cap.text, m, 5) {
+                                    consumed = Some(true);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    // Escape is RETRY-ONLY (attempt > 0). Researcher discovery:
+                    // Escape on Claude TUI with [Pasted content] visible may
+                    // CLEAR the composer content instead of exiting paste mode.
+                    // Python never sends Escape and never has this issue. So:
+                    // attempt 0 → direct Enter (Python parity); attempt 1+ →
+                    // Escape+Enter as remediation for stuck bracketed-paste.
+                    if attempt > 0 {
+                        if let Some(ref esc) = escape_argv {
+                            let _ = self.run_inject_stage(esc, InjectStage::Submit);
+                            for _ in 0..10 {
+                                match self.capture(target, CaptureRange::Tail(30)) {
+                                    Ok(cap) if !pasted_prompt_in_bottom(&cap.text, 3) => break,
+                                    Err(_) => break,
+                                    _ => {}
+                                }
+                                std::thread::sleep(Duration::from_millis(50));
+                            }
+                        }
+                    }
+
+                    // Enter — send-keys failure is degraded (tmux may not have
+                    // the pane in sim/test env). Break to consumed=None path
+                    // which returns EnterSentWithoutPlaceholderCheck.
+                    if self.run_inject_stage(&submit_argv, InjectStage::Submit).is_err() {
+                        consumed = None;
+                        break;
+                    }
+                    consumption_attempts = attempt + 1;
+
+                    // Post-submit token readback (U1 #7 parity: check token
+                    // visible after Enter for no-echo panes).
+                    if attempt == 0 && matches!(token_visible_for_report, Some(false)) {
+                        token_visible_for_report =
+                            post_submit_token_visible(self, target, payload)
+                                .unwrap_or(Some(false));
+                    }
+
+                    // Poll: token disappeared from bottom 5 lines = consumed.
+                    // Capture failures → consumed=None (non-blocking).
+                    if let Some(m) = marker {
+                        let mut found_consumed = false;
+                        let mut capture_failed = false;
+                        for _ in 0..6 {
+                            std::thread::sleep(Duration::from_millis(50));
+                            match self.capture(target, CaptureRange::Tail(30)) {
+                                Ok(cap) => {
+                                    if !token_in_bottom_n(&cap.text, m, 5) {
+                                        found_consumed = true;
+                                        break;
+                                    }
+                                }
+                                Err(_) => { capture_failed = true; break; }
+                            }
+                        }
+                        if capture_failed {
+                            consumed = None;
+                            break;
+                        }
+                        consumed = Some(found_consumed);
+                        if found_consumed {
                             break;
                         }
-                        consumption_attempts += 1;
-                        let _ = self.run_inject_stage(&submit_argv, InjectStage::Submit);
+                    } else {
+                        // Non-token payload: single Enter, no consumption check.
+                        consumed = None;
+                        break;
                     }
                 }
+
                 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).
+                    Some(false) => {
+                        // Consumption not observed (token still in bottom 5 after
+                        // all attempts). As a grace fallback, check if the token
+                        // is visible ANYWHERE in the pane capture. If yes, the
+                        // paste DID land — the pane just doesn't clear the token
+                        // from the bottom region (bare shell panes, MCP sim env,
+                        // busy agent TUI). Treat as "submitted, verification
+                        // degraded" → EnterSentWithoutPlaceholderCheck (generous;
+                        // matches pre-0.3.27 behaviour for these edge cases).
+                        // If the token is NOT visible at all, the paste truly
+                        // failed → SubmitConsumptionUnverified.
+                        if matches!(token_visible_for_report, Some(true)) {
+                            SubmitVerification::EnterSentWithoutPlaceholderCheck
+                        } else {
+                            SubmitVerification::SubmitConsumptionUnverified
+                        }
+                    }
                     None => submit_verification_for_key(submit),
                 };
+                let total_elapsed_ms = inject_start.elapsed().as_millis() as u64;
                 return Ok(InjectReport {
                     stage_reached: InjectStage::Submit,
                     inject_verification: inject_verification_after_readback(
@@ -1249,6 +1544,12 @@ impl Transport for TmuxBackend {
                         InjectPayload::Text(_) => TurnVerification::NotYetObserved,
                     },
                     attempts: consumption_attempts,
+                    submit_diagnostics: Some(crate::transport::SubmitDiagnostics {
+                        appear_gate_elapsed_ms: 0,
+                        appear_gate_matched: false,
+                        total_elapsed_ms,
+                        attempts_detail: Vec::new(),
+                    }),
                 });
             }
         }
@@ -1264,6 +1565,9 @@ impl Transport for TmuxBackend {
                 InjectPayload::Text(_) => TurnVerification::NotYetObserved,
             },
             attempts: 1,
+            // E50 PR-1: Empty payload / non-Text fallthrough path — no submit
+            // diagnostics applicable.
+            submit_diagnostics: None,
         })
     }
 

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

@@ -277,6 +277,7 @@ impl OfflineTransport {
             submit_verification: SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: TurnVerification::NotYetObserved,
             attempts: 1,
+            submit_diagnostics: None,
         }
     }
 }

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

@@ -74,6 +74,7 @@
                 submit_verification,
                 turn_verification,
                 attempts: 1,
+                submit_diagnostics: None,
             })
         }
         fn send_keys(&self, _target: &Target, _keys: &[Key]) -> Result<(), TransportError> {

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

@@ -271,7 +271,8 @@
                 "sh",
                 false,
             ),
-            vec!["tmux", "new-window", "-t", "team-sess", "-n", "worker-2", "sh", "-lc", "sh"]
+            // E53 (0.3.26): new-window now carries `-d` (detached, no focus steal).
+            vec!["tmux", "new-window", "-d", "-t", "team-sess", "-n", "worker-2", "sh", "-lc", "sh"]
         );
     }