@team-agent/installer 0.3.24 → 0.3.25

package/crates/team-agent/src/messaging/delivery.rs

@@ -469,7 +469,19 @@ fn inject_submit_verified(report: &InjectReport) -> bool {
         SubmitVerification::PastedContentPromptStillPresentAfterSubmit => false,
         SubmitVerification::PastedContentPromptAbsentAfterSubmit => true,
         SubmitVerification::KeySentAfterVisibleToken { .. } => true,
+        // MUST-10 preserved: EnterSentWithoutPlaceholderCheck still ⇒ delivered
+        // (provider_submit_verification_red.rs:113-159 contract). E46 narrows
+        // when transport returns this variant: it is now emitted ONLY after
+        // post-Enter input-consumption confirmation succeeds. Fresh TUI
+        // (bracketed-paste-stuck) instead returns SubmitConsumptionUnverified
+        // so this branch keeps delivered semantics intact.
         SubmitVerification::EnterSentWithoutPlaceholderCheck => true,
+        // E46 (0.3.24 bug#5): Enter was sent but post-Enter consumption was
+        // NOT observed within the bounded resend cap. Treat as not delivered
+        // (submitted_unverified / failed) — prevents the macmini假阳 where
+        // demo-director's stuck bracketed-paste swallowed the Enter and
+        // delivery still reported delivered.
+        SubmitVerification::SubmitConsumptionUnverified => false,
     }
 }
 

package/crates/team-agent/src/messaging/helpers.rs

@@ -112,9 +112,20 @@ pub(crate) fn parse_scheduled_kind(kind: &str) -> Result<ScheduledKind, Messagin
 }
 
 pub(crate) fn working_seconds(scrollback: &str) -> Option<u64> {
-    let lower = scrollback.to_ascii_lowercase();
+    // E47 ROOT-FIX#1 (0.3.24 P0, idle/busy 假阳): the pre-fix `lower.find(...)`
+    // scanned the WHOLE scrollback (Tail(40) lines) and matched historical
+    // working markers — e.g. an old `• Working (514s · esc to interrupt)`
+    // still in the 40-line window after the worker idled. That stale token
+    // flipped a truly-idle agent to Stuck whenever the historical seconds
+    // exceeded 300. Real fix: only consult the LIVE composer / status line
+    // (last non-empty line). If the current bottom line is something like
+    // `❯ Run /review`, `Worked for 8m 34s`, or an empty composer prompt,
+    // there is no LIVE working indicator and we return None — handing off
+    // to the structural latest_prompt_signal / IRON LAW Uncertain path.
+    let last_non_empty = scrollback.lines().rev().find(|line| !line.trim().is_empty())?;
+    let lower = last_non_empty.to_ascii_lowercase();
     let start = lower.find("working (")?;
-    let rest = scrollback.get(start + "Working (".len()..)?;
+    let rest = last_non_empty.get(start + "Working (".len()..)?;
     let seconds = rest.split_once('s')?.0;
     seconds.parse::<u64>().ok()
 }
