@team-agent/installer 0.5.75 → 0.5.78

package/crates/team-agent/src/state/persist.rs

@@ -377,6 +377,7 @@ fn save_runtime_state_with_merge_options(
         exact_owner_seed_to_clear,
         None,
         None,
+        None,
     )
 }
 
@@ -399,6 +400,7 @@ pub(crate) fn save_runtime_state_with_receiver_authority_and_expected(
         None,
         Some((expected_owner, expected_receiver)),
         None,
+        None,
     )
 }
 
@@ -421,6 +423,38 @@ pub(crate) fn save_runtime_state_with_exact_owner_receiver_cleanup(
         None,
         None,
         Some((team_key, expected_owner, expected_receiver)),
+        None,
+    )
+}
+
+pub(crate) fn save_runtime_state_with_exact_owner_receiver_restore(
+    workspace: &Path,
+    state: &Value,
+    team_key: &str,
+    expected_owner: &Value,
+    expected_receiver: &Value,
+    previous_owner: &Value,
+    previous_receiver: &Value,
+) -> Result<(), StateError> {
+    persist_runtime_state_with_merge_options_and_expected(
+        workspace,
+        state,
+        &[],
+        None,
+        &[],
+        None,
+        &[],
+        Some(team_key),
+        None,
+        None,
+        None,
+        Some((
+            team_key,
+            expected_owner,
+            expected_receiver,
+            previous_owner,
+            previous_receiver,
+        )),
     )
 }
 
@@ -436,6 +470,7 @@ fn persist_runtime_state_with_merge_options_and_expected(
     exact_owner_seed_to_clear: Option<&Value>,
     expected_owner_receiver: Option<(&Value, &Value)>,
     exact_owner_receiver_to_clear: Option<(&str, &Value, &Value)>,
+    exact_owner_receiver_to_restore: Option<(&str, &Value, &Value, &Value, &Value)>,
 ) -> Result<(), StateError> {
     let path = runtime_state_path(workspace);
     // Python `state.py:497`:先对入参 state 跑 `_migrate_state_identity`(就地填缺失 leader uuid)。
@@ -459,7 +494,8 @@ fn persist_runtime_state_with_merge_options_and_expected(
     // and leave the seed, or skip copying a concurrent owner.
     let skip_pre_lock_fast_path = exact_owner_seed_to_clear.is_some()
         || expected_owner_receiver.is_some()
-        || exact_owner_receiver_to_clear.is_some();
+        || exact_owner_receiver_to_clear.is_some()
+        || exact_owner_receiver_to_restore.is_some();
     if !skip_pre_lock_fast_path && cache_equals(&path, &migrated) {
         return Ok(());
     }
@@ -544,6 +580,7 @@ fn persist_runtime_state_with_merge_options_and_expected(
             &receiver_updates,
             receiver_update_team_key.zip(exact_owner_seed_to_clear),
             exact_owner_receiver_to_clear,
+            exact_owner_receiver_to_restore,
         )?;
     }
     // Stage 3 save-output strip second pass (defence-in-depth): after the
@@ -613,6 +650,7 @@ fn apply_persist_merge_contract(
     receiver_updates: &BTreeSet<String>,
     exact_owner_seed_to_clear: Option<(&str, &Value)>,
     exact_owner_receiver_to_clear: Option<(&str, &Value, &Value)>,
+    exact_owner_receiver_to_restore: Option<(&str, &Value, &Value, &Value, &Value)>,
 ) -> Result<(), StateError> {
     // A0/R1: the projection gate only guards the TOP-LEVEL passes (top-level agents and
     // the top-level<->active-team cross projections depend on which team is active); the
@@ -745,6 +783,25 @@ fn apply_persist_merge_contract(
                     );
                 }
             }
