@team-agent/installer 0.5.42 → 0.5.44

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

@@ -18,7 +18,10 @@ fn tick_never_panics_returns_ok_tickreport_on_clean_state() {
     let report = report.expect("tick must not Err on clean state");
     assert!(report.ok, "clean tick is ok=true");
     assert!(!report.stop, "clean tick does not stop the main loop");
-    assert_eq!(report.reason, None, "clean tick has no degraded/stop reason");
+    assert_eq!(
+        report.reason, None,
+        "clean tick has no degraded/stop reason"
+    );
     assert_eq!(report.persisted, Some(true), "clean tick persisted state");
 }
 
@@ -29,15 +32,23 @@ fn tick_save_failure_returns_degraded_not_panic_not_err() {
     // returned as Ok — NOT a panic, NOT an Err (the main loop must NOT catch+backoff this).
     let (coord, _calls) = coord_for_test(true, Some(failing_save_hook()), None);
     let report = coord.tick();
-    let report = report.expect("save failure is a DEGRADED Ok, NOT an Err (main loop must not backoff)");
+    let report =
+        report.expect("save failure is a DEGRADED Ok, NOT an Err (main loop must not backoff)");
     assert!(!report.ok, "bug-084: degraded => ok=false");
     assert_eq!(
         report.reason,
         Some(TickStopReason::PersistenceDegraded),
         "bug-084: reason=persistence_degraded"
     );
-    assert_eq!(report.persisted, Some(false), "bug-084: persisted=Some(false)");
-    assert!(!report.stop, "bug-084: stop=false (degrade, do NOT exit main loop)");
+    assert_eq!(
+        report.persisted,
+        Some(false),
+        "bug-084: persisted=Some(false)"
+    );
+    assert!(
+        !report.stop,
+        "bug-084: stop=false (degrade, do NOT exit main loop)"
+    );
 }
 
 #[test]
