@team-agent/installer 0.5.77 → 0.5.78

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

@@ -1,16 +1,33 @@
 use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::os::unix::net::{UnixListener, UnixStream};
+use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
-use std::time::Duration;
+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 READY_SOCKET_ENV: &str = "TEAM_AGENT_MODELS_TIMEOUT_READY_SOCKET";
 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)
@@ -27,14 +44,29 @@ fn append_receipt(path: &Path, key: &str, value: impl std::fmt::Display) -> Resu
     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();
-    let socket = std::env::var_os(READY_SOCKET_ENV)
-        .map(PathBuf::from)
-        .unwrap_or_else(|| std::process::exit(5));
+    wait_for_parent_handoff(&receipt);
 
     let mut stdout = std::io::stdout();
     if stdout.write_all(STDOUT_MARKER).is_err() || stdout.flush().is_err() {
@@ -48,10 +80,6 @@ fn child_main(args: &[String]) {
         std::process::exit(5);
     }
 
-    let mut ready = UnixStream::connect(socket).unwrap_or_else(|_| std::process::exit(5));
-    if ready.write_all(b"1").is_err() {
-        std::process::exit(5);
-    }
     std::thread::sleep(Duration::from_secs(2));
 }
 
@@ -86,10 +114,8 @@ fn main() {
         Ok(_) | Err(std::env::VarError::NotUnicode(_)) => std::process::exit(2),
     }
 
+    append_stage("parent_entry_ms");
     let receipt = receipt_path();
-    let socket = PathBuf::from(format!("{}.sock", receipt.display()));
-    let _ = std::fs::remove_file(&socket);
-    let listener = UnixListener::bind(&socket).unwrap_or_else(|_| std::process::exit(4));
     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()
@@ -99,24 +125,20 @@ fn main() {
     }
 
     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)
-        .env(READY_SOCKET_ENV, &socket)
         .stdin(Stdio::null())
         .stdout(Stdio::inherit())
         .stderr(Stdio::null())
         .spawn()
         .unwrap_or_else(|_| std::process::exit(4));
-    let (mut ready, _) = listener.accept().unwrap_or_else(|_| std::process::exit(4));
-    let mut byte = [0_u8; 1];
-    if ready.read_exact(&mut byte).is_err() || byte != [b'1'] {
-        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);
     }
-    let _ = std::fs::remove_file(&socket);
+    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]