+            if let Some((
+                restore_team,
+                expected_owner,
+                expected_receiver,
+                previous_owner,
+                previous_receiver,
+            )) = exact_owner_receiver_to_restore
+            {
+                if team == restore_team {
+                    apply_lock_held_exact_owner_receiver_restore(
+                        incoming_entry,
+                        latest_entry,
+                        expected_owner,
+                        expected_receiver,
+                        previous_owner,
+                        previous_receiver,
+                    );
+                }
+            }
             preserve_latest_endpoint_convergence_fields(incoming_entry, latest_entry);
         }
     }
@@ -919,6 +976,43 @@ fn apply_lock_held_exact_owner_receiver_cleanup(
     }
 }
 
+fn apply_lock_held_exact_owner_receiver_restore(
+    incoming: &mut Value,
+    latest: &Value,
+    expected_owner: &Value,
+    expected_receiver: &Value,
+    previous_owner: &Value,
+    previous_receiver: &Value,
+) {
+    let latest_owner = latest.get("team_owner");
+    let latest_receiver = latest.get("leader_receiver");
+    let Some(incoming_obj) = incoming.as_object_mut() else {
+        return;
+    };
+    if latest_owner == Some(expected_owner) && latest_receiver == Some(expected_receiver) {
+        incoming_obj.insert("team_owner".to_string(), previous_owner.clone());
+        incoming_obj.insert("leader_receiver".to_string(), previous_receiver.clone());
+        if let Some(epoch) = previous_owner
+            .get("owner_epoch")
+            .cloned()
+            .or_else(|| latest.get("owner_epoch").cloned())
+        {
+            incoming_obj.insert("owner_epoch".to_string(), epoch);
+        }
+        return;
+    }
+    for key in ["team_owner", "leader_receiver", "owner_epoch"] {
+        match latest.get(key) {
+            Some(value) => {
+                incoming_obj.insert(key.to_string(), value.clone());
+            }
+            None => {
+                incoming_obj.remove(key);
+            }
+        }
+    }
+}
+
 fn preserve_latest_endpoint_convergence_fields(incoming: &mut Value, latest: &Value) {
     if !latest_has_preferable_endpoint_convergence(incoming, latest) {
         return;
@@ -3113,6 +3207,7 @@ mod tests {
             &BTreeSet::new(),
             None,
             None,
+            None,
         )
         .unwrap();
 
@@ -3149,6 +3244,7 @@ mod tests {
             &receiver_updates,
             None,
             None,
+            None,
         )
         .unwrap();
 

package/crates/team-agent/src/state/projection.rs

@@ -16,7 +16,8 @@ use serde_json::{json, Map, Value};
 
 use super::StateError;
 use crate::state::persist::{
-    load_runtime_state, save_runtime_state_with_deleted_agents,
+    load_runtime_state, load_runtime_state_without_migrations,
+    save_runtime_state_with_deleted_agents,
     save_runtime_state_with_lifecycle_topology_authority,
     save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip,
     save_runtime_state_with_team_tombstone_lifecycle_topology_authority,
@@ -504,7 +505,22 @@ pub fn resolve_runtime_team_scope(
     workspace: &Path,
     team: Option<&str>,
 ) -> Result<TeamScopeResolution, StateError> {
-    let state = load_runtime_state(workspace)?;
+    resolve_runtime_team_scope_loaded(load_runtime_state(workspace)?, team)
+}
+
+/// Same team selection as [`resolve_runtime_team_scope`], but never migrates or
+/// writes runtime state. Status and other read-only CLI surfaces must use this.
+pub fn resolve_runtime_team_scope_readonly(
+    workspace: &Path,
+    team: Option<&str>,
+) -> Result<TeamScopeResolution, StateError> {
+    resolve_runtime_team_scope_loaded(load_runtime_state_without_migrations(workspace)?, team)
+}
+
+fn resolve_runtime_team_scope_loaded(
+    state: Value,
+    team: Option<&str>,
+) -> Result<TeamScopeResolution, StateError> {
     let alive = team_state_candidates(&state);
     // Python `if team:` —— 空串 falsy,等同无 team(对抗 P1:此前 Some("") 误入 team 分支,空
     // team_dir 匹配致歧义/未找到错误串漂移)。

package/crates/team-agent/src/state/repository.rs

@@ -52,6 +52,8 @@ use super::persist::{
         as helper_write_root_with_receiver_authority_and_expected,
     save_runtime_state_with_exact_owner_receiver_cleanup
         as helper_write_root_with_exact_owner_receiver_cleanup,
+    save_runtime_state_with_exact_owner_receiver_restore
+        as helper_write_root_with_exact_owner_receiver_restore,
     save_runtime_state_with_team_tombstone_lifecycle_topology_authority as helper_write_root_with_team_tombstone_lifecycle_topology_authority,
     save_runtime_state_with_team_tombstoned_agents as helper_write_root_with_team_tombstoned_agents,
     save_runtime_state_without_migrations as helper_write_root_without_migrations,
@@ -224,9 +226,20 @@ pub enum StateWriteIntent<'a> {
         seed: &'a Value,
         expected_receiver: &'a Value,
     },
+    RestoreExactTeamOwnerAndReceiver {
+        team_key: &'a str,
+        expected_owner: &'a Value,
+        expected_receiver: &'a Value,
+        previous_owner: &'a Value,
+        previous_receiver: &'a Value,
+    },
     LeaderBindingRestoreNonTargetTeams {
         target_team_key: &'a str,
     },
+    /// Strip extra keys written by a failed or degraded quick-start bind attempt.
+    QuickStartBindingCleanup {
+        team_key: &'a str,
+    },
     LeaderStartBinding {
         team_key: &'a str,
         transport_kind: &'a str,
@@ -428,6 +441,22 @@ fn route_direct(
             seed,
             expected_receiver,
         ),
+        StateWriteIntent::RestoreExactTeamOwnerAndReceiver {
+            team_key,
+            expected_owner,
+            expected_receiver,
+            previous_owner,
+            previous_receiver,
+        } => helper_write_root_with_exact_owner_receiver_restore(
+            workspace,
+            state,
+            team_key,
+            expected_owner,
+            expected_receiver,
+            previous_owner,
+            previous_receiver,
+        ),
+        StateWriteIntent::QuickStartBindingCleanup { .. } => helper_write_root(workspace, state),
         StateWriteIntent::LeaderBindingRestoreNonTargetTeams { .. } => {
             helper_write_root_without_migrations(workspace, state)
         }

package/crates/team-agent/src/state/selector.rs

@@ -7,7 +7,9 @@ use serde_json::Value;
 
 use crate::model::paths::{canonical_run_workspace, runtime_spec_path, team_workspace};
 use crate::state::persist::runtime_state_path;
-use crate::state::projection::resolve_runtime_team_scope;
+use crate::state::projection::{
+    resolve_runtime_team_scope, resolve_runtime_team_scope_readonly, TeamScopeResolution,
+};
 use crate::state::StateError;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -35,6 +37,24 @@ pub fn resolve_active_team(
     input: &Path,
     team: Option<&str>,
     mode: SelectorMode,
+) -> Result<SelectedTeam, StateError> {
+    resolve_active_team_with(input, team, mode, resolve_runtime_team_scope)
+}
+
+/// Status-path selector: in-memory projection only, no runtime-state writeback.
+pub fn resolve_active_team_readonly(
+    input: &Path,
+    team: Option<&str>,
+    mode: SelectorMode,
+) -> Result<SelectedTeam, StateError> {
+    resolve_active_team_with(input, team, mode, resolve_runtime_team_scope_readonly)
+}
+
+fn resolve_active_team_with(
+    input: &Path,
+    team: Option<&str>,
+    mode: SelectorMode,
+    resolve_scope: fn(&Path, Option<&str>) -> Result<TeamScopeResolution, StateError>,
 ) -> Result<SelectedTeam, StateError> {
     let explicit_spec = input.join("team.spec.yaml");
     let (run_workspace, resolved) = if explicit_spec.exists() {
@@ -44,7 +64,7 @@ pub fn resolve_active_team(
         } else {
             team_run
         };
-        let resolved = resolve_runtime_team_scope(&run, team)?;
+        let resolved = resolve_scope(&run, team)?;
         (run, resolved)
     } else {
         let run =
@@ -59,7 +79,7 @@ pub fn resolve_active_team(
                 input.display()
             )));
         }
-        let resolved = resolve_runtime_team_scope(&run, team)?;
+        let resolved = resolve_scope(&run, team)?;
         (run, resolved)
     };
     let state = resolved.state;

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

@@ -0,0 +1,144 @@
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::time::{Duration, Instant};
+
+const CHILD_FLAG: &str = "--team-agent-models-timeout-child";
+const LIST_MODELS_FLAG: &str = "--list-models";
+const RECEIPT_ENV: &str = "TEAM_AGENT_MODELS_TIMEOUT_RECEIPT";
+const STAGE_RECEIPT_ENV: &str = "TEAM_AGENT_MODELS_TIMEOUT_STAGE_RECEIPT";
+const MODE_ENV: &str = "TEAM_AGENT_MODELS_TIMEOUT_MODE";
+const STDOUT_MARKER: &[u8] = b"__team_agent_models_timeout_descendant_stdout_v1__\n";
+const PARENT_HANDOFF_TIMEOUT: Duration = Duration::from_secs(1);
+
+// Stage values are UNIX epoch milliseconds so the test process and helper use
+// one directly comparable clock. Stage writes are best-effort diagnostics and
+// never change the fixture's production-facing exit semantics.
+fn append_stage(key: &str) {
+    let Some(path) = std::env::var_os(STAGE_RECEIPT_ENV) else {
+        return;
+    };
+    let Some(milliseconds) = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .ok()
+        .map(|duration| duration.as_millis())
+    else {
+        return;
+    };
+    let _ = append_receipt(Path::new(&path), key, milliseconds);
+}
+
+fn receipt_path() -> PathBuf {
+    std::env::var_os(RECEIPT_ENV)
+        .map(PathBuf::from)
+        .unwrap_or_else(|| std::process::exit(4))
+}
+
+fn append_receipt(path: &Path, key: &str, value: impl std::fmt::Display) -> Result<(), ()> {
+    let mut receipt = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)
+        .map_err(|_| ())?;
+    writeln!(receipt, "{key}={value}").map_err(|_| ())
+}
+
+fn wait_for_parent_handoff(receipt: &Path) {
+    let expected = format!("child_pid={}", std::process::id());
+    let deadline = Instant::now() + PARENT_HANDOFF_TIMEOUT;
+    loop {
+        if std::fs::read_to_string(receipt)
+            .ok()
+            .is_some_and(|text| text.lines().any(|line| line == expected))
+        {
+            return;
+        }
+        if Instant::now() >= deadline {
+            std::process::exit(5);
+        }
+        std::thread::sleep(Duration::from_millis(1));
+    }
+}
+
+fn child_main(args: &[String]) {
+    if args.len() != 1 || args[0] != CHILD_FLAG {
+        std::process::exit(5);
+    }
+    let receipt = receipt_path();
+    wait_for_parent_handoff(&receipt);
+
+    let mut stdout = std::io::stdout();
+    if stdout.write_all(STDOUT_MARKER).is_err() || stdout.flush().is_err() {
+        std::process::exit(5);
+    }
+    if append_receipt(&receipt, "child_argv_exact", 1).is_err()
+        || append_receipt(&receipt, "descendant_pid", std::process::id()).is_err()
+        || append_receipt(&receipt, "descendant_started", 1).is_err()
+        || append_receipt(&receipt, "descendant_stdout_inherited", 1).is_err()
+    {
+        std::process::exit(5);
+    }
+
+    std::thread::sleep(Duration::from_secs(2));
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    if args.first().is_some_and(|arg| arg == CHILD_FLAG) {
+        child_main(&args);
+        return;
+    }
+    if args.len() != 1 || args[0] != LIST_MODELS_FLAG {
+        std::process::exit(2);
+    }
+
+    match std::env::var(MODE_ENV) {
+        Ok(mode) if mode == "exit7" => {
+            eprintln!("sensitive-token");
+            std::process::exit(7);
+        }
+        Ok(mode) if mode == "oversize" => {
+            let mut stdout = std::io::stdout();
+            let bytes = [b'x'; 64];
+            let _ = stdout.write_all(&bytes);
+            let _ = stdout.flush();
+            return;
+        }
+        Ok(mode) if mode == "sleep" => {
+            std::thread::sleep(Duration::from_secs(2));
+            return;
+        }
+        Ok(mode) if mode == "descendant" => {}
+        Err(std::env::VarError::NotPresent) => {}
+        Ok(_) | Err(std::env::VarError::NotUnicode(_)) => std::process::exit(2),
+    }
+
+    append_stage("parent_entry_ms");
+    let receipt = receipt_path();
+    if append_receipt(&receipt, "parent_started_once", 1).is_err()
+        || append_receipt(&receipt, "parent_argv_exact", 1).is_err()
+        || append_receipt(&receipt, "parent_pid", std::process::id()).is_err()
+        || append_receipt(&receipt, "child_spawn_attempts", 1).is_err()
+    {
+        std::process::exit(4);
+    }
+
+    let executable = std::env::current_exe().unwrap_or_else(|_| std::process::exit(4));
+    append_stage("parent_before_child_spawn_ms");
+    let child = Command::new(executable)
+        .arg(CHILD_FLAG)
+        .env(RECEIPT_ENV, &receipt)
+        .stdin(Stdio::null())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::null())
+        .spawn()
+        .unwrap_or_else(|_| std::process::exit(4));
+    append_stage("parent_after_child_spawn_ms");
+    if append_receipt(&receipt, "child_pid", child.id()).is_err() {
+        std::process::exit(4);
+    }
+    append_stage("parent_before_exit_ms");
+    // The parent exits successfully without waiting; the child retains the
+    // inherited stdout pipe and self-exits after the real reader deadline.
+}

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

@@ -28,10 +28,10 @@ use crate::layout::worker_env::{
 use crate::model::enums::{PaneLiveness, Provider};
 use crate::transport::{
     command_basename, normalize_capture, tmux_capture_argv, tmux_query_argv, tmux_send_keys_argv,
-    tmux_spawn_argv, tmux_submit_key_name, AttachOutcome, CaptureRange, CaptureSampleOutcome,
-    InjectPayload, InjectStage, InjectVerification, InputSurfaceProbe, Key, PaneField, PaneId,
-    QueryOutcome, SessionName, SetEnvOutcome, SubmitVerification, Target, Transport,
-    TransportError, TurnVerification, WindowName,
+    tmux_spawn_argv, tmux_submit_key_name, AttachOutcome, BusySignalKind, CaptureRange,
+    CaptureSampleOutcome, InjectPayload, InjectStage, InjectVerification, InputSurfaceProbe, Key,
+    PaneField, PaneId, QueryOutcome, SessionName, SetEnvOutcome, SubmitConsumptionReason,
+    SubmitVerification, Target, Transport, TransportError, TurnVerification, WindowName,
 };
 
 type RecordedArgv = Arc<Mutex<Vec<Vec<String>>>>;
@@ -1051,6 +1051,15 @@ fn inject_text_runs_buffer_paste_submit_sequence_and_reports_submit() {
         SubmitVerification::EnterSentWithoutPlaceholderCheck
     );
     assert_eq!(report.turn_verification, TurnVerification::NotYetObserved);
+    let diagnostics = report.submit_diagnostics.expect("diagnostics");
+    assert_eq!(
+        diagnostics.consumption_reason,
+        SubmitConsumptionReason::NoMarker
+    );
+    assert_eq!(diagnostics.busy_signal_kind, None);
+    assert_eq!(diagnostics.current_marker_in_bottom_15, None);
+    assert_eq!(diagnostics.paste_identity_in_composer, None);
+    assert_eq!(diagnostics.consumption_from_capture_result, None);
 }
 
 #[test]
@@ -1409,10 +1418,18 @@ fn e46_post_submit_matched_token_without_scroll_is_unverified() {
         "token still in composer and no busy must report 没开跑, not unknown/started"
     );
     let diagnostics = report.submit_diagnostics.expect("diagnostics");
+    assert_eq!(diagnostics.busy_signal_kind, None);
+    assert_eq!(diagnostics.current_marker_in_bottom_15, Some(true));
+    assert_eq!(diagnostics.paste_identity_in_composer, None);
+    assert_eq!(diagnostics.consumption_from_capture_result, Some(false));
     assert!(
         diagnostics.attempts_detail.iter().any(|obs| obs.matched),
         "the unverified verdict must still record that paste landed"
     );
+    assert_eq!(
+        diagnostics.consumption_reason,
+        SubmitConsumptionReason::Unverified
+    );
 }
 
 #[test]
