@team-agent/installer 0.3.24 → 0.3.26

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,13 +926,252 @@ fn submit_verification_for_key(key: Key) -> SubmitVerification {
 }
 
 fn capture_has_pasted_content_prompt(text: &str) -> bool {
+    pasted_prompt_match(text).is_some()
+}
+
+/// 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;
 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,
@@ -1073,6 +1318,10 @@ impl Transport for TmuxBackend {
                         self.run_inject_stage(&argv, stage)?;
                     }
                 }
+                // E50 PR-1 (0.3.24 P0): record appear-gate timing + per-attempt
+                // observations. Pure diagnostic — no behavioural change. The
+                // existing matcher / windows / actions are byte-identical.
+                let appear_gate_start = std::time::Instant::now();
                 let mut saw_pasted_prompt = false;
                 for _ in 0..PASTED_CONTENT_APPEAR_POLLS {
                     let captured = self.capture(target, CaptureRange::Tail(80))?;
@@ -1082,8 +1331,25 @@ impl Transport for TmuxBackend {
                     }
                     std::thread::sleep(Duration::from_millis(25));
                 }
+                let appear_gate_elapsed_ms = appear_gate_start.elapsed().as_millis() as u64;
                 let submit_argv = tmux_send_keys_argv(&pane, &[submit]);
-                if saw_pasted_prompt {
+                // E50 PR-2 Fix-B (0.3.26 P0): when the payload carries a token
+                // marker (ALL delivery messages do via render_message), SKIP the
+                // legacy pasted-prompt weak loop even if `saw_pasted_prompt` is
+                // true. Fall through to the E46 token-based consumption gate
+                // (Escape pre-Enter + post_submit_input_consumed + resend cap
+                // with C3 re-check), which has NONE of the two defects:
+                //   A. E46 gate uses 60ms sleep + 3 retries (not zero-sleep).
+                //   B. E46 gate anchors on the token marker in the bottom 5
+                //      lines (composer region), not a substring match on
+                //      Tail(80) that catches scrollback residue.
+                //
+                // Non-token payloads (rare: test harness / trust prompt Empty)
+                // still use the legacy loop for backward compatibility with
+                // provider_submit_verification_red.rs::PastePromptRunner tests.
+                let has_token = payload_token_marker(payload).is_some();
+                if saw_pasted_prompt && !has_token {
+                    // Legacy weak loop preserved for non-token payloads (test harness).
                     let mut attempts = 0;
                     let mut cleared = false;
                     for _ in 0..PASTED_CONTENT_SUBMIT_ATTEMPTS {
@@ -1106,6 +1372,7 @@ impl Transport for TmuxBackend {
                         },
                         turn_verification: TurnVerification::NotYetObserved,
                         attempts,
+                        submit_diagnostics: None,
                     });
                 }
                 // U1 #7 (efd189b redo, canonical-native): around the final submit, read
@@ -1117,11 +1384,105 @@ 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),
+                };
+                // E50 PR-1: surface appear-gate timing on the E46 token path too.
+                // saw_pasted_prompt=false here; the placeholder never appeared
+                // within PASTED_CONTENT_APPEAR_POLLS, so the route is E46. The
+                // gate elapsed_ms still helps operators see how long we waited
+                // (e.g. codex slow-render).
+                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,
+                    submit_diagnostics: Some(crate::transport::SubmitDiagnostics {
+                        appear_gate_elapsed_ms,
+                        appear_gate_matched: false,
+                        total_elapsed_ms: appear_gate_elapsed_ms,
+                        attempts_detail: Vec::new(),
+                    }),
+                });
             }
         }
         Ok(InjectReport {
@@ -1136,6 +1497,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"]
         );
     }
 

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

@@ -157,6 +157,13 @@ pub enum Key {
     Char(char),
     /// `\x03`。
     CtrlC,
+    /// E46 (0.3.24 bug#5): pre-submit Escape to exit bracketed-paste mode on
+    /// fresh provider TUIs (claude). When a bracketed paste lands on a TUI
+    /// whose composer is still initialising, the framework's plain `Enter`
+    /// gets interpreted as paste content, not submit. Sending `Escape` first
+    /// closes the paste bracket so the subsequent `Enter` submits.
+    /// Real-machine truth source: macmini demo-director repro.
+    Escape,
     /// tmux `-X cancel` / `q` / `d`;非 tmux 后端无 copy-mode 概念 → no-op。
     CancelMode,
 }
