@team-agent/installer 0.5.42 → 0.5.44

package/crates/team-agent/src/coordinator/tests/basics.rs

@@ -30,30 +30,102 @@ fn rotation_marker_is_byte_exact() {
 #[test]
 fn status_enums_serialize_to_exact_python_strings() {
     let cases: &[(String, &str)] = &[
-        (serde_json::to_string(&CoordinatorHealthStatus::Missing).unwrap(), "\"missing\""),
-        (serde_json::to_string(&CoordinatorHealthStatus::InvalidPid).unwrap(), "\"invalid_pid\""),
-        (serde_json::to_string(&CoordinatorHealthStatus::Running).unwrap(), "\"running\""),
-        (serde_json::to_string(&CoordinatorHealthStatus::Stale).unwrap(), "\"stale\""),
-        (serde_json::to_string(&StartOutcome::AlreadyRunning).unwrap(), "\"already_running\""),
-        (serde_json::to_string(&StartOutcome::RestartIncompatibleStopFailed).unwrap(), "\"restart_incompatible_stop_failed\""),
-        (serde_json::to_string(&StartOutcome::SchemaIncompatible).unwrap(), "\"schema_incompatible\""),
-        (serde_json::to_string(&StartOutcome::Started).unwrap(), "\"started\""),
-        (serde_json::to_string(&StartOutcome::StartedAfterRotation).unwrap(), "\"started_after_rotation\""),
-        (serde_json::to_string(&StopOutcome::Missing).unwrap(), "\"missing\""),
-        (serde_json::to_string(&StopOutcome::InvalidPidRemoved).unwrap(), "\"invalid_pid_removed\""),
-        (serde_json::to_string(&StopOutcome::KillFailed).unwrap(), "\"kill_failed\""),
-        (serde_json::to_string(&StopOutcome::Stopped).unwrap(), "\"stopped\""),
-        (serde_json::to_string(&TickStopReason::TmuxSessionMissing).unwrap(), "\"tmux_session_missing\""),
-        (serde_json::to_string(&TickStopReason::PersistenceDegraded).unwrap(), "\"persistence_degraded\""),
-        (serde_json::to_string(&MetadataSource::Boot).unwrap(), "\"boot\""),
-        (serde_json::to_string(&MetadataSource::Start).unwrap(), "\"start\""),
-        (serde_json::to_string(&AbnormalDecision::Skip).unwrap(), "\"skip\""),
-        (serde_json::to_string(&AbnormalDecision::NotifyBlacklist).unwrap(), "\"notify_blacklist\""),
-        (serde_json::to_string(&AbnormalDecision::NotifyDefault).unwrap(), "\"notify_default\""),
-        (serde_json::to_string(&WholeTeamGoneClass::Alive).unwrap(), "\"alive\""),
-        (serde_json::to_string(&WholeTeamGoneClass::CleanShutdown).unwrap(), "\"clean_shutdown\""),
-        (serde_json::to_string(&WholeTeamGoneClass::RestartInProgress).unwrap(), "\"restart_in_progress\""),
-        (serde_json::to_string(&WholeTeamGoneClass::UnexpectedExit).unwrap(), "\"unexpected_exit\""),
+        (
+            serde_json::to_string(&CoordinatorHealthStatus::Missing).unwrap(),
+            "\"missing\"",
+        ),
+        (
+            serde_json::to_string(&CoordinatorHealthStatus::InvalidPid).unwrap(),
+            "\"invalid_pid\"",
+        ),
+        (
+            serde_json::to_string(&CoordinatorHealthStatus::Running).unwrap(),
+            "\"running\"",
+        ),
+        (
+            serde_json::to_string(&CoordinatorHealthStatus::Stale).unwrap(),
+            "\"stale\"",
+        ),
+        (
+            serde_json::to_string(&StartOutcome::AlreadyRunning).unwrap(),
+            "\"already_running\"",
+        ),
+        (
+            serde_json::to_string(&StartOutcome::RestartIncompatibleStopFailed).unwrap(),
+            "\"restart_incompatible_stop_failed\"",
+        ),
+        (
+            serde_json::to_string(&StartOutcome::SchemaIncompatible).unwrap(),
+            "\"schema_incompatible\"",
+        ),
+        (
+            serde_json::to_string(&StartOutcome::Started).unwrap(),
+            "\"started\"",
+        ),
+        (
+            serde_json::to_string(&StartOutcome::StartedAfterRotation).unwrap(),
+            "\"started_after_rotation\"",
+        ),
+        (
+            serde_json::to_string(&StopOutcome::Missing).unwrap(),
+            "\"missing\"",
+        ),
+        (
+            serde_json::to_string(&StopOutcome::InvalidPidRemoved).unwrap(),
+            "\"invalid_pid_removed\"",
+        ),
+        (
+            serde_json::to_string(&StopOutcome::KillFailed).unwrap(),
+            "\"kill_failed\"",
+        ),
+        (
+            serde_json::to_string(&StopOutcome::Stopped).unwrap(),
+            "\"stopped\"",
+        ),
+        (
+            serde_json::to_string(&TickStopReason::TmuxSessionMissing).unwrap(),
+            "\"tmux_session_missing\"",
+        ),
+        (
+            serde_json::to_string(&TickStopReason::PersistenceDegraded).unwrap(),
+            "\"persistence_degraded\"",
+        ),
+        (
+            serde_json::to_string(&MetadataSource::Boot).unwrap(),
+            "\"boot\"",
+        ),
+        (
+            serde_json::to_string(&MetadataSource::Start).unwrap(),
+            "\"start\"",
+        ),
+        (
+            serde_json::to_string(&AbnormalDecision::Skip).unwrap(),
+            "\"skip\"",
+        ),
+        (
+            serde_json::to_string(&AbnormalDecision::NotifyBlacklist).unwrap(),
+            "\"notify_blacklist\"",
+        ),
+        (
+            serde_json::to_string(&AbnormalDecision::NotifyDefault).unwrap(),
+            "\"notify_default\"",
+        ),
+        (
+            serde_json::to_string(&WholeTeamGoneClass::Alive).unwrap(),
+            "\"alive\"",
+        ),
+        (
+            serde_json::to_string(&WholeTeamGoneClass::CleanShutdown).unwrap(),
+            "\"clean_shutdown\"",
+        ),
+        (
+            serde_json::to_string(&WholeTeamGoneClass::RestartInProgress).unwrap(),
+            "\"restart_in_progress\"",
+        ),
+        (
+            serde_json::to_string(&WholeTeamGoneClass::UnexpectedExit).unwrap(),
+            "\"unexpected_exit\"",
+        ),
     ];
     for (got, want) in cases {
         assert_eq!(got, want);
@@ -65,26 +137,64 @@ fn coordinator_event_tags_are_byte_stable() {
     // 逐一钉 events.jsonl tag(events.py 稳定契约)。
     let pid = Pid(4242);
     let cases: Vec<(CoordinatorEvent, &str)> = vec![
-        (CoordinatorEvent::Boot { workspace: "/w".into(), once: true }, "coordinator.boot"),
-        (CoordinatorEvent::Started { pid, log: "/l".into() }, "coordinator.started"),
+        (
+            CoordinatorEvent::Boot {
+                workspace: "/w".into(),
+                once: true,
+            },
+            "coordinator.boot",
+        ),
+        (
+            CoordinatorEvent::Started {
+                pid,
+                log: "/l".into(),
+            },
+            "coordinator.started",
+        ),
         (CoordinatorEvent::Stopped { pid }, "coordinator.stopped"),
         (CoordinatorEvent::Exit { stop: true }, "coordinator.exit"),
-        (CoordinatorEvent::SessionMissing { session: "s".into() }, "coordinator.session_missing"),
         (
-            CoordinatorEvent::OrphanSelfTerminate { initial_ppid: 9, current_ppid: 1, workspace: "/w".into() },
+            CoordinatorEvent::SessionMissing {
+                session: "s".into(),
+            },
+            "coordinator.session_missing",
+        ),
+        (
+            CoordinatorEvent::OrphanSelfTerminate {
+                initial_ppid: 9,
+                current_ppid: 1,
+                workspace: "/w".into(),
+            },
             "coordinator.orphan_self_terminate",
         ),
         (
-            CoordinatorEvent::TickError { error: "boom".into(), exc_type: "OSError".into(), consecutive_failures: 1, next_sleep_sec: 5.0 },
+            CoordinatorEvent::TickError {
+                error: "boom".into(),
+                exc_type: "OSError".into(),
+                consecutive_failures: 1,
+                next_sleep_sec: 5.0,
+            },
             "coordinator.tick_error",
         ),
         (
-            CoordinatorEvent::TickErrorSuppressed { consecutive_failures: 2, next_sleep_sec: 10.0 },
+            CoordinatorEvent::TickErrorSuppressed {
+                consecutive_failures: 2,
+                next_sleep_sec: 10.0,
+            },
             "coordinator.tick_error.suppressed",
         ),
-        (CoordinatorEvent::TickRecovered { consecutive_failures: 3 }, "coordinator.tick_recovered"),
         (
-            CoordinatorEvent::RestartIncompatible { pid: Some(pid), expected_protocol: 2, expected_schema: 3 },
+            CoordinatorEvent::TickRecovered {
+                consecutive_failures: 3,
+            },
+            "coordinator.tick_recovered",
+        ),
+        (
+            CoordinatorEvent::RestartIncompatible {
+                pid: Some(pid),
+                expected_protocol: 2,
+                expected_schema: 3,
+            },
             "coordinator.restart_incompatible",
         ),
         (
@@ -92,7 +202,10 @@ fn coordinator_event_tags_are_byte_stable() {
             "coordinator.restart_incompatible_stop_failed",
         ),
         (
-            CoordinatorEvent::SchemaIncompatible { table: Some("messages".into()), missing_columns: vec!["owner_team_id".into()] },
+            CoordinatorEvent::SchemaIncompatible {
+                table: Some("messages".into()),
+                missing_columns: vec!["owner_team_id".into()],
+            },
             "coordinator.schema_incompatible",
         ),
         (
@@ -106,17 +219,33 @@ fn coordinator_event_tags_are_byte_stable() {
             "idle_takeover.unknown_persistent",
         ),
         (
-            CoordinatorEvent::AbnormalNotify { signature: "sig".into(), turn_id: None, decision: AbnormalDecision::NotifyDefault },
+            CoordinatorEvent::AbnormalNotify {
+                signature: "sig".into(),
+                turn_id: None,
+                decision: AbnormalDecision::NotifyDefault,
+            },
             "abnormal.notify",
         ),
         (
-            CoordinatorEvent::AbnormalWholeTeamGone { classification: WholeTeamGoneClass::UnexpectedExit },
+            CoordinatorEvent::AbnormalWholeTeamGone {
+                classification: WholeTeamGoneClass::UnexpectedExit,
+            },
             "abnormal.whole_team_gone",
         ),
-        (CoordinatorEvent::LeaderNotificationLogPruned { removed: 7 }, "leader_notification.log_pruned"),
-        (CoordinatorEvent::LeaderNotificationPruneFailed { error: "io".into() }, "leader_notification.prune_failed"),
         (
-            CoordinatorEvent::RuntimeStateSaveFailed { phase: "tick_end".into(), error: "replace".into(), exc_type: "OSError".into() },
+            CoordinatorEvent::LeaderNotificationLogPruned { removed: 7 },
+            "leader_notification.log_pruned",
+        ),
+        (
+            CoordinatorEvent::LeaderNotificationPruneFailed { error: "io".into() },
+            "leader_notification.prune_failed",
+        ),
+        (
+            CoordinatorEvent::RuntimeStateSaveFailed {
+                phase: "tick_end".into(),
+                error: "replace".into(),
+                exc_type: "OSError".into(),
+            },
             "runtime.state.save_failed",
         ),
     ];
@@ -157,11 +286,20 @@ fn unknown_persistent_event_provider_none_is_null_not_missing() {
     let json = serde_json::to_value(&evt).unwrap();
     assert_eq!(json["event"], "idle_takeover.unknown_persistent");
     assert_eq!(json["node_id"], "w7");
-    assert!(json.get("provider").is_some(), "provider key MUST be present (None→null)");
+    assert!(
+        json.get("provider").is_some(),
+        "provider key MUST be present (None→null)"
+    );
     assert!(json["provider"].is_null(), "provider None → JSON null");
-    assert!(json.get("auth_mode").is_some(), "auth_mode key MUST be present");
+    assert!(
+        json.get("auth_mode").is_some(),
+        "auth_mode key MUST be present"
+    );
     assert!(json["auth_mode"].is_null(), "auth_mode None → JSON null");
-    assert!(json.get("rollout_path").is_some(), "rollout_path key MUST be present");
+    assert!(
+        json.get("rollout_path").is_some(),
+        "rollout_path key MUST be present"
+    );
     assert!(json["rollout_path"].is_null());
     assert_eq!(json["consecutive_ticks"], 72);
 }

package/crates/team-agent/src/coordinator/tests/daemon.rs

@@ -12,7 +12,11 @@ use super::*;
 fn daemon_ws() -> (WorkspacePath, std::path::PathBuf) {
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
-    let dir = std::env::temp_dir().join(format!("ta-rs-daemon-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
+    let dir = std::env::temp_dir().join(format!(
+        "ta-rs-daemon-{}-{}",
+        std::process::id(),
+        N.fetch_add(1, Ordering::Relaxed)
+    ));
     std::fs::create_dir_all(crate::model::paths::runtime_dir(&dir)).unwrap();
     let _ = crate::message_store::MessageStore::open(&dir).unwrap(); // create the schema (schema_ok)
     (WorkspacePath::new(dir.clone()), dir)
@@ -35,8 +39,15 @@ fn coordinator_health_running_with_matching_metadata_is_ok() {
     write_coordinator_metadata(&wp, me, MetadataSource::Boot).unwrap();
     std::fs::write(coordinator_pid_path(&wp), me.0.to_string()).unwrap();
     let h = coordinator_health(&wp);
-    assert_eq!(h.status, CoordinatorHealthStatus::Running, "a live pid -> status running");
-    assert!(h.metadata_ok, "pid+protocol+schema all match -> metadata_ok");
+    assert_eq!(
+        h.status,
+        CoordinatorHealthStatus::Running,
+        "a live pid -> status running"
+    );
+    assert!(
+        h.metadata_ok,
+        "pid+protocol+schema all match -> metadata_ok"
+    );
     assert!(h.ok, "running ∧ metadata_ok ∧ schema_ok -> healthy");
 }
 
@@ -48,7 +59,11 @@ fn coordinator_health_dead_pid_is_stale_not_ok() {
     write_coordinator_metadata(&wp, dead, MetadataSource::Boot).unwrap();
     std::fs::write(coordinator_pid_path(&wp), dead.0.to_string()).unwrap();
     let h = coordinator_health(&wp);
-    assert_eq!(h.status, CoordinatorHealthStatus::Stale, "a dead pid -> status stale");
+    assert_eq!(
+        h.status,
+        CoordinatorHealthStatus::Stale,
+        "a dead pid -> status stale"
+    );
     assert!(!h.ok, "a stale daemon is not healthy");
 }
 
@@ -60,7 +75,11 @@ fn start_coordinator_when_healthy_is_already_running_no_spawn() {
     write_coordinator_metadata(&wp, me, MetadataSource::Boot).unwrap();
     std::fs::write(coordinator_pid_path(&wp), me.0.to_string()).unwrap();
     let report = start_coordinator(&wp).expect("start_coordinator");
-    assert_eq!(report.status, StartOutcome::AlreadyRunning, "a healthy coordinator -> AlreadyRunning (no spawn)");
+    assert_eq!(
+        report.status,
+        StartOutcome::AlreadyRunning,
+        "a healthy coordinator -> AlreadyRunning (no spawn)"
+    );
     assert!(report.ok);
     assert_eq!(report.pid, Some(me));
 }
@@ -86,10 +105,22 @@ fn start_coordinator_fresh_workspace_decides_started() {
             single-tick testing"]
 fn run_daemon_once_writes_boot_metadata_and_returns_ok() {
     let (wp, dir) = daemon_ws();
-    crate::state::persist::save_runtime_state(&dir, &serde_json::json!({"session_name": "team-x", "agents": {}})).unwrap();
-    let r = run_daemon(DaemonArgs { workspace: wp.clone(), once: true, tick_interval_sec: None, team_key: None });
+    crate::state::persist::save_runtime_state(
+        &dir,
+        &serde_json::json!({"session_name": "team-x", "agents": {}}),
+    )
+    .unwrap();
+    let r = run_daemon(DaemonArgs {
+        workspace: wp.clone(),
+        once: true,
+        tick_interval_sec: None,
+        team_key: None,
+    });
     assert!(r.is_ok(), "run_daemon --once must return Ok; got {r:?}");
-    assert!(coordinator_meta_path(&wp).exists(), "run_daemon must write the coordinator boot metadata");
+    assert!(
+        coordinator_meta_path(&wp).exists(),
+        "run_daemon must write the coordinator boot metadata"
+    );
 }
 
 // ═════════════════════════════════════════════════════════════════════════
@@ -403,8 +434,11 @@ fn tick_genuine_fast_session_miss_still_stops() {
     // genuinely gone) => {ok:false, stop:true, reason:tmux_session_missing}. The OTHER side of the
     // fork from the timeout case: a definitive miss MUST still stop the daemon. LOCK (already GREEN):
     // guards the genuine-miss stop from being swallowed when the timeout tolerance is added.
-    let (coord, _dir, _seen) =
-        coord_over_staged_tmux("team-spine", vec![RunnerStep::Exit(false)], RunnerStep::Exit(false));
+    let (coord, _dir, _seen) = coord_over_staged_tmux(
+        "team-spine",
+        vec![RunnerStep::Exit(false)],
+        RunnerStep::Exit(false),
+    );
     let report = coord
         .tick()
         .expect("a definitive miss is a typed stop report, not an Err");
@@ -453,15 +487,21 @@ fn run_daemon_backs_off_on_transient_tick_err_then_recovers_without_exiting() {
     let err_idx = tags
         .iter()
         .position(|t| *t == "coordinator.tick_error")
-        .unwrap_or_else(|| panic!("a transient tick Err must log coordinator.tick_error; got {tags:?}"));
+        .unwrap_or_else(|| {
+            panic!("a transient tick Err must log coordinator.tick_error; got {tags:?}")
+        });
     let rec_idx = tags
         .iter()
         .position(|t| *t == "coordinator.tick_recovered")
-        .unwrap_or_else(|| panic!("the recovering Ok tick must log coordinator.tick_recovered; got {tags:?}"));
+        .unwrap_or_else(|| {
+            panic!("the recovering Ok tick must log coordinator.tick_recovered; got {tags:?}")
+        });
     let exit_idx = tags
         .iter()
         .position(|t| *t == "coordinator.exit")
-        .unwrap_or_else(|| panic!("the daemon must log coordinator.exit once it stops; got {tags:?}"));
+        .unwrap_or_else(|| {
+            panic!("the daemon must log coordinator.exit once it stops; got {tags:?}")
+        });
     assert!(
         err_idx < rec_idx,
         "tick_recovered must FOLLOW tick_error (backoff then recover); got {tags:?}"

package/crates/team-agent/src/coordinator/tests/health_sync.rs

@@ -20,17 +20,38 @@ impl Transport for CapturingTransport {
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
     }
-    fn spawn_first(&self, _s: &SessionName, _w: &WindowName, _a: &[String], _c: &std::path::Path, _e: &std::collections::BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_first(
+        &self,
+        _s: &SessionName,
+        _w: &WindowName,
+        _a: &[String],
+        _c: &std::path::Path,
+        _e: &std::collections::BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         unimplemented!("not reached")
     }
-    fn spawn_into(&self, _s: &SessionName, _w: &WindowName, _a: &[String], _c: &std::path::Path, _e: &std::collections::BTreeMap<String, String>) -> Result<SpawnResult, TransportError> {
+    fn spawn_into(
+        &self,
+        _s: &SessionName,
+        _w: &WindowName,
+        _a: &[String],
+        _c: &std::path::Path,
+        _e: &std::collections::BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
         unimplemented!("not reached")
     }
-    fn inject(&self, _t: &Target, _p: &InjectPayload, _s: Key, _b: bool) -> Result<InjectReport, TransportError> {
+    fn inject(
+        &self,
+        _t: &Target,
+        _p: &InjectPayload,
+        _s: Key,
+        _b: bool,
+    ) -> Result<InjectReport, TransportError> {
         Ok(InjectReport {
             stage_reached: crate::transport::InjectStage::Submit,
             inject_verification: crate::transport::InjectVerification::CaptureContainsToken,
-            submit_verification: crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
+            submit_verification:
+                crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck,
             turn_verification: crate::transport::TurnVerification::NotYetObserved,
             attempts: 1,
             submit_diagnostics: None,
@@ -40,7 +61,10 @@ impl Transport for CapturingTransport {
         Ok(())
     }
     fn capture(&self, _t: &Target, range: CaptureRange) -> Result<CapturedText, TransportError> {
-        Ok(CapturedText { text: self.scrollback.clone(), range })
+        Ok(CapturedText {
+            text: self.scrollback.clone(),
+            range,
+        })
     }
     fn query(&self, _t: &Target, _f: PaneField) -> Result<Option<String>, TransportError> {
         Ok(None)
@@ -57,7 +81,12 @@ impl Transport for CapturingTransport {
     fn list_windows(&self, _s: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         Ok(vec![WindowName::new("w1")])
     }
-    fn set_session_env(&self, _s: &SessionName, _k: &str, _v: &str) -> Result<SetEnvOutcome, TransportError> {
+    fn set_session_env(
+        &self,
+        _s: &SessionName,
+        _k: &str,
+        _v: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
         Ok(SetEnvOutcome::Applied)
     }
     fn kill_session(&self, _s: &SessionName) -> Result<(), TransportError> {
@@ -74,7 +103,10 @@ impl Transport for CapturingTransport {
 /// Build a Coordinator over a real seeded workspace (truthy session_name + the given agents map) with
 /// the CapturingTransport staging `scrollback` for every pane. Returns the workspace dir so the test
 /// can load_runtime_state after the tick.
-fn seeded_health_coord(agents: serde_json::Value, scrollback: &str) -> (Coordinator, std::path::PathBuf) {
+fn seeded_health_coord(
+    agents: serde_json::Value,
+    scrollback: &str,
+) -> (Coordinator, std::path::PathBuf) {
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
     let dir = std::env::temp_dir().join(format!(
@@ -93,7 +125,9 @@ fn seeded_health_coord(agents: serde_json::Value, scrollback: &str) -> (Coordina
     let coord = Coordinator::for_test(
         ws,
         reg,
-        Box::new(CapturingTransport { scrollback: scrollback.to_string() }),
+        Box::new(CapturingTransport {
+            scrollback: scrollback.to_string(),
+        }),
         None,
         None,
     );
@@ -136,11 +170,18 @@ fn spine2_sync_health_classifies_idle_scrollback() {
 // NEVER as idle. Today: no activity written.
 #[test]
 fn spine2_sync_health_unknown_scrollback_never_idle() {
-    let (coord, dir) = seeded_health_coord(one_agent("codex"), "garbled noise xyz 12345 no recognizable signal");
+    let (coord, dir) = seeded_health_coord(
+        one_agent("codex"),
+        "garbled noise xyz 12345 no recognizable signal",
+    );
     coord.tick().expect("tick");
     let status = agent_activity_status(&dir, "w1");
     assert!(status.is_some(), "sync_health must classify the agent (write activity); today the probe writes nothing. got {status:?}");
-    assert_ne!(status.as_deref(), Some("idle"), "§11: an UNKNOWN scrollback must NEVER be classified idle");
+    assert_ne!(
+        status.as_deref(),
+        Some("idle"),
+        "§11: an UNKNOWN scrollback must NEVER be classified idle"
+    );
 }
 
 // P0 §11 — a WORKING scrollback classifies the agent but never idle.
@@ -149,8 +190,15 @@ fn spine2_sync_health_working_scrollback_never_idle() {
     let (coord, dir) = seeded_health_coord(one_agent("codex"), "Working (5s · esc to interrupt)");
     coord.tick().expect("tick");
     let status = agent_activity_status(&dir, "w1");
-    assert!(status.is_some(), "sync_health must classify a working agent; today no activity. got {status:?}");
-    assert_ne!(status.as_deref(), Some("idle"), "§11: a WORKING scrollback must not be idle");
+    assert!(
+        status.is_some(),
+        "sync_health must classify a working agent; today no activity. got {status:?}"
+    );
+    assert_ne!(
+        status.as_deref(),
+        Some("idle"),
+        "§11: a WORKING scrollback must not be idle"
+    );
 }
 
 // P1 — sync_health records last_output_at on a pane delta (so detect_stuck / take-over downstream can
@@ -172,7 +220,11 @@ fn spine2_sync_health_records_last_output_at() {
 fn spine2_capture_missing_captures_session_id_for_missing_agent() {
     use std::sync::atomic::{AtomicU64, Ordering};
     static N: AtomicU64 = AtomicU64::new(0);
-    let tdir = std::env::temp_dir().join(format!("ta-rs-health-tx-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
+    let tdir = std::env::temp_dir().join(format!(
+        "ta-rs-health-tx-{}-{}",
+        std::process::id(),
+        N.fetch_add(1, Ordering::Relaxed)
+    ));
     std::fs::create_dir_all(&tdir).unwrap();
     // lane-046-capture-gap: Claude no-expected_session_id capture now requires
     // positive_agent_id_match (TEAM_AGENT_ID=<id>) OR agent_path_match. Without
@@ -195,7 +247,9 @@ fn spine2_capture_missing_captures_session_id_for_missing_agent() {
         "capture_missing must capture+persist a session_id for an agent with a discoverable transcript; today it's a probe"
     );
     assert_eq!(
-        agent_field(&dir, "w2", "session_id").and_then(|v| v.as_str().map(str::to_string)).as_deref(),
+        agent_field(&dir, "w2", "session_id")
+            .and_then(|v| v.as_str().map(str::to_string))
+            .as_deref(),
         Some("existing-sess"),
         "an agent that already has a session_id must be untouched"
     );
@@ -208,7 +262,9 @@ fn spine2_capture_missing_captures_session_id_for_missing_agent() {
 fn spine2_sync_health_working_status_delivers_same_tick() {
     let (coord, dir) = seeded_health_coord(one_agent("codex"), "Working (5s · esc to interrupt)");
     let store = MessageStore::open(&dir).unwrap();
-    let mid = store.create_message(Some("t"), "leader", "w1", "hi", None, true, None).unwrap();
+    let mid = store
+        .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
+        .unwrap();
     let conn = crate::db::schema::open_db(store.db_path()).unwrap();
     conn.execute(
         "insert into agent_health(owner_team_id, agent_id, status, updated_at)
@@ -223,7 +279,9 @@ fn spine2_sync_health_working_status_delivers_same_tick() {
     coord.tick().expect("tick");
     let events = read_event_log_dir(&dir);
     assert!(
-        !events.iter().any(|e| e.get("event").and_then(|v| v.as_str()) == Some("send.deferred_busy")),
+        !events
+            .iter()
+            .any(|e| e.get("event").and_then(|v| v.as_str()) == Some("send.deferred_busy")),
         "turn-level WORKING must not trigger lifecycle busy deferral; got {events:?}"
     );
     assert!(
@@ -250,7 +308,9 @@ fn spine2_sync_health_working_status_delivers_same_tick() {
 fn contract_working_worker_stays_alive_and_deliverable_in_real_tick() {
     let (coord, dir) = seeded_health_coord(one_agent("codex"), "Working (5s · esc to interrupt)");
     let store = MessageStore::open(&dir).unwrap();
-    let _mid = store.create_message(Some("t"), "leader", "w1", "hi", None, true, None).unwrap();
+    let _mid = store
+        .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
+        .unwrap();
     drop(store);
     coord.tick().expect("tick");
     let status = agent_field(&dir, "w1", "status").and_then(|v| v.as_str().map(str::to_string));
@@ -406,8 +466,7 @@ fn rm039_stat001_jsonl_close_turn_preserves_e47_idle_classification() {
     // The pane Tail(40) still shows the live working spinner — the E47
     // stale-working scenario. The JSONL `task_complete` MUST close the
     // turn anyway.
-    let (coord, dir) =
-        seeded_health_coord(agents, "Working (5s · esc to interrupt)\n• Working\n");
+    let (coord, dir) = seeded_health_coord(agents, "Working (5s · esc to interrupt)\n• Working\n");
     coord.tick().expect("tick");
     let status = agent_activity_status(&dir, "stat-worker");
     assert_eq!(