@@ -1452,6 +1469,56 @@ fn e46_unconsumed_token_with_live_busy_state_is_treated_as_processing() {
         "busy-state capture should be recorded in attempts_detail: {:?}",
         diagnostics.attempts_detail
     );
+    assert_eq!(
+        diagnostics.consumption_reason,
+        SubmitConsumptionReason::FallbackBusy
+    );
+    assert_eq!(diagnostics.before_busy_signal_kind, None);
+    assert_eq!(diagnostics.busy_signal_kind, Some(BusySignalKind::Working));
+    assert_eq!(diagnostics.busy_line_from_bottom, Some(0));
+    assert_eq!(diagnostics.current_marker_in_bottom_15, Some(true));
+    assert_eq!(diagnostics.paste_identity_in_composer, None);
+    assert_eq!(diagnostics.consumption_from_capture_result, Some(false));
+}
+
+#[test]
+fn e46_capture_error_clears_previous_consumption_observation() {
+    let token_text = "Team Agent message from leader:\n\nhi\n\n[team-agent-token:msg_capture_error]";
+    let busy_tail = format!("{token_text}\n● Working (1s · esc to interrupt)\n");
+    let visible = ok(token_text);
+    let queued = vec![
+        MockResp::Out(ok("")),         // set-buffer
+        MockResp::Out(ok("")),         // paste-buffer
+        MockResp::Out(ok("")),         // delete-buffer
+        MockResp::Out(visible.clone()), // pasted-content prompt: continue
+        MockResp::Out(visible),         // pre-submit token visibility
+        MockResp::Out(ok("")),         // Escape
+        MockResp::Out(ok("")),         // Enter
+        MockResp::Out(ok(&busy_tail)),  // first post-Enter capture: busy
+        // Default capture error forces the next poll/fallback/resend reads to fail.
+    ];
+    let (be, _rec) = backend_with(MockResp::Io(std::io::ErrorKind::Other), queued);
+    let report = be
+        .inject(
+            &Target::Pane(PaneId::new("%7")),
+            &InjectPayload::Text(token_text.to_string()),
+            Key::Enter,
+            true,
+        )
+        .expect("inject runs through capture failure");
+    let diagnostics = report.submit_diagnostics.expect("diagnostics");
+    assert_eq!(
+        report.submit_verification,
+        SubmitVerification::SubmitConsumptionUnverified
+    );
+    assert_eq!(diagnostics.consumption_reason, SubmitConsumptionReason::Unverified);
+    assert!(diagnostics.capture_err_count > 0);
+    assert_eq!(diagnostics.before_busy_signal_kind, None);
+    assert_eq!(diagnostics.busy_signal_kind, None);
+    assert_eq!(diagnostics.busy_line_from_bottom, None);
+    assert_eq!(diagnostics.current_marker_in_bottom_15, None);
+    assert_eq!(diagnostics.paste_identity_in_composer, None);
+    assert_eq!(diagnostics.consumption_from_capture_result, None);
 }
 
 /// NeverSeen + 无占位符：空 pane 不得再把「token 不在底部」写成 consumed。
