style: apply cargo fmt to runtime drivers (librefang#2380)

* style: apply cargo fmt to runtime drivers

* test(fallback): seed primary health state directly in cooldown recovery test

The dispatch loop never accrued three errors because health_order()
reroutes to the healthy secondary after the first failure. Seed the
counters directly so the test exercises what it claims to.

Author: houko

crates/librefang-runtime/src/drivers/fallback.rs

@@ -330,9 +330,10 @@ mod tests {
 
     #[tokio::test]
     async fn unhealthy_driver_recovers_after_cooldown() {
-        // Two drivers: primary fails, secondary succeeds. After a few primary
-        // failures we simulate the recovery window elapsing and verify that
-        // `maybe_recover` clears both the error counter and the EWMA penalty.
+        // Seed the primary's health state directly to simulate three
+        // accumulated failures. We can't get there via dispatch: after the
+        // first failure health_order() reroutes to the healthy secondary,
+        // so the primary would never accrue a second error through complete().
         let fb = FallbackDriver::with_models(vec![
             (
                 Arc::new(FailDriver) as Arc<dyn LlmDriver>,
@@ -341,20 +342,22 @@ mod tests {
             (Arc::new(OkDriver) as Arc<dyn LlmDriver>, "ok".to_string()),
         ]);
 
-        // Three dispatches → primary accumulates 3 errors and 3×ERROR_PENALTY_MS.
-        for _ in 0..3 {
-            let _ = fb.complete(test_request()).await;
-        }
         let primary = &fb.drivers[0];
+        primary.consecutive_errors.store(3, Ordering::Relaxed);
+        primary
+            .last_failure_at_ms
+            .store(FallbackDriver::now_ms(), Ordering::Relaxed);
+        primary
+            .ewma_latency_ms
+            .store(ERROR_PENALTY_MS * 3, Ordering::Relaxed);
+
         assert_eq!(primary.consecutive_errors.load(Ordering::Relaxed), 3);
         let penalised = primary.ewma_latency_ms.load(Ordering::Relaxed);
         assert!(penalised >= ERROR_PENALTY_MS * 3);
 
         // Simulate the cooldown elapsing by calling maybe_recover with a
         // fabricated future timestamp.
-        let future = primary.last_failure_at_ms.load(Ordering::Relaxed)
-            + HEALTH_RECOVERY_MS
-            + 1;
+        let future = primary.last_failure_at_ms.load(Ordering::Relaxed) + HEALTH_RECOVERY_MS + 1;
         FallbackDriver::maybe_recover(primary, future);
 
         assert_eq!(

crates/librefang-runtime/src/drivers/qwen_code.rs

@@ -558,19 +558,19 @@ impl LlmDriver for QwenCodeDriver {
             // Qwen CLI 0.14+ sometimes emits a full JSON array on a single
             // line instead of one event per line. Unwrap it into individual
             // events before the normal line-by-line handler runs.
-            let events: Vec<QwenStreamEvent> =
-                if trimmed.starts_with('[') && trimmed.ends_with(']') {
-                    serde_json::from_str(trimmed).unwrap_or_default()
-                } else if let Ok(single) = serde_json::from_str::<QwenStreamEvent>(trimmed) {
-                    vec![single]
-                } else {
-                    // Not valid JSON. This used to be forwarded to the UI as
-                    // a TextDelta, which surfaced raw stderr/preamble/garbage
-                    // in the chat. Log and drop — assistant text only comes
-                    // from structured events.
-                    warn!(line = %trimmed, "Dropping non-JSON line from Qwen CLI stdout");
-                    continue;
-                };
+            let events: Vec<QwenStreamEvent> = if trimmed.starts_with('[') && trimmed.ends_with(']')
+            {
+                serde_json::from_str(trimmed).unwrap_or_default()
+            } else if let Ok(single) = serde_json::from_str::<QwenStreamEvent>(trimmed) {
+                vec![single]
+            } else {
+                // Not valid JSON. This used to be forwarded to the UI as
+                // a TextDelta, which surfaced raw stderr/preamble/garbage
+                // in the chat. Log and drop — assistant text only comes
+                // from structured events.
+                warn!(line = %trimmed, "Dropping non-JSON line from Qwen CLI stdout");
+                continue;
+            };
 
             for event in events {
                 match event.r#type.as_str() {
@@ -752,7 +752,10 @@ mod tests {
         // object shape — must not leak raw text into the chat.
         let out = r#"{"totally":"unexpected","shape":123}"#;
         let (t, _) = extract_text_from_qwen_output(out);
-        assert_eq!(t, "", "unrecognised JSON shape must produce empty text, not leak raw JSON into chat");
+        assert_eq!(
+            t, "",
+            "unrecognised JSON shape must produce empty text, not leak raw JSON into chat"
+        );
     }
 
     #[test]