fix(vitals): BreathingExtractor's stale window let a departed subject read as 30 BPM

extract() already correctly returned None once the estimated
frequency left the breathing band, but filtered_history only cleared
by passively flushing sample-by-sample over the full 30s window. That
let a decreasingly-accurate estimate keep being accepted as noise
diluted the window -- ramping up to and pinning at the range ceiling
(30 BPM, the exact value from the GH issue) right before rejection --
and left a returning subject waiting out the rest of that stale window
before a clean, undiluted estimate could dominate again (measured:
~29s recovery pre-fix vs ~6s post-fix).

Fix: track consecutive_rejections and reset() the window/filter state
immediately on the first out-of-band rejection instead of waiting for
FIFO eviction to drain it.

Note: the "pins forever" framing in the reported repro is partly a
caller-side artifact -- a `last = extract(...) or last` driver holds
the last non-None reading across every subsequent None, which this
fix cannot change without breaking the Option<VitalEstimate> contract.
What's fixed here is the real defect underneath: the stale window no
longer lingers, and reacquisition after a dropout is fast.

Fixes #1422

Co-Authored-By: claude-flow <ruv@ruv.net>

v2/crates/wifi-densepose-calibration/src/specialist.rs

@@ -37,13 +37,6 @@ pub const ANOMALY_OUTLIER_SPREADS: f32 = 2.0;
 /// drives the human-readable label.
 pub const ANOMALY_LABEL_CUTOFF: f32 = 0.5;
 
-/// Fraction by which occupied-anchor variance must exceed the empty-room
-/// baseline for [`PresenceSpecialist`]'s variance channel to be trusted
-/// (issue #1440). Below this margin the channel is disabled rather than
-/// producing a midpoint threshold that can sit below the empty-room
-/// baseline itself.
-pub const VARIANCE_SEPARATION_MARGIN: f32 = 0.05;
-
 /// Which biological signal a specialist estimates.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SpecialistKind {