@@ -129,32 +140,61 @@ pub(crate) fn non_provider_command(command: &str) -> Option<&str> {
 }
 
 pub(crate) fn latest_prompt_signal(scrollback: &str) -> Option<AgentActivity> {
-    let lower = scrollback.to_ascii_lowercase();
-    let idle_pos = latest_idle_prompt_pos(scrollback);
-    let working_pos = [
-        "working", "thinking", "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏",
-    ]
-    .iter()
-    .filter_map(|needle| lower.rfind(needle))
-    .max();
-    match (idle_pos, working_pos) {
-        (Some(i), Some(w)) if i > w => Some(idle_activity()),
-        (Some(_), None) => Some(idle_activity()),
-        (_, Some(_)) => Some(AgentActivity {
+    // E47 ROOT-FIX#2 (0.3.24 P0, idle/busy 假阳): limit the scan to the
+    // BOTTOM ACTIVE REGION (last 1-3 non-empty lines = composer / status
+    // line). The pre-fix `rfind` across the whole Tail(40) buffer let a
+    // historical spinner/`Working` token out-position the live `❯`/`›`
+    // composer (the rfind-recency family bug — same shape as the #320
+    // codex prompt residue). When the composer line is `❯ Run /review`
+    // (idle), a scrollback `Working (514s)` 20 lines up should NOT win.
+    //
+    // IRON LAW (activity.rs:3 / bug-071/077/085): no-signal in the bottom
+    // region must be Uncertain (caller treats None here as "no decisive
+    // signal" and surfaces Uncertain), NEVER silently flipped to Idle.
+    let active_region: Vec<&str> = scrollback
+        .lines()
+        .rev()
+        .filter(|line| !line.trim().is_empty())
+        .take(3)
+        .collect();
+    if active_region.is_empty() {
+        return None;
+    }
+    let mut has_idle_prompt = false;
+    let mut has_live_working_indicator = false;
+    for line in &active_region {
+        let lower = line.to_ascii_lowercase();
+        if line.contains('❯') || line.contains('›') {
+            has_idle_prompt = true;
+        }
+        // codex live spinner shapes (provider/adapter.rs:875-876 markers):
+        // braille spinner, `• Working (`, `Thinking`; claude `✶`/`✢` per
+        // adapter; we look for STRUCTURAL composer signals.
+        if [
+            "working (", "thinking", "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦",
+            "⠧", "⠇", "⠏", "✶", "✢",
+        ]
+        .iter()
+        .any(|needle| lower.contains(needle))
+        {
+            has_live_working_indicator = true;
+        }
+    }
+    // Working indicator IN the active region wins over a stale `❯`/`›`
+    // (composer may show a prompt char before the live spinner refreshes).
+    if has_live_working_indicator {
+        return Some(AgentActivity {
             status: ActivityStatus::Working,
             confidence: 0.9,
             rationale: "working_indicator".to_string(),
-        }),
-        (None, None) => None,
+        });
     }
-}
-
-fn latest_idle_prompt_pos(scrollback: &str) -> Option<usize> {
-    scrollback
-        .match_indices('❯')
-        .map(|(idx, _)| idx)
-        .chain(scrollback.match_indices('›').map(|(idx, _)| idx))
-        .max()
+    if has_idle_prompt {
+        return Some(idle_activity());
+    }
+    // No structural signal in the bottom region → caller (activity.rs:184)
+    // gets None and treats as no-decisive-signal → Uncertain (IRON LAW).
+    None
 }
 
 fn idle_activity() -> AgentActivity {

package/crates/team-agent/src/messaging/tests/spine.rs

@@ -71,7 +71,14 @@ fn p2_owner_bypass_denies_on_env_agent_id_mismatch() {
 }
 
 // P1 — classify_agent_activity must read current_command, stale last_output, multiline /
-// Codex idle prompts, and Thinking/lowercase-working (activity_detector.py:90-146).
+// Codex idle prompts, and Thinking/codex-spinner working indicators
+// (activity_detector.py:90-146). **E47 amendment (0.3.24 P0)**: the
+// working-indicator probe is now bottom-active-region scoped (last 1-3
+// non-empty lines) and looks for STRUCTURAL spinner markers (codex
+// `• Working (`/`Thinking`/braille; claude `✶`/`✢`), not bare lowercase
+// `working` anywhere in the scrollback. Pre-fix rfind across the whole
+// Tail(40) buffer is the macmini假阳 root cause (historical Working tokens
+// out-positioning a live idle composer).
 #[test]
 fn p2_classify_activity_reads_command_stale_and_prompts() {
     let st = serde_json::json!({});
@@ -85,12 +92,28 @@ fn p2_classify_activity_reads_command_stale_and_prompts() {
     // (3) embedded multiline idle prompt (Codex ❯ not on its own trimmed line) → idle 0.9.
     let c = classify_agent_activity(&st, "some line\n❯\nmore", false, None, None);
     assert_eq!((c.status, c.confidence), (ActivityStatus::Idle, 0.9));
-    // (4) 'Thinking' working indicator → working 0.9.
+    // (4) 'Thinking' working indicator in the bottom active region → working 0.9.
     let d = classify_agent_activity(&st, "Thinking about it", false, None, None);
     assert_eq!((d.status, d.confidence), (ActivityStatus::Working, 0.9));
-    // (5) lowercase 'working' indicator → working 0.9.
+    // (5) E47 amendment: bare lowercase 'working on it' is NOT a structural
+    // spinner marker; the live codex spinner is `• Working (Ns · esc to
+    // interrupt)`. Treat as no-decisive-signal → Uncertain. The pre-fix
+    // expectation here is exactly the macmini假阳 shape — a stale 'working'
+    // token (without the parenthesised seconds + esc-to-interrupt tail) is
+    // either scrollback residue or unrelated text, not a live working
+    // indicator. To assert the Working path use the structural codex shape.
     let e = classify_agent_activity(&st, "working on it", false, None, None);
-    assert_eq!((e.status, e.confidence), (ActivityStatus::Working, 0.9));
+    assert_eq!((e.status, e.confidence), (ActivityStatus::Uncertain, 0.5));
+    // (5b) E47 structural Working: a real codex live spinner in the bottom
+    // active region must still classify Working 0.9.
+    let e_struct = classify_agent_activity(
+        &st,
+        "• Working (12s · esc to interrupt)",
+        false,
+        None,
+        None,
+    );
+    assert_eq!((e_struct.status, e_struct.confidence), (ActivityStatus::Working, 0.9));
 }
 
 // P1 — scheduler dispatch must be exhaustive: an unknown kind surfaces an error, not a
@@ -484,3 +507,133 @@ fn spine_delivery_injects_rendered_protocol_block_not_raw_content() {
          worker builds a result_envelope; got {payload:?}"
     );
 }
+
+// ═════════════════════════════════════════════════════════════════════════════
+// E47 (0.3.24 P0, idle/busy 假阳) — TUI keyword grep is structurally bounded.
+//
+// Real-machine repro (macmini): a Tail(40) capture of an idle codex worker
+// still carries historical `• Working (514s · esc to interrupt)` plus a
+// `─ Worked for 8m 34s ─` summary plus a fresh `❯ Run /review` prompt. The
+// pre-fix `working_seconds` full-buffer find matched the 514s token and
+// returned ≥300 → Stuck. The pre-fix `latest_prompt_signal` rfind let the
+// historical spinner out-position the bottom `❯` → Working. E47 narrows
+// both probes to the bottom active region (last 1-3 non-empty lines).
+//
+// The authoritative provider JSONL classify is wired in coordinator/tick.rs
+// (jsonl_activity_for_agent); these unit tests pin the TUI fallback layer.
+// ═════════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn e47_codex_idle_with_historical_working_in_scrollback_is_idle_not_stuck_or_working() {
+    // Exact macmini repro shape from the architect locate (E47).
+    let scrollback = "• Working (514s · esc to interrupt)\n\
+                      tool call 1\n\
+                      tool call 2\n\
+                      ─ Worked for 8m 34s ─\n\
+                      › Run /review\n\
+                      ❯ ";
+    let st = serde_json::json!({});
+    let a = classify_agent_activity(&st, scrollback, false, None, None);
+    assert_eq!(
+        a.status,
+        ActivityStatus::Idle,
+        "E47 (RED-1): codex idle worker whose scrollback still carries \
+         historical `• Working (514s · esc to interrupt)` must classify IDLE \
+         (bottom active region is `❯`+`› Run /review` = idle composer). \
+         pre-fix: Stuck/Working via rfind-recency. Got {a:?}"
+    );
+}
+
+#[test]
+fn e47_past_tense_worked_for_is_not_stale_working_indicator() {
+    // RED-2: past-tense `Worked for` summary line must NOT trigger
+    // working_seconds Stuck. The pre-fix scanned the whole buffer and would
+    // match the embedded `8m 34s ─` against `working (` if formatted slightly
+    // differently — but more importantly this test pins the "past-tense
+    // summary is idle context" semantics.
+    let scrollback = "─ Worked for 8m 34s ─\n❯ ";
+    let st = serde_json::json!({});
+    let a = classify_agent_activity(&st, scrollback, false, None, None);
+    assert_ne!(
+        a.status,
+        ActivityStatus::Stuck,
+        "E47 (RED-2): past-tense `Worked for 8m 34s` must NOT trigger \
+         stale_working_indicator Stuck. Got {a:?}"
+    );
+    assert_eq!(
+        a.status,
+        ActivityStatus::Idle,
+        "E47 (RED-2): bottom `❯` composer = idle. Got {a:?}"
+    );
+}
+
+#[test]
+fn e47_claude_idle_with_historical_spinner_classifies_idle() {
+    // RED-3: claude idle worker; historical spinner shape (`✶` per
+    // adapter.rs:875-876) earlier in the buffer (>= 3 non-empty lines deep),
+    // bottom composer is idle (`›` glyph variant or `> ` claude prompt).
+    // The bottom active region (last 3 non-empty lines) has NO spinner.
+    let scrollback = "✶ Working on plan\n\
+                      tool 1\n\
+                      tool 2\n\
+                      assistant reply text\n\
+                      summary line A\n\
+                      summary line B\n\
+                      › Continue?";
+    let st = serde_json::json!({});
+    let a = classify_agent_activity(&st, scrollback, false, None, None);
+    assert_eq!(
+        a.status,
+        ActivityStatus::Idle,
+        "E47 (RED-3): claude idle worker — historical ✶ above, idle `›` \
+         below — must classify IDLE. Got {a:?}"
+    );
+}
+
+#[test]
+fn e47_codex_live_spinner_in_bottom_active_region_classifies_working() {
+    // RED-4 (defence vs over-tightening 假阴): a TRULY busy codex worker
+    // whose bottom active region carries the live spinner must still be
+    // Working. No idle composer present.
+    let scrollback = "tool call x\nassistant response so far\n• Working (12s · esc to interrupt)";
+    let st = serde_json::json!({});
+    let a = classify_agent_activity(&st, scrollback, false, None, None);
+    assert_eq!(
+        a.status,
+        ActivityStatus::Working,
+        "E47 (RED-4): live codex spinner in bottom active region must \
+         classify Working. Got {a:?}"
+    );
+}
+
+#[test]
+fn e47_claude_live_working_in_bottom_active_region_classifies_working() {
+    // RED-5: a TRULY busy claude worker showing `✶ Working` at the bottom
+    // active region must be Working — even without the `(Ns)` codex shape.
+    let scrollback = "earlier output\nmore output\n✶ Working through the request";
+    let st = serde_json::json!({});
+    let a = classify_agent_activity(&st, scrollback, false, None, None);
+    assert_eq!(
+        a.status,
+        ActivityStatus::Working,
+        "E47 (RED-5): claude ✶ Working in bottom active region → Working. \
+         Got {a:?}"
+    );
+}
+
+#[test]
+fn e47_iron_law_no_signal_in_bottom_region_stays_uncertain_not_idle() {
+    // Defence: IRON LAW (activity.rs:3 / bug-071/077/085). When the bottom
+    // active region has no spinner AND no `❯`/`›` AND no other decisive
+    // signal, classify_agent_activity falls through to no_decisive_signal →
+    // Uncertain — NEVER silently to Idle.
+    let scrollback = "some neutral text\nmore neutral text\nstill nothing decisive";
+    let st = serde_json::json!({});
+    let a = classify_agent_activity(&st, scrollback, false, None, None);
+    assert_eq!(
+        a.status,
+        ActivityStatus::Uncertain,
+        "E47 IRON LAW guard: bottom region carries no spinner and no idle \
+         composer → Uncertain, never silently Idle. Got {a:?}"
+    );
+}

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

@@ -572,6 +572,257 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
         );
     }
 
+    // ═════════════════════════════════════════════════════════════════════════════
+    // 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(