@team-agent/installer 0.3.28 → 0.3.29

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.28"
+version = "0.3.29"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.28"
+version = "0.3.29"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/leader/start.rs

@@ -493,7 +493,9 @@ fn persist_managed_leader_binding(
         .unwrap_or(0)
         .saturating_add(1);
     let now = chrono::Utc::now().to_rfc3339();
-    let socket = crate::tmux_backend::socket_name_for_workspace(workspace);
+    let socket = crate::tmux_backend::socket_path_for_workspace(workspace)
+        .map(|path| path.to_string_lossy().to_string())
+        .unwrap_or_else(|| crate::tmux_backend::socket_name_for_workspace(workspace));
     let provider = serde_json::to_value(plan.provider)?;
     let session = spawned.session.as_str().to_string();
     let window = spawned.window.as_str().to_string();

package/crates/team-agent/src/lifecycle/launch.rs

@@ -2985,8 +2985,19 @@ pub(crate) fn annotate_runtime_tmux_endpoint(state: &mut serde_json::Value, tran
     let Some(endpoint) = transport.tmux_endpoint() else {
         return;
     };
+    let endpoint_for_state = if Path::new(&endpoint).is_absolute() || endpoint == "default" {
+        endpoint.clone()
+    } else if endpoint == crate::tmux_backend::socket_name_for_workspace(workspace) {
+        crate::tmux_backend::socket_path_for_workspace(workspace)
+            .map(|path| path.to_string_lossy().to_string())
+            .unwrap_or_else(|| endpoint.clone())
+    } else {
+        crate::tmux_backend::socket_path_for_name(&endpoint)
+            .map(|path| path.to_string_lossy().to_string())
+            .unwrap_or_else(|| endpoint.clone())
+    };
     if let Some(obj) = state.as_object_mut() {
-        obj.insert("tmux_endpoint".to_string(), serde_json::json!(endpoint));
+        obj.insert("tmux_endpoint".to_string(), serde_json::json!(endpoint_for_state));
         obj.insert(
             "tmux_socket".to_string(),
             obj.get("tmux_endpoint")

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -1192,6 +1192,29 @@ fn quick_start_persists_selected_tmux_endpoint_and_attach_commands() {
     assert_eq!(state["teams"]["teamdir"]["is_external_leader"], json!(false));
 }
 
+#[test]
+fn annotate_runtime_tmux_endpoint_persists_workspace_socket_as_full_path() {
+    let workspace = temp_ws();
+    let short = crate::tmux_backend::socket_name_for_workspace(&workspace);
+    let expected = crate::tmux_backend::socket_path_for_workspace(&workspace)
+        .expect("workspace socket should have a physical path");
+    let transport = OfflineTransport::new().with_tmux_endpoint(short);
+    let mut state = json!({});
+
+    annotate_runtime_tmux_endpoint(&mut state, &transport, &workspace);
+
+    assert_eq!(
+        state["tmux_endpoint"],
+        json!(expected.to_string_lossy().to_string()),
+        "runtime endpoint state must persist the full tmux socket path, not the short -L name"
+    );
+    assert_eq!(
+        state["tmux_socket"],
+        state["tmux_endpoint"],
+        "tmux_socket mirrors the canonical persisted endpoint"
+    );
+}
+
 #[test]
 fn quick_start_preserves_managed_leader_topology_and_emits_leader_attach_command() {
     let team = quick_start_team_dir(QS_VALID_ROLE);

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

@@ -296,8 +296,14 @@ pub fn deliver_pending_message(
         &message.content,
         message_id,
     );
+    let is_leader_recipient = message.recipient == "leader";
+    let payload = if is_leader_recipient {
+        InjectPayload::TextSkipConsumptionPoll(rendered)
+    } else {
+        InjectPayload::Text(rendered)
+    };
     let inject_report =
-        match transport.inject(&target, &InjectPayload::Text(rendered), Key::Enter, true) {
+        match transport.inject(&target, &payload, Key::Enter, true) {
             Ok(report) => report,
             Err(error) => {
                 let reason = format!("inject_failed:{error}");
@@ -373,13 +379,18 @@ pub fn deliver_pending_message(
                     channel: None,
                 });
             }
-        };
+    };
     let submit_verified = inject_submit_verified(&inject_report);
     let readback_verified = pane_readback_verified(&inject_report);
-    // U1 #7: delivery is verified only when the submit succeeded AND the token was read
-    // back as visible in the pane. A submit-verified-but-token-missing inject (silent
-    // paste drop) is NOT delivered — it falls through to the unverified/degraded path.
-    if !(submit_verified && readback_verified) {
+    // Worker panes run provider TUIs, so delivery needs both submit consumption
+    // and pane readback. The leader pane is a human-facing receiver: no provider
+    // consumes the token, so readback is the delivery proof.
+    let verified = if is_leader_recipient {
+        true
+    } else {
+        submit_verified && readback_verified
+    };
+    if !verified {
         let reason = if !readback_verified {
             "pane_readback_unverified:capture_missing_token".to_string()
         } else {

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.
     //
@@ -629,6 +663,37 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
         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
@@ -968,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;
                                 }
@@ -1468,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;
                                     }
@@ -1504,16 +1594,43 @@ impl Transport for TmuxBackend {
                     Some(true) => SubmitVerification::EnterSentWithoutPlaceholderCheck,
                     // 0.3.28-final (E55 truth source): consumed=Some(false)
                     // means we ran ALL retries and the token never left
-                    // bottom 5 lines. That is a genuine consumption failure;
+                    // 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). Always return Unverified now;
-                    // delivery treats it as not delivered.
-                    Some(false) => SubmitVerification::SubmitConsumptionUnverified,
+                    // 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;
@@ -1526,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,
                     }),
                 });
             }
@@ -1547,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

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

@@ -337,7 +337,9 @@ impl Transport for OfflineTransport {
             state.inject_targets.push(target.clone());
             state.inject_payloads.push(match payload {
                 InjectPayload::Empty => String::new(),
-                InjectPayload::Text(text) => text.clone(),
+                InjectPayload::Text(text) | InjectPayload::TextSkipConsumptionPoll(text) => {
+                    text.clone()
+                }
             });
         });
         Ok(Self::inject_report())

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

