@team-agent/installer 0.3.27 → 0.3.29

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

@@ -959,6 +959,18 @@ fn format_report_result_notification(
     if let Some(tests) = format_report_result_tests(envelope) {
         lines.push(tests);
     }
+    if let Some(changes) = format_report_result_changes(envelope) {
+        lines.push(changes);
+    }
+    if let Some(risks) = format_report_result_risks(envelope) {
+        lines.push(risks);
+    }
+    if let Some(artifacts) = format_report_result_artifacts(envelope) {
+        lines.push(artifacts);
+    }
+    if let Some(next_actions) = format_report_result_next_actions(envelope) {
+        lines.push(next_actions);
+    }
     lines.push(format!("Result id: {result_id}"));
     lines.push(
         "Team Agent stored this result. The coordinator/collect path will update team_state.md; no manual polling loop is needed."
@@ -986,6 +998,97 @@ fn format_report_result_tests(envelope: &serde_json::Value) -> Option<String> {
     }
 }
 
+fn report_result_array<'a>(
+    envelope: &'a serde_json::Value,
+    key: &str,
+) -> Option<&'a Vec<serde_json::Value>> {
+    let values = envelope.get(key).and_then(serde_json::Value::as_array)?;
+    if values.is_empty() {
+        None
+    } else {
+        Some(values)
+    }
+}
+
+fn report_field<'a>(value: &'a serde_json::Value, key: &str) -> Option<&'a str> {
+    value
+        .get(key)
+        .and_then(serde_json::Value::as_str)
+        .filter(|text| !text.is_empty())
+}
+
+fn report_field_any<'a>(value: &'a serde_json::Value, keys: &[&str]) -> Option<&'a str> {
+    keys.iter().find_map(|key| report_field(value, key))
+}
+
+fn format_report_result_changes(envelope: &serde_json::Value) -> Option<String> {
+    let parts = report_result_array(envelope, "changes")?
+        .iter()
+        .filter_map(|change| {
+            let path = report_field_any(change, &["path", "file", "filepath", "filename"])?;
+            let kind = report_field_any(change, &["kind", "type", "action"]).unwrap_or("changed");
+            let description =
+                report_field_any(change, &["description", "summary", "detail", "details", "message"])
+                    .unwrap_or(path);
+            Some(format!("{kind} {path}: {description}"))
+        })
+        .collect::<Vec<_>>();
+    if parts.is_empty() {
+        None
+    } else {
+        Some(format!("Changes: {}", parts.join(", ")))
+    }
+}
+
+fn format_report_result_risks(envelope: &serde_json::Value) -> Option<String> {
+    let parts = report_result_array(envelope, "risks")?
+        .iter()
+        .filter_map(|risk| {
+            let severity = report_field_any(risk, &["severity", "level"]).unwrap_or("low");
+            let description =
+                report_field_any(risk, &["description", "summary", "detail", "message"])?;
+            Some(format!("{severity}: {description}"))
+        })
+        .collect::<Vec<_>>();
+    if parts.is_empty() {
+        None
+    } else {
+        Some(format!("Risks: {}", parts.join(", ")))
+    }
+}
+
+fn format_report_result_artifacts(envelope: &serde_json::Value) -> Option<String> {
+    let parts = report_result_array(envelope, "artifacts")?
+        .iter()
+        .filter_map(|artifact| {
+            let path = report_field_any(artifact, &["path", "file", "filepath", "filename"])?;
+            let description =
+                report_field_any(artifact, &["description", "summary", "detail"]).unwrap_or(path);
+            Some(format!("{path}: {description}"))
+        })
+        .collect::<Vec<_>>();
+    if parts.is_empty() {
+        None
+    } else {
+        Some(format!("Artifacts: {}", parts.join(", ")))
+    }
+}
+
+fn format_report_result_next_actions(envelope: &serde_json::Value) -> Option<String> {
+    let parts = report_result_array(envelope, "next_actions")?
+        .iter()
+        .filter_map(|action| {
+            report_field_any(action, &["description", "summary", "action", "todo", "message"])
+                .map(|text| text.to_string())
+        })
+        .collect::<Vec<_>>();
+    if parts.is_empty() {
+        None
+    } else {
+        Some(format!("Next actions: {}", parts.join(", ")))
+    }
+}
+
 /// `_collect_results_and_notify_watchers` (`results.py:430`):coordinator tick 调用 —— collect +
 /// notify_result_watchers 编排。daemon-path → Result。
 pub fn collect_results_and_notify_watchers(
@@ -999,3 +1102,43 @@ pub fn collect_results_and_notify_watchers(
         "notified": notified
     }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::format_report_result_notification;
+
+    #[test]
+    fn report_result_notification_includes_full_envelope_sections() {
+        let envelope = serde_json::json!({
+            "schema_version": "result_envelope_v1",
+            "task_id": "task-1",
+            "agent_id": "worker",
+            "status": "success",
+            "summary": "done",
+            "changes": [
+                {"path": "src/a.rs", "kind": "modified", "description": "patched delivery"}
+            ],
+            "tests": [
+                {"command": "cargo test", "status": "passed"}
+            ],
+            "risks": [
+                {"severity": "low", "description": "none known"}
+            ],
+            "artifacts": [
+                {"path": ".team/artifacts/evidence.md", "description": "evidence"}
+            ],
+            "next_actions": [
+                {"description": "ship after review"}
+            ]
+        });
+        let notification =
+            format_report_result_notification("res_1", "task-1", "worker", "success", &envelope);
+        assert!(notification.contains("Task task-1 reported success from worker: done"));
+        assert!(notification.contains("Tests: cargo test=passed"));
+        assert!(notification.contains("Changes: modified src/a.rs: patched delivery"));
+        assert!(notification.contains("Risks: low: none known"));
+        assert!(notification.contains("Artifacts: .team/artifacts/evidence.md: evidence"));
+        assert!(notification.contains("Next actions: ship after review"));
+        assert!(notification.contains("Result id: res_1"));
+    }
+}

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