@@ -1521,6 +1588,14 @@ fn e46_inject_text_with_token_consumed_after_enter_keeps_enter_sent_without_plac
              hold (provider_submit_verification_red.rs:113-159). Got {:?}",
         report.submit_verification
     );
+    let diagnostics = report.submit_diagnostics.expect("diagnostics");
+    assert_eq!(
+        diagnostics.consumption_reason,
+        SubmitConsumptionReason::ConsumptionFromCapture
+    );
+    assert_eq!(diagnostics.busy_signal_kind, None);
+    assert_eq!(diagnostics.current_marker_in_bottom_15, Some(false));
+    assert_eq!(diagnostics.consumption_from_capture_result, Some(true));
 }
 
 /// **E46 RED-3 (resend-to-cap, no double-submit)**: when the FIRST Enter
@@ -3289,6 +3364,15 @@ fn cursor_single_enter_busy_transcript_placeholder_does_not_retry() {
         "busy after first Enter is consumption for cursor; got {:?}",
         report.submit_verification
     );
+    let diagnostics = report.submit_diagnostics.expect("diagnostics");
+    assert_eq!(
+        diagnostics.consumption_reason,
+        SubmitConsumptionReason::CursorPollingBusy
+    );
+    assert_eq!(diagnostics.busy_signal_kind, Some(BusySignalKind::Working));
+    assert!(diagnostics.busy_line_from_bottom.is_some());
+    assert!(diagnostics.current_marker_in_bottom_15.is_some());
+    assert!(diagnostics.consumption_from_capture_result.is_some());
     let calls = rec.lock().unwrap().clone();
     assert_eq!(
         count_submit_enters(&calls),
@@ -3570,6 +3654,39 @@ fn grok_fold_worker_text_payload_polls_consumption() {
     );
 }
 
