feat(host): capture-stall watch — DWM-level self-diagnosis for the Exclusive-topology stutter

Field repro (Mounjay, still present on 0.9.0): the ~4 s double-jolt stutter
appears ONLY while the virtual display is the sole active display (Exclusive
topology) and stops the instant Windows switches to Extend — live, both ways.
Cross-project research (Apollo #179/#358/#368/#563/#776, VDD #36, Tom's HW)
points at the display/present path BELOW capture: an inactive-but-connected
DisplayPort head being periodically serviced (standby HPD/AUX/link events),
with a DWM software-vsync clock beat as the secondary (different-signature)
class. Neither ends in anything our recovery-side detector can see unless the
client actually loses data — so give the HOST a direct sensor at the ring:

- StallWatch (idd_push.rs): a >150 ms hole in DWM frame delivery counts as a
  capture stall only when the 8 preceding frames arrived within 400 ms —
  sustained >=20 fps flow, so an idle desktop, a caret blink, or a paused
  video can never trip it. Per-stall debug line; when stalls settle into an
  evenly-spaced multi-second cycle, one rate-limited WARN names the class:
  'capture stalls are METRONOMIC', with the topology=primary/extend and
  refresh-rate leads. Ring-recreate recovery gaps reset the watch (self-
  inflicted, already logged by the recreate path).
- The evenly-spaced-cycle detector moves out of punktfunk1.rs into
  metronome.rs (RecoveryCadence -> Metronome, unchanged logic + tests) so the
  IDR-serve detector and the stall watch share one implementation; the
  recovery WARN now cross-references the capture-stall lines.

Diagnosis map for an Exclusive-mode stutter log: 'slow display-descriptor
poll' = something holds the win32k display lock; 'capture stalls are
METRONOMIC' without it = DWM stopped composing (DP servicing / present
clock, below us); recovery-IDR METRONOMIC alone = frames flowed but clients
lost data. Verified: Linux tests+clippy+fmt clean; Windows (RTX box)
220/220 + clippy clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/punktfunk-host/src/punktfunk1.rs

@@ -3230,82 +3230,6 @@ struct SessionContext {
     launch: Option<String>,
 }
 
-/// Detector for METRONOMIC client keyframe-recovery cycles — the "periodic double-jolt" symptom
-/// class field reports keep describing: a host/display-side disturbance repeating every few
-/// seconds (display-topology churn, display-poller software, virtual-display timing), where each
-/// cycle ends in a client keyframe request the host serves. Random network loss is bursty and
-/// irregular; a stable period is a machine, and saying so in the host log turns a "nothing in the
-/// logs :/" report into a self-diagnosis.
-///
-/// Served forced IDRs within [`Self::COALESCE`] count as ONE event (a double-jolt's paired IDRs —
-/// the cooldown re-issue of a lost keyframe — are one user-visible disturbance). When the gaps
-/// between the last [`Self::STREAK`] events are all within ±[`Self::TOLERANCE`] of their mean,
-/// [`Self::note`] returns the mean period for the caller to warn with, then stays quiet for
-/// [`Self::REWARN`] while the cycle persists. Pure logic — unit-tested below.
-struct RecoveryCadence {
-    events: std::collections::VecDeque<std::time::Instant>,
-    last_warn: Option<std::time::Instant>,
-}
-
-impl RecoveryCadence {
-    /// Serves closer together than this are the same user-visible disturbance.
-    const COALESCE: std::time::Duration = std::time::Duration::from_millis(1500);
-    /// Consecutive evenly-spaced events before the cycle counts as metronomic.
-    const STREAK: usize = 4;
-    /// "Evenly spaced" = every gap within this fraction of the mean gap.
-    const TOLERANCE: f64 = 0.2;
-    /// Once warned, re-warn at most this often while the cycle persists.
-    const REWARN: std::time::Duration = std::time::Duration::from_secs(30);
-
-    fn new() -> Self {
-        Self {
-            events: std::collections::VecDeque::new(),
-            last_warn: None,
-        }
-    }
-
-    /// Record a served client-recovery IDR at `now`; `Some(mean period)` exactly when the
-    /// metronomic-cycle warning should fire.
-    fn note(&mut self, now: std::time::Instant) -> Option<std::time::Duration> {
-        if self
-            .events
-            .back()
-            .is_some_and(|last| now.duration_since(*last) < Self::COALESCE)
-        {
-            return None;
-        }
-        self.events.push_back(now);
-        if self.events.len() > Self::STREAK {
-            self.events.pop_front();
-        }
-        if self.events.len() < Self::STREAK {
-            return None;
-        }
-        let gaps: Vec<f64> = self
-            .events
-            .iter()
-            .zip(self.events.iter().skip(1))
-            .map(|(a, b)| b.duration_since(*a).as_secs_f64())
-            .collect();
-        let mean = gaps.iter().sum::<f64>() / gaps.len() as f64;
-        if mean <= 0.0
-            || gaps
-                .iter()
-                .any(|g| (g - mean).abs() > mean * Self::TOLERANCE)
-        {
-            return None;
-        }
-        if self
-            .last_warn
-            .is_some_and(|t| now.duration_since(t) < Self::REWARN)
-        {
-            return None;
-        }
-        self.last_warn = Some(now);
-        Some(std::time::Duration::from_secs_f64(mean))
-    }
-}
-
 fn virtual_stream(ctx: SessionContext) -> Result<()> {
     // This thread runs the capture+encode loop (single-process — the only topology: Linux portal /
     // synthetic, Windows in-process IDD-push). Elevate it so a CPU-heavy game can't deschedule our GPU
@@ -3521,8 +3445,8 @@ fn virtual_stream(ctx: SessionContext) -> Result<()> {
     // opening GOP, instead of answering it with a redundant second IDR.
     let mut last_forced_idr: Option<std::time::Instant> = Some(std::time::Instant::now());
     // Self-diagnosis for the periodic-stutter class: warns when the served recovery IDRs settle
-    // into a stable multi-second rhythm (see [`RecoveryCadence`]).
-    let mut recovery_cadence = RecoveryCadence::new();
+    // into a stable multi-second rhythm (see [`crate::metronome::Metronome`]).
+    let mut recovery_cadence = crate::metronome::Metronome::new();
     // Per-stage latency breakdown (PUNKTFUNK_PERF): per-call µs for the GPU-bound stages so we see
     // exactly where the capture→encoded latency goes — cap=try_latest (ring read + colour convert),
     // submit=encode_picture launch, wait=lock_bitstream (the scheduling wait + ASIC encode, the one
@@ -3733,7 +3657,7 @@ fn virtual_stream(ctx: SessionContext) -> Result<()> {
                          disturbance (display-topology churn, display-poller software, \
                          virtual-display timing) is the likely cause, not random network loss; \
                          correlate with 'slow display-descriptor poll' / 'display descriptor \
-                         changed' lines"
+                         changed' / 'IDD-push capture stall' lines"
                     );
                 }
             }