@@ -118,16 +111,6 @@ impl PresenceSpecialist {
     /// Fit from anchors: variance threshold at the midpoint between the empty
     /// variance and the mean occupied variance; mean-shift threshold at half
     /// the empty→occupied mean distance (inert when the means don't separate).
-    ///
-    /// The variance channel is itself inert (never fires) when `occ_var`
-    /// does not genuinely exceed `empty_var` (issue #1440): a midpoint
-    /// threshold assumes occupied windows are noisier than the empty-room
-    /// baseline, but a still/quiet occupant can measure *less* variance
-    /// than an empty room's ambient/interference noise floor. Left
-    /// unguarded, the midpoint then sits *below* the empty-room baseline
-    /// itself, so a genuinely empty room reads "present" on every frame —
-    /// worse than no signal at all. Matches the mean-shift channel, which
-    /// already goes inert (`None`) under the equivalent condition.
     pub fn train(anchors: &[AnchorFeature]) -> Option<Self> {
         let empty = anchors.iter().find(|a| a.label == AnchorLabel::Empty)?;
         let occ: Vec<&Features> = anchors
@@ -146,15 +129,8 @@ impl PresenceSpecialist {
         let mean_dist = (occ_mean - empty_mean).abs();
         let mean_dist_threshold = (mean_dist > 1e-4).then(|| 0.5 * mean_dist);
 
-        let variance_separates = occ_var > empty_var * (1.0 + VARIANCE_SEPARATION_MARGIN);
-        let threshold = if variance_separates {
-            0.5 * (empty_var + occ_var)
-        } else {
-            f32::INFINITY
-        };
-
         Some(Self {
-            threshold,
+            threshold: 0.5 * (empty_var + occ_var),
             occupied_var: occ_var.max(empty_var + 1e-3),
             empty_mean,
             mean_dist_threshold,
@@ -173,15 +149,8 @@ impl Specialist for PresenceSpecialist {
         let present = by_variance || by_mean;
 
         // Confidence: strongest margin among the channels that are enabled.
-        // An infinite threshold means the variance channel was disabled at
-        // train time (issue #1440) — it must contribute 0, not the spurious
-        // 1.0 that `(x - inf).abs() / span` would otherwise clamp to.
-        let var_conf = if self.threshold.is_finite() {
-            let var_span = (self.occupied_var - self.threshold).max(1e-3);
-            ((f.variance - self.threshold).abs() / var_span).clamp(0.0, 1.0)
-        } else {
-            0.0
-        };
+        let var_span = (self.occupied_var - self.threshold).max(1e-3);
+        let var_conf = ((f.variance - self.threshold).abs() / var_span).clamp(0.0, 1.0);
         let mean_conf = self
             .mean_dist_threshold
             .map(|thr| ((mean_dist - thr).abs() / thr.max(1e-3)).clamp(0.0, 1.0))
@@ -503,26 +472,6 @@ mod tests {
         assert!(p.infer(&feat(1.0, 0.1, 0.0, 0.0)).unwrap().value == 0.0);
     }
 
-    /// Issue #1440: a still/quiet occupant can measure LESS variance than an
-    /// empty room's ambient/interference noise floor. Before the
-    /// `variance_separates` guard, the midpoint threshold would then sit
-    /// below the empty-room baseline itself, so a window matching that
-    /// baseline exactly (empty room) read "present" — the reporter's
-    /// "known-empty room read present 31/31 frames" symptom. The means are
-    /// identical here (no mean-shift channel to fall back on), isolating
-    /// the variance-channel bug.
-    #[test]
-    fn presence_inverted_variance_never_reports_empty_room_as_present() {
-        let anchors = vec![
-            af(AnchorLabel::Empty, 5.0, 0.1),
-            af(AnchorLabel::StandStill, 2.0, 0.15),
-        ];
-        let p = PresenceSpecialist::train(&anchors).unwrap();
-        let r = p.infer(&feat(5.0, 0.1, 0.0, 0.0)).unwrap();
-        assert_eq!(r.value, 0.0, "empty-room-baseline variance must not read present when occ_var < empty_var");
-        assert_eq!(r.confidence, 0.0, "a disabled channel must not report spurious confidence");
-    }
-
     /// ADR-152 "variance-only presence" regression: a MOTIONLESS person raises
     /// the scalar mean (extra multipath energy) but barely the variance — the
     /// mean channel must still detect them, and a window matching the empty

v2/crates/wifi-densepose-sensing-server/src/main.rs

@@ -393,62 +393,6 @@ struct ClassificationInfo {
     confidence: f64,
 }
 
-/// Derives the classification triple from raw ESP32 vitals fields.
-///
-/// `presence` is derived from `motion_level`, never taken from the raw
-/// `presence` flag directly, so `motion_level: "present_moving"` can never
-/// pair with `presence: false` (issue #1442) — matches the convention
-/// already used elsewhere (the per-node path and `csi.rs`'s label-derived
-/// `classification.presence = label != "absent"`).
-fn classify_vitals(motion: bool, presence: bool, presence_score: f32) -> ClassificationInfo {
-    let motion_level = if motion {
-        "present_moving"
-    } else if presence {
-        "present_still"
-    } else {
-        "absent"
-    };
-    ClassificationInfo {
-        motion_level: motion_level.to_string(),
-        presence: motion_level != "absent",
-        confidence: presence_score as f64,
-    }
-}
-
-#[cfg(test)]
-mod classify_vitals_tests {
-    use super::classify_vitals;
-
-    #[test]
-    fn motion_implies_presence_issue_1442() {
-        // The exact contradictory frame from issue #1442:
-        // motion=true, presence=false must not yield presence: false.
-        let c = classify_vitals(true, false, 0.69);
-        assert_eq!(c.motion_level, "present_moving");
-        assert!(c.presence, "motion implies presence regardless of the raw presence flag");
-    }
-
-    #[test]
-    fn presence_without_motion_is_present_still() {
-        let c = classify_vitals(false, true, 0.5);
-        assert_eq!(c.motion_level, "present_still");
-        assert!(c.presence);
-    }
-
-    #[test]
-    fn neither_motion_nor_presence_is_absent() {
-        let c = classify_vitals(false, false, 0.0);
-        assert_eq!(c.motion_level, "absent");
-        assert!(!c.presence);
-    }
-
-    #[test]
-    fn confidence_passes_through_presence_score() {
-        let c = classify_vitals(true, true, 0.33);
-        assert!((c.confidence - 0.33_f64).abs() < 1e-6);
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct SignalField {
     grid_size: [usize; 3],
@@ -5842,6 +5786,13 @@ async fn udp_receiver_task(state: SharedState, udp_port: u16) {
                     s.tick += 1;
                     let tick = s.tick;
 
+                    let motion_level = if vitals.motion {
+                        "present_moving"
+                    } else if vitals.presence {
+                        "present_still"
+                    } else {
+                        "absent"
+                    };
                     let motion_score = if vitals.motion {
                         0.8
                     } else if vitals.presence {
@@ -5948,8 +5899,11 @@ async fn udp_receiver_task(state: SharedState, udp_port: u16) {
                     // Cross-node fusion: combine features from all active nodes.
                     let fused_features = fuse_multi_node_features(&features, &s.node_states);
 
-                    let mut classification =
-                        classify_vitals(vitals.motion, vitals.presence, vitals.presence_score);
+                    let mut classification = ClassificationInfo {
+                        motion_level: motion_level.to_string(),
+                        presence: vitals.presence,
+                        confidence: vitals.presence_score as f64,
+                    };
 
                     // Boost classification confidence with multi-node coverage.
                     let n_active = s