@team-agent/installer 0.3.28 → 0.3.30

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.28"
+version = "0.3.30"
 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.30"
 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/profile_launch.rs

@@ -157,9 +157,7 @@ fn prepare_profile_launch(
     let mut claude_projects_root = None;
     let mut managed_mcp_config = false;
 
-    if matches!(agent.provider, Provider::Claude | Provider::ClaudeCode)
-        && agent.auth_mode == AuthMode::CompatibleApi
-    {
+    if matches!(agent.provider, Provider::Claude | Provider::ClaudeCode) {
         let dir = compatible_claude_config_dir(workspace, &agent.id)?;
         if let Some(config) = mcp_config {
             ensure_compatible_claude_mcp_config(&dir, workspace, config)?;

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) {
+    // Leader pane: inject success is delivery proof. Worker pane: post-submit
+    // evidence is the delivery proof; stale Phase-1 readback must not veto it
+    // and cannot independently prove the current Enter submitted.
+    let verified = if is_leader_recipient {
+        true
+    } else {
+        submit_verified
+    };
+    if !verified {
         let reason = if !readback_verified {
             "pane_readback_unverified:capture_missing_token".to_string()
         } else {
@@ -496,13 +507,9 @@ pub(crate) fn inject_submit_verified(report: &InjectReport) -> bool {
     }
 }
 
-/// U1 #7 step-2: pane-readback gate. The submit may report verified (a key was sent)
-/// while the pasted token never actually landed in the pane — `inject()` step-1 now
-/// surfaces that as `InjectVerification::CaptureMissingToken`. A delivery is only truly
-/// verified when BOTH the submit succeeded AND the token was read back as visible.
-/// `CaptureMissingToken` → readback failed → not delivered (degraded/unverified). All
-/// other inject_verification variants (incl. token-less payloads, empty sends, new
-/// pasted-content prompt) are not readback-negative and pass this gate.
+/// U1 #7 step-2: pane-readback gate. `CaptureMissingToken` is negative readback
+/// evidence, but 0.3.30 submit evidence can supersede it: consumption or
+/// post-submit token observation proves the message reached the pane.
 /// 0.3.27: promoted to pub(crate) for leader_receiver.rs verification gate.
 pub(crate) fn pane_readback_verified(report: &InjectReport) -> bool {
     !matches!(

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

@@ -393,17 +393,12 @@ pub fn deliver_to_leader_fallback_pane(
 
     match inject_result {
         Ok(report) => {
-            // 0.3.27 P0: leader_receiver verification gate. The pre-fix path
-            // marked every inject Ok as delivered regardless of whether the
-            // submit was actually verified. Apply the same two-gate check that
-            // deliver_pending_message uses (delivery.rs:376-381):
-            //   (a) inject_submit_verified — Enter was accepted by the TUI
-            //   (b) pane_readback_verified — token was visible in the pane
-            // Both must pass to mark delivered; otherwise degrade to
-            // submitted_unverified (loud, not silent).
+            // 0.3.30: submit verification is enough for fallback-pane
+            // delivery. Readback is retained for diagnostics when submit
+            // itself is unverified.
             let submit_ok = super::delivery::inject_submit_verified(&report);
             let readback_ok = super::delivery::pane_readback_verified(&report);
-            if submit_ok && readback_ok {
+            if submit_ok {
                 store.mark(message_id, "delivered", None)?;
                 event_log.write(
                     "leader_receiver.fallback_pane_submitted",

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/messaging/tests/e23.rs

@@ -6,6 +6,11 @@ fn e23_fallback_pane_has_single_shared_noisy_surface() {
     assert!(leader_receiver.contains("leader_receiver.fallback_pane_submitted"));
     assert!(leader_receiver.contains("leader_receiver.fallback_pane_failed"));
     assert!(leader_receiver.contains("delivered_via=fallback_pane"));
+    assert!(
+        leader_receiver.contains("if submit_ok {")
+            && !leader_receiver.contains("submit_ok && readback_ok"),
+        "fallback pane delivery must accept submit_ok alone; stale readback must not veto it"
+    );
     assert!(
         leader_receiver.find("if primary_ok").unwrap()
             < leader_receiver

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

@@ -1269,7 +1269,9 @@ fn fire_due_scheduled_events_fires_each_scheduled_kind() {
     );
 }
 
-struct UnverifiedInjectTransport;
+struct UnverifiedInjectTransport {
+    readback_visible: bool,
+}
 impl Transport for UnverifiedInjectTransport {
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
@@ -1303,7 +1305,11 @@ impl Transport for UnverifiedInjectTransport {
     ) -> Result<InjectReport, TransportError> {
         Ok(InjectReport {
             stage_reached: crate::transport::InjectStage::Submit,
-            inject_verification: crate::transport::InjectVerification::CaptureContainsToken,
+            inject_verification: if self.readback_visible {
+                crate::transport::InjectVerification::CaptureContainsToken
+            } else {
+                crate::transport::InjectVerification::CaptureMissingToken
+            },
             submit_verification:
                 crate::transport::SubmitVerification::PastedContentPromptStillPresentAfterSubmit,
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
@@ -1441,12 +1447,8 @@ impl Transport for FailingInjectTransport {
     }
 }
 
-// U1 #7 step-2 (RED→GREEN) — pane-readback gate: a token payload whose token was NOT
-// read back as visible in the pane (`InjectVerification::CaptureMissingToken`, surfaced by
-// the step-1 tmux_backend readback) must NOT be counted delivered, even when the SUBMIT
-// itself verified. Today the delivery gate only consulted submit_verification → a silent
-// paste-drop reported delivered (false green). This transport returns a verified submit
-// (KeySentAfterVisibleToken) but a missing-token readback.
+// 0.3.30: submit evidence supersedes stale readback. This transport returns a
+// verified submit but a missing-token readback.
 struct ReadbackMissingTransport;
 impl Transport for ReadbackMissingTransport {
     fn kind(&self) -> BackendKind {
@@ -1507,7 +1509,7 @@ impl Transport for ReadbackMissingTransport {
 }
 
 #[test]
-fn deliver_pending_readback_missing_token_is_not_delivered() {
+fn deliver_pending_submit_verified_overrides_missing_readback() {
     let ws = tmp_ws("readbackmiss");
     let store = store_for(&ws);
     let log = EventLog::new(&ws);
@@ -1532,23 +1534,47 @@ fn deliver_pending_readback_missing_token_is_not_delivered() {
     .unwrap();
 
     assert!(
-        !out.ok,
-        "U1 #7: a submit-verified inject whose token was NOT read back (CaptureMissingToken) \
-must NOT be delivered — readback gate catches the silent paste drop"
+        out.ok,
+        "0.3.30: submit-verified delivery must not be vetoed by stale CaptureMissingToken readback"
     );
-    assert_ne!(
+    assert_eq!(
         out.message_status.0, "delivered",
-        "U1 #7: readback-missing must not mark the message delivered (false green)"
+        "0.3.30: submit evidence is stronger than readback"
     );
-    let events = log.tail(0).unwrap();
+}
+
+#[test]
+fn deliver_pending_submit_unverified_is_not_saved_by_readback() {
+    let ws = tmp_ws("readbacksaves");
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let state = serde_json::json!({
+        "session_name": "team-readbacksaves",
+        "leader_receiver": {"pane_id": "%leader"},
+        "agents": {"w1": {"provider": "fake", "pane_id": "%1"}}
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let message_id = store
+        .create_message(None, "leader", "w1", "ping", None, false, None)
+        .unwrap();
+
+    let out = deliver_pending_message(
+        &ws,
+        &store,
+        &UnverifiedInjectTransport {
+            readback_visible: true,
+        },
+        &message_id,
+        &log,
+        &state,
+    )
+    .unwrap();
+
     assert!(
-        events.iter().any(|event| event
-            .get("reason")
-            .and_then(serde_json::Value::as_str)
-            .map(|r| r.contains("pane_readback_unverified"))
-            .unwrap_or(false)),
-        "U1 #7: the failure reason must name pane_readback_unverified (loud, not silent); got {events:?}"
+        !out.ok,
+        "0.3.30: positive readback alone must not mark delivered when submit is unverified"
     );
+    assert_ne!(out.message_status.0, "delivered");
 }
 
 #[test]
@@ -1569,7 +1595,9 @@ fn deliver_pending_exhausted_unverified_send_emits_failed_event() {
     let out = deliver_pending_message(
         &ws,
         &store,
-        &UnverifiedInjectTransport,
+        &UnverifiedInjectTransport {
+            readback_visible: false,
+        },
         &message_id,
         &log,
         &state,

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.
     //
@@ -589,21 +623,11 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
     // 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.
-    /// 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.
+    /// 0.3.30 false-negative fix: token seen during post-submit consumption
+    /// polling proves the paste landed after Enter was sent. If it never
+    /// scrolls away, that is slow provider output, not transport failure.
     #[test]
-    fn e46_inject_text_with_token_visible_but_unconsumed_reports_unverified() {
+    fn e46_post_submit_matched_token_without_scroll_is_verified() {
         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,19 +638,50 @@ CaptureMissingToken, not the static CaptureContainsToken false-positive"
                 true,
             )
             .expect("inject runs");
-        // 0.3.28-final: no grace fallback. Token visible + not consumed →
-        // SubmitConsumptionUnverified (delivery treats as not delivered).
         assert_eq!(
             report.submit_verification,
-            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 {:?}",
+            SubmitVerification::EnterSentWithoutPlaceholderCheck,
+            "0.3.30: post-submit matched=true is delivery proof even when \
+             the token stays in the bottom capture window. Got {:?}",
             report.submit_verification
         );
         assert_eq!(report.turn_verification, TurnVerification::NotYetObserved);
+        let diagnostics = report.submit_diagnostics.expect("diagnostics");
+        assert!(
+            diagnostics.attempts_detail.iter().any(|obs| obs.matched),
+            "the positive verdict must be backed by a post-submit matched observation"
+        );
+    }
+
+    #[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
@@ -968,6 +1023,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,38 @@ 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();
+                let mut any_attempt_matched = false;
 
-                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)) {
+                                let obs = submit_attempt_observation(
+                                    attempt_index,
+                                    &cap,
+                                    marker,
+                                    attempt_start.elapsed().as_millis() as u64,
+                                );
+                                if obs.matched {
+                                    any_attempt_matched = true;
+                                }
+                                attempts_detail.push(obs);
+                                if !token_in_bottom_n(&cap.text, m, 15) {
                                     consumed = Some(true);
                                     break;
                                 }
@@ -1468,16 +1557,26 @@ 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) {
+                                    let obs = submit_attempt_observation(
+                                        attempt_index,
+                                        &cap,
+                                        marker,
+                                        attempt_start.elapsed().as_millis() as u64,
+                                    );
+                                    if obs.matched {
+                                        any_attempt_matched = true;
+                                    }
+                                    attempts_detail.push(obs);
+                                    if !token_in_bottom_n(&cap.text, m, 15) {
                                         found_consumed = true;
                                         break;
                                     }
@@ -1502,18 +1601,40 @@ impl Transport for TmuxBackend {
 
                 let submit_verification = match consumed {
                     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;
-                    // 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,
+                    Some(false) => {
+                        if any_attempt_matched {
+                            eprintln!(
+                                "team-agent submit consumption: consumed=false any_attempt_matched=true -> verified"
+                            );
+                            SubmitVerification::EnterSentWithoutPlaceholderCheck
+                        } else {
+                            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 any_attempt_matched=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 +1647,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 +1668,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.30",
   "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.30",
+    "@team-agent/cli-darwin-x64": "0.3.30",
+    "@team-agent/cli-linux-x64": "0.3.30"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",