@@ -4425,69 +4349,6 @@ mod tests {
         assert_eq!(dec, snap);
     }
 
-    /// Feed [`RecoveryCadence`] a schedule of event offsets (ms from a common origin) and return
-    /// what each `note` produced.
-    fn cadence_run(offsets_ms: &[u64]) -> Vec<Option<std::time::Duration>> {
-        let base = std::time::Instant::now();
-        let mut c = RecoveryCadence::new();
-        offsets_ms
-            .iter()
-            .map(|ms| c.note(base + std::time::Duration::from_millis(*ms)))
-            .collect()
-    }
-
-    #[test]
-    fn cadence_detects_metronomic_recoveries() {
-        // Four IDR serves ~4 s apart (±5%) → the fourth trips the detector at ~4 s.
-        let out = cadence_run(&[0, 4_000, 8_100, 11_950]);
-        assert_eq!(out[..3], [None, None, None]);
-        let period = out[3].expect("metronomic series must be detected");
-        assert!(
-            (period.as_secs_f64() - 3.98).abs() < 0.2,
-            "period={period:?}"
-        );
-    }
-
-    #[test]
-    fn cadence_coalesces_double_jolt_pairs() {
-        // The field signature: a jolt pair (second IDR ~0.7 s after the first, the cooldown
-        // re-issue) every ~4 s. Each pair is ONE event; detection still lands on the ~4 s cycle.
-        let out = cadence_run(&[
-            0, 700, // pair 1
-            4_000, 4_700, // pair 2
-            8_000, 8_650,  // pair 3
-            12_000, // pair 4 (first serve trips it)
-        ]);
-        assert!(out[..6].iter().all(Option::is_none));
-        let period = out[6].expect("coalesced pairs must still read as a 4 s cycle");
-        assert!(
-            (period.as_secs_f64() - 4.0).abs() < 0.2,
-            "period={period:?}"
-        );
-    }
-
-    #[test]
-    fn cadence_ignores_irregular_bursts() {
-        // Genuine Wi-Fi-style loss: irregular gaps → never flagged.
-        assert!(cadence_run(&[0, 2_000, 9_000, 12_500, 21_000])
-            .iter()
-            .all(Option::is_none));
-    }
-
-    #[test]
-    fn cadence_rewarns_at_most_every_30s() {
-        // A persisting 4 s cycle: warn on the 4th event (t=12 s), then stay quiet until ≥30 s
-        // past the warn — the t=44 s event (index 11) is the first at or beyond t=42 s.
-        let offsets: Vec<u64> = (0..12).map(|i| i * 4_000).collect();
-        let out = cadence_run(&offsets);
-        let warned: Vec<usize> = out
-            .iter()
-            .enumerate()
-            .filter_map(|(i, o)| o.map(|_| i))
-            .collect();
-        assert_eq!(warned, vec![3, 11], "warn indices");
-    }
-
     #[test]
     fn adapt_fec_maps_loss_to_recovery_band() {
         // A perfectly clean window (0 loss) lands on the floor.