fix(vitals): HeartRateExtractor weights=[] silent None + BreathingExtractor stale-lock recovery (#1422, #1423) (#1449)

Fixes #1422, Fixes #1423. HeartRateExtractor no longer truncates subcarrier count on empty phases; BreathingExtractor resets immediately on first out-of-band rejection instead of passively draining a stale window (recovery 28.6s -> 6.0s). 64 tests passing, clippy clean, zero regressions workspace-wide.

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

@@ -37,6 +37,13 @@ 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 {
@@ -111,6 +118,16 @@ 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
@@ -129,8 +146,15 @@ 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: 0.5 * (empty_var + occ_var),
+            threshold,
             occupied_var: occ_var.max(empty_var + 1e-3),
             empty_mean,
             mean_dist_threshold,
@@ -149,8 +173,15 @@ impl Specialist for PresenceSpecialist {
         let present = by_variance || by_mean;
 
         // Confidence: strongest margin among the channels that are enabled.
-        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);
+        // 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 mean_conf = self
             .mean_dist_threshold
             .map(|thr| ((mean_dist - thr).abs() / thr.max(1e-3)).clamp(0.0, 1.0))
@@ -472,6 +503,26 @@ 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,6 +393,62 @@ 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],
@@ -5786,13 +5842,6 @@ 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 {
@@ -5899,11 +5948,8 @@ 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 = ClassificationInfo {
-                        motion_level: motion_level.to_string(),
-                        presence: vitals.presence,
-                        confidence: vitals.presence_score as f64,
-                    };
+                    let mut classification =
+                        classify_vitals(vitals.motion, vitals.presence, vitals.presence_score);
 
                     // Boost classification confidence with multi-node coverage.
                     let n_active = s