@@ -49,9 +60,14 @@ fn tick_tmux_session_missing_returns_stop_true() {
     // p2_tick_skips_tmux_gate_when_session_name_absent.)
     let (coord, _calls) =
         coord_for_test_with_session(/*session_present=*/ false, "team-missing");
-    let report = coord.tick().expect("session-missing is a typed report, not an Err");
+    let report = coord
+        .tick()
+        .expect("session-missing is a typed report, not an Err");
     assert!(!report.ok, "session missing => ok=false");
-    assert!(report.stop, "session missing => stop=true (break main loop)");
+    assert!(
+        report.stop,
+        "session missing => stop=true (break main loop)"
+    );
     assert_eq!(
         report.reason,
         Some(TickStopReason::TmuxSessionMissing),
@@ -68,8 +84,7 @@ fn tick_side_effect_order_is_the_fixed_sequence() {
     //   detect_deadlocks -> detect_compaction -> detect_drift -> detect_api_errors ->
     //   ATOMIC_save (bug-084 wrap) -> collect_results -> prune_dedupe_log.
     // The porter must push each step name into the injected recorder at its call site.
-    let recorder: OrderRecorder =
-        std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+    let recorder: OrderRecorder = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     let (coord, _calls) = coord_for_test(true, None, Some(std::sync::Arc::clone(&recorder)));
     let _ = coord.tick().expect("tick ok");
     let order = recorder.lock().unwrap().clone();
@@ -101,11 +116,17 @@ fn tick_side_effect_order_is_the_fixed_sequence() {
         "collect_results",
         "prune_dedupe_log",
     ];
-    assert_eq!(order, expected, "tick side-effect ORDER must match the fixed sequence");
+    assert_eq!(
+        order, expected,
+        "tick side-effect ORDER must match the fixed sequence"
+    );
     // ATOMIC save is the LAST mutation before read-only collect/prune (bug-084 wrap point).
     let save_idx = order.iter().position(|s| *s == "atomic_save").unwrap();
     let collect_idx = order.iter().position(|s| *s == "collect_results").unwrap();
-    assert!(save_idx < collect_idx, "save precedes collect (bug-084 wrap is the last mutation)");
+    assert!(
+        save_idx < collect_idx,
+        "save precedes collect (bug-084 wrap is the last mutation)"
+    );
 }
 
 #[test]
@@ -132,7 +153,11 @@ fn health_ok_is_conjunction_of_running_metadata_ok_and_schema_ok() {
     let (coord, _calls) = coord_for_test(true, None, None);
     let h = coord.health().expect("health is a typed report");
     assert!(!h.ok, "no pid file => not running => ok=false");
-    assert_eq!(h.status, CoordinatorHealthStatus::Missing, "no pid => status=missing");
+    assert_eq!(
+        h.status,
+        CoordinatorHealthStatus::Missing,
+        "no pid => status=missing"
+    );
     assert!(!h.metadata_ok, "no metadata => metadata_ok=false");
 }
 
@@ -193,7 +218,10 @@ fn read_coordinator_metadata_missing_file_is_none() {
 fn p2_tick_skips_tmux_gate_when_session_name_absent() {
     let (coord, _calls) = coord_for_test(false, None, None);
     let report = coord.tick().unwrap();
-    assert!(!report.stop, "missing/null session_name must skip the gate, not stop the daemon");
+    assert!(
+        !report.stop,
+        "missing/null session_name must skip the gate, not stop the daemon"
+    );
     assert_ne!(report.reason, Some(TickStopReason::TmuxSessionMissing));
 }
 
@@ -223,8 +251,14 @@ fn p2_render_result_received_truncates_summary_to_80_chars() {
     let long = "x".repeat(200);
     let e = serde_json::json!({"event":"result_received","agent_id":"w1","summary": long});
     let line = render_event_line(&e).expect("renders");
-    assert!(line.contains(&"x".repeat(80)), "first 80 summary chars are kept");
-    assert!(!line.contains(&"x".repeat(81)), "summary must be truncated to 80 chars");
+    assert!(
+        line.contains(&"x".repeat(80)),
+        "first 80 summary chars are kept"
+    );
+    assert!(
+        !line.contains(&"x".repeat(81)),
+        "summary must be truncated to 80 chars"
+    );
 }
 
 // P1 — idle_takeover.unknown_persistent must carry the auth_mode field (null when absent)
@@ -252,7 +286,8 @@ fn p2_unknown_persistent_event_serializes_auth_mode_key() {
 #[test]
 fn p2_abnormal_matches_lowercased_signature_too() {
     let reg = MockRegistry::new(&[], &["timeout"]);
-    let records = vec![serde_json::json!({"raw":"nothing here","signature":"TimeoutError","kind":"error"})];
+    let records =
+        vec![serde_json::json!({"raw":"nothing here","signature":"TimeoutError","kind":"error"})];
     let out = process_abnormal_records(
         &records,
         &reg,

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

@@ -9,38 +9,64 @@ use super::*;
 fn render_result_received_collapses_whitespace_and_defaults() {
     // watch.py:48-49 + _result_line — "result_received: <agent|-> -> <clean summary>".
     let e = serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": "did   the\nthing"});
-    assert_eq!(render_event_line(&e), Some("result_received: w1 -> did the thing".to_string()));
+    assert_eq!(
+        render_event_line(&e),
+        Some("result_received: w1 -> did the thing".to_string())
+    );
     // missing agent + summary → both '-'.
     let bare = serde_json::json!({"event": "result_received"});
-    assert_eq!(render_event_line(&bare), Some("result_received: - -> -".to_string()));
+    assert_eq!(
+        render_event_line(&bare),
+        Some("result_received: - -> -".to_string())
+    );
 }
 
 #[test]
 fn render_injected_and_submitted_share_prefix_and_truncate_message_id() {
     // watch.py:50-51 — both render as "leader_receiver.injected"; message_id truncated to 12.
     let inj = serde_json::json!({"event": "leader_receiver.injected", "message_id": "abcdef0123456789", "recipient": "w2"});
-    assert_eq!(render_event_line(&inj), Some("leader_receiver.injected: abcdef012345 -> w2".to_string()));
+    assert_eq!(
+        render_event_line(&inj),
+        Some("leader_receiver.injected: abcdef012345 -> w2".to_string())
+    );
     // submitted uses same label, msg_id fallback, `to` recipient fallback.
     let sub = serde_json::json!({"event": "leader_receiver.submitted", "msg_id": "xy", "to": "w3"});
-    assert_eq!(render_event_line(&sub), Some("leader_receiver.injected: xy -> w3".to_string()));
+    assert_eq!(
+        render_event_line(&sub),
+        Some("leader_receiver.injected: xy -> w3".to_string())
+    );
 }
 
 #[test]
 fn render_send_failed_uses_reason_then_error_fallback() {
     // watch.py:52-53 — reason || error || '-', recipient || to || target || '-', whitespace-cleaned.
-    let with_reason = serde_json::json!({"event": "send.failed", "recipient": "w4", "reason": "  pane   gone  "});
-    assert_eq!(render_event_line(&with_reason), Some("send.failed: w4 reason=pane gone".to_string()));
+    let with_reason =
+        serde_json::json!({"event": "send.failed", "recipient": "w4", "reason": "  pane   gone  "});
+    assert_eq!(
+        render_event_line(&with_reason),
+        Some("send.failed: w4 reason=pane gone".to_string())
+    );
     let with_error = serde_json::json!({"event": "send.failed", "target": "w5", "error": "boom"});
-    assert_eq!(render_event_line(&with_error), Some("send.failed: w5 reason=boom".to_string()));
+    assert_eq!(
+        render_event_line(&with_error),
+        Some("send.failed: w5 reason=boom".to_string())
+    );
 }
 
 #[test]
 fn render_rebind_required_uses_pane_and_reason_fallbacks() {
     // watch.py:54-57 — old_pane_id || pane_id || target || '-'; reason || rediscovery_status || '-'.
     let e = serde_json::json!({"event": "leader_receiver.rebind_required", "old_pane_id": "%9", "reason": "lost"});
-    assert_eq!(render_event_line(&e), Some("leader_receiver.rebind_required: pane=%9 reason=lost".to_string()));
-    let no_reason = serde_json::json!({"event": "leader_receiver.rebind_required", "pane_id": "%7"});
-    assert_eq!(render_event_line(&no_reason), Some("leader_receiver.rebind_required: pane=%7 reason=-".to_string()));
+    assert_eq!(
+        render_event_line(&e),
+        Some("leader_receiver.rebind_required: pane=%9 reason=lost".to_string())
+    );
+    let no_reason =
+        serde_json::json!({"event": "leader_receiver.rebind_required", "pane_id": "%7"});
+    assert_eq!(
+        render_event_line(&no_reason),
+        Some("leader_receiver.rebind_required: pane=%7 reason=-".to_string())
+    );
 }
 
 #[test]
@@ -49,16 +75,32 @@ fn render_api_error_defaults_unknown_class_and_dash() {
     let error_class = ["Over", "loaded"].concat();
     let code = (500 + 29).to_string();
     let e = serde_json::json!({"event": "leader.api_error", "error_class": error_class, "provider": "claude_code", "matched_pattern_snippet": format!("{code}  too  many")});
-    assert_eq!(render_event_line(&e), Some(format!("leader.api_error: {} provider=claude_code snippet={} too many", ["Over", "loaded"].concat(), code)));
+    assert_eq!(
+        render_event_line(&e),
+        Some(format!(
+            "leader.api_error: {} provider=claude_code snippet={} too many",
+            ["Over", "loaded"].concat(),
+            code
+        ))
+    );
     let bare = serde_json::json!({"event": "leader.api_error"});
-    assert_eq!(render_event_line(&bare), Some("leader.api_error: Unknown provider=- snippet=-".to_string()));
+    assert_eq!(
+        render_event_line(&bare),
+        Some("leader.api_error: Unknown provider=- snippet=-".to_string())
+    );
 }
 
 #[test]
 fn render_non_renderable_events_return_none() {
     // watch.py:63 — coordinator.* / unknown events → None.
-    assert_eq!(render_event_line(&serde_json::json!({"event": "coordinator.boot"})), None);
-    assert_eq!(render_event_line(&serde_json::json!({"event": "unknown.thing"})), None);
+    assert_eq!(
+        render_event_line(&serde_json::json!({"event": "coordinator.boot"})),
+        None
+    );
+    assert_eq!(
+        render_event_line(&serde_json::json!({"event": "unknown.thing"})),
+        None
+    );
 }
 
 // ═════════════════════════════════════════════════════════════════════════
@@ -88,7 +130,8 @@ fn seed_watch_workspace(event_summary: &str, archive_bytes: Option<&[u8]>) -> Wo
     ));
     let logs = crate::model::paths::logs_dir(&dir);
     std::fs::create_dir_all(&logs).unwrap();
-    let line = serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": event_summary});
+    let line =
+        serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": event_summary});
     std::fs::write(
         logs.join("events.jsonl"),
         format!("{}\n", serde_json::to_string(&line).unwrap()),
@@ -125,14 +168,20 @@ fn watch_rotation_emits_marker_once_resets_offset_and_does_not_replay() {
         "first segment line is rendered exactly once"
     );
     let offset_after_first = cursor.event_offset;
-    assert!(offset_after_first > 0, "offset advanced past the consumed segment");
+    assert!(
+        offset_after_first > 0,
+        "offset advanced past the consumed segment"
+    );
 
     // Simulate rotation: an archive segment now appears (archive_signature changes from
     // None -> Some), and the live events.jsonl is replaced with a fresh, SHORTER file
     // whose new content must NOT include the archived "first segment".
     let logs = crate::model::paths::logs_dir(ws.as_path());
-    std::fs::write(logs.join("events.jsonl.1"), b"archived old bytes that must never replay\n")
-        .unwrap();
+    std::fs::write(
+        logs.join("events.jsonl.1"),
+        b"archived old bytes that must never replay\n",
+    )
+    .unwrap();
     let fresh = serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": "post rotation"});
     std::fs::write(
         logs.join("events.jsonl"),
@@ -142,13 +191,18 @@ fn watch_rotation_emits_marker_once_resets_offset_and_does_not_replay() {
 
     let second = collect_watch_lines(&ws, &mut cursor, &store, None).unwrap();
     let marker_count = second.iter().filter(|l| **l == ROTATION_MARKER).count();
-    assert_eq!(marker_count, 1, "ROTATION_MARKER emitted exactly once on rotation");
+    assert_eq!(
+        marker_count, 1,
+        "ROTATION_MARKER emitted exactly once on rotation"
+    );
     assert!(
         !second.iter().any(|l| l.contains("first segment")),
         "archived segment is NOT replayed"
     );
     assert!(
-        !second.iter().any(|l| l.contains("old bytes that must never replay")),
+        !second
+            .iter()
+            .any(|l| l.contains("old bytes that must never replay")),
         "archive file contents are NEVER read/replayed"
     );
     assert!(

package/crates/team-agent/src/db/message_store.rs

@@ -230,7 +230,12 @@ impl MessageStore {
 
     /// `mark` (`core.py:116-138`) — the messages.status state machine (this slice
     /// excludes the `delivery_tokens` side-effect, which is deferred).
-    pub fn mark(&self, message_id: &str, status: &str, error: Option<&str>) -> Result<(), MessageStoreError> {
+    pub fn mark(
+        &self,
+        message_id: &str,
+        status: &str,
+        error: Option<&str>,
+    ) -> Result<(), MessageStoreError> {
         let conn = crate::db::schema::open_db(&self.path)?;
         let now = now_ts();
         conn.execute(
@@ -594,7 +599,15 @@ mod tests {
     fn create_message_inserts_accepted_row() {
         let s = store();
         let mid = s
-            .create_message(Some("task_1"), "leader", "alice", "hello", None, true, Some("team_A"))
+            .create_message(
+                Some("task_1"),
+                "leader",
+                "alice",
+                "hello",
+                None,
+                true,
+                Some("team_A"),
+            )
             .unwrap();
         assert!(mid.starts_with("msg_"), "id: {mid}");
         assert_eq!(mid.len(), 16, "msg_ + 12 hex");
@@ -604,7 +617,10 @@ mod tests {
         assert_eq!(col_str(&c, &mid, "task_id").as_deref(), Some("task_1"));
         assert_eq!(col_str(&c, &mid, "sender").as_deref(), Some("leader"));
         assert_eq!(col_str(&c, &mid, "recipient").as_deref(), Some("alice"));
-        assert_eq!(col_str(&c, &mid, "owner_team_id").as_deref(), Some("team_A"));
+        assert_eq!(
+            col_str(&c, &mid, "owner_team_id").as_deref(),
+            Some("team_A")
+        );
         assert_eq!(col_str(&c, &mid, "content").as_deref(), Some("hello"));
         assert_eq!(col_str(&c, &mid, "artifact_refs").as_deref(), Some("[]"));
         assert_eq!(col_str(&c, &mid, "reply_to"), None);
@@ -618,7 +634,9 @@ mod tests {
     #[test]
     fn create_message_no_task_no_owner_ack_false() {
         let s = store();
-        let mid = s.create_message(None, "leader", "bob", "hi", None, false, None).unwrap();
+        let mid = s
+            .create_message(None, "leader", "bob", "hi", None, false, None)
+            .unwrap();
         let c = read(&s);
         assert_eq!(col_str(&c, &mid, "task_id"), None);
         assert_eq!(col_str(&c, &mid, "owner_team_id"), None);
@@ -631,9 +649,14 @@ mod tests {
     #[test]
     fn claim_for_delivery_first_caller_wins() {
         let s = store();
-        let mid = s.create_message(Some("t"), "s", "r", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
 
-        assert!(s.claim_for_delivery(&mid).unwrap(), "accepted is eligible → claim wins");
+        assert!(
+            s.claim_for_delivery(&mid).unwrap(),
+            "accepted is eligible → claim wins"
+        );
         let c = read(&s);
         assert_eq!(status_of(&c, &mid), "target_resolved");
         assert_eq!(col_i64(&c, &mid, "delivery_attempts"), 1);
@@ -644,9 +667,14 @@ mod tests {
         // Atomic single-winner: once target_resolved, a re-claim returns false and
         // must NOT bump delivery_attempts again.
         let s = store();
-        let mid = s.create_message(Some("t"), "s", "r", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
         assert!(s.claim_for_delivery(&mid).unwrap());
-        assert!(!s.claim_for_delivery(&mid).unwrap(), "already target_resolved → no second winner");
+        assert!(
+            !s.claim_for_delivery(&mid).unwrap(),
+            "already target_resolved → no second winner"
+        );
 
         let c = read(&s);
         assert_eq!(status_of(&c, &mid), "target_resolved");
@@ -663,7 +691,9 @@ mod tests {
     fn claim_for_delivery_ineligible_status_is_false() {
         // 'failed' is not in the eligible set → claim returns false, status unchanged.
         let s = store();
-        let mid = s.create_message(Some("t"), "s", "r", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
         s.mark(&mid, "failed", Some("boom")).unwrap();
         assert!(!s.claim_for_delivery(&mid).unwrap());
         assert_eq!(status_of(&read(&s), &mid), "failed");
@@ -674,11 +704,16 @@ mod tests {
     #[test]
     fn mark_injected_sets_status_and_delivered_at() {
         let s = store();
-        let mid = s.create_message(Some("t"), "s", "r", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
         s.mark(&mid, "injected", None).unwrap();
         let c = read(&s);
         assert_eq!(status_of(&c, &mid), "injected");
-        assert!(col_str(&c, &mid, "delivered_at").is_some(), "delivered_at set for injected");
+        assert!(
+            col_str(&c, &mid, "delivered_at").is_some(),
+            "delivered_at set for injected"
+        );
         assert_eq!(col_str(&c, &mid, "acknowledged_at"), None);
     }
 
@@ -686,22 +721,34 @@ mod tests {
     fn mark_acknowledged_is_sticky_against_delivery_statuses() {
         // CASE guard: once acknowledged, marks to injected/visible/... are ignored.
         let s = store();
-        let mid = s.create_message(Some("t"), "s", "r", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
         s.mark(&mid, "acknowledged", None).unwrap();
         assert_eq!(status_of(&read(&s), &mid), "acknowledged");
         assert!(col_str(&read(&s), &mid, "acknowledged_at").is_some());
 
         s.mark(&mid, "injected", None).unwrap();
-        assert_eq!(status_of(&read(&s), &mid), "acknowledged", "injected ignored after ack");
+        assert_eq!(
+            status_of(&read(&s), &mid),
+            "acknowledged",
+            "injected ignored after ack"
+        );
         s.mark(&mid, "visible", None).unwrap();
-        assert_eq!(status_of(&read(&s), &mid), "acknowledged", "visible ignored after ack");
+        assert_eq!(
+            status_of(&read(&s), &mid),
+            "acknowledged",
+            "visible ignored after ack"
+        );
     }
 
     #[test]
     fn mark_acknowledged_then_failed_overwrites() {
         // 'failed' is NOT in the guarded delivery set → it overwrites acknowledged.
         let s = store();
-        let mid = s.create_message(Some("t"), "s", "r", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
         s.mark(&mid, "acknowledged", None).unwrap();
         s.mark(&mid, "failed", Some("x")).unwrap();
         assert_eq!(status_of(&read(&s), &mid), "failed");
@@ -710,7 +757,9 @@ mod tests {
     #[test]
     fn mark_overwrites_for_non_acknowledged() {
         let s = store();
-        let mid = s.create_message(Some("t"), "s", "r", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
         s.mark(&mid, "injected", None).unwrap();
         s.mark(&mid, "visible", None).unwrap();
         assert_eq!(status_of(&read(&s), &mid), "visible");
@@ -742,16 +791,31 @@ mod tests {
         // and proposed id → second is deduped to the first winner.
         let s = store();
         let r1 = s
-            .claim_leader_notification_delivery(params("res_1", Some("team_A"), Some(7), Some("uuid-AAA"), "msg_notif_1"))
+            .claim_leader_notification_delivery(params(
+                "res_1",
+                Some("team_A"),
+                Some(7),
+                Some("uuid-AAA"),
+                "msg_notif_1",
+            ))
             .unwrap();
         assert_eq!(r1.status, "claimed_by_you");
         assert_eq!(r1.notified_message_id, "msg_notif_1");
 
         let r2 = s
-            .claim_leader_notification_delivery(params("res_1", Some("team_A"), Some(7), Some("uuid-BBB"), "msg_notif_2"))
+            .claim_leader_notification_delivery(params(
+                "res_1",
+                Some("team_A"),
+                Some(7),
+                Some("uuid-BBB"),
+                "msg_notif_2",
+            ))
             .unwrap();
         assert_eq!(r2.status, "already_notified_by");
-        assert_eq!(r2.notified_message_id, "msg_notif_1", "loser sees first winner's id, not its own");
+        assert_eq!(
+            r2.notified_message_id, "msg_notif_1",
+            "loser sees first winner's id, not its own"
+        );
 
         // Exactly ONE row — carrying the FIRST caller's uuid (uuid not in the key).
         assert_eq!(
@@ -769,12 +833,27 @@ mod tests {
     #[test]
     fn leader_notification_different_epoch_is_a_new_claim() {
         let s = store();
-        s.claim_leader_notification_delivery(params("res_1", Some("team_A"), Some(7), Some("uuid-AAA"), "msg_notif_1"))
-            .unwrap();
+        s.claim_leader_notification_delivery(params(
+            "res_1",
+            Some("team_A"),
+            Some(7),
+            Some("uuid-AAA"),
+            "msg_notif_1",
+        ))
+        .unwrap();
         let r3 = s
-            .claim_leader_notification_delivery(params("res_1", Some("team_A"), Some(8), Some("uuid-AAA"), "msg_notif_3"))
+            .claim_leader_notification_delivery(params(
+                "res_1",
+                Some("team_A"),
+                Some(8),
+                Some("uuid-AAA"),
+                "msg_notif_3",
+            ))
             .unwrap();
-        assert_eq!(r3.status, "claimed_by_you", "different owner_epoch → different PK → new claim");
+        assert_eq!(
+            r3.status, "claimed_by_you",
+            "different owner_epoch → different PK → new claim"
+        );
 
         let rows = notif_rows(&read(&s));
         assert_eq!(rows.len(), 2);
@@ -789,20 +868,41 @@ mod tests {
         // yields a different derived epoch → a new claim.
         let s = store();
         let a1 = s
-            .claim_leader_notification_delivery(params("res_2", Some("team_B"), None, Some("uuid-AAA"), "m1"))
+            .claim_leader_notification_delivery(params(
+                "res_2",
+                Some("team_B"),
+                None,
+                Some("uuid-AAA"),
+                "m1",
+            ))
             .unwrap();
         assert_eq!(a1.status, "claimed_by_you");
 
         let a2 = s
-            .claim_leader_notification_delivery(params("res_2", Some("team_B"), None, Some("uuid-AAA"), "m2"))
+            .claim_leader_notification_delivery(params(
+                "res_2",
+                Some("team_B"),
+                None,
+                Some("uuid-AAA"),
+                "m2",
+            ))
             .unwrap();
         assert_eq!(a2.status, "already_notified_by");
         assert_eq!(a2.notified_message_id, "m1");
 
         let a3 = s
-            .claim_leader_notification_delivery(params("res_2", Some("team_B"), None, Some("uuid-BBB"), "m3"))
+            .claim_leader_notification_delivery(params(
+                "res_2",
+                Some("team_B"),
+                None,
+                Some("uuid-BBB"),
+                "m3",
+            ))
             .unwrap();
-        assert_eq!(a3.status, "claimed_by_you", "different uuid → different derived epoch → new claim");
+        assert_eq!(
+            a3.status, "claimed_by_you",
+            "different uuid → different derived epoch → new claim"
+        );
 
         // Stored epochs equal the crc32 derivation of each uuid.
         let rows = notif_rows(&read(&s));
@@ -829,7 +929,9 @@ mod tests {
         let mut rows = c
             .prepare("select a, b from peer_allowlist order by a, b")
             .unwrap()
-            .query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))
+            .query_map([], |row| {
+                Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
+            })
             .unwrap()
             .collect::<Result<Vec<_>, _>>()
             .unwrap();
@@ -851,7 +953,9 @@ mod tests {
     #[test]
     fn fix_b1_mark_preserves_existing_error_when_none_given() {
         let s = store();
-        let mid = s.create_message(Some("t"), "a", "b", "c", None, true, None).unwrap();
+        let mid = s
+            .create_message(Some("t"), "a", "b", "c", None, true, None)
+            .unwrap();
 
         s.mark(&mid, "failed", Some("boom")).unwrap();
         assert_eq!(col_str(&read(&s), &mid, "error").as_deref(), Some("boom"));
@@ -861,7 +965,11 @@ mod tests {
         s.mark(&mid, "injected", None).unwrap();
         let c = read(&s);
         assert_eq!(status_of(&c, &mid), "injected");
-        assert_eq!(col_str(&c, &mid, "error").as_deref(), Some("boom"), "existing error must survive a no-error mark");
+        assert_eq!(
+            col_str(&c, &mid, "error").as_deref(),
+            Some("boom"),
+            "existing error must survive a no-error mark"
+        );
 
         // A NEW error overwrites.
         s.mark(&mid, "failed", Some("second")).unwrap();