@@ -573,6 +573,40 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
         );
     }
 
+    #[test]
+    fn inject_skip_consumption_payload_sends_enter_without_phase2_poll() {
+        let text = "hello leader [team-agent-token:skip]";
+        let (be, rec) = backend_with(MockResp::Out(ok(text)), vec![]);
+        let report = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::TextSkipConsumptionPoll(text.to_string()),
+                Key::Enter,
+                true,
+            )
+            .expect("inject");
+        let calls = rec.lock().unwrap().clone();
+
+        assert_eq!(
+            report.submit_verification,
+            SubmitVerification::EnterSentWithoutPlaceholderCheck
+        );
+        assert_eq!(report.attempts, 1);
+        assert!(
+            calls.iter().any(|argv| {
+                argv.get(1).map(String::as_str) == Some("send-keys")
+                    && argv.contains(&"Enter".to_string())
+            }),
+            "skip-consumption payload must still submit once; calls={calls:?}"
+        );
+        assert!(
+            !calls.iter().any(|argv| {
+                argv == &tmux_capture_argv(&PaneId::new("%7"), CaptureRange::Tail(40))
+            }),
+            "leader-bound skip payload must not run Phase 2 consumption polls; calls={calls:?}"
+        );
+    }
+
     // ═════════════════════════════════════════════════════════════════════════════
     // E46 0.3.24 task#327 P0 — submit verification false-positive / false-negative.
     //
@@ -595,15 +629,15 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
     /// report `SubmitConsumptionUnverified`, NOT
     /// `EnterSentWithoutPlaceholderCheck`. Otherwise delivery emits delivered
     /// + message.delivered (假阳) even though the worker never consumed it.
-    /// 0.3.27 amendment: when token IS visible in the pane (Phase 1 confirmed)
-    /// but NOT consumed from bottom 5 after all retries, the grace fallback
-    /// treats "paste landed but composer didn't clear" as
-    /// EnterSentWithoutPlaceholderCheck. This handles bare-shell panes (MCP sim)
-    /// and busy-agent TUIs (E55) that keep the token visible after submit.
-    /// SubmitConsumptionUnverified is reserved for the case where the token was
-    /// NEVER visible (paste truly failed / dropped).
+    /// 0.3.28-final E55 truth source: grace fallback DELETED.
+    /// `consumed=Some(false)` (token still in bottom 5 after all retries)
+    /// MUST report SubmitConsumptionUnverified unconditionally. Pre-final
+    /// returned EnterSentWithoutPlaceholderCheck when Phase-1 saw the token
+    /// at all (token_visible_for_report=Some(true)) — but Phase-1 visibility
+    /// only proves the paste LANDED, not that the provider CONSUMED it.
+    /// That masked E55 busy-agent false positives as delivered=true.
     #[test]