@@ -287,7 +294,10 @@ pub enum InjectVerification {
 /// `{key}_sent_after_visible_token` 是模板 → 用携带 Key 的 variant 表达。
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SubmitVerification {
-    /// `enter_sent_without_placeholder_check`。
+    /// `enter_sent_without_placeholder_check`。MUST-10:此 variant 代表 paste+Enter
+    /// 完成且无需 placeholder probe(纯 peer 消息路径)。**保留** ⇒ delivered 语义;
+    /// E46 后只有 post-Enter consumption 确认通过(input 清空 / Working 信号)才返回
+    /// 此 variant — fresh TUI 未消费走 [`Self::SubmitConsumptionUnverified`]。
     EnterSentWithoutPlaceholderCheck,
     /// `pasted_content_prompt_absent_after_submit`。
     PastedContentPromptAbsentAfterSubmit,
@@ -297,6 +307,14 @@ pub enum SubmitVerification {
     KeySentAfterVisibleToken { key: Key },
     /// `send_keys_failed`。
     SendKeysFailed,
+    /// E46 (0.3.24 bug#5, demo-director 卡 bracketed paste): Enter 已发但
+    /// post-Enter 接收侧消费信号(input 行清空 / provider 进 Working)在 bounded
+    /// resend 上限内未观察到。**delivery 不当作 delivered**;走 submitted_unverified /
+    /// failed 路径。区别于
+    /// [`Self::PastedContentPromptStillPresentAfterSubmit`](claude paste-prompt
+    /// 折叠场景)— 本 variant 是结构化 input-empty 检测,适配 demo-director
+    /// 直接渲染文本路径。
+    SubmitConsumptionUnverified,
 }
 
 /// turn-boundary 观测(tmux_io.py:224-260,09-transport.md 表 §40)。
@@ -319,6 +337,75 @@ pub struct InjectReport {
     /// Gap42:仅 metadata,`not_yet_observed` 也算成功。
     pub turn_verification: TurnVerification,
     pub attempts: u32,
+    /// E50 PR-1 (0.3.24 P0, pasted-prompt 假阴诊断): per-attempt observations
+    /// emitted by the paste-prompt + Enter loop in `tmux_backend.rs::inject`.
+    /// `None` when the inject path did not exercise the diagnostic
+    /// instrumentation (peer payloads, empty payloads, non-bracketed Text,
+    /// or any path that bypasses `capture_has_pasted_content_prompt`). When
+    /// present, downstream `send.unverified` / `send.failed` events surface
+    /// it as `submit_attempts_detail[]` so operators see live pane state
+    /// per attempt (matched literal, where-in-tail offset, scrubbed pane
+    /// excerpt, elapsed ms) — the missing forensic data the user has been
+    /// asking for for many rounds.
+    ///
+    /// Tests / mocks should default this to `None` via `Default`. Wire
+    /// byte-lock (`transport::tests::wire`) is untouched: this field is NOT
+    /// serialised on the typed wire — it lives only in the in-process
+    /// `InjectReport` and is rendered into JSON manually by the delivery
+    /// layer when emitting forensic events.
+    pub submit_diagnostics: Option<SubmitDiagnostics>,
+}
+
+/// E50 PR-1 diagnostic payload — one entry per submit attempt in the
+/// pasted-prompt branch + (informational) for the appear-gate poll.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct SubmitDiagnostics {
+    /// Time spent in the appear-gate (poll for the pasted-content placeholder
+    /// before Enter). When `saw_pasted_prompt == false` this is the time we
+    /// spent polling before falling through to the E46 token path.
+    pub appear_gate_elapsed_ms: u64,
+    /// Did the appear-gate ever match the `pasted content` / `pasted text`
+    /// literal? When `false`, the inject took the E46 token path; the
+    /// `attempts_detail` may still capture observations the operator wants.
+    pub appear_gate_matched: bool,
+    /// Total elapsed across the whole submit gate (appear-gate + Enter
+    /// loop). Useful to triage real-machine slow-paste (codex large-paste
+    /// collapse can take >100 s while the framework's loop is sub-second).
+    pub total_elapsed_ms: u64,
+    /// Per-attempt observations of the post-Enter capture in the pasted-
+    /// prompt loop. Empty when `saw_pasted_prompt == false` and the inject
+    /// went through the E46 token path.
+    pub attempts_detail: Vec<SubmitAttemptObservation>,
+}
+
+/// E50 PR-1 single attempt observation (one Enter + one capture). All fields
+/// are forensic — they exist to make `send.unverified` / `send.failed` events
+/// self-describing rather than requiring the operator to guess.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct SubmitAttemptObservation {
+    /// 1-based attempt index (mirrors the `attempts` counter that already
+    /// ships in `InjectReport.attempts`).
+    pub attempt_index: u32,
+    /// Did this attempt's post-Enter capture STILL match the pasted-prompt
+    /// literal? `true` means the inject saw the placeholder; `false` means
+    /// the placeholder cleared (= submit succeeded by the legacy criterion).
+    pub matched: bool,
+    /// The matched literal substring (`pasted content` / `pasted text`)
+    /// when `matched == true`. `None` otherwise.
+    pub matched_literal: Option<String>,
+    /// Distance from the bottom of the tail where the match occurred:
+    /// `Some(0)` = bottom-most line (composer), `Some(N)` = N lines above
+    /// bottom (likely scrollback), `None` = no match. Critical for the
+    /// false-negative root cause: a `pasted content` literal in scrollback
+    /// is NOT the live composer placeholder.
+    pub where_in_tail: Option<u32>,
+    /// Scrubbed last 20 / 80 lines of the captured tail, ANSI-stripped,
+    /// capped ~1200 bytes. Secrets scrubbed (sk-/ghp_/AKIA/Bearer/hex32+).
+    pub pane_tail_excerpt: String,
+    /// Number of non-empty lines in `pane_tail_excerpt`.
+    pub pane_tail_lines: u32,
+    /// Time elapsed for THIS attempt (Enter + capture + match).
+    pub elapsed_ms: u64,
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -621,6 +708,10 @@ pub fn tmux_key_name(key: Key) -> &'static str {
         Key::Char('8') => "8",
         Key::Char('9') => "9",
         Key::CtrlC => "C-c",
+        // E46 (0.3.24 bug#5): tmux supports `Escape` as a key name; sending
+        // it as a send-keys arg emits `\x1b` to the pane (closes bracketed
+        // paste mode on a stuck TUI composer).
+        Key::Escape => "Escape",
         Key::CancelMode | Key::Char(_) => "",
     }
 }
@@ -739,9 +830,17 @@ pub fn tmux_spawn_argv(
             command.to_string(),
         ]
     } else {
+        // E53 (0.3.26, adaptive layout same-session tabs): `-d` makes the new
+        // window start without switching the client's active window to it. The
+        // leader stays on its own window; the worker opens as a background tab.
+        // Without `-d` every `new-window` call yanks the leader's terminal to
+        // the freshly spawned worker window, disrupting whatever the leader is
+        // doing. `-d` matches the Python golden: the managed leader and all
+        // workers share the same tmux session (= same terminal window tabs).
         vec![
             "tmux".to_string(),
             "new-window".to_string(),
+            "-d".to_string(),
             "-t".to_string(),
             session.as_str().to_string(),
             "-n".to_string(),
@@ -850,6 +949,9 @@ pub fn submit_verification_wire(v: SubmitVerification) -> String {
             format!("{}_sent_after_visible_token", tmux_key_name(key))
         }
         SubmitVerification::SendKeysFailed => "send_keys_failed".to_string(),
+        SubmitVerification::SubmitConsumptionUnverified => {
+            "submit_consumption_unverified".to_string()
+        }
     }
 }