+#[test]
+fn provider_busy_signal_match_preserves_category_priority_and_tail_boundary() {
+    let cases = [
+        ("working", BusySignalKind::Working),
+        ("thinking", BusySignalKind::Thinking),
+        ("processing", BusySignalKind::Processing),
+        ("esc to interrupt", BusySignalKind::EscToInterrupt),
+        ("⠋", BusySignalKind::SpinnerGlyph),
+        ("working ⠋", BusySignalKind::Working),
+    ];
+    for (text, expected) in cases {
+        let matched = super::provider_busy_signal_match(text).expect("busy match");
+        assert_eq!(matched.kind, expected, "text={text:?}");
+        assert_eq!(matched.line_from_bottom, 0, "text={text:?}");
+        assert!(super::provider_busy_signal_in_tail(text));
+    }
+
+    let inside_bottom_15 = std::iter::once("working".to_string())
+        .chain((0..14).map(|index| format!("tail-{index}")))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let matched = super::provider_busy_signal_match(&inside_bottom_15).expect("15th line");
+    assert_eq!(matched.kind, BusySignalKind::Working);
+    assert_eq!(matched.line_from_bottom, 14);
+
+    let outside_bottom_15 = std::iter::once("working".to_string())
+        .chain((0..15).map(|index| format!("tail-{index}")))
+        .collect::<Vec<_>>()
+        .join("\n");
+    assert!(super::provider_busy_signal_match(&outside_bottom_15).is_none());
+    assert!(!super::provider_busy_signal_in_tail(&outside_bottom_15));
+}
+
 const G4_TOKEN: &str = "[team-agent-token:msg_g4]";
 
 #[test]