-    fn e46_inject_text_with_token_visible_but_unconsumed_uses_grace_fallback() {
+    fn e46_inject_text_with_token_visible_but_unconsumed_reports_unverified() {
         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
@@ -614,20 +648,52 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
                 true,
             )
             .expect("inject runs");
-        // 0.3.27 grace fallback: token visible + not consumed from bottom →
-        // EnterSentWithoutPlaceholderCheck (paste landed, consumption unclear).
+        // 0.3.28-final: no grace fallback. Token visible + not consumed →
+        // SubmitConsumptionUnverified (delivery treats as not delivered).
         assert_eq!(
             report.submit_verification,
-            SubmitVerification::EnterSentWithoutPlaceholderCheck,
-            "0.3.27: when token is visible but not consumed from bottom 5 \
-             after all retries, grace fallback degrades to \
-             EnterSentWithoutPlaceholderCheck (paste landed, bare-shell/busy \
-             pane parity). Got {:?}",
+            SubmitVerification::SubmitConsumptionUnverified,
+            "0.3.28-final: when token still in bottom 5 after all retries, \
+             MUST be SubmitConsumptionUnverified — grace fallback masking \
+             this as EnterSentWithoutPlaceholderCheck caused E55 false \
+             positives (paste landed but busy agent never consumed). \
+             Got {:?}",
             report.submit_verification
         );
         assert_eq!(report.turn_verification, TurnVerification::NotYetObserved);
     }
 
+    #[test]
+    fn e46_unconsumed_token_with_live_busy_state_is_treated_as_processing() {
+        let token_text = "Team Agent message from leader:\n\nhi\n\n[team-agent-token:msg_busy]";
+        let busy_tail = format!("{token_text}\n● Working (1s · esc to interrupt)\n");
+        let (be, _rec) = backend_with(MockResp::Out(ok(&busy_tail)), 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::EnterSentWithoutPlaceholderCheck,
+            "busy provider state means the turn is being processed even if \
+             the token has not yet scrolled out of the bottom capture"
+        );
+        let diagnostics = report.submit_diagnostics.expect("diagnostics");
+        assert!(
+            diagnostics
+                .attempts_detail
+                .last()
+                .map(|obs| obs.pane_tail_excerpt.to_ascii_lowercase().contains("working"))
+                .unwrap_or(false),
+            "busy-state capture should be recorded in attempts_detail: {:?}",
+            diagnostics.attempts_detail
+        );
+    }
+
     /// 0.3.27: empty pane captures → consumption poll sees "no token in
     /// bottom 5" → consumed=true → EnterSentWithoutPlaceholderCheck. This is
     /// the generous default for panes where the capture can't distinguish
@@ -967,6 +1033,19 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
              EnterSentWithoutPlaceholderCheck; got {:?}",
             report.submit_verification
         );
+        let diagnostics = report.submit_diagnostics.expect("diagnostics");
+        assert!(
+            !diagnostics.attempts_detail.is_empty(),
+            "E50: E46 consumption gate must preserve per-capture diagnostics"
+        );
+        assert_eq!(diagnostics.attempts_detail[0].attempt_index, 1);
+        assert!(
+            diagnostics.attempts_detail[0]
+                .pane_tail_excerpt
+                .contains("Pasted content"),
+            "E50: recorded pane tail should contain the post-submit capture; got {:?}",
+            diagnostics.attempts_detail[0]
+        );
     }
 
     /// **E50 PR-1 secret scrubbing**: `scrub_pane_excerpt` must strip ANSI

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

@@ -29,7 +29,8 @@ use crate::transport::{
     tmux_query_argv, tmux_send_keys_argv, tmux_spawn_argv, AttachOutcome, BackendKind,
     CaptureRange, CapturedText, InjectPayload, InjectReport, InjectStage, InjectVerification, Key,
     PaneField, PaneId, PaneInfo, PaneMode, SessionName, SetEnvOutcome, SpawnResult,
-    SubmitVerification, Target, Transport, TransportError, TurnVerification, WindowName,
+    SubmitAttemptObservation, SubmitVerification, Target, Transport, TransportError,
+    TurnVerification, WindowName,
 };
 
 /// Result of running an external command — the typed output of the OS edge.
@@ -815,10 +816,12 @@ fn buffer_name_for_text(text: &str) -> String {
 fn inject_verification_for_payload(payload: &InjectPayload) -> InjectVerification {
     match payload {
         InjectPayload::Empty => InjectVerification::EmptyTextSendKeys,
-        InjectPayload::Text(text) if text.contains("[team-agent-token:") => {
+        InjectPayload::Text(text) | InjectPayload::TextSkipConsumptionPoll(text)
+            if text.contains("[team-agent-token:") =>
+        {
             InjectVerification::CaptureContainsToken
         }
-        InjectPayload::Text(_) => InjectVerification::NoToken,
+        InjectPayload::Text(_) | InjectPayload::TextSkipConsumptionPoll(_) => InjectVerification::NoToken,
     }
 }
 
@@ -826,15 +829,11 @@ fn inject_verification_for_payload(payload: &InjectPayload) -> InjectVerificatio
 /// (`[team-agent-token:<id>]`). Use the full marker, not only the prefix, so an old
 /// scrollback token cannot verify a new message.
 fn payload_token_marker(payload: &InjectPayload) -> Option<&str> {
-    match payload {
-        InjectPayload::Text(text) => {
-            let start = text.find("[team-agent-token:")?;
-            let marker = &text[start..];
-            let end = marker.find(']')?;
-            Some(&marker[..=end])
-        }
-        _ => None,
-    }
+    let text = payload.text()?;
+    let start = text.find("[team-agent-token:")?;
+    let marker = &text[start..];
+    let end = marker.find(']')?;
+    Some(&marker[..=end])
 }
 
 fn token_visible_in_capture(
@@ -940,6 +939,74 @@ fn token_in_bottom_n(text: &str, marker: &str, n: usize) -> bool {
         .any(|line| line.contains(marker))
 }
 
+fn marker_position_from_bottom(text: &str, marker: &str) -> Option<u32> {
+    let mut from_bottom = 0u32;
+    for line in text.lines().rev().filter(|line| !line.trim().is_empty()) {
+        if line.contains(marker) {
+            return Some(from_bottom);
+        }
+        from_bottom = from_bottom.saturating_add(1);
+    }
+    None
+}
+
+fn provider_busy_signal_in_tail(text: &str) -> bool {
+    text.lines()
+        .rev()
+        .filter(|line| !line.trim().is_empty())
+        .take(15)
+        .any(|line| {
+            let lower = line.to_ascii_lowercase();
+            lower.contains("working")
+                || lower.contains("thinking")
+                || lower.contains("esc to interrupt")
+                || line.contains('●')
+                || line.contains('⏳')
+                || line.contains('⠋')
+                || line.contains('⠙')
+                || line.contains('⠹')
+                || line.contains('⠸')
+                || line.contains('⠼')
+                || line.contains('⠴')
+                || line.contains('⠦')
+                || line.contains('⠧')
+                || line.contains('⠇')
+                || line.contains('⠏')
+                || line.contains('✶')
+                || line.contains('✢')
+        })
+}
+
+fn submit_attempt_observation(
+    attempt_index: u32,
+    captured: &CapturedText,
+    marker: Option<&str>,
+    elapsed_ms: u64,
+) -> SubmitAttemptObservation {
+    let marker_position = marker.and_then(|m| marker_position_from_bottom(&captured.text, m));
+    let (matched, matched_literal, where_in_tail) = if let Some(marker) = marker {
+        (
+            token_in_bottom_n(&captured.text, marker, 15),
+            marker_position.map(|_| marker.to_string()),
+            marker_position,
+        )
+    } else if let Some((literal, where_in_tail)) = pasted_prompt_match(&captured.text) {
+        (true, Some(literal.to_string()), Some(where_in_tail))
+    } else {
+        (false, None, None)
+    };
+    let (pane_tail_excerpt, pane_tail_lines) = scrub_pane_excerpt(&captured.text, 20);
+    SubmitAttemptObservation {
+        attempt_index,
+        matched,
+        matched_literal,
+        where_in_tail,
+        pane_tail_excerpt,
+        pane_tail_lines,
+        elapsed_ms,
+    }
+}
+
 /// 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).
@@ -1184,15 +1251,15 @@ fn post_submit_input_consumed(
     let Some(marker) = payload_token_marker(payload) else {
         return Ok(None);
     };
-    let captured = backend.capture(target, CaptureRange::Tail(30))?;
+    let captured = backend.capture(target, CaptureRange::Tail(40))?;
     // 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
+    // token marker out of the bottom 15 lines by the time the response
     // composer redraws.
-    let tail_lines: Vec<&str> = captured.text.lines().rev().take(5).collect();
+    let tail_lines: Vec<&str> = captured.text.lines().rev().take(15).collect();
     let token_in_tail = tail_lines.iter().any(|line| line.contains(marker));
     Ok(Some(!token_in_tail))
 }
@@ -1333,7 +1400,7 @@ impl Transport for TmuxBackend {
                 let argv = tmux_empty_inject_argv(&pane, submit);
                 self.run_ok(&argv)?;
             }
-            InjectPayload::Text(text) => {
+            InjectPayload::Text(text) | InjectPayload::TextSkipConsumptionPoll(text) => {
                 let buffer = buffer_name_for_text(text);
                 for argv in tmux_inject_text_argv(&pane, &buffer, text, bracketed) {
                     let stage = inject_stage_for_argv(&argv);
@@ -1389,7 +1456,7 @@ impl Transport for TmuxBackend {
 
                 // Phase 2: submit_and_verify — unified Escape+Enter+poll loop.
                 let use_escape = bracketed
-                    && matches!(payload, InjectPayload::Text(_))
+                    && payload.text().is_some()
                     && matches!(submit, Key::Enter);
                 let escape_argv = if use_escape {
                     Some(tmux_send_keys_argv(&pane, &[Key::Escape]))
@@ -1424,16 +1491,33 @@ impl Transport for TmuxBackend {
                 let max_submit_attempts: u32 = 3;
                 let mut consumption_attempts: u32 = 0;
                 let mut consumed: Option<bool> = None;
+                let mut attempts_detail: Vec<SubmitAttemptObservation> = Vec::new();
 
-                for attempt in 0..max_submit_attempts {
+                let poll_consumption = !payload.skip_consumption_poll();
+                if !poll_consumption {
+                    if self.run_inject_stage(&submit_argv, InjectStage::Submit).is_ok() {
+                        consumption_attempts = 1;
+                    }
+                }
+                let submit_attempt_limit = if poll_consumption { max_submit_attempts } else { 0 };
+
+                for attempt in 0..submit_attempt_limit {
+                    let attempt_index = attempt + 1;
+                    let attempt_start = std::time::Instant::now();
                     // 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) {
+                            if let Ok(cap) = self.capture(target, CaptureRange::Tail(40)) {
+                                attempts_detail.push(submit_attempt_observation(
+                                    attempt_index,
+                                    &cap,
+                                    marker,
+                                    attempt_start.elapsed().as_millis() as u64,
+                                ));
+                                if !token_in_bottom_n(&cap.text, m, 15) {
                                     consumed = Some(true);
                                     break;
                                 }
@@ -1441,25 +1525,15 @@ impl Transport for TmuxBackend {
                         }
                     }
 
-                    // 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));
-                            }
-                        }
-                    }
+                    // 0.3.28-final (E55 false-positive truth source):
+                    // Escape retry is DELETED. The researcher established
+                    // Escape on Claude TUI with [Pasted content] visible
+                    // may CLEAR the composer content rather than exit paste
+                    // mode — sending Escape+Enter on retry would submit an
+                    // empty message and hide the genuine consumption failure
+                    // under a fake-success path. Python parity: ONLY ever
+                    // send Enter, never Escape.
+                    let _ = escape_argv;
 
                     // Enter — send-keys failure is degraded (tmux may not have
                     // the pane in sim/test env). Break to consumed=None path
@@ -1478,16 +1552,22 @@ impl Transport for TmuxBackend {
                                 .unwrap_or(Some(false));
                     }
 
-                    // Poll: token disappeared from bottom 5 lines = consumed.
+                    // Poll: token disappeared from bottom 15 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)) {
+                        for _ in 0..12 {
+                            std::thread::sleep(Duration::from_millis(100));
+                            match self.capture(target, CaptureRange::Tail(40)) {
                                 Ok(cap) => {
-                                    if !token_in_bottom_n(&cap.text, m, 5) {
+                                    attempts_detail.push(submit_attempt_observation(
+                                        attempt_index,
+                                        &cap,
+                                        marker,
+                                        attempt_start.elapsed().as_millis() as u64,
+                                    ));
+                                    if !token_in_bottom_n(&cap.text, m, 15) {
                                         found_consumed = true;
                                         break;
                                     }
@@ -1512,23 +1592,45 @@ impl Transport for TmuxBackend {
 
                 let submit_verification = match consumed {
                     Some(true) => SubmitVerification::EnterSentWithoutPlaceholderCheck,
-                    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 {
+                    // 0.3.28-final (E55 truth source): consumed=Some(false)
+                    // means we ran ALL retries and the token never left
+                    // bottom 15 lines. That is a genuine consumption failure
+                    // unless a provider busy marker proves the TUI is already
+                    // processing the turn and simply has not scrolled yet;
+                    // it MUST NOT be masked. Pre-final used a grace fallback
+                    // that returned EnterSentWithoutPlaceholderCheck whenever
+                    // token_visible_for_report=Some(true) — but Phase-1 token
+                    // visibility only proves the paste landed, NOT that the
+                    // provider consumed it. The fallback caused
+                    // delivered=true under E55 (busy-agent paste-landed-not-
+                    // consumed false positive). Do not restore that grace
+                    // fallback; only a live busy-state signal upgrades this to
+                    // EnterSentWithoutPlaceholderCheck.
+                    Some(false) => match self.capture(target, CaptureRange::Tail(15)) {
+                        Ok(cap) => {
+                            attempts_detail.push(submit_attempt_observation(
+                                consumption_attempts.max(1),
+                                &cap,
+                                marker,
+                                inject_start.elapsed().as_millis() as u64,
+                            ));
+                            let busy = provider_busy_signal_in_tail(&cap.text);
+                            eprintln!(
+                                "team-agent submit consumption fallback: consumed=false busy_state={busy}"
+                            );
+                            if busy {
+                                SubmitVerification::EnterSentWithoutPlaceholderCheck
+                            } else {
+                                SubmitVerification::SubmitConsumptionUnverified
+                            }
+                        }
+                        Err(err) => {
+                            eprintln!(
+                                "team-agent submit consumption fallback: consumed=false busy_capture_error={err}"
+                            );
                             SubmitVerification::SubmitConsumptionUnverified
                         }
-                    }
+                    },
                     None => submit_verification_for_key(submit),
                 };
                 let total_elapsed_ms = inject_start.elapsed().as_millis() as u64;
@@ -1541,14 +1643,14 @@ impl Transport for TmuxBackend {
                     submit_verification,
                     turn_verification: match payload {
                         InjectPayload::Empty => TurnVerification::NotRequired,
-                        InjectPayload::Text(_) => TurnVerification::NotYetObserved,
+                        InjectPayload::Text(_) | InjectPayload::TextSkipConsumptionPoll(_) => 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(),
+                        attempts_detail,
                     }),
                 });
             }
@@ -1562,7 +1664,7 @@ impl Transport for TmuxBackend {
             submit_verification: submit_verification_for_key(submit),
             turn_verification: match payload {
                 InjectPayload::Empty => TurnVerification::NotRequired,
-                InjectPayload::Text(_) => TurnVerification::NotYetObserved,
+                InjectPayload::Text(_) | InjectPayload::TextSkipConsumptionPoll(_) => TurnVerification::NotYetObserved,
             },
             attempts: 1,
             // E50 PR-1: Empty payload / non-Text fallthrough path — no submit