@@ -55,11 +55,13 @@
                     InjectVerification::EmptyTextSendKeys,
                     TurnVerification::NotRequired,
                 ),
-                InjectPayload::Text(text) if text.contains("[team-agent-token:") => (
+                InjectPayload::Text(text) | InjectPayload::TextSkipConsumptionPoll(text)
+                    if text.contains("[team-agent-token:") =>
+                (
                     InjectVerification::CaptureContainsToken,
                     TurnVerification::NotYetObserved,
                 ),
-                InjectPayload::Text(_) => (
+                InjectPayload::Text(_) | InjectPayload::TextSkipConsumptionPoll(_) => (
                     InjectVerification::NoToken,
                     TurnVerification::NotYetObserved,
                 ),

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

@@ -141,6 +141,21 @@ pub enum InjectPayload {
     /// → 纯 send submit-key。
     Empty,
     Text(String),
+    /// Text payload for human-facing panes that do not consume provider turns.
+    TextSkipConsumptionPoll(String),
+}
+
+impl InjectPayload {
+    pub fn text(&self) -> Option<&str> {
+        match self {
+            Self::Text(text) | Self::TextSkipConsumptionPoll(text) => Some(text),
+            Self::Empty => None,
+        }
+    }
+
+    pub fn skip_consumption_poll(&self) -> bool {
+        matches!(self, Self::TextSkipConsumptionPoll(_))
+    }
 }
 
 /// 抽象 Key 枚举(§gap-5):各后端翻译,不透传 tmux 字面量。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.28",
-    "@team-agent/cli-darwin-x64": "0.3.28",
-    "@team-agent/cli-linux-x64": "0.3.28"
+    "@team-agent/cli-darwin-arm64": "0.3.29",
+    "@team-agent/cli-darwin-x64": "0.3.29",
+    "@team-agent/cli-linux-x64": "0.3.29"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",