chore: update vendor submodules to latest main

README.md

@@ -14,7 +14,7 @@
 
 Instead of relying on cameras or cloud models, it observes whatever signals exist in a space such as WiFi, radio waves across the spectrum, motion patterns, vibration, sound, or other sensory inputs and builds an understanding of what is happening locally.
 
-Built on top of [RuVector](https://github.com/ruvnet/ruvector/) Self Learning Vector Memory system and [Cognitum.One](https://Cognitum.One) , the project became widely known for its implementation of WiFi DensePose — a sensing technique first explored in academic research such as Carnegie Mellon University's *DensePose From WiFi* work. That research demonstrated that WiFi signals can be used to reconstruct human pose.
+Built on top of [RuVector](https://github.com/ruvnet/ruvector/), the project became widely known for its implementation of WiFi DensePose — a sensing technique first explored in academic research such as Carnegie Mellon University's *DensePose From WiFi* work. That research demonstrated that WiFi signals can be used to reconstruct human pose.
 
 RuView extends that concept into a practical edge system. By analyzing Channel State Information (CSI) disturbances caused by human movement, RuView reconstructs body position, breathing rate, heart rate, and presence in real time using physics-based signal processing and machine learning.
 

firmware/esp32-csi-node/main/edge_processing.c

@@ -41,14 +41,12 @@ static const char *TAG = "edge_proc";
  * ====================================================================== */
 
 static edge_ring_buf_t s_ring;
-static uint32_t s_ring_drops;  /* Frames dropped due to full ring buffer. */
 
 static inline bool ring_push(const uint8_t *iq, uint16_t len,
                              int8_t rssi, uint8_t channel)
 {
     uint32_t next = (s_ring.head + 1) % EDGE_RING_SLOTS;
     if (next == s_ring.tail) {
-        s_ring_drops++;
         return false;  /* Full — drop frame. */
     }
 
@@ -790,13 +788,12 @@ static void process_frame(const edge_ring_slot_t *slot)
 
         if ((s_frame_count % 200) == 0) {
             ESP_LOGI(TAG, "Vitals: br=%.1f hr=%.1f motion=%.4f pres=%s "
-                     "fall=%s persons=%u frames=%lu drops=%lu",
+                     "fall=%s persons=%u frames=%lu",
                      s_breathing_bpm, s_heartrate_bpm, s_motion_energy,
                      s_presence_detected ? "YES" : "no",
                      s_fall_detected ? "YES" : "no",
                      (unsigned)s_latest_pkt.n_persons,
-                     (unsigned long)s_frame_count,
-                     (unsigned long)s_ring_drops);
+                     (unsigned long)s_frame_count);
         }
     }
 
@@ -834,32 +831,18 @@ static void edge_task(void *arg)
 
     edge_ring_slot_t slot;
 
-    /* Maximum frames to process before a longer yield.  On busy LANs
-     * (corporate networks, many APs), the ring buffer fills continuously.
-     * Without a batch limit the task processes frames back-to-back with
-     * only 1-tick yields, which on high frame rates can still starve
-     * IDLE1 enough to trip the 5-second task watchdog.  See #266, #321. */
-    const uint8_t BATCH_LIMIT = 4;
-
     while (1) {
-        uint8_t processed = 0;
-
-        while (processed < BATCH_LIMIT && ring_pop(&slot)) {
+        if (ring_pop(&slot)) {
             process_frame(&slot);
-            processed++;
-            /* 1-tick yield between frames within a batch. */
+            /* Yield after every frame to feed the Core 1 watchdog.
+             * process_frame() is CPU-intensive (biquad filters, Welford stats,
+             * BPM estimation, multi-person vitals) and can take several ms.
+             * Without this yield, edge_dsp at priority 5 starves IDLE1 at
+             * priority 0, triggering the task watchdog. See issue #266. */
             vTaskDelay(1);
-        }
-
-        if (processed > 0) {
-            /* Post-batch yield: 2 ticks (~20 ms at 100 Hz) so IDLE1 can
-             * run and feed the Core 1 watchdog even under sustained load.
-             * This is intentionally longer than the 1-tick inter-frame yield. */
-            vTaskDelay(2);
         } else {
-            /* No frames available — sleep one full tick.
-             * NOTE: pdMS_TO_TICKS(5) == 0 at 100 Hz, which would busy-spin. */
-            vTaskDelay(1);
+            /* No frames available — yield briefly. */
+            vTaskDelay(pdMS_TO_TICKS(1));
         }
     }
 }

rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/main.rs

@@ -285,8 +285,6 @@ struct AppStateInner {
     frame_history: VecDeque<Vec<f64>>,
     tick: u64,
     source: String,
-    /// Instant of the last ESP32 UDP frame received (for offline detection).
-    last_esp32_frame: Option<std::time::Instant>,
     tx: broadcast::Sender<String>,
     total_detections: u64,
     start_time: std::time::Instant,
@@ -366,25 +364,6 @@ struct AppStateInner {
     adaptive_model: Option<adaptive_classifier::AdaptiveModel>,
 }
 
-/// If no ESP32 frame arrives within this duration, source reverts to offline.
-const ESP32_OFFLINE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
-
-impl AppStateInner {
-    /// Return the effective data source, accounting for ESP32 frame timeout.
-    /// If the source is "esp32" but no frame has arrived in 5 seconds, returns
-    /// "esp32:offline" so the UI can distinguish active vs stale connections.
-    fn effective_source(&self) -> String {
-        if self.source == "esp32" {
-            if let Some(last) = self.last_esp32_frame {
-                if last.elapsed() > ESP32_OFFLINE_TIMEOUT {
-                    return "esp32:offline".to_string();
-                }
-            }
-        }
-        self.source.clone()
-    }
-}
-
 /// Number of frames retained in `frame_history` for temporal analysis.
 /// At 500 ms ticks this covers ~50 seconds; at 100 ms ticks ~10 seconds.
 const FRAME_HISTORY_CAPACITY: usize = 100;
@@ -1690,7 +1669,7 @@ async fn health(State(state): State<SharedState>) -> Json<serde_json::Value> {
     let s = state.read().await;
     Json(serde_json::json!({
         "status": "ok",
-        "source": s.effective_source(),
+        "source": s.source,
         "tick": s.tick,
         "clients": s.tx.receiver_count(),
     }))
@@ -1998,7 +1977,7 @@ async fn health_ready(State(state): State<SharedState>) -> Json<serde_json::Valu
     let s = state.read().await;
     Json(serde_json::json!({
         "status": "ready",
-        "source": s.effective_source(),
+        "source": s.source,
     }))
 }
 
@@ -2009,10 +1988,7 @@ async fn health_system(State(state): State<SharedState>) -> Json<serde_json::Val
         "status": "healthy",
         "components": {
             "api": { "status": "healthy", "message": "Rust Axum server" },
-            "hardware": {
-                "status": if s.effective_source().ends_with(":offline") { "degraded" } else { "healthy" },
-                "message": format!("Source: {}", s.effective_source())
-            },
+            "hardware": { "status": "healthy", "message": format!("Source: {}", s.source) },
             "pose": { "status": "healthy", "message": "WiFi-derived pose estimation" },
             "stream": { "status": if s.tx.receiver_count() > 0 { "healthy" } else { "idle" },
                         "message": format!("{} client(s)", s.tx.receiver_count()) },
@@ -2052,7 +2028,7 @@ async fn api_info(State(state): State<SharedState>) -> Json<serde_json::Value> {
         "version": env!("CARGO_PKG_VERSION"),
         "environment": "production",
         "backend": "rust",
-        "source": s.effective_source(),
+        "source": s.source,
         "features": {
             "wifi_sensing": true,
             "pose_estimation": true,
@@ -2073,7 +2049,7 @@ async fn pose_current(State(state): State<SharedState>) -> Json<serde_json::Valu
         "timestamp": chrono::Utc::now().timestamp_millis() as f64 / 1000.0,
         "persons": persons,
         "total_persons": persons.len(),
-        "source": s.effective_source(),
+        "source": s.source,
     }))
 }
 
@@ -2083,7 +2059,7 @@ async fn pose_stats(State(state): State<SharedState>) -> Json<serde_json::Value>
         "total_detections": s.total_detections,
         "average_confidence": 0.87,
         "frames_processed": s.tick,
-        "source": s.effective_source(),
+        "source": s.source,
     }))
 }
 
@@ -2107,7 +2083,7 @@ async fn stream_status(State(state): State<SharedState>) -> Json<serde_json::Val
         "active": true,
         "clients": s.tx.receiver_count(),
         "fps": if s.tick > 1 { 10u64 } else { 0u64 },
-        "source": s.effective_source(),
+        "source": s.source,
     }))
 }
 
@@ -2643,7 +2619,7 @@ async fn vital_signs_endpoint(State(state): State<SharedState>) -> Json<serde_js
             "heartbeat_samples": hb_len,
             "heartbeat_capacity": hb_cap,
         },
-        "source": s.effective_source(),
+        "source": s.source,
         "tick": s.tick,
     }))
 }
@@ -2820,90 +2796,6 @@ async fn udp_receiver_task(state: SharedState, udp_port: u16) {
                     })) {
                         let _ = s.tx.send(json);
                     }
-
-                    // Issue #323: Also emit a sensing_update so the UI renders
-                    // detections for ESP32 nodes running the edge DSP pipeline
-                    // (Tier 2+).  Without this, vitals arrive but the UI shows
-                    // "no detection" because it only renders sensing_update msgs.
-                    s.source = "esp32".to_string();
-                    s.last_esp32_frame = Some(std::time::Instant::now());
-                    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 { 0.3 }
-                        else { 0.05 };
-                    let est_persons = if vitals.presence {
-                        (vitals.n_persons as usize).max(1)
-                    } else {
-                        0
-                    };
-
-                    let features = FeatureInfo {
-                        mean_rssi: vitals.rssi as f64,
-                        variance: vitals.motion_energy as f64,
-                        motion_band_power: vitals.motion_energy as f64,
-                        breathing_band_power: if vitals.presence { 0.5 } else { 0.0 },
-                        dominant_freq_hz: vitals.breathing_rate_bpm / 60.0,
-                        change_points: 0,
-                        spectral_power: vitals.motion_energy as f64,
-                    };
-                    let classification = ClassificationInfo {
-                        motion_level: motion_level.to_string(),
-                        presence: vitals.presence,
-                        confidence: vitals.presence_score as f64,
-                    };
-                    let signal_field = generate_signal_field(
-                        vitals.rssi as f64, motion_score, vitals.breathing_rate_bpm / 60.0,
-                        (vitals.presence_score as f64).min(1.0), &[],
-                    );
-
-                    let mut update = SensingUpdate {
-                        msg_type: "sensing_update".to_string(),
-                        timestamp: chrono::Utc::now().timestamp_millis() as f64 / 1000.0,
-                        source: "esp32".to_string(),
-                        tick,
-                        nodes: vec![NodeInfo {
-                            node_id: vitals.node_id,
-                            rssi_dbm: vitals.rssi as f64,
-                            position: [2.0, 0.0, 1.5],
-                            amplitude: vec![],
-                            subcarrier_count: 0,
-                        }],
-                        features: features.clone(),
-                        classification,
-                        signal_field,
-                        vital_signs: Some(VitalSigns {
-                            breathing_rate_bpm: if vitals.breathing_rate_bpm > 0.0 { Some(vitals.breathing_rate_bpm) } else { None },
-                            heart_rate_bpm: if vitals.heartrate_bpm > 0.0 { Some(vitals.heartrate_bpm) } else { None },
-                            breathing_confidence: if vitals.presence { 0.7 } else { 0.0 },
-                            heartbeat_confidence: if vitals.presence { 0.7 } else { 0.0 },
-                            signal_quality: vitals.presence_score as f64,
-                        }),
-                        enhanced_motion: None,
-                        enhanced_breathing: None,
-                        posture: None,
-                        signal_quality_score: None,
-                        quality_verdict: None,
-                        bssid_count: None,
-                        pose_keypoints: None,
-                        model_status: None,
-                        persons: None,
-                        estimated_persons: if est_persons > 0 { Some(est_persons) } else { None },
-                    };
-
-                    let persons = derive_pose_from_sensing(&update);
-                    if !persons.is_empty() {
-                        update.persons = Some(persons);
-                    }
-
-                    if let Ok(json) = serde_json::to_string(&update) {
-                        let _ = s.tx.send(json);
-                    }
-                    s.latest_update = Some(update);
                     s.edge_vitals = Some(vitals);
                     continue;
                 }
@@ -2933,7 +2825,6 @@ async fn udp_receiver_task(state: SharedState, udp_port: u16) {
 
                     let mut s = state.write().await;
                     s.source = "esp32".to_string();
-                    s.last_esp32_frame = Some(std::time::Instant::now());
 
                     // Append current amplitudes to history before extracting features so
                     // that temporal analysis includes the most recent frame.
@@ -3716,7 +3607,6 @@ async fn main() {
         frame_history: VecDeque::new(),
         tick: 0,
         source: source.into(),
-        last_esp32_frame: None,
         tx,
         total_detections: 0,
         start_time: std::time::Instant::now(),
@@ -3891,7 +3781,7 @@ async fn main() {
             "WiFi DensePose sensing model state",
         );
         builder.add_metadata(&serde_json::json!({
-            "source": s.effective_source(),
+            "source": s.source,
             "total_ticks": s.tick,
             "total_detections": s.total_detections,
             "uptime_secs": s.start_time.elapsed().as_secs(),