docs: add download/run instructions to desktop README

Co-Authored-By: claude-flow <ruv@ruv.net>
docs: add desktop crate README and link from main README
2026-06-30 13:43:18 +00:00 · 2026-03-08 23:30:12 -04:00 · 2026-03-08 23:26:22 -04:00 · 2026-03-08 23:20:59 -04:00 · 2026-03-06 16:30:15 -05:00 · 2026-03-06 16:28:29 -05:00
9772 changed files with 37870 additions and 5418650 deletions
@@ -0,0 +1,50 @@
+name: Update vendor submodules
+
+on:
+  schedule:
+    - cron: '0 */6 * * *'  # Every 6 hours
+  workflow_dispatch:        # Manual trigger
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Update submodules to latest main
+        run: git submodule update --remote --merge
+
+      - name: Check for changes
+        id: check
+        run: |
+          if git diff --quiet; then
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Create PR with updates
+        if: steps.check.outputs.changed == 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          BRANCH="chore/update-submodules-$(date +%Y%m%d-%H%M%S)"
+          git checkout -b "$BRANCH"
+          git add vendor/
+          git commit -m "chore: update vendor submodules to latest main"
+          git push origin "$BRANCH"
+          gh pr create \
+            --title "chore: update vendor submodules" \
+            --body "Automated submodule update to latest upstream main." \
+            --base main \
+            --head "$BRANCH"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -8,6 +8,16 @@ firmware/esp32-csi-node/sdkconfig.defaults
 firmware/esp32-csi-node/sdkconfig.old
 # Downloaded WASM3 source (fetched at configure time)
 firmware/esp32-csi-node/components/wasm3/wasm3-src/
+# ESP-IDF managed components (downloaded at build time)
+firmware/esp32-csi-node/managed_components/
+firmware/esp32-csi-node/dependencies.lock
+firmware/esp32-csi-node/sdkconfig.defaults.bak
+
+# Claude Flow swarm runtime state
+.swarm/
+
+# CSI recordings (local training data, machine-specific)
+rust-port/wifi-densepose-rs/data/recordings/

 # NVS partition images and CSVs (contain WiFi credentials)
 nvs.bin
@@ -0,0 +1,12 @@
+[submodule "vendor/midstream"]
+	path = vendor/midstream
+	url = https://github.com/ruvnet/midstream
+	branch = main
+[submodule "vendor/ruvector"]
+	path = vendor/ruvector
+	url = https://github.com/ruvnet/ruvector
+	branch = main
+[submodule "vendor/sublinear-time-solver"]
+	path = vendor/sublinear-time-solver
+	url = https://github.com/ruvnet/sublinear-time-solver
+	branch = main
@@ -8,6 +8,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]

 ### Added
+- **Sensing server UI API completion (ADR-043)** — 14 fully-functional REST endpoints for model management, CSI recording, and training control
+  - Model CRUD: `GET /api/v1/models`, `GET /api/v1/models/active`, `POST /api/v1/models/load`, `POST /api/v1/models/unload`, `DELETE /api/v1/models/:id`, `GET /api/v1/models/lora/profiles`, `POST /api/v1/models/lora/activate`
+  - CSI recording: `GET /api/v1/recording/list`, `POST /api/v1/recording/start`, `POST /api/v1/recording/stop`, `DELETE /api/v1/recording/:id`
+  - Training control: `GET /api/v1/train/status`, `POST /api/v1/train/start`, `POST /api/v1/train/stop`
+  - Recording writes CSI frames to `.jsonl` files via tokio background task
+  - Model/recording directories scanned at startup, state managed via `Arc<RwLock<AppStateInner>>`
+- **ADR-044: Provisioning tool enhancements** — 5-phase plan for complete NVS coverage (7 missing keys), JSON config files, mesh presets, read-back/verify, and auto-detect
+- **25 real mobile tests** replacing `it.todo()` placeholders — 205 assertions covering components, services, stores, hooks, screens, and utils
 - **Project MERIDIAN (ADR-027)** — Cross-environment domain generalization for WiFi pose estimation (1,858 lines, 72 tests)
  - `HardwareNormalizer` — Catmull-Rom cubic interpolation resamples any hardware CSI to canonical 56 subcarriers; z-score + phase sanitization
  - `DomainFactorizer` + `GradientReversalLayer` — adversarial disentanglement of pose-relevant vs environment-specific features
@@ -23,6 +31,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ADR-025: macOS CoreWLAN WiFi Sensing (ORCA)

 ### Fixed
+- **sendto ENOMEM crash (Issue #127)** — CSI callbacks in promiscuous mode exhaust lwIP pbuf pool causing guru meditation crash. Fixed with 50 Hz rate limiter in `csi_collector.c` and 100 ms ENOMEM backoff in `stream_sender.c`. Hardware-verified on ESP32-S3 (200+ callbacks, zero crashes)
+- **Provisioning script missing TDM/edge flags (Issue #130)** — Added `--tdm-slot`, `--tdm-total`, `--edge-tier`, `--pres-thresh`, `--fall-thresh`, `--vital-win`, `--vital-int`, `--subk-count` to `provision.py`
+- **WebSocket "RECONNECTING" on Dashboard/Live Demo** — `sensingService.start()` now called on app init in `app.js` so WebSocket connects immediately instead of waiting for Sensing tab visit
+- **Mobile WebSocket port** — `ws.service.ts` `buildWsUrl()` uses same-origin port instead of hardcoded port 3001
+- **Mobile Jest config** — `testPathIgnorePatterns` no longer silently ignores the entire test directory
 - Removed synthetic byte counters from Python `MacosWifiCollector` — now reports `tx_bytes=0, rx_bytes=0` instead of fake incrementing values

 ---
@@ -57,7 +57,7 @@ All 5 ruvector crates integrated in workspace:
 - `ruvector-attention` → `model.rs` (apply_spatial_attention) + `bvp.rs`

 ### Architecture Decisions
-32 ADRs in `docs/adr/` (ADR-001 through ADR-032). Key ones:
+43 ADRs in `docs/adr/` (ADR-001 through ADR-043). Key ones:
 - ADR-014: SOTA signal processing (Accepted)
 - ADR-015: MM-Fi + Wi-Pose training datasets (Accepted)
 - ADR-016: RuVector training pipeline integration (Accepted — complete)
@@ -173,7 +173,7 @@ Active feature branch: `ruvsense-full-implementation` (PR #77)
 ## File Organization

 - NEVER save to root folder — use the directories below
- `docs/adr/` — Architecture Decision Records (32 ADRs)
+- `docs/adr/` — Architecture Decision Records (43 ADRs)
 - `docs/ddd/` — Domain-Driven Design models
 - `rust-port/wifi-densepose-rs/crates/` — Rust workspace crates (15 crates)
 - `rust-port/wifi-densepose-rs/crates/wifi-densepose-signal/src/ruvsense/` — RuvSense multistatic modules (14 files)
@@ -1,13 +1,23 @@
 # π RuView

-**See through walls with WiFi.** No cameras. No wearables. Just radio waves.
+<p align="center">
+  <a href="https://ruvnet.github.io/RuView/">
+    <img src="assets/ruview-small-gemini.jpg" alt="RuView - WiFi DensePose" width="100%">
+  </a>
+</p>

-WiFi DensePose turns commodity WiFi signals into real-time human pose estimation, vital sign monitoring, and presence detection — all without a single pixel of video. By analyzing Channel State Information (CSI) disturbances caused by human movement, the system reconstructs body position, breathing rate, and heartbeat using physics-based signal processing and machine learning.
+**See through walls with WiFi.** No cameras. No wearables. No Internet. Just radio waves.
+
+WiFi DensePose turns commodity WiFi signals into real-time human pose estimation, vital sign monitoring, and presence detection — all without a single pixel of video. 
+
+By analyzing Channel State Information (CSI) disturbances caused by human movement, the system reconstructs body position, breathing rate, and heartbeat using physics-based signal processing and machine learning. 
+
+[Edge modules](#edge-intelligence-adr-041) are small programs that run directly on the ESP32 sensor — no internet needed, no cloud fees, instant response.

 [![Rust 1.85+](https://img.shields.io/badge/rust-1.85+-orange.svg)](https://www.rust-lang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests: 1300+](https://img.shields.io/badge/tests-1300%2B-brightgreen.svg)](https://github.com/ruvnet/wifi-densepose)
-[![Docker: 132 MB](https://img.shields.io/badge/docker-132%20MB-blue.svg)](https://hub.docker.com/r/ruvnet/wifi-densepose)
+[![Tests: 1300+](https://img.shields.io/badge/tests-1300%2B-brightgreen.svg)](https://github.com/ruvnet/RuView)
+[![Docker: multi-arch](https://img.shields.io/badge/docker-amd64%20%2B%20arm64-blue.svg)](https://hub.docker.com/r/ruvnet/wifi-densepose)
 [![Vital Signs](https://img.shields.io/badge/vital%20signs-breathing%20%2B%20heartbeat-red.svg)](#vital-sign-detection)
 [![ESP32 Ready](https://img.shields.io/badge/ESP32--S3-CSI%20streaming-purple.svg)](#esp32-s3-hardware-pipeline)
 [![crates.io](https://img.shields.io/crates/v/wifi-densepose-ruvector.svg)](https://crates.io/crates/wifi-densepose-ruvector)
@@ -40,7 +50,7 @@ docker run -p 3000:3000 ruvnet/wifi-densepose:latest
 > | **Any WiFi** | Windows, macOS, or Linux laptop | $0 | No | RSSI-only: coarse presence and motion |
 >
 > No hardware? Verify the signal processing pipeline with the deterministic reference signal: `python v1/data/proof/verify.py`
-
+>
 ---

 ## 📖 Documentation
@@ -48,17 +58,23 @@ docker run -p 3000:3000 ruvnet/wifi-densepose:latest
 | Document | Description |
 |----------|-------------|
 | [User Guide](docs/user-guide.md) | Step-by-step guide: installation, first run, API usage, hardware setup, training |
-| [WiFi-Mat User Guide](docs/wifi-mat-user-guide.md) | Disaster response module: search & rescue, START triage |
 | [Build Guide](docs/build-guide.md) | Building from source (Rust and Python) |
-| [Architecture Decisions](docs/adr/) | 41 ADRs covering signal processing, training, hardware, security, domain generalization, multistatic sensing, CRV signal-line integration, edge intelligence |
-| [DDD Domain Model](docs/ddd/ruvsense-domain-model.md) | RuvSense bounded contexts, aggregates, domain events, and ubiquitous language |
+| [Architecture Decisions](docs/adr/README.md) | 48 ADRs — why each technical choice was made, organized by domain (hardware, signal processing, ML, platform, infrastructure) |
+| [Domain Models](docs/ddd/README.md) | 7 DDD models (RuvSense, Signal Processing, Training Pipeline, Hardware Platform, Sensing Server, WiFi-Mat, CHCI) — bounded contexts, aggregates, domain events, and ubiquitous language |
+| [Desktop App](rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/README.md) | **WIP** — Tauri v2 desktop app for node management, OTA updates, WASM deployment, and mesh visualization |

 ---


-  <img src="assets/screen.png" alt="WiFi DensePose — Live pose detection with setup guide" width="800">
+  <a href="https://ruvnet.github.io/RuView/">
+    <img src="assets/v2-screen.png" alt="WiFi DensePose — Live pose detection with setup guide" width="800">
+  </a>
  <br>
  <em>Real-time pose skeleton from WiFi CSI signals — no cameras, no wearables</em>
+  <br>
+  <a href="https://ruvnet.github.io/RuView/"><strong>▶ Live Observatory Demo</strong></a>
+
+> The [server](#-quick-start) is optional for visualization and aggregation — the ESP32 [runs independently](#esp32-s3-hardware-pipeline) for presence detection, vital signs, and fall alerts.


 ## 🚀 Key Features
@@ -89,6 +105,7 @@ The system learns on its own and gets smarter over time — no hand-tuning, no l
 | 👁️ | **Cross-Viewpoint Fusion** | AI combines what each sensor sees from its own angle — fills in blind spots and depth ambiguity that no single viewpoint can resolve on its own ([ADR-031](docs/adr/ADR-031-ruview-sensing-first-rf-mode.md)) |
 | 🔮 | **Signal-Line Protocol** | A 6-stage processing pipeline transforms raw WiFi signals into structured body representations — from signal cleanup through graph-based spatial reasoning to final pose output ([ADR-033](docs/adr/ADR-033-crv-signal-line-sensing-integration.md)) |
 | 🔒 | **QUIC Mesh Security** | All sensor-to-sensor communication is encrypted end-to-end with tamper detection, replay protection, and seamless reconnection if a node moves or drops offline ([ADR-032](docs/adr/ADR-032-multistatic-mesh-security-hardening.md)) |
+| 🎯 | **Adaptive Classifier** | Records labeled CSI sessions, trains a 15-feature logistic regression model in pure Rust, and learns your room's unique signal characteristics — replaces hand-tuned thresholds with data-driven classification ([ADR-048](docs/adr/ADR-048-adaptive-csi-classifier.md)) |

 ### Performance & Deployment

@@ -97,9 +114,12 @@ Fast enough for real-time use, small enough for edge devices, simple enough for
 | | Feature | What It Means |
 |---|---------|---------------|
 | ⚡ | **Real-Time** | Analyzes WiFi signals in under 100 microseconds per frame — fast enough for live monitoring |
-| 🦀 | **810x Faster** | Complete Rust rewrite: 54,000 frames/sec pipeline, 132 MB Docker image, 1,031+ tests |
-| 🐳 | **One-Command Setup** | `docker pull ruvnet/wifi-densepose:latest` — live sensing in 30 seconds, no toolchain needed |
+| 🦀 | **810x Faster** | Complete Rust rewrite: 54,000 frames/sec pipeline, multi-arch Docker image, 1,031+ tests |
+| 🐳 | **One-Command Setup** | `docker pull ruvnet/wifi-densepose:latest` — live sensing in 30 seconds, no toolchain needed (amd64 + arm64 / Apple Silicon) |
+| 📡 | **Fully Local** | Runs completely on a $9 ESP32 — no internet connection, no cloud account, no recurring fees. Detects presence, vital signs, and falls on-device with instant response |
 | 📦 | **Portable Models** | Trained models package into a single `.rvf` file — runs on edge, cloud, or browser (WASM) |
+| 🔭 | **Observatory Visualization** | Cinematic Three.js dashboard with 5 holographic panels — subcarrier manifold, vital signs oracle, presence heatmap, phase constellation, convergence engine — all driven by live or demo CSI data ([ADR-047](docs/adr/ADR-047-psychohistory-observatory-visualization.md)) |
+| 📟 | **AMOLED Display** | ESP32-S3 boards with built-in AMOLED screens show real-time presence, vital signs, and room status directly on the sensor — no phone or PC needed ([ADR-045](docs/adr/ADR-045-amoled-display-support.md)) |

 ---

@@ -506,8 +526,8 @@ The installer walks through 7 steps: system detection, toolchain check, WiFi har
 <summary><strong>From Source</strong> — Rust (primary) or Python</summary>

 ```bash
-git clone https://github.com/ruvnet/wifi-densepose.git
-cd wifi-densepose
+git clone https://github.com/ruvnet/RuView.git
+cd RuView

 # Rust (primary — 810x faster)
 cd rust-port/wifi-densepose-rs
@@ -545,10 +565,10 @@ cd docker && docker compose up
 docker run --rm -v $(pwd):/out ruvnet/wifi-densepose:latest --export-rvf /out/model.rvf
 ```

-| Image | Tag | Size | Ports |
-|-------|-----|------|-------|
-| `ruvnet/wifi-densepose` | `latest`, `rust` | 132 MB | 3000 (REST), 3001 (WS), 5005/udp (ESP32) |
-| `ruvnet/wifi-densepose` | `python` | 569 MB | 8765 (WS), 8080 (UI) |
+| Image | Tag | Platforms | Ports |
+|-------|-----|-----------|-------|
+| `ruvnet/wifi-densepose` | `latest`, `rust` | linux/amd64, linux/arm64 | 3000 (REST), 3001 (WS), 5005/udp (ESP32) |
+| `ruvnet/wifi-densepose` | `python` | linux/amd64 | 8765 (WS), 8080 (UI) |

 </details>

@@ -683,9 +703,9 @@ The signal processing stack transforms raw WiFi Channel State Information into a
 |---------|-------------|------|
 | [Key Features](#key-features) | Sensing, Intelligence, and Performance & Deployment capabilities | — |
 | [How It Works](#how-it-works) | End-to-end pipeline: radio waves → CSI capture → signal processing → AI → pose + vitals | — |
-| [ESP32-S3 Hardware Pipeline](#esp32-s3-hardware-pipeline) | 20 Hz CSI streaming, binary frame parsing, flash & provision | [ADR-018](docs/adr/ADR-018-esp32-dev-implementation.md) · [Tutorial #34](https://github.com/ruvnet/wifi-densepose/issues/34) |
+| [ESP32-S3 Hardware Pipeline](#esp32-s3-hardware-pipeline) | 20 Hz CSI streaming, binary frame parsing, flash & provision | [ADR-018](docs/adr/ADR-018-esp32-dev-implementation.md) · [Tutorial #34](https://github.com/ruvnet/RuView/issues/34) |
 | [Vital Sign Detection](#vital-sign-detection) | Breathing 6-30 BPM, heartbeat 40-120 BPM, FFT peak detection | [ADR-021](docs/adr/ADR-021-vital-sign-detection-rvdna-pipeline.md) |
-| [WiFi Scan Domain Layer](#wifi-scan-domain-layer) | 8-stage RSSI pipeline, multi-BSSID fingerprinting, Windows WiFi | [ADR-022](docs/adr/ADR-022-windows-wifi-enhanced-fidelity-ruvector.md) · [Tutorial #36](https://github.com/ruvnet/wifi-densepose/issues/36) |
+| [WiFi Scan Domain Layer](#wifi-scan-domain-layer) | 8-stage RSSI pipeline, multi-BSSID fingerprinting, Windows WiFi | [ADR-022](docs/adr/ADR-022-windows-wifi-enhanced-fidelity-ruvector.md) · [Tutorial #36](https://github.com/ruvnet/RuView/issues/36) |
 | [WiFi-Mat Disaster Response](#wifi-mat-disaster-response) | Search & rescue, START triage, 3D localization through debris | [ADR-001](docs/adr/ADR-001-wifi-mat-disaster-detection.md) · [User Guide](docs/wifi-mat-user-guide.md) |
 | [SOTA Signal Processing](#sota-signal-processing) | SpotFi, Hampel, Fresnel, STFT spectrogram, subcarrier selection, BVP | [ADR-014](docs/adr/ADR-014-sota-signal-processing.md) |

@@ -754,7 +774,7 @@ WiFi DensePose is MIT-licensed open source, developed by [ruvnet](https://github
 |---------|-------------|------|
 | [Changelog](#changelog) | v3.0.0 (AETHER AI + Docker), v2.0.0 (Rust port + SOTA + WiFi-Mat) | [CHANGELOG.md](CHANGELOG.md) |
 | [License](#license) | MIT License | [LICENSE](LICENSE) |
-| [Support](#support) | Bug reports, feature requests, community discussion | [Issues](https://github.com/ruvnet/wifi-densepose/issues) · [Discussions](https://github.com/ruvnet/wifi-densepose/discussions) |
+| [Support](#support) | Bug reports, feature requests, community discussion | [Issues](https://github.com/ruvnet/RuView/issues) · [Discussions](https://github.com/ruvnet/RuView/discussions) |

 </details>

@@ -970,67 +990,103 @@ let convergence = pipeline.find_cross_room_convergence("person-001", 0.75)?;
 ## 📡 Signal Processing & Sensing

 <details>
-<summary><a id="esp32-s3-hardware-pipeline"></a><strong>📡 ESP32-S3 Hardware Pipeline (ADR-018)</strong> — 20 Hz CSI streaming, flash & provision</summary>
+<summary><a id="esp32-s3-hardware-pipeline"></a><strong>📡 ESP32-S3 Hardware Pipeline (ADR-018)</strong> — 28 Hz CSI streaming, flash & provision</summary>
+
+A single ESP32-S3 board (~$9) captures WiFi signal data 28 times per second and streams it over UDP. A host server can visualize and record the data, but the ESP32 can also run on its own — detecting presence, measuring breathing and heart rate, and alerting on falls without any server at all.

 ```
-ESP32-S3 (STA + promiscuous)     UDP/5005      Rust aggregator
-┌─────────────────────────┐    ──────────>    ┌──────────────────┐
-│ WiFi CSI callback 20 Hz │    ADR-018        │ Esp32CsiParser   │
-│ ADR-018 binary frames   │    binary         │ CsiFrame output  │
-│ stream_sender (UDP)     │                   │ presence detect  │
-└─────────────────────────┘                   └──────────────────┘
+ESP32-S3 node                    UDP/5005        Host server (optional)
+┌───────────────────────┐      ──────────>      ┌──────────────────────┐
+│ Captures WiFi signals │      binary frames    │ Parses frames        │
+│ 28 Hz, up to 192 sub- │      or 32-byte       │ Visualizes poses     │
+│ carriers per frame     │      vitals packets   │ Records CSI data     │
+│                        │                       │ REST API + WebSocket │
+│ On-device (optional):  │                       └──────────────────────┘
+│  Presence detection    │
+│  Breathing + heart rate│
+│  Fall detection        │
+│  WASM custom modules   │
+└───────────────────────┘
 ```

-| Metric | Measured |
-|--------|----------|
-| Frame rate | ~20 Hz sustained |
-| Subcarriers | 64 / 128 / 192 (LLTF, HT, HT40) |
-| Latency | < 1ms (UDP loopback) |
-| Presence detection | Motion score 10/10 at 3m |
+| Metric | Measured on hardware |
+|--------|----------------------|
+| CSI frame rate | 28.5 Hz (channel 5, BW20) |
+| Subcarriers per frame | 64 / 128 / 192 (depends on WiFi mode) |
+| UDP latency | < 1 ms on local network |
+| Presence detection range | Reliable at 3 m through walls |
+| Binary size | 947 KB (fits in 1 MB flash partition) |
+| Boot to ready | ~3.9 seconds |

-**Firmware releases** (pre-built, no toolchain required):
+### Flash and provision

-| Release | Features | Tag |
-|---------|----------|-----|
-| [v0.2.0](https://github.com/ruvnet/wifi-densepose/releases/tag/v0.2.0-esp32) | Stable — raw CSI streaming, TDM, channel hopping, QUIC mesh | `v0.2.0-esp32` |
-| [v0.3.0-alpha](https://github.com/ruvnet/wifi-densepose/releases/tag/v0.3.0-alpha-esp32) | Alpha — adds on-device edge intelligence ([ADR-039](docs/adr/ADR-039-esp32-edge-intelligence.md)) | `v0.3.0-alpha-esp32` |
+Download a pre-built binary — no build toolchain needed:
+
+| Release | What's included | Tag |
+|---------|-----------------|-----|
+| [v0.2.0](https://github.com/ruvnet/RuView/releases/tag/v0.2.0-esp32) | Stable — raw CSI streaming, multi-node TDM, channel hopping | `v0.2.0-esp32` |
+| [v0.3.0-alpha](https://github.com/ruvnet/RuView/releases/tag/v0.3.0-alpha-esp32) | Alpha — adds on-device edge intelligence and WASM modules ([ADR-039](docs/adr/ADR-039-esp32-edge-intelligence.md), [ADR-040](docs/adr/ADR-040-wasm-programmable-sensing.md)) | `v0.3.0-alpha-esp32` |

 ```bash
-# Flash (works with either release)
+# 1. Flash the firmware to your ESP32-S3
 python -m esptool --chip esp32s3 --port COM7 --baud 460800 \
-  write-flash --flash-mode dio --flash-size 4MB \
+  write_flash --flash_mode dio --flash_size 8MB \
  0x0 bootloader.bin 0x8000 partition-table.bin 0x10000 esp32-csi-node.bin

-# Provision WiFi (no credentials baked into the binary)
+# 2. Set WiFi credentials and server address (stored in flash, survives reboots)
 python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20

-# Start the aggregator
-cargo run -p wifi-densepose-sensing-server -- --http-port 3000 --source esp32
+# 3. (Optional) Start the host server to visualize data
+cargo run -p wifi-densepose-sensing-server -- --http-port 3000 --source auto
+# Open http://localhost:3000
 ```

-**Edge Intelligence (v0.3.0-alpha only):**
+### Multi-node mesh

-The alpha firmware adds on-device CSI processing — the ESP32 analyzes signals locally and sends compact results instead of raw data. Disabled by default (tier 0) for backward compatibility.
+For better accuracy and room coverage, deploy 3-6 nodes with time-division multiplexing (TDM) so they take turns transmitting:

-| Tier | What It Does | Extra RAM |
-|------|-------------|-----------|
-| **0** | Off — raw CSI streaming only (same as v0.2.0) | 0 KB |
-| **1** | Phase unwrapping, running stats, top-K subcarrier selection, delta compression | ~30 KB |
-| **2** | Tier 1 + presence detection, breathing rate, heart rate, fall detection | ~33 KB |
+```bash
+# Node 0 of a 3-node mesh
+python firmware/esp32-csi-node/provision.py --port COM7 \
+  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20 \
+  --node-id 0 --tdm-slot 0 --tdm-total 3

-Enable via NVS — no reflash needed:
+# Node 1
+python firmware/esp32-csi-node/provision.py --port COM8 \
+  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20 \
+  --node-id 1 --tdm-slot 1 --tdm-total 3
+```
+
+Nodes can also hop across WiFi channels (1, 6, 11) to increase sensing bandwidth — configured via [ADR-029](docs/adr/ADR-029-ruvsense-multistatic-sensing-mode.md) channel hopping.
+
+### On-device intelligence (v0.3.0-alpha)
+
+The alpha firmware can analyze signals locally and send compact results instead of raw data. This means the ESP32 works standalone — no server needed for basic sensing. Disabled by default for backward compatibility.
+
+| Tier | What it does | RAM used |
+|------|-------------|----------|
+| **0** | Off — streams raw CSI only (same as v0.2.0) | 0 KB |
+| **1** | Cleans up signals, picks the best subcarriers, compresses data (saves 30-50% bandwidth) | ~30 KB |
+| **2** | Everything in Tier 1 + detects presence, measures breathing and heart rate, detects falls | ~33 KB |
+| **3** | Everything in Tier 2 + runs custom WASM modules (gesture recognition, intrusion detection, and [63 more](docs/edge-modules/README.md)) | ~160 KB/module |
+
+Enable without reflashing — just reprovision:

 ```bash
 # Turn on Tier 2 (vitals) on an already-flashed node
 python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20 \
  --edge-tier 2
+
+# Fine-tune detection thresholds
+python firmware/esp32-csi-node/provision.py --port COM7 \
+  --edge-tier 2 --vital-int 500 --fall-thresh 5000 --subk-count 16
 ```

-When active, the node sends a 32-byte vitals packet at 1 Hz with presence, motion, breathing BPM, heart rate BPM, confidence, fall flag, and occupancy. Binary size: 777 KB (24% free).
+When Tier 2 is active, the node sends a 32-byte vitals packet once per second containing: presence, motion level, breathing BPM, heart rate BPM, confidence scores, fall alert flag, and occupancy count.

-See [firmware/esp32-csi-node/README.md](firmware/esp32-csi-node/README.md), [ADR-039](docs/adr/ADR-039-esp32-edge-intelligence.md), and [Tutorial #34](https://github.com/ruvnet/wifi-densepose/issues/34).
+See [firmware/esp32-csi-node/README.md](firmware/esp32-csi-node/README.md), [ADR-039](docs/adr/ADR-039-esp32-edge-intelligence.md), [ADR-044](docs/adr/ADR-044-provisioning-tool-enhancements.md), and [Tutorial #34](https://github.com/ruvnet/RuView/issues/34).

 </details>

@@ -1101,7 +1157,7 @@ See [ADR-021](docs/adr/ADR-021-vital-sign-detection-rvdna-pipeline.md).
 cargo test -p wifi-densepose-wifiscan
 ```

-See [ADR-022](docs/adr/ADR-022-windows-wifi-enhanced-fidelity-ruvector.md) and [Tutorial #36](https://github.com/ruvnet/wifi-densepose/issues/36).
+See [ADR-022](docs/adr/ADR-022-windows-wifi-enhanced-fidelity-ruvector.md) and [Tutorial #36](https://github.com/ruvnet/RuView/issues/36).

 </details>

@@ -1205,7 +1261,7 @@ The [`wifi-densepose-ruvector`](https://crates.io/crates/wifi-densepose-ruvector
 | **O(1) survivor triangulation** | O(N^3) matrix inversion | `ruvector-solver` | Neumann series linearization for instant position updates |
 | **75% memory compression** | 13.4 MB breathing buffers that overflow edge devices | `ruvector-temporal-tensor` | Tiered 3-8 bit quantization fits 60s of vitals in 3.4 MB |

-See [issue #67](https://github.com/ruvnet/wifi-densepose/issues/67) for a deep dive with code examples, or [`cargo add wifi-densepose-ruvector`](https://crates.io/crates/wifi-densepose-ruvector) to use it directly.
+See [issue #67](https://github.com/ruvnet/RuView/issues/67) for a deep dive with code examples, or [`cargo add wifi-densepose-ruvector`](https://crates.io/crates/wifi-densepose-ruvector) to use it directly.

 </details>

@@ -1599,10 +1655,10 @@ WebSocket: `ws://localhost:3001/ws/sensing` (real-time sensing + vital signs)

 | Hardware | CSI | Cost | Guide |
 |----------|-----|------|-------|
-| **ESP32-S3** | Native | ~$8 | [Tutorial #34](https://github.com/ruvnet/wifi-densepose/issues/34) |
+| **ESP32-S3** | Native | ~$8 | [Tutorial #34](https://github.com/ruvnet/RuView/issues/34) |
 | Intel 5300 | Firmware mod | ~$15 | Linux `iwl-csi` |
 | Atheros AR9580 | ath9k patch | ~$20 | Linux only |
-| Any Windows WiFi | RSSI only | $0 | [Tutorial #36](https://github.com/ruvnet/wifi-densepose/issues/36) |
+| Any Windows WiFi | RSSI only | $0 | [Tutorial #36](https://github.com/ruvnet/RuView/issues/36) |
 | Any macOS WiFi | RSSI only (CoreWLAN) | $0 | [ADR-025](docs/adr/ADR-025-macos-corewlan-wifi-sensing.md) |
 | Any Linux WiFi | RSSI only (`iw`) | $0 | Requires `iw` + `CAP_NET_ADMIN` |

@@ -1741,8 +1797,8 @@ POSE_MAX_PERSONS=10              # Max tracked individuals
 <summary><strong>Dev setup, code standards, PR process</strong></summary>

 ```bash
-git clone https://github.com/ruvnet/wifi-densepose.git
-cd wifi-densepose
+git clone https://github.com/ruvnet/RuView.git
+cd RuView

 # Rust development
 cd rust-port/wifi-densepose-rs
@@ -1840,7 +1896,7 @@ MIT License — see [LICENSE](LICENSE) for details.

 ## 📞 Support

-[GitHub Issues](https://github.com/ruvnet/wifi-densepose/issues) | [Discussions](https://github.com/ruvnet/wifi-densepose/discussions) | [PyPI](https://pypi.org/project/wifi-densepose/)
+[GitHub Issues](https://github.com/ruvnet/RuView/issues) | [Discussions](https://github.com/ruvnet/RuView/discussions) | [PyPI](https://pypi.org/project/wifi-densepose/)

 ---

@@ -96,6 +96,13 @@ static void csi_data_callback(void *ctx, wifi_csi_info_t *info) {

 **No on-device FFT** (contradicting ADR-012's optional feature extraction path): The Rust aggregator will do feature extraction using the SOTA `wifi-densepose-signal` pipeline. Raw I/Q is cheaper to stream at ESP32 sampling rates (~100 Hz at 56 subcarriers = ~35 KB/s per node).

+**Rate-limiting and ENOMEM backoff** (Issue #127 fix):
+
+CSI callbacks fire 100-500+ times/sec in promiscuous mode. Two safeguards prevent lwIP pbuf exhaustion:
+
+1. **50 Hz rate limiter** (`csi_collector.c`): `sendto()` is skipped if less than 20 ms have elapsed since the last successful send. Excess CSI callbacks are dropped silently.
+2. **ENOMEM backoff** (`stream_sender.c`): When `sendto()` returns `ENOMEM` (errno 12), all sends are suppressed for 100 ms to let lwIP reclaim packet buffers. Without this, rapid-fire failed sends cause a guru meditation crash.
+
 **`sdkconfig.defaults`** must enable:

 ```
@@ -74,6 +74,8 @@ static uint32_t s_dwell_ms = 50;  // 50ms per channel

 At 100 Hz raw CSI rate with 50 ms dwell across 3 channels, each channel yields ~33 frames/second. The existing ADR-018 binary frame format already carries `channel_freq_mhz` at offset 8, so no wire format change is needed.

+> **Note (Issue #127 fix):** In promiscuous mode, CSI callbacks fire 100-500+ times/sec — far exceeding the channel dwell rate. The firmware now rate-limits UDP sends to 50 Hz and applies a 100 ms ENOMEM backoff if lwIP buffers are exhausted. This is essential for stable channel hopping under load.
+
 **NDP frame injection:** `esp_wifi_80211_tx()` injects deterministic Null Data Packet frames (preamble-only, no payload, ~24 us airtime) at GPIO-triggered intervals. This is sensing-first: the primary RF emission purpose is CSI measurement, not data communication.

 ### 2.3 Multi-Band Frame Fusion
@@ -364,6 +366,7 @@ No new workspace dependencies. All ruvector crates are already in the workspace
 | Risk | Probability | Impact | Mitigation |
 |------|-------------|--------|------------|
 | ESP32 channel hop causes CSI gaps | Medium | Reduced effective rate | Measure gap duration; increase dwell if >5ms |
+| CSI callback rate exhausts lwIP pbufs | **Resolved** | Guru meditation crash | 50 Hz rate limiter + 100 ms ENOMEM backoff (Issue #127, PR #132) |
 | 5 GHz CSI unavailable on S3 | High | Lose frequency diversity | Fallback: 3-channel 2.4 GHz still provides 3x BW; ESP32-C6 for dual-band |
 | Model inference >40ms | Medium | Miss 20 Hz target | Run model at 10 Hz; Kalman predict at 20 Hz interpolates |
 | Two-person separation fails at 3 nodes | Low | Identity swaps | AETHER re-ID recovers; increase to 4-6 nodes |
@@ -208,3 +208,4 @@ Measured on ESP32-S3 (QFN56 rev v0.2, 8 MB flash, 160 MHz, ESP-IDF v5.2).
 2. **No PSRAM on test board** — WASM arena falls back to internal heap. Boards with PSRAM would support larger modules.
 3. **CSI rate exceeds spec** — measured 28.5 Hz vs. expected ~20 Hz. Performance headroom is better than estimated.
 4. **WiFi-to-Ethernet isolation** — some routers block UDP between WiFi and wired clients. Recommend same-subnet verification in deployment guide.
+5. **sendto ENOMEM crash (Issue #127)** — CSI callbacks in promiscuous mode fire 100-500+ times/sec, exhausting the lwIP pbuf pool and causing a guru meditation crash. Fixed with a dual approach: 50 Hz rate limiter in `csi_collector.c` (20 ms minimum send interval) and a 100 ms ENOMEM backoff in `stream_sender.c`. Binary size with fix: 947 KB. Hardware-verified stable for 200+ CSI callbacks with zero ENOMEM errors.
@@ -0,0 +1,334 @@
+# ADR-043: Sensing Server UI API Completion
+
+**Status**: Accepted
+**Date**: 2026-03-03
+**Deciders**: @ruvnet
+**Supersedes**: None
+**Related**: ADR-034, ADR-036, ADR-039, ADR-040, ADR-041
+
+---
+
+## Context
+
+The WiFi-DensePose sensing server (`wifi-densepose-sensing-server`) is a single-binary Axum server that receives ESP32 CSI frames via UDP, processes them through the RuVector signal pipeline, and serves both a web UI at `/ui/` and a REST/WebSocket API. The UI provides tabs for live sensing visualization, model management, CSI recording, and training -- all designed to operate without external dependencies.
+
+However, the UI's JavaScript expected several backend endpoints that were not yet implemented in the Rust server. Opening the browser console revealed persistent 404 errors for model, recording, and training API routes. Three categories of functionality were broken:
+
+### 1. Model Management (7 endpoints missing)
+
+The Models tab calls `GET /api/v1/models` to list available `.rvf` model files, `GET /api/v1/models/active` to show the currently loaded model, `POST /api/v1/models/load` and `POST /api/v1/models/unload` to control the model lifecycle, and `DELETE /api/v1/models/:id` to remove models from disk. LoRA fine-tuning profiles are managed via `GET /api/v1/models/lora/profiles` and `POST /api/v1/models/lora/activate`. All of these returned 404.
+
+### 2. CSI Recording (5 endpoints missing)
+
+The Recording tab calls `POST /api/v1/recording/start` and `POST /api/v1/recording/stop` to capture CSI frames to `.csi.jsonl` files for later training. `GET /api/v1/recording/list` enumerates stored sessions. `DELETE /api/v1/recording/:id` removes recordings. None of these were wired into the server's router.
+
+### 3. Training Pipeline (5 endpoints missing)
+
+The Training tab calls `POST /api/v1/train/start` to launch a background training run against recorded CSI data, `POST /api/v1/train/stop` to abort, and `GET /api/v1/train/status` to poll progress. Contrastive pretraining (`POST /api/v1/train/pretrain`) and LoRA fine-tuning (`POST /api/v1/train/lora`) endpoints were also unavailable. A WebSocket endpoint at `/ws/train/progress` streams epoch-level progress updates to the UI.
+
+### 4. Sensing Service Not Started on App Init
+
+The web UI's `sensingService` singleton (which manages the WebSocket connection to `/ws/sensing`) was only started lazily when the user navigated to the Sensing tab (`SensingTab.js:182`). However, the Dashboard and Live Demo tabs both read `sensingService.dataSource` at load time — and since the service was never started, the status permanently showed **"RECONNECTING"** with no WebSocket connection attempt and no console errors. This silent failure affected the first-load experience for every user.
+
+### 5. Mobile App Defects
+
+The Expo React Native mobile companion (ADR-034) had two integration defects:
+
+- **WebSocket URL builder**: `ws.service.ts` hardcoded port `3001` for the WebSocket connection instead of using the same-origin port derived from the REST API URL. When the sensing server runs on a different port (e.g., `8080` or `3000`), the mobile app could not connect.
+- **Test configuration**: `jest.config.js` contained a `testPathIgnorePatterns` entry that effectively excluded the entire test directory, causing all 25 tests to be skipped silently.
+- **Placeholder tests**: All 25 mobile test files contained `it.todo()` stubs with no assertions, providing false confidence in test coverage.
+
+---
+
+## Decision
+
+Implement the complete model management, CSI recording, and training API directly in the sensing server's `main.rs` as inline handler functions sharing `AppStateInner` via `Arc<RwLock<…>>`. Wire all 14 routes into the server's main router so the UI loads without any 404 console errors. Start the sensing WebSocket service on application init (not lazily on tab visit) so Dashboard and Live Demo tabs connect immediately. Fix the mobile app WebSocket URL builder, test configuration, and replace placeholder tests with real implementations.
+
+### Architecture
+
+All 14 new handler functions are implemented directly in `main.rs` as async functions taking `State<AppState>` extractors, sharing the existing `AppStateInner` via `Arc<RwLock<…>>`. This avoids introducing new module files and keeps all API routes in one place alongside the existing sensing and pose handlers.
+
+```
+┌───────────────────────────────────────────────────────────────────────┐
+│                     Sensing Server (main.rs)                           │
+│                                                                       │
+│  Router::new()                                                        │
+│  ├── /api/v1/sensing/*       (existing — CSI streaming)               │
+│  ├── /api/v1/pose/*          (existing — pose estimation)             │
+│  ├── /api/v1/models          GET    list_models          (NEW)        │
+│  ├── /api/v1/models/active   GET    get_active_model     (NEW)        │
+│  ├── /api/v1/models/load     POST   load_model           (NEW)        │
+│  ├── /api/v1/models/unload   POST   unload_model         (NEW)        │
+│  ├── /api/v1/models/:id      DELETE delete_model         (NEW)        │
+│  ├── /api/v1/models/lora/profiles   GET  list_lora       (NEW)        │
+│  ├── /api/v1/models/lora/activate   POST activate_lora   (NEW)        │
+│  ├── /api/v1/recording/list  GET    list_recordings      (NEW)        │
+│  ├── /api/v1/recording/start POST   start_recording      (NEW)        │
+│  ├── /api/v1/recording/stop  POST   stop_recording       (NEW)        │
+│  ├── /api/v1/recording/:id   DELETE delete_recording     (NEW)        │
+│  ├── /api/v1/train/status    GET    train_status         (NEW)        │
+│  ├── /api/v1/train/start     POST   train_start          (NEW)        │
+│  ├── /api/v1/train/stop      POST   train_stop           (NEW)        │
+│  ├── /ws/sensing             (existing — sensing WebSocket)           │
+│  └── /ui/*                   (existing — static file serving)         │
+│                                                                       │
+│  AppStateInner (new fields)                                           │
+│  ├── discovered_models: Vec<Value>                                    │
+│  ├── active_model_id: Option<String>                                  │
+│  ├── recordings: Vec<Value>                                           │
+│  ├── recording_active / recording_start_time / recording_current_id   │
+│  ├── recording_stop_tx: Option<watch::Sender<bool>>                   │
+│  ├── training_status: Value                                           │
+│  └── training_config: Option<Value>                                   │
+│                                                                       │
+│  data/                                                                │
+│  ├── models/         *.rvf files scanned at startup                   │
+│  └── recordings/     *.jsonl files written by background task         │
+└───────────────────────────────────────────────────────────────────────┘
+```
+
+Routes are registered individually in the `http_app` Router before the static UI fallback handler.
+
+### New Endpoints (17 total)
+
+#### Model Management (`model_manager.rs`)
+
+| Method | Path | Request Body | Response | Description |
+|--------|------|-------------|----------|-------------|
+| `GET` | `/api/v1/models` | -- | `{ models: ModelInfo[], count: usize }` | Scan `data/models/` for `.rvf` files and return manifest metadata |
+| `GET` | `/api/v1/models/{id}` | -- | `ModelInfo` | Detailed info for a single model (version, PCK score, LoRA profiles, segment count) |
+| `GET` | `/api/v1/models/active` | -- | `ActiveModelInfo \| { status: "no_model" }` | Active model with runtime stats (avg inference ms, frames processed) |
+| `POST` | `/api/v1/models/load` | `{ model_id: string }` | `{ status: "loaded", model_id, weight_count }` | Load model weights into memory via `RvfReader`, set `model_loaded = true` |
+| `POST` | `/api/v1/models/unload` | -- | `{ status: "unloaded", model_id }` | Drop loaded weights, set `model_loaded = false` |
+| `POST` | `/api/v1/models/lora/activate` | `{ model_id, profile_name }` | `{ status: "activated", profile_name }` | Activate a LoRA adapter profile on the loaded model |
+| `GET` | `/api/v1/models/lora/profiles` | -- | `{ model_id, profiles: string[], active }` | List LoRA profiles available in the loaded model |
+
+#### CSI Recording (`recording.rs`)
+
+| Method | Path | Request Body | Response | Description |
+|--------|------|-------------|----------|-------------|
+| `POST` | `/api/v1/recording/start` | `{ session_name, label?, duration_secs? }` | `{ status: "recording", session_id, file_path }` | Create a new `.csi.jsonl` file and begin appending frames |
+| `POST` | `/api/v1/recording/stop` | -- | `{ status: "stopped", session_id, frame_count }` | Stop the active recording, write companion `.meta.json` |
+| `GET` | `/api/v1/recording/list` | -- | `{ recordings: RecordingSession[], count }` | List all recordings by scanning `.meta.json` files |
+| `GET` | `/api/v1/recording/download/{id}` | -- | `application/x-ndjson` file | Download the raw JSONL recording file |
+| `DELETE` | `/api/v1/recording/{id}` | -- | `{ status: "deleted", deleted_files }` | Remove `.csi.jsonl` and `.meta.json` files |
+
+#### Training Pipeline (`training_api.rs`)
+
+| Method | Path | Request Body | Response | Description |
+|--------|------|-------------|----------|-------------|
+| `POST` | `/api/v1/train/start` | `TrainingConfig { epochs, batch_size, learning_rate, ... }` | `{ status: "started", run_id }` | Launch background training task against recorded CSI data |
+| `POST` | `/api/v1/train/stop` | -- | `{ status: "stopped", run_id }` | Cancel the active training run via a stop signal |
+| `GET` | `/api/v1/train/status` | -- | `TrainingStatus { phase, epoch, loss, ... }` | Current training state (idle, training, complete, failed) |
+| `POST` | `/api/v1/train/pretrain` | `{ epochs?, learning_rate? }` | `{ status: "started", mode: "pretrain" }` | Start self-supervised contrastive pretraining (ADR-024) |
+| `POST` | `/api/v1/train/lora` | `{ profile_name, epochs?, rank? }` | `{ status: "started", mode: "lora" }` | Start LoRA fine-tuning on a loaded base model |
+| `WS` | `/ws/train/progress` | -- | Streaming `TrainingProgress` JSON | Epoch-level progress with loss, metrics, and ETA |
+
+### State Management
+
+All three modules share the server's `AppStateInner` via `Arc<RwLock<AppStateInner>>`. New fields added to `AppStateInner`:
+
+```rust
+/// Runtime state for a loaded RVF model (None if no model loaded).
+pub loaded_model: Option<LoadedModelState>,
+
+/// Runtime state for the active CSI recording session.
+pub recording_state: RecordingState,
+
+/// Runtime state for the active training run.
+pub training_state: TrainingState,
+
+/// Broadcast channel for training progress updates (consumed by WebSocket).
+pub train_progress_tx: broadcast::Sender<TrainingProgress>,
+```
+
+Key design constraints:
+
+- **Single writer**: Only one recording session can be active at a time. Starting a new recording while one is active returns an error.
+- **Single model**: Only one model can be loaded at a time. Loading a new model implicitly unloads the previous one.
+- **Background training**: Training runs in a spawned `tokio::task`. Progress is broadcast via a `tokio::sync::broadcast` channel. The WebSocket handler subscribes to this channel.
+- **Auto-stop**: Recordings with a `duration_secs` parameter automatically stop after the specified elapsed time.
+
+### Training Pipeline (No External Dependencies)
+
+The training pipeline is implemented entirely in Rust without PyTorch or `tch` dependencies. The pipeline:
+
+1. **Loads data**: Reads `.csi.jsonl` recording files from `data/recordings/`
+2. **Extracts features**: Subcarrier variance (sliding window), temporal gradients, Goertzel frequency-domain power across 9 bands, and 3 global scalar features (mean amplitude, std, motion score)
+3. **Trains model**: Regularised linear model via batch gradient descent targeting 17 COCO keypoints x 3 dimensions = 51 output targets
+4. **Exports model**: Best checkpoint exported as `.rvf` container using `RvfBuilder`, stored in `data/models/`
+
+This design means the sensing server is fully self-contained: a field operator can record CSI data, train a model, and load it for inference without any external tooling.
+
+### File Layout
+
+```
+data/
+├── models/                          # RVF model files
+│   ├── wifi-densepose-v1.rvf       # Trained model container
+│   └── wifi-densepose-v1.rvf       # (additional models...)
+└── recordings/                      # CSI recording sessions
+    ├── walking-20260303_140000.csi.jsonl      # Raw CSI frames (JSONL)
+    ├── walking-20260303_140000.csi.meta.json  # Session metadata
+    ├── standing-20260303_141500.csi.jsonl
+    └── standing-20260303_141500.csi.meta.json
+```
+
+### Mobile App Fixes
+
+Three defects were corrected in the Expo React Native mobile companion (`ui/mobile/`):
+
+1. **WebSocket URL builder** (`src/services/ws.service.ts`): The URL construction logic previously hardcoded port `3001` for WebSocket connections. This was changed to derive the WebSocket port from the same-origin HTTP URL, using `window.location.port` on web and the configured server URL on native platforms. This ensures the mobile app connects to whatever port the sensing server is actually running on.
+
+2. **Jest configuration** (`jest.config.js`): The `testPathIgnorePatterns` array previously contained an entry that matched the test directory itself, causing Jest to silently skip all test files. The pattern was corrected to only ignore `node_modules/`.
+
+3. **Placeholder tests replaced**: All 25 mobile test files contained only `it.todo()` stubs. These were replaced with real test implementations covering:
+
+   | Category | Test Files | Coverage |
+   |----------|-----------|----------|
+   | Utils | `format.test.ts`, `validation.test.ts` | Number formatting, URL validation, input sanitization |
+   | Services | `ws.service.test.ts`, `api.service.test.ts` | WebSocket connection lifecycle, REST API calls, error handling |
+   | Stores | `poseStore.test.ts`, `settingsStore.test.ts`, `matStore.test.ts` | Zustand state transitions, persistence, selector memoization |
+   | Components | `BreathingGauge.test.tsx`, `HeartRateGauge.test.tsx`, `MetricCard.test.tsx`, `ConnectionBanner.test.tsx` | Rendering, prop validation, theme compliance |
+   | Hooks | `useConnection.test.ts`, `useSensing.test.ts` | Hook lifecycle, cleanup, error states |
+   | Screens | `LiveScreen.test.tsx`, `VitalsScreen.test.tsx`, `SettingsScreen.test.tsx` | Screen rendering, navigation, data binding |
+
+---
+
+## Rationale
+
+### Why implement model/training/recording in the sensing server?
+
+The alternative would be to run a separate Python training service and proxy requests. This was rejected for three reasons:
+
+1. **Single-binary deployment**: WiFi-DensePose targets edge deployments (disaster response, building security, healthcare monitoring per ADR-034) where installing Python, pip, and PyTorch is impractical. A single Rust binary that handles sensing, recording, training, and inference is the correct architecture for field use.
+
+2. **Zero-configuration UI**: The web UI is served by the same binary that exposes the API. When a user opens `http://server:8080/`, everything works -- no additional services to start, no ports to configure, no CORS to manage.
+
+3. **Data locality**: CSI frames arrive via UDP, are processed for real-time display, and can simultaneously be written to disk for training. The recording module hooks directly into the CSI processing loop via `maybe_record_frame()`, avoiding any serialization overhead or inter-process communication.
+
+### Why fix mobile in the same change?
+
+The mobile app's WebSocket failure was caused by the same root problem -- assumptions about server port layout that did not match reality. Fixing the server API without fixing the mobile client would leave a broken user experience. The test fixes were included because the placeholder tests masked the WebSocket URL bug during development.
+
+---
+
+## Consequences
+
+### Positive
+
+- **UI loads with zero console errors**: All model, recording, and training tabs render correctly and receive real data from the server
+- **End-to-end workflow**: Users can record CSI data, train a model, load it, and see pose estimation results -- all from the web UI without any external tools
+- **LoRA fine-tuning support**: Users can adapt a base model to new environments via LoRA profiles, activated through the UI
+- **Mobile app connects reliably**: The WebSocket URL builder uses same-origin port derivation, working correctly regardless of which port the server runs on
+- **25 real mobile tests**: Provide actual regression protection for utils, services, stores, components, hooks, and screens
+- **Self-contained sensing server**: No Python, PyTorch, or external training infrastructure required
+
+### Negative
+
+- **Sensing server binary grows**: The three new modules add approximately 2,000 lines of Rust to the sensing server crate, increasing compile time marginally
+- **Training is lightweight**: The built-in training pipeline uses regularised linear regression, not deep learning. For production-grade pose estimation models, the full Python training pipeline (`wifi-densepose-train`) with PyTorch is still needed. The in-server training is designed for quick field calibration, not SOTA accuracy.
+- **File-based storage**: Models and recordings are stored as files on the local filesystem (`data/models/`, `data/recordings/`). There is no database, no replication, and no access control. This is acceptable for single-node edge deployments but not for multi-user production environments.
+
+### Risks
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| Disk fills up during long recording sessions | Medium | Medium | `duration_secs` auto-stop parameter; UI shows file size; manual `DELETE` endpoint |
+| Concurrent model load/unload during inference causes race | Low | High | `RwLock` on `AppStateInner` serializes all state mutations; inference path acquires read lock |
+| Training on insufficient data produces poor model | Medium | Low | Training API validates minimum frame count before starting; UI shows dataset statistics |
+| JSONL recording format is inefficient for large datasets | Low | Low | Acceptable for field calibration (minutes of data); production datasets use the Python pipeline with HDF5 |
+
+---
+
+## Implementation
+
+### Server-Side Changes
+
+All 14 new handler functions were added directly to `main.rs` (~400 lines of new code). Key additions:
+
+| Handler | Method | Path | Description |
+|---------|--------|------|-------------|
+| `list_models` | GET | `/api/v1/models` | Scans `data/models/` for `.rvf` files at startup, returns cached list |
+| `get_active_model` | GET | `/api/v1/models/active` | Returns currently loaded model or `null` |
+| `load_model` | POST | `/api/v1/models/load` | Sets `active_model_id` in state |
+| `unload_model` | POST | `/api/v1/models/unload` | Clears `active_model_id` |
+| `delete_model` | DELETE | `/api/v1/models/:id` | Removes model from disk and state |
+| `list_lora_profiles` | GET | `/api/v1/models/lora/profiles` | Scans `data/models/lora/` directory |
+| `activate_lora_profile` | POST | `/api/v1/models/lora/activate` | Activates a LoRA adapter |
+| `list_recordings` | GET | `/api/v1/recording/list` | Scans `data/recordings/` for `.jsonl` files with frame counts |
+| `start_recording` | POST | `/api/v1/recording/start` | Spawns tokio background task writing CSI frames to `.jsonl` |
+| `stop_recording` | POST | `/api/v1/recording/stop` | Sends stop signal via `tokio::sync::watch`, returns duration |
+| `delete_recording` | DELETE | `/api/v1/recording/:id` | Removes recording file from disk |
+| `train_status` | GET | `/api/v1/train/status` | Returns training phase (idle/running/complete/failed) |
+| `train_start` | POST | `/api/v1/train/start` | Sets training status to running with config |
+| `train_stop` | POST | `/api/v1/train/stop` | Sets training status to idle |
+
+Helper functions: `scan_model_files()`, `scan_lora_profiles()`, `scan_recording_files()`, `chrono_timestamp()`.
+
+Startup creates `data/models/` and `data/recordings/` directories and populates initial state with scanned files.
+
+### Web UI Fix
+
+| File | Change | Description |
+|------|--------|-------------|
+| `ui/app.js` | Modified | Import `sensingService` and call `sensingService.start()` in `initializeServices()` after backend health check, so Dashboard and Live Demo tabs connect to `/ws/sensing` immediately on load instead of waiting for Sensing tab visit |
+| `ui/services/sensing.service.js` | Comment | Updated comment documenting that `/ws/sensing` is on the same HTTP port |
+
+### Mobile App Files
+
+| File | Change | Description |
+|------|--------|-------------|
+| `ui/mobile/src/services/ws.service.ts` | Modified | `buildWsUrl()` uses `parsed.host` directly with `/ws/sensing` path instead of hardcoded port `3001` |
+| `ui/mobile/jest.config.js` | Modified | `testPathIgnorePatterns` corrected to only ignore `node_modules/` |
+| `ui/mobile/src/__tests__/*.test.ts{x}` | Replaced | 25 placeholder `it.todo()` tests replaced with real implementations |
+
+---
+
+## Verification
+
+```bash
+# 1. Start sensing server with auto source (simulated fallback)
+cd rust-port/wifi-densepose-rs
+cargo run -p wifi-densepose-sensing-server -- --http-port 3000 --source auto
+
+# 2. Verify model endpoints return 200
+curl -s http://localhost:3000/api/v1/models | jq '.count'
+curl -s http://localhost:3000/api/v1/models/active | jq '.status'
+
+# 3. Verify recording endpoints return 200
+curl -s http://localhost:3000/api/v1/recording/list | jq '.count'
+curl -s -X POST http://localhost:3000/api/v1/recording/start \
+  -H 'Content-Type: application/json' \
+  -d '{"session_name":"test","duration_secs":5}' | jq '.status'
+
+# 4. Verify training endpoint returns 200
+curl -s http://localhost:3000/api/v1/train/status | jq '.phase'
+
+# 5. Verify LoRA endpoints return 200
+curl -s http://localhost:3000/api/v1/models/lora/profiles | jq '.'
+
+# 6. Open UI — check browser console for zero 404 errors
+# Navigate to http://localhost:3000/ui/
+
+# 7. Run mobile tests
+cd ../../ui/mobile
+npx jest --no-coverage
+
+# 8. Run Rust workspace tests (must pass, 1031+ tests)
+cd ../../rust-port/wifi-densepose-rs
+cargo test --workspace --no-default-features
+```
+
+---
+
+## References
+
+- ADR-034: Expo React Native Mobile Application (mobile companion architecture)
+- ADR-036: RVF Training Pipeline UI (training pipeline design)
+- ADR-039: ESP32-S3 Edge Intelligence Pipeline (CSI frame format and processing tiers)
+- ADR-040: WASM Programmable Sensing (Tier 3 edge compute)
+- ADR-041: WASM Module Collection (module catalog)
+- `crates/wifi-densepose-sensing-server/src/main.rs` -- all 14 new handler functions (model, recording, training)
+- `ui/app.js` -- sensing service early initialization fix
+- `ui/mobile/src/services/ws.service.ts` -- mobile WebSocket URL fix
@@ -0,0 +1,214 @@
+# ADR-044: Provisioning Tool Enhancements
+
+**Status**: Proposed
+**Date**: 2026-03-03
+**Deciders**: @ruvnet
+**Supersedes**: None
+**Related**: ADR-029, ADR-032, ADR-039, ADR-040
+
+---
+
+## Context
+
+The ESP32-S3 CSI node provisioning script (`firmware/esp32-csi-node/provision.py`) is the primary tool for configuring pre-built firmware binaries without recompiling. It writes NVS key-value pairs that the firmware reads at boot.
+
+After #131 added TDM and edge intelligence flags, the script now covers the most-requested NVS keys. However, there remain gaps between what the firmware reads from NVS (`nvs_config.c`, 20 keys) and what the provisioning script can write (13 keys). Additionally, the script lacks usability features that would help field operators deploying multi-node meshes.
+
+### Gap 1: Missing NVS Keys (7 keys)
+
+The firmware reads these NVS keys at boot but the provisioning script has no corresponding CLI flags:
+
+| NVS Key | Type | Firmware Default | Purpose |
+|---------|------|-----------------|---------|
+| `hop_count` | u8 | 1 (no hop) | Number of channels to hop through |
+| `chan_list` | blob (u8[6]) | {1,6,11} | Channel numbers for hopping sequence |
+| `dwell_ms` | u32 | 100 | Time to dwell on each channel before hopping (ms) |
+| `power_duty` | u8 | 100 | Power duty cycle percentage (10-100%) for battery life |
+| `wasm_max` | u8 | 4 | Max concurrent WASM modules (ADR-040) |
+| `wasm_verify` | u8 | 0 | Require Ed25519 signature for WASM uploads (0/1) |
+| `wasm_pubkey` | blob (32B) | zeros | Ed25519 public key for WASM signature verification |
+
+### Gap 2: No Read-Back
+
+There is no way to read the current NVS configuration from a device. Field operators must remember what was provisioned or reflash everything. This is especially problematic for multi-node meshes where each node has different TDM slots.
+
+### Gap 3: No Verification
+
+After flashing, there is no automated check that the device booted successfully with the new configuration. Operators must manually run a serial monitor and inspect logs.
+
+### Gap 4: No Config File Support
+
+Provisioning a 6-node mesh requires running the script 6 times with largely overlapping flags (same SSID, password, target IP) and only TDM slot varying. There is no way to define a mesh configuration in a file.
+
+### Gap 5: No Presets
+
+Common deployment scenarios (single-node basic, 3-node mesh, 6-node mesh with vitals) require operators to know which flags to combine. Named presets would lower the barrier to entry.
+
+### Gap 6: No Auto-Detect
+
+The `--port` flag is required even though the script could auto-detect connected ESP32-S3 devices via `esptool.py`.
+
+---
+
+## Decision
+
+Enhance `provision.py` with the following capabilities, implemented incrementally.
+
+### Phase 1: Complete NVS Coverage
+
+Add flags for all remaining firmware NVS keys:
+
+```
+--hop-count N          Channel hop count (1=no hop, default: 1)
+--channels 1,6,11      Comma-separated channel list for hopping
+--dwell-ms N           Dwell time per channel in ms (default: 100)
+--power-duty N         Power duty cycle 10-100% (default: 100)
+--wasm-max N           Max concurrent WASM modules 1-8 (default: 4)
+--wasm-verify          Require Ed25519 signature for WASM uploads
+--wasm-pubkey FILE     Path to Ed25519 public key file (32 bytes raw or PEM)
+```
+
+Validation:
+- `--channels` length must match `--hop-count`
+- `--power-duty` clamped to 10-100
+- `--wasm-pubkey` implies `--wasm-verify`
+
+### Phase 2: Config File and Mesh Provisioning
+
+Add `--config FILE` to load settings from a JSON or TOML file:
+
+```json
+{
+  "common": {
+    "ssid": "SensorNet",
+    "password": "secret",
+    "target_ip": "192.168.1.20",
+    "target_port": 5005,
+    "edge_tier": 2
+  },
+  "nodes": [
+    { "port": "COM7", "node_id": 0, "tdm_slot": 0 },
+    { "port": "COM8", "node_id": 1, "tdm_slot": 1 },
+    { "port": "COM9", "node_id": 2, "tdm_slot": 2 }
+  ]
+}
+```
+
+`--config mesh.json` provisions all listed nodes in sequence, computing `tdm_total` automatically from the `nodes` array length.
+
+### Phase 3: Presets
+
+Add `--preset NAME` for common deployment profiles:
+
+| Preset | What It Sets |
+|--------|-------------|
+| `basic` | Single node, edge_tier=0, no TDM, no hopping |
+| `vitals` | Single node, edge_tier=2, vital_int=1000, subk_count=32 |
+| `mesh-3` | 3-node TDM, edge_tier=1, hop_count=3, channels=1,6,11 |
+| `mesh-6-vitals` | 6-node TDM, edge_tier=2, hop_count=3, channels=1,6,11, vital_int=500 |
+
+Presets set defaults that can be overridden by explicit flags.
+
+### Phase 4: Read-Back and Verify
+
+Add `--read` to dump the current NVS configuration from a connected device:
+
+```bash
+python provision.py --port COM7 --read
+# Output:
+#   ssid:         SensorNet
+#   target_ip:    192.168.1.20
+#   tdm_slot:     0
+#   tdm_nodes:    3
+#   edge_tier:    2
+#   ...
+```
+
+Implementation: use `esptool.py read_flash` to read the NVS partition, then parse the NVS binary format to extract key-value pairs.
+
+Add `--verify` to provision and then confirm the device booted:
+
+```bash
+python provision.py --port COM7 --ssid "Net" --password "pass" --target-ip 192.168.1.20 --verify
+# After flash, opens serial monitor for 5 seconds
+# Checks for "CSI streaming active" log line
+# Reports PASS or FAIL
+```
+
+### Phase 5: Auto-Detect Port
+
+When `--port` is omitted, scan for connected ESP32-S3 devices:
+
+```bash
+python provision.py --ssid "Net" --password "pass" --target-ip 192.168.1.20
+# Auto-detected ESP32-S3 on COM7 (Silicon Labs CP210x)
+# Proceed? [Y/n]
+```
+
+Implementation: use `esptool.py` or `serial.tools.list_ports` to enumerate ports.
+
+---
+
+## Rationale
+
+### Why incremental phases?
+
+Phase 1 is a small diff that closes the NVS coverage gap immediately. Phases 2-5 add progressively more UX polish. Each phase is independently useful and can be shipped separately.
+
+### Why JSON config over YAML/TOML?
+
+JSON requires no additional Python dependencies (stdlib `json` module). TOML requires `tomllib` (Python 3.11+) or `tomli`. JSON is sufficient for this use case.
+
+### Why not a GUI?
+
+The target users are embedded developers and field operators who are already running `esptool` from the command line. A TUI/GUI would add dependencies and complexity for minimal benefit.
+
+---
+
+## Consequences
+
+### Positive
+
+- **Complete NVS coverage**: Every firmware-readable key can be set from the provisioning tool
+- **Mesh provisioning in one command**: `--config mesh.json` replaces 6 separate invocations
+- **Lower barrier to entry**: Presets eliminate the need to know which flags to combine
+- **Auditability**: `--read` lets operators inspect and verify deployed configurations
+- **Fewer mis-provisions**: `--verify` catches flashing failures before the operator walks away
+
+### Negative
+
+- **NVS binary parsing** (Phase 4) requires understanding the ESP-IDF NVS binary format, which is not officially documented as a stable API
+- **Auto-detect** (Phase 5) may produce false positives if other ESP32 variants are connected
+
+### Risks
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| NVS binary format changes in ESP-IDF v6 | Low | Medium | Pin to known ESP-IDF NVS page format; add format version check |
+| `--verify` serial parsing is fragile | Medium | Low | Match on stable log tag `[CSI_MAIN]`; timeout after 10s |
+| Config file credentials in plaintext | Medium | Medium | Document that config files should not be committed; add `.gitignore` pattern |
+
+---
+
+## Implementation Priority
+
+| Phase | Effort | Impact | Priority |
+|-------|--------|--------|----------|
+| Phase 1: Complete NVS coverage | Small (1 file, ~50 lines) | High — closes feature gap | P0 |
+| Phase 2: Config file + mesh | Medium (~100 lines) | High — biggest UX win | P1 |
+| Phase 3: Presets | Small (~40 lines) | Medium — convenience | P2 |
+| Phase 4: Read-back + verify | Medium (~150 lines) | Medium — debugging aid | P2 |
+| Phase 5: Auto-detect | Small (~30 lines) | Low — minor convenience | P3 |
+
+---
+
+## References
+
+- `firmware/esp32-csi-node/main/nvs_config.h` — NVS config struct (20 fields)
+- `firmware/esp32-csi-node/main/nvs_config.c` — NVS read logic (20 keys)
+- `firmware/esp32-csi-node/provision.py` — Current provisioning script (13 of 20 keys)
+- ADR-029: RuvSense multistatic sensing mode (TDM, channel hopping)
+- ADR-032: Multistatic mesh security hardening (mesh keys)
+- ADR-039: ESP32-S3 edge intelligence (edge tiers, vitals)
+- ADR-040: WASM programmable sensing (WASM modules, signature verification)
+- Issue #130: Provisioning script doesn't support TDM
@@ -0,0 +1,110 @@
+# ADR-045: AMOLED Display Support for ESP32-S3 CSI Node
+
+## Status
+
+Proposed
+
+## Context
+
+The ESP32-S3 board (LilyGO T-Display-S3 AMOLED) has an integrated RM67162 QSPI AMOLED display (536x240) and 8MB octal PSRAM that were unused by the CSI firmware. Users want real-time on-device visualization of CSI statistics, vital signs, and system health without relying on an external server.
+
+### Constraints
+
+- Binary was 947 KB in a 1 MB partition — needed 8MB flash + custom partition table
+- SPIRAM was disabled in sdkconfig despite hardware having 8MB PSRAM
+- Core 1 is pinned to DSP (edge processing) — display must use Core 0
+- Existing CSI pipeline must not be affected
+
+### Available APIs
+
+Thread-safe edge APIs already exist (`edge_get_vitals()`, `edge_get_multi_person()`) — the display task only reads from these, no new synchronization needed.
+
+## Decision
+
+Add optional AMOLED display support with the following architecture:
+
+### Hardware Abstraction Layer
+
+- `display_hal.c/h`: RM67162 QSPI panel driver + CST816S capacitive touch via I2C
+- Auto-detect at boot: probe RM67162 and check SPIRAM; log warning and skip if absent
+
+### UI Layer
+
+- `display_ui.c/h`: LVGL 8.3 with 4 swipeable views via tileview widget
+- Dark theme (#0a0a0f) with cyan (#00d4ff) accent for three.js-like aesthetic
+- Views: Dashboard (CSI amplitude chart + stats), Vitals (breathing + HR line graphs), Presence (4x4 occupancy grid), System (CPU, heap, PSRAM, WiFi, uptime, FPS)
+
+### Task Layer
+
+- `display_task.c/h`: FreeRTOS task on Core 0, priority 1 (lowest)
+- LVGL pump loop at configurable FPS (default 30)
+- Double-buffered draw buffers allocated in SPIRAM
+
+### Compile-Time Control
+
+- `CONFIG_DISPLAY_ENABLE=y` (default): compiles display code, auto-detects hardware at boot
+- `CONFIG_DISPLAY_ENABLE=n`: zero-cost — no display code compiled
+- `CONFIG_SPIRAM_IGNORE_NOTFOUND=y`: boots fine on boards without PSRAM
+
+### Flash Layout
+
+8MB partition table (`partitions_display.csv`):
+- Dual OTA partitions: 2 x 2MB (supports larger binaries with LVGL)
+- SPIFFS: 1.9MB (for future font/asset storage)
+- NVS + otadata + phy: standard sizes
+
+### Core/Task Layout
+
+| Task | Core | Priority | Impact |
+|------|------|----------|--------|
+| WiFi/LwIP | 0 | 18-23 | unchanged |
+| OTA httpd | 0 | 5 | unchanged |
+| **display_task** | **0** | **1** | **NEW — lowest priority** |
+| edge_task (DSP) | 1 | 5 | unchanged |
+
+### Dependencies
+
+- LVGL ~8.3 (via ESP-IDF managed components)
+- espressif/esp_lcd_touch_cst816s ^1.0
+- espressif/esp_lcd_touch ^1.0
+
+## Consequences
+
+### Positive
+
+- Real-time on-device stats without network dependency
+- Zero impact on CSI pipeline (display reads thread-safe APIs, runs at lowest priority)
+- Graceful degradation: works on boards without display or PSRAM
+- SPIRAM enabled for all boards (benefits WASM runtime too)
+- 8MB flash + dual OTA 2MB partitions give headroom for future features
+
+### Negative
+
+- Binary size increase (~200-300 KB with LVGL)
+- SPIRAM + 8MB flash config is specific to T-Display-S3 AMOLED boards
+- Boards with only 4MB flash need `CONFIG_DISPLAY_ENABLE=n` and the old partition table
+
+### Risks
+
+- RM67162 init sequence is board-specific; other AMOLED panels may need different commands
+- QSPI bus conflicts if other peripherals use SPI2_HOST (currently unused)
+
+## New Files
+
+| File | Purpose |
+|------|---------|
+| `main/display_hal.c/h` | RM67162 QSPI + CST816S touch HAL |
+| `main/display_ui.c/h` | LVGL 4-view UI |
+| `main/display_task.c/h` | FreeRTOS task, LVGL pump |
+| `main/lv_conf.h` | LVGL compile config |
+| `partitions_display.csv` | 8MB partition table |
+| `idf_component.yml` | Managed component deps |
+
+## Modified Files
+
+| File | Change |
+|------|--------|
+| `sdkconfig.defaults` | 8MB flash, SPIRAM, custom partitions |
+| `main/CMakeLists.txt` | Conditional display sources + deps |
+| `main/main.c` | +1 include, +5 lines guarded init |
+| `main/Kconfig.projbuild` | "AMOLED Display" menu |
@@ -0,0 +1,263 @@
+# ADR-046: Android TV Box / Armbian Deployment Target
+
+## Status
+
+Proposed
+
+## Context
+
+Issue [#138](https://github.com/ruvnet/wifi-densepose/issues/138) requests ESP8266 and mobile device support. The ESP8266 lacks CSI capability and sufficient resources, but the discussion revealed a compelling deployment target: **Android TV boxes** (Amlogic/Allwinner/Rockchip SoCs) running **Armbian** (Debian for ARM).
+
+These devices cost $15–35, are always-on mains-powered, include 802.11ac WiFi, 2–4 GB RAM, quad-core ARM Cortex-A53/A55 CPUs, and HDMI output. They are widely available as consumer "IPTV boxes" (T95, H96 Max, X96, MXQ Pro, etc.) and can boot Armbian from SD card without modifying the factory Android installation.
+
+### Current deployment model
+
+```
+[ESP32-S3 nodes] --UDP CSI--> [Laptop/PC running sensing-server] --browser--> [UI]
+```
+
+This requires a general-purpose computer ($300+) to run the Rust sensing server, NN inference, and web dashboard. For permanent installations (elder care, smart home, security), dedicating a laptop is impractical.
+
+### Proposed deployment model
+
+```
+[ESP32-S3 nodes] --UDP CSI--> [TV Box running Armbian + sensing-server] --HDMI--> [Display]
+                                 $25, always-on, fanless
+```
+
+### Future: custom WiFi firmware for standalone operation
+
+Many TV box WiFi chipsets (Realtek RTL8822CS, MediaTek MT7661, Broadcom BCM43455) can potentially be patched for CSI extraction when running under Linux with custom drivers. This would eliminate the ESP32 dependency entirely for basic sensing:
+
+```
+[TV Box with patched WiFi driver] --CSI extraction--> [sensing-server on same box] --HDMI--> [Display]
+                                    $25 total, single device
+```
+
+This ADR covers Phase 1 (TV box as aggregator) and Phase 2 (custom WiFi firmware for CSI). Phase 2 is speculative and requires per-chipset R&D.
+
+## Decision
+
+### Phase 1: TV Box as Aggregator (Armbian)
+
+1. **Cross-compile the sensing server** for `aarch64-unknown-linux-gnu` using `cross` or Docker-based cross-compilation.
+
+2. **Create an Armbian deployment package** containing:
+   - Pre-built `wifi-densepose-sensing-server` binary (aarch64)
+   - systemd service file for auto-start on boot
+   - Kiosk-mode Chromium configuration for HDMI dashboard display
+   - Network configuration for ESP32 UDP reception (port 5005)
+   - Optional: `hostapd` config to create a dedicated WiFi AP for the ESP32 mesh
+
+3. **Define minimum hardware requirements:**
+
+   | Component | Minimum | Recommended |
+   |-----------|---------|-------------|
+   | SoC | Amlogic S905W (A53 quad) | Amlogic S905X3 (A55 quad) |
+   | RAM | 2 GB | 4 GB |
+   | Storage | 8 GB eMMC + 8 GB SD | 16 GB eMMC + 16 GB SD |
+   | WiFi | 802.11n 2.4 GHz | 802.11ac dual-band |
+   | Ethernet | 100 Mbps | Gigabit |
+   | USB | 1x USB 2.0 | 2x USB 3.0 |
+   | HDMI | 1.4 | 2.0 |
+
+4. **Tested reference devices** (initial target list):
+
+   | Device | SoC | WiFi Chip | Price | Armbian Support |
+   |--------|-----|-----------|-------|-----------------|
+   | T95 Max+ | S905X3 | RTL8822CS | ~$30 | Good (meson-sm1) |
+   | H96 Max X3 | S905X3 | RTL8822CS | ~$35 | Good (meson-sm1) |
+   | X96 Max+ | S905X3 | RTL8822CS | ~$28 | Good (meson-sm1) |
+   | Tanix TX6S | H616 | MT7668 | ~$25 | Moderate (sun50i-h616) |
+
+5. **New Rust compilation target** in workspace CI:
+   - Add `aarch64-unknown-linux-gnu` to cross-compilation matrix
+   - Binary size target: <15 MB stripped (fits easily in SD card)
+   - No GPU dependency — CPU-only inference using `candle` or ONNX Runtime for ARM
+
+### Phase 2: Custom WiFi Firmware for CSI Extraction (Future)
+
+1. **CSI extraction feasibility by chipset:**
+
+   | Chipset | Driver | CSI Support | Monitor Mode | Effort |
+   |---------|--------|-------------|--------------|--------|
+   | Broadcom BCM43455 | brcmfmac | **Proven** (Nexmon CSI) | Yes | Low — patches exist |
+   | Realtek RTL8822CS | rtw88 | **Moderate** — driver is open-source, CSI hooks need adding | Yes (patched) | Medium |
+   | MediaTek MT7661 | mt76 | **Unknown** — MediaTek has released CSI tools for some chips | Yes | Medium-High |
+
+2. **CSI extraction architecture** (Linux kernel driver modification):
+
+   ```
+   [WiFi chipset firmware] → [Modified kernel driver] → [Netlink/procfs CSI export]
+                                                              ↓
+                                                     [userspace CSI reader]
+                                                              ↓
+                                                     [sensing-server UDP input]
+   ```
+
+   The CSI data would be reformatted into the existing ESP32 binary protocol (ADR-018 header, magic `0xC5100001`) so the sensing server treats it identically to ESP32 frames. This means zero changes to the ingestion context.
+
+3. **Hybrid mode**: When the TV box has both patched WiFi CSI and ESP32 UDP input, the sensing server's multi-node architecture (already supporting multiple `node_id` values) handles both sources transparently. The TV box's own WiFi becomes an additional viewpoint in the multistatic array.
+
+### Phase 3: Android Companion App (Optional)
+
+For users who want mobile monitoring without Armbian:
+
+1. **PWA (Progressive Web App)**: The sensing server already serves a web UI. Adding a PWA manifest with offline caching makes it installable on any Android device. No native app needed.
+
+2. **Native Android app** (future): Only if PWA proves insufficient. Would use Kotlin + Jetpack Compose, consuming the existing REST API and WebSocket endpoints.
+
+## Deployment Architecture
+
+### Single-Room Deployment (Phase 1)
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                        Room                                  │
+│                                                              │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐                  │
+│  │ ESP32-S3 │  │ ESP32-S3 │  │ ESP32-S3 │  CSI sensor mesh │
+│  │ Node 1   │  │ Node 2   │  │ Node 3   │  ($10 each)      │
+│  └────┬─────┘  └────┬─────┘  └────┬─────┘                  │
+│       │              │              │                         │
+│       └──────────────┼──────────────┘                        │
+│                      │ UDP port 5005                         │
+│                      ▼                                       │
+│  ┌──────────────────────────────────────┐                   │
+│  │      Android TV Box (Armbian)        │                   │
+│  │                                      │                   │
+│  │  ┌──────────────────────────────┐   │                   │
+│  │  │   wifi-densepose-sensing-    │   │                   │
+│  │  │   server (aarch64 binary)    │   │                   │
+│  │  │                              │   │                   │
+│  │  │  • CSI ingestion (UDP)       │   │                   │
+│  │  │  • Feature extraction        │   │                   │
+│  │  │  • NN inference (CPU)        │   │                   │
+│  │  │  • WebSocket streaming       │   │                   │
+│  │  │  • REST API                  │   │                   │
+│  │  │  • Web UI (:3000)            │   │                   │
+│  │  └──────────────────────────────┘   │                   │
+│  │                                      │                   │
+│  │  ┌──────────────────────────────┐   │                   │
+│  │  │   Chromium Kiosk Mode        │───│──→ HDMI out       │
+│  │  │   (localhost:3000)           │   │    to display      │
+│  │  └──────────────────────────────┘   │                   │
+│  │                                      │                   │
+│  │  Cost: $25-35                        │                   │
+│  │  Power: 5-10W (USB-C or barrel)      │                   │
+│  │  Form: fits behind TV/monitor        │                   │
+│  └──────────────────────────────────────┘                   │
+│                                                              │
+└──────────────────────────────────────────────────────────────┘
+
+Total system cost: $55-65 (3 ESP32 nodes + 1 TV box)
+```
+
+### Multi-Room Deployment
+
+```
+                    ┌──────────────┐
+                    │   Router     │
+                    │  (WiFi AP)   │
+                    └──────┬───────┘
+                           │ LAN
+            ┌──────────────┼──────────────┐
+            │              │              │
+    ┌───────▼───────┐ ┌───▼────────┐ ┌──▼──────────┐
+    │  Room A       │ │  Room B    │ │  Room C     │
+    │  TV Box +     │ │  TV Box +  │ │  TV Box +   │
+    │  3x ESP32     │ │  3x ESP32  │ │  3x ESP32   │
+    │  HDMI display │ │  HDMI      │ │  HDMI       │
+    └───────────────┘ └────────────┘ └─────────────┘
+
+    Each room: self-contained sensing + display
+    Central dashboard: aggregate all rooms via REST API
+```
+
+### Standalone Mode (Phase 2 — Custom WiFi FW)
+
+```
+┌──────────────────────────────────────┐
+│      Android TV Box (Armbian)        │
+│                                      │
+│  ┌────────────────────┐              │
+│  │  Patched WiFi      │              │
+│  │  Driver             │              │
+│  │  (CSI extraction)  │              │
+│  └─────────┬──────────┘              │
+│            │ CSI frames              │
+│            ▼                         │
+│  ┌────────────────────┐              │
+│  │  sensing-server    │──→ HDMI out  │
+│  │  (inference +      │              │
+│  │   dashboard)       │              │
+│  └────────────────────┘              │
+│                                      │
+│  Single device: $25                  │
+│  No ESP32 nodes needed               │
+└──────────────────────────────────────┘
+```
+
+## Consequences
+
+### Positive
+
+- **10x cost reduction** for aggregator: $25 TV box vs $300+ laptop/PC
+- **Always-on deployment**: Mains-powered, fanless, designed for 24/7 operation
+- **HDMI output**: Direct connection to TV/monitor for wall-mounted dashboards
+- **Familiar hardware**: Available globally, no specialized ordering required
+- **Armbian ecosystem**: Mature Debian-based distro with package management, systemd, SSH
+- **Path to standalone**: Custom WiFi firmware could eliminate ESP32 dependency entirely
+- **PWA for mobile**: No native app development needed for mobile monitoring
+- **Multi-room scaling**: One TV box per room, each self-contained
+
+### Negative
+
+- **ARM cross-compilation**: Adds CI complexity; `candle`/ONNX Runtime ARM builds need testing
+- **Armbian compatibility**: Not all TV boxes are well-supported; need a tested device list
+- **Performance uncertainty**: ARM A53 cores are ~3-5x slower than x86 for NN inference; may need model quantization (INT8) for real-time operation
+- **Phase 2 risk**: Custom WiFi firmware is chipset-specific, may require kernel patches per driver version, and CSI quality varies by chipset
+- **Support burden**: Different hardware = more configurations to support
+- **No GPU**: TV boxes lack discrete GPU; inference is CPU-only (but our models are small enough)
+
+### Neutral
+
+- **No changes to existing ESP32 firmware** — TV box receives the same UDP frames
+- **No changes to sensing server protocol** — Phase 2 CSI output uses same binary format
+- **Existing web UI works as-is** — Chromium kiosk mode or any browser on the LAN
+
+## Implementation Plan
+
+### Phase 1 (2-3 weeks)
+
+1. Add `aarch64-unknown-linux-gnu` cross-compilation target using `cross`
+2. Build and test sensing-server binary on reference TV box (T95 Max+ / S905X3)
+3. Create systemd service + Armbian deployment script
+4. Benchmark: measure inference latency, memory usage, thermal throttling
+5. Create `docs/deployment/armbian-tv-box.md` setup guide
+6. Add HDMI kiosk mode configuration (Chromium autostart)
+
+### Phase 2 (4-8 weeks, R&D)
+
+1. Acquire TV box with BCM43455 (proven Nexmon CSI support)
+2. Build Armbian with Nexmon CSI patches for BCM43455
+3. Write userspace CSI reader → ESP32 binary protocol converter
+4. Test CSI quality comparison: ESP32 vs BCM43455
+5. If viable: add RTL8822CS CSI extraction via rtw88 driver modification
+
+### Phase 3 (1 week)
+
+1. Add PWA manifest to sensing server web UI
+2. Test on Android Chrome, iOS Safari
+3. Add service worker for offline dashboard caching
+
+## References
+
+- [Nexmon CSI](https://github.com/seemoo-lab/nexmon_csi) — Broadcom WiFi CSI extraction (BCM43455, BCM4339, BCM4358)
+- [Armbian](https://www.armbian.com/) — Debian/Ubuntu for ARM SBCs and TV boxes
+- [rtw88 driver](https://github.com/torvalds/linux/tree/master/drivers/net/wireless/realtek/rtw88) — Mainline Linux driver for Realtek 802.11ac chips
+- [mt76 driver](https://github.com/torvalds/linux/tree/master/drivers/net/wireless/mediatek/mt76) — Mainline Linux driver for MediaTek WiFi chips
+- [cross](https://github.com/cross-rs/cross) — Zero-setup Rust cross-compilation
+- [ADR-018: ESP32 CSI Binary Protocol](ADR-018-dev-implementation.md) — Binary frame format reused for Phase 2 CSI extraction
+- [ADR-039: Edge Intelligence](ADR-039-esp32-edge-intelligence.md) — On-device processing tiers
+- [ADR-043: Sensing Server](ADR-043-sensing-server-ui-api-completion.md) — Single-binary deployment target
@@ -0,0 +1,152 @@
+# ADR-047: RuView Observatory — Immersive Three.js WiFi Sensing Visualization
+
+## Status
+
+Accepted (Implemented)
+
+## Date
+
+2026-03-04
+
+## Context
+
+The project has a functional tabbed dashboard UI (`ui/index.html`) with existing Three.js components (body model, gaussian splats, signal visualization, environment). While effective for monitoring, it lacks a cinematic, immersive visualization suitable for demonstrations and stakeholder presentations.
+
+We need an immersive Three.js room-based visualization with practical WiFi sensing data overlays — human wireframe pose, dot-matrix body mass, vital signs HUD, signal field heatmap — powered by ESP32 CSI data (demo mode with live WebSocket path).
+
+## Decision
+
+### Standalone Page Architecture
+
+`ui/observatory.html` is a standalone full-screen entry point, separate from the tabbed dashboard. Linked via "Observatory" nav tab in `ui/index.html`. No build step — vanilla JS modules with Three.js r160 via CDN importmap.
+
+### Room-Based Visualization
+
+Instead of abstract holographic panels, the observatory renders a practical room scene with:
+
+| Element | Implementation | Data Source |
+|---------|---------------|-------------|
+| Human wireframe | COCO 17-keypoint skeleton, CylinderGeometry tube bones, SphereGeometry joints with glow halos | `persons[].position`, `vital_signs.breathing_rate_bpm` |
+| Dot-matrix mist | 800 Points with per-particle alpha ShaderMaterial, body-shaped distribution | `persons[].position`, `persons[].motion_score` |
+| Particle trail | 200 Points with age-based fade, emitted from moving person | `persons[].position`, `persons[].motion_score` |
+| Signal field | 400 floor-level Points with green→amber color ramp | `signal_field.values` (20×20 grid) |
+| WiFi waves | 5 wireframe SphereGeometry shells, AdditiveBlending, pulsing outward | Always-on animation from router position |
+| Router | BoxGeometry body, 3 CylinderGeometry antennas, pulsing LED, PointLight | Static scene element |
+| Room | GridHelper floor, BoxGeometry wireframe boundary, reflective MeshStandardMaterial floor, furniture (table, bed) | Static scene element |
+
+### HUD Overlay
+
+Glass-morphism HTML panels overlaid on the 3D canvas:
+
+- **Left panel (Vital Signs):** Heart rate (BPM), respiration (RPM), confidence (%) with animated bars
+- **Right panel (WiFi Signal):** RSSI, variance, motion power, person count, 2D RSSI sparkline, presence state badge, fall alert
+- **Top-right:** Data source badge (DEMO/LIVE), scenario badge, FPS counter, settings gear
+- **Bottom:** Capability bar (Pose Estimation, Vital Monitoring, Presence Detection)
+- **Bottom-right:** Keyboard shortcut hints
+
+### Settings Dialog (4 Tabs)
+
+Full customization with localStorage persistence and JSON export:
+
+| Tab | Controls |
+|-----|----------|
+| **Rendering** | Bloom strength/radius/threshold, exposure, vignette, film grain, chromatic aberration |
+| **Wireframe** | Bone thickness, joint size, glow intensity, particle trail, wireframe color, joint color, aura opacity |
+| **Scene** | Signal field opacity, WiFi wave intensity, room brightness, floor reflection, FOV, orbit speed, grid toggle, room boundary toggle |
+| **Data** | Scenario selector (auto-cycle or fixed), cycle speed, data source (demo/WebSocket), WS URL, reset camera, export settings |
+
+### Demo-First with Live Data Path
+
+Four auto-cycling scenarios (30s default, configurable) with 2s cosine crossfade:
+
+| Scenario | Description |
+|----------|-------------|
+| `empty_room` | Low variance, no presence, flat amplitude, stable RSSI -45dBm |
+| `single_breathing` | 1 person, breathing 16 BPM, HR 72 BPM, sinusoidal subcarrier modulation |
+| `two_walking` | 2 persons, high motion, Doppler-like shifts, moving signal field peaks |
+| `fall_event` | 2s variance spike at t=5s, then stillness, fall flag, confidence drop |
+
+Data contract matches `SensingUpdate` struct from the Rust sensing server. Live WebSocket connection configurable in settings dialog.
+
+### Post-Processing Pipeline
+
+EffectComposer chain: RenderPass → UnrealBloomPass → custom VignetteShader
+
+- **UnrealBloom:** strength 1.0, radius 0.5, threshold 0.25 (configurable)
+- **VignetteShader:** warm shadow shift, edge chromatic aberration, film grain
+- **Adaptive quality:** Auto-degrades when FPS < 25, restores when FPS > 55
+
+### RuView Foundation Color Palette
+
+| Role | Color | Hex |
+|------|-------|-----|
+| Background | Deep dark | `#080c14` |
+| Primary wireframe | Green glow | `#00d878` |
+| Warm accent | Amber | `#ffb020` |
+| Signal | Blue | `#2090ff` |
+| Heart / joints | Red | `#ff4060` |
+| Alert | Crimson | `#ff3040` |
+
+### Technology Choices
+
+| Decision | Rationale |
+|----------|-----------|
+| Standalone page vs tab | Full-screen immersion, independent loading |
+| Room-based vs abstract panels | Practical spatial context for WiFi sensing data |
+| Vanilla JS + CDN, no build step | Matches existing `ui/` pattern, served as static files by Axum |
+| Custom ShaderMaterial for mist | Per-particle alpha, body-shaped distribution, AdditiveBlending |
+| CylinderGeometry tube bones | Visible at any zoom vs thin Line geometry |
+| COCO 17-keypoint skeleton | Standard pose format, 16 bone connections |
+| localStorage settings | Persistent customization without server round-trip |
+| Adaptive quality | 3 levels, auto-switches based on FPS measurement |
+
+### Keyboard Shortcuts
+
+| Key | Action |
+|-----|--------|
+| `A` | Toggle autopilot orbit |
+| `D` | Cycle demo scenario |
+| `F` | Toggle FPS counter |
+| `S` | Open/close settings |
+| `Space` | Pause/resume data |
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `ui/observatory.html` | Full-screen entry point with HUD overlay + settings dialog |
+| `ui/observatory/js/main.js` | Scene orchestrator (~1,100 lines): room, wireframe, mist, trails, settings, HUD, animation loop |
+| `ui/observatory/js/demo-data.js` | 4 scenarios with cosine crossfade, setScenario/setCycleDuration API |
+| `ui/observatory/js/nebula-background.js` | Procedural fBM nebula + star field background sphere |
+| `ui/observatory/js/post-processing.js` | EffectComposer: UnrealBloom + VignetteShader (chromatic, grain, warmth) |
+| `ui/observatory/css/observatory.css` | Foundation color scheme, glass-morphism panels, settings dialog, responsive |
+| `ui/index.html` | Modified: added Observatory nav link |
+
+## Consequences
+
+### Positive
+- Standalone page does not affect existing dashboard stability
+- Demo-first allows offline presentations without hardware
+- Same `SensingUpdate` contract enables seamless live WebSocket switch
+- Room-based visualization provides intuitive spatial context for WiFi sensing
+- Dot-matrix mist gives visual body mass without occluding wireframe
+- Full settings customization without code changes (localStorage + JSON export)
+- Adaptive quality ensures usability on weaker hardware
+- ~20 draw calls keeps performance well within budget
+
+### Negative
+- Additional static files served by Axum (minimal overhead)
+- Three.js r160 loaded from CDN (no build step, matches existing pattern)
+- Settings persistence is per-browser (localStorage, not synced)
+
+### Risks
+- CDN dependency for Three.js (mitigated: can vendor locally if needed)
+- Post-processing may not work on very old GPUs (mitigated: adaptive quality disables bloom)
+
+## References
+
+- ADR-045: AMOLED display support
+- ADR-046: Android TV / Armbian deployment
+- Existing `ui/components/scene.js` — Three.js scene pattern
+- Existing `ui/components/gaussian-splats.js` — ShaderMaterial pattern
+- Existing `ui/services/sensing.service.js` — WebSocket data contract
@@ -0,0 +1,140 @@
+# ADR-048: Adaptive CSI Activity Classifier
+
+| Field | Value |
+|-------|-------|
+| Status | Accepted |
+| Date | 2026-03-05 |
+| Deciders | ruv |
+| Depends on | ADR-024 (AETHER Embeddings), ADR-039 (Edge Processing), ADR-045 (AMOLED Display) |
+
+## Context
+
+WiFi-based activity classification using ESP32 Channel State Information (CSI) relies on hand-tuned thresholds to distinguish between activity states (absent, present_still, present_moving, active). These static thresholds are brittle — they don't account for:
+
+- **Environment-specific signal patterns**: Room geometry, furniture, wall materials, and ESP32 placement all affect how CSI signals respond to human activity.
+- **Temporal noise characteristics**: Real ESP32 CSI data at ~10 FPS has significant frame-to-frame jitter that causes classification to jump between states.
+- **Vital signs estimation noise**: Heart rate and breathing rate estimates from Goertzel filter banks produce large swings (50+ BPM frame-to-frame) at low confidence levels.
+
+The existing threshold-based approach produces noisy, unstable classifications that degrade the user experience in the Observatory visualization and the main dashboard.
+
+## Decision
+
+### 1. Three-Stage Signal Smoothing Pipeline
+
+All CSI-derived metrics pass through a three-stage pipeline before reaching the UI:
+
+#### Stage 1: Adaptive Baseline Subtraction
+- EMA with α=0.003 (~30s time constant) tracks the "quiet room" noise floor
+- Only updates during low-motion periods to avoid inflating baseline during activity
+- 50-frame warm-up period for initial baseline learning
+- Subtracts 70% of baseline from raw motion score to remove environmental drift
+
+#### Stage 2: EMA + Median Filtering
+- **Motion score**: Blended from 4 signals (temporal diff 40%, variance 20%, motion band power 25%, change points 15%), then EMA-smoothed with α=0.15
+- **Vital signs**: 21-frame sliding window → trimmed mean (drop top/bottom 25%) → EMA with α=0.02 (~5s time constant)
+- **Dead-band**: HR won't update unless trimmed mean differs by >2 BPM; BR needs >0.5 BPM
+- **Outlier rejection**: HR jumps >8 BPM/frame and BR jumps >2 BPM/frame are discarded
+
+#### Stage 3: Hysteresis Debounce
+- Activity state transitions require 4 consecutive frames (~0.4s) of agreement before committing
+- Prevents rapid flickering between states
+- Independent candidate tracking resets on new direction changes
+
+### 2. Adaptive Classifier Module (`adaptive_classifier.rs`)
+
+A Rust-native environment-tuned classifier that learns from labeled JSONL recordings:
+
+#### Feature Extraction (15 features)
+| # | Feature | Source | Discriminative Power |
+|---|---------|--------|---------------------|
+| 0 | variance | Server | Medium — temporal CSI spread |
+| 1 | motion_band_power | Server | Medium — high-frequency subcarrier energy |
+| 2 | breathing_band_power | Server | Low — respiratory band energy |
+| 3 | spectral_power | Server | Low — mean squared amplitude |
+| 4 | dominant_freq_hz | Server | Low — peak subcarrier index |
+| 5 | change_points | Server | Medium — threshold crossing count |
+| 6 | mean_rssi | Server | Low — received signal strength |
+| 7 | amp_mean | Subcarrier | Medium — mean amplitude across 56 subcarriers |
+| 8 | amp_std | Subcarrier | **High** — amplitude spread (motion increases spread) |
+| 9 | amp_skew | Subcarrier | Medium — asymmetry of amplitude distribution |
+| 10 | amp_kurt | Subcarrier | **High** — peakedness (presence creates peaks) |
+| 11 | amp_iqr | Subcarrier | Medium — inter-quartile range |
+| 12 | amp_entropy | Subcarrier | **High** — spectral entropy (motion increases disorder) |
+| 13 | amp_max | Subcarrier | Medium — peak amplitude value |
+| 14 | amp_range | Subcarrier | Medium — amplitude dynamic range |
+
+#### Training Algorithm
+- **Multiclass logistic regression** with softmax output
+- **Mini-batch SGD** (batch size 32, 200 epochs, linear learning rate decay)
+- **Z-score normalisation** using global mean/stddev computed from all training data
+- Per-class statistics (mean, stddev) stored for Mahalanobis distance fallback
+- Deterministic shuffling (LCG PRNG, seed 42) for reproducible results
+
+#### Training Data Pipeline
+1. Record labeled CSI sessions via `POST /api/v1/recording/start {"id":"train_<label>"}`
+2. Filename-based label assignment: `*empty*`→absent, `*still*`→present_still, `*walking*`→present_moving, `*active*`→active
+3. Train via `POST /api/v1/adaptive/train`
+4. Model saved to `data/adaptive_model.json`, auto-loaded on server restart
+
+#### Inference Pipeline
+1. Extract 15-feature vector from current CSI frame
+2. Z-score normalise using stored global mean/stddev
+3. Compute softmax probabilities across 4 classes
+4. Blend adaptive model confidence (70%) with smoothed threshold confidence (30%)
+5. Override classification only when adaptive model is loaded
+
+### 3. API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/v1/adaptive/train` | Train classifier from `train_*` recordings |
+| GET | `/api/v1/adaptive/status` | Check model status, accuracy, class stats |
+| POST | `/api/v1/adaptive/unload` | Revert to threshold-based classification |
+| POST | `/api/v1/recording/start` | Start recording CSI frames (JSONL) |
+| POST | `/api/v1/recording/stop` | Stop recording |
+| GET | `/api/v1/recording/list` | List available recordings |
+
+### 4. Vital Signs Smoothing
+
+| Parameter | Value | Rationale |
+|-----------|-------|-----------|
+| Median window | 21 frames | ~2s of history, robust to transients |
+| Aggregation | Trimmed mean (middle 50%) | More stable than pure median, less noisy than raw mean |
+| EMA alpha | 0.02 | ~5s time constant — readings change very slowly |
+| HR dead-band | ±2 BPM | Prevents display creep from micro-fluctuations |
+| BR dead-band | ±0.5 BPM | Same for breathing rate |
+| HR max jump | 8 BPM/frame | Outlier rejection threshold |
+| BR max jump | 2 BPM/frame | Outlier rejection threshold |
+
+## Consequences
+
+### Benefits
+- **Stable UI**: Vital signs readings hold steady for 5-10+ seconds instead of jumping every frame
+- **Environment adaptation**: Classifier learns the specific room's signal characteristics
+- **Graceful fallback**: If no adaptive model is loaded, threshold-based classification with smoothing still works
+- **No external dependencies**: Pure Rust implementation, no Python/ML frameworks needed
+- **Fast training**: 3,000+ frames train in <1 second on commodity hardware
+- **Portable model**: JSON serialisation, loadable on any platform
+
+### Limitations
+- **Single-link**: With one ESP32, the feature space is limited. Multi-AP setups (ADR-029) would dramatically improve separability.
+- **No temporal features**: Current frame-level classification doesn't use sequence models (LSTM/Transformer). Could be added later.
+- **Label quality**: Training accuracy depends heavily on recording quality (distinct activities, actual room vacancy for "empty").
+- **Linear classifier**: Logistic regression may underfit non-linear decision boundaries. Could upgrade to 2-layer MLP if needed.
+
+### Future Work
+- **Online learning**: Continuously update model weights from user corrections
+- **Sequence models**: Use sliding window of N frames as input for temporal pattern recognition
+- **Contrastive pretraining**: Leverage ADR-024 AETHER embeddings for self-supervised feature learning
+- **Multi-AP fusion**: Use ADR-029 multistatic sensing for richer feature space
+- **Edge deployment**: Export learned thresholds to ESP32 firmware (ADR-039 Tier 2) for on-device classification
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `crates/wifi-densepose-sensing-server/src/adaptive_classifier.rs` | Adaptive classifier module (feature extraction, training, inference) |
+| `crates/wifi-densepose-sensing-server/src/main.rs` | Smoothing pipeline, API endpoints, integration |
+| `ui/observatory/js/hud-controller.js` | UI-side lerp smoothing (4% per frame) |
+| `data/adaptive_model.json` | Trained model (auto-created by training endpoint) |
+| `data/recordings/train_*.jsonl` | Labeled training recordings |
@@ -0,0 +1,122 @@
+# ADR-049: Cross-Platform WiFi Interface Detection and Graceful Degradation
+
+| Field | Value |
+|-------|-------|
+| Status | Proposed |
+| Date | 2026-03-06 |
+| Deciders | ruv |
+| Depends on | ADR-013 (Feature-Level Sensing), ADR-025 (macOS CoreWLAN) |
+| Issue | [#148](https://github.com/ruvnet/wifi-densepose/issues/148) |
+
+## Context
+
+Users report `RuntimeError: Cannot read /proc/net/wireless` when running WiFi DensePose in environments where the Linux wireless proc filesystem is unavailable:
+
+- **Docker containers** on macOS/Windows (Linux kernel detected, but no wireless subsystem)
+- **WSL2** without USB WiFi passthrough
+- **Headless Linux servers** without WiFi hardware
+- **Embedded Linux** boards without wireless-extensions support
+
+The current architecture has two layers of defense:
+
+1. **`ws_server.py`** (line 345-355) checks `os.path.exists("/proc/net/wireless")` before instantiating `LinuxWifiCollector` and falls back to `SimulatedCollector` if missing.
+2. **`rssi_collector.py`** `LinuxWifiCollector._validate_interface()` (line 178-196) raises a hard `RuntimeError` if `/proc/net/wireless` is missing or the interface isn't listed.
+
+However, there are gaps:
+
+- **Direct usage**: Any code that instantiates `LinuxWifiCollector` directly (outside `ws_server.py`) hits the unguarded `RuntimeError` with no fallback.
+- **Error message**: The RuntimeError message tells users to "use SimulatedCollector instead" but doesn't explain how.
+- **No auto-detection**: The collector selection logic is duplicated between `ws_server.py` and `install.sh` with no shared platform-detection utility.
+- **Partial `/proc/net/wireless`**: The file may exist (e.g., kernel module loaded) but contain no interfaces, producing a confusing "interface not found" error instead of a clean fallback.
+
+## Decision
+
+### 1. Platform-Aware Collector Factory
+
+Introduce a `create_collector()` factory function in `rssi_collector.py` that encapsulates the platform detection and fallback chain:
+
+```python
+def create_collector(
+    preferred: str = "auto",
+    interface: str = "wlan0",
+    sample_rate_hz: float = 10.0,
+) -> BaseCollector:
+    """
+    Create the best available WiFi collector for the current platform.
+
+    Resolution order (when preferred="auto"):
+      1. ESP32 CSI (if UDP port 5005 is receiving frames)
+      2. Platform-native WiFi:
+         - Linux: LinuxWifiCollector (requires /proc/net/wireless + active interface)
+         - Windows: WindowsWifiCollector (netsh wlan)
+         - macOS: MacosWifiCollector (CoreWLAN)
+      3. SimulatedCollector (always available)
+
+    Raises nothing — always returns a usable collector.
+    """
+```
+
+### 2. Soft Validation in LinuxWifiCollector
+
+Replace the hard `RuntimeError` in `_validate_interface()` with a class method that returns availability status without raising:
+
+```python
+@classmethod
+def is_available(cls, interface: str = "wlan0") -> tuple[bool, str]:
+    """Check if Linux WiFi collection is possible. Returns (available, reason)."""
+    if not os.path.exists("/proc/net/wireless"):
+        return False, "/proc/net/wireless not found (Docker, WSL, or no wireless subsystem)"
+    with open("/proc/net/wireless") as f:
+        content = f.read()
+    if interface not in content:
+        names = cls._parse_interface_names(content)
+        return False, f"Interface '{interface}' not in /proc/net/wireless. Available: {names}"
+    return True, "ok"
+```
+
+The existing `_validate_interface()` continues to raise `RuntimeError` for direct callers who need fail-fast behavior, but `create_collector()` uses `is_available()` to probe without exceptions.
+
+### 3. Structured Fallback Logging
+
+When auto-detection skips a collector, log at `WARNING` level with actionable context:
+
+```
+WiFi collector: LinuxWifiCollector unavailable (/proc/net/wireless not found — likely Docker/WSL).
+WiFi collector: Falling back to SimulatedCollector. For real sensing, connect ESP32 nodes via UDP:5005.
+```
+
+### 4. Consolidate Platform Detection
+
+Remove duplicated platform-detection logic from `ws_server.py` and `install.sh`. Both should use `create_collector()` (Python) or a shared `detect_wifi_platform()` shell function.
+
+## Consequences
+
+### Positive
+
+- **Zero-crash startup**: `create_collector("auto")` never raises — Docker, WSL, and headless users get `SimulatedCollector` automatically with a clear log message.
+- **Single detection path**: Platform logic lives in one place (`rssi_collector.py`), reducing drift between `ws_server.py`, `install.sh`, and future entry points.
+- **Better DX**: Error messages explain *why* a collector is unavailable and *what to do* (connect ESP32, install WiFi driver, etc.).
+
+### Negative
+
+- **SimulatedCollector may mask hardware issues**: Users with real WiFi hardware that fails detection might unknowingly run on simulated data. Mitigated by the `WARNING`-level log.
+- **Breaking change for direct `LinuxWifiCollector` callers**: Code that catches `RuntimeError` from `_validate_interface()` as a signal needs to migrate to `is_available()` or `create_collector()`. This is a minor change — there are no known external consumers.
+
+### Neutral
+
+- `_validate_interface()` behavior is unchanged for existing direct callers — this is additive.
+
+## Implementation Notes
+
+1. Add `create_collector()` and `BaseCollector.is_available()` to `v1/src/sensing/rssi_collector.py`
+2. Refactor `ws_server.py` `_init_collector()` to call `create_collector()`
+3. Update `install.sh` `detect_wifi_hardware()` to use shared detection logic
+4. Add unit tests for each platform path (mock `/proc/net/wireless` presence/absence)
+5. Comment on issue #148 with the fix
+
+## References
+
+- Issue #148: RuntimeError: Cannot read /proc/net/wireless
+- ADR-013: Feature-Level Sensing on Commodity Gear
+- ADR-025: macOS CoreWLAN WiFi Sensing
+- [Linux /proc/net/wireless documentation](https://www.kernel.org/doc/html/latest/networking/statistics.html)
@@ -0,0 +1,100 @@
+# ADR-050: Quality Engineering Response — Security Hardening & Code Quality
+
+| Field | Value |
+|-------|-------|
+| Status | Accepted |
+| Date | 2026-03-06 |
+| Deciders | ruv |
+| Depends on | ADR-032 (Multistatic Mesh Security) |
+| Issue | [#170](https://github.com/ruvnet/wifi-densepose/issues/170) |
+
+## Context
+
+An independent quality engineering analysis ([issue #170](https://github.com/ruvnet/wifi-densepose/issues/170)) identified 7 critical findings across the Rust codebase. After verification against the source code, the following findings are confirmed and require action:
+
+### Confirmed Critical Findings
+
+| # | Finding | Location | Verified |
+|---|---------|----------|----------|
+| 1 | Fake HMAC in `secure_tdm.rs` — XOR fold with hardcoded key | `hardware/src/esp32/secure_tdm.rs:253` | YES — comments say "sufficient for testing" |
+| 2 | `sensing-server/main.rs` is 3,741 lines — CC=65, god object | `sensing-server/src/main.rs` | YES — confirmed 3,741 lines |
+| 3 | WebSocket server has zero authentication | Rust WS codebase | YES — no auth/token checks found |
+| 4 | Zero security tests in Rust codebase | Entire workspace | YES — no auth/injection/tampering tests |
+| 5 | 54K fps claim has no supporting benchmark | No criterion benchmarks | YES — no benchmarks exist |
+
+### Findings Requiring Further Investigation
+
+| # | Finding | Status |
+|---|---------|--------|
+| 6 | Unauthenticated OTA firmware endpoint | Not found in Rust code — may be ESP32 C firmware level |
+| 7 | WASM upload without mandatory signatures | Needs review of WASM loader |
+| 8 | O(n^2) autocorrelation in heart rate detection | Needs profiling to confirm impact |
+
+## Decision
+
+Address findings in 3 priority sprints as recommended by the report.
+
+### Sprint 1: Security (Blocks Deployment)
+
+1. **Replace fake HMAC with real HMAC-SHA256** in `secure_tdm.rs`
+   - Use the `hmac` + `sha2` crates (already in `Cargo.lock`)
+   - Remove XOR fold implementation
+   - Add key derivation (no more hardcoded keys)
+
+2. **Add WebSocket authentication**
+   - Token-based auth on WS upgrade handshake
+   - Optional API key for local-network deployments
+   - Configurable via environment variable
+
+3. **Add security test suite**
+   - Auth bypass attempts
+   - Malformed CSI frame injection
+   - Protocol tampering (TDM beacon replay, nonce reuse)
+
+### Sprint 2: Code Quality & Testability
+
+4. **Decompose `main.rs`** (3,741 lines -> ~14 focused modules)
+   - Extract HTTP routes, WebSocket handler, CSI pipeline, config, state
+   - Target: no file over 500 lines
+
+5. **Add criterion benchmarks**
+   - CSI frame parsing throughput
+   - Signal processing pipeline latency
+   - WebSocket broadcast fanout
+
+### Sprint 3: Functional Verification
+
+6. **Vital sign accuracy verification**
+   - Reference signal tests with known BPM
+   - False-negative rate measurement
+
+7. **Fix O(n^2) autocorrelation** (if confirmed by profiling)
+   - Replace brute-force lag with FFT-based autocorrelation
+
+## Consequences
+
+### Positive
+
+- Addresses all critical security findings before any production deployment
+- `main.rs` decomposition enables unit testing of server components
+- Criterion benchmarks provide verifiable performance claims
+- Security test suite prevents regression
+
+### Negative
+
+- Sprint 1 security changes are breaking for any existing TDM mesh deployments (fake HMAC -> real HMAC requires firmware update)
+- `main.rs` decomposition is a large refactor with merge conflict risk
+
+### Neutral
+
+- The report correctly identifies that life-safety claims (disaster detection, vital signs) require rigorous verification — this is an ongoing process, not a single sprint
+
+## Acknowledgment
+
+Thanks to [@proffesor-for-testing](https://github.com/proffesor-for-testing) for the thorough 10-report analysis. The full report is archived at the [original gist](https://gist.github.com/proffesor-for-testing/02321e3f272720aa94484fffec6ab19b).
+
+## References
+
+- Issue #170: Quality Engineering Analysis
+- ADR-032: Multistatic Mesh Security Hardening
+- ADR-028: ESP32 Capability Audit
@@ -0,0 +1,621 @@
+# ADR-052 Appendix: DDD Bounded Contexts — Tauri Desktop Frontend
+
+This document maps out the domain model for the RuView Tauri desktop application
+described in ADR-052. It defines bounded contexts, their aggregates, entities,
+value objects, and the domain events flowing between them.
+
+## Context Map
+
+```
+-------------------+       +---------------------+       +--------------------+
+|                   |       |                     |       |                    |
+|  Device Discovery |------>| Firmware Management |------>| Configuration /    |
+|                   |       |                     |       | Provisioning       |
+-------------------+       +---------------------+       +--------------------+
+        |                           |                             |
+        |                           |                             |
+        v                           v                             v
+-------------------+       +---------------------+       +--------------------+
+|                   |       |                     |       |                    |
+| Sensing Pipeline  |<------| Edge Module         |       | Visualization      |
+|                   |       | (WASM)              |       |                    |
+-------------------+       +---------------------+       +--------------------+
+
+Relationship types:
+  -----> Upstream/Downstream (upstream publishes events, downstream consumes)
+  <----- Conformist (downstream conforms to upstream's model)
+```
+
+---
+
+## 1. Device Discovery Context
+
+**Purpose**: Find, identify, and monitor ESP32 CSI nodes on the local network.
+
+**Upstream of**: Firmware Management, Configuration, Sensing Pipeline, Visualization
+
+### Aggregates
+
+#### `NodeRegistry` (Aggregate Root)
+
+Maintains the authoritative list of all known nodes. Merges discovery results
+from multiple strategies (mDNS, UDP probe, HTTP sweep) and deduplicates by MAC
+address.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `nodes` | `Map<MacAddress, Node>` | All discovered nodes keyed by MAC |
+| `scan_state` | `ScanState` | Idle, Scanning, Error |
+| `last_scan` | `DateTime<Utc>` | Timestamp of last completed scan |
+
+**Invariant**: No two nodes may share the same MAC address. If a node is
+discovered via multiple strategies, the most recent data wins.
+
+**Persistence**: The registry is persisted to `~/.ruview/nodes.db` (SQLite via
+`rusqlite`). On startup, all previously known nodes are loaded as `Offline` and
+reconciled against a fresh discovery scan. This means the app **remembers the
+mesh** across restarts — critical for field deployments where nodes may be
+temporarily powered off.
+
+#### `Node` (Entity)
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `mac` | `MacAddress` (VO) | IEEE 802.11 MAC address (unique identity) |
+| `ip` | `IpAddr` | Current IP address (may change on DHCP renewal) |
+| `hostname` | `Option<String>` | mDNS hostname |
+| `node_id` | `u8` | NVS-provisioned node ID |
+| `firmware_version` | `Option<SemVer>` | Firmware version string |
+| `health` | `HealthStatus` (VO) | Online / Offline / Degraded |
+| `discovery_method` | `DiscoveryMethod` (VO) | How this node was found |
+| `last_seen` | `DateTime<Utc>` | Last successful contact |
+| `tdm_config` | `Option<TdmConfig>` (VO) | TDM slot assignment |
+| `edge_tier` | `Option<u8>` | Edge processing tier (0/1/2) |
+
+### Value Objects
+
+- `MacAddress` — 6-byte hardware address, formatted as `AA:BB:CC:DD:EE:FF`
+- `HealthStatus` — enum: `Online`, `Offline`, `Degraded(reason: String)`
+- `DiscoveryMethod` — enum: `Mdns`, `UdpProbe`, `HttpSweep`, `Manual`
+- `TdmConfig` — `{ slot_index: u8, total_nodes: u8 }`
+- `SemVer` — semantic version `major.minor.patch`
+
+### Domain Events
+
+| Event | Payload | Consumers |
+|-------|---------|-----------|
+| `NodeDiscovered` | `{ node: Node }` | Firmware Mgmt (check for updates), Visualization (add to mesh graph) |
+| `NodeWentOffline` | `{ mac: MacAddress, last_seen: DateTime }` | Visualization (gray out node), Sensing Pipeline (remove from active set) |
+| `NodeCameOnline` | `{ node: Node }` | Visualization (restore node), Sensing Pipeline (re-add) |
+| `NodeHealthChanged` | `{ mac: MacAddress, old: HealthStatus, new: HealthStatus }` | Visualization (update indicator) |
+| `ScanCompleted` | `{ found: usize, new: usize, lost: usize }` | Dashboard (update summary) |
+
+### Anti-Corruption Layer
+
+When receiving data from the ESP32 OTA status endpoint (`GET /ota/status`), the
+response format is owned by the firmware and may change across firmware versions.
+The ACL translates the raw JSON response into `Node` entity fields:
+
+```rust
+/// ACL: Translate ESP32 OTA status response to Node fields.
+fn translate_ota_status(raw: &serde_json::Value) -> Result<NodePatch, AclError> {
+    NodePatch {
+        firmware_version: raw["version"].as_str().map(SemVer::parse).transpose()?,
+        uptime_secs: raw["uptime_s"].as_u64(),
+        free_heap: raw["free_heap"].as_u64(),
+        // Firmware may add fields in future versions — unknown fields are ignored
+    }
+}
+```
+
+---
+
+## 2. Firmware Management Context
+
+**Purpose**: Flash, update, and verify firmware on ESP32 nodes.
+
+**Upstream of**: Configuration (a fresh flash triggers provisioning)
+**Downstream of**: Device Discovery (needs node list and serial port info)
+
+### Aggregates
+
+#### `FlashSession` (Aggregate Root)
+
+Represents a single firmware flashing operation from start to completion. Each
+session has a lifecycle: Created -> Connecting -> Erasing -> Writing -> Verifying ->
+Completed | Failed.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `Uuid` | Session identifier |
+| `port` | `SerialPort` (VO) | Target serial port |
+| `firmware` | `FirmwareBinary` (Entity) | The binary being flashed |
+| `chip` | `ChipType` (VO) | Target chip (ESP32, ESP32-S3, ESP32-C3) |
+| `phase` | `FlashPhase` (VO) | Current phase of the flash operation |
+| `progress` | `Progress` (VO) | Bytes written / total, speed |
+| `started_at` | `DateTime<Utc>` | When the session started |
+| `error` | `Option<String>` | Error message if failed |
+
+**Invariant**: Only one `FlashSession` may be active per serial port at a time.
+
+#### `FirmwareBinary` (Entity)
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `path` | `PathBuf` | Filesystem path to the `.bin` file |
+| `size_bytes` | `u64` | Binary size |
+| `version` | `Option<SemVer>` | Extracted from ESP32 image header |
+| `chip_type` | `Option<ChipType>` | Detected from image magic bytes |
+| `checksum` | `Sha256Hash` (VO) | SHA-256 of the binary |
+
+#### `OtaSession` (Aggregate Root)
+
+Represents an over-the-air firmware update to a running node.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `Uuid` | Session identifier |
+| `target_node` | `MacAddress` | Target node MAC |
+| `target_ip` | `IpAddr` | Target node IP |
+| `firmware` | `FirmwareBinary` | The binary being pushed |
+| `psk` | `Option<SecureString>` | PSK for authentication (ADR-050) |
+| `phase` | `OtaPhase` | Uploading / Rebooting / Verifying / Done / Failed |
+| `progress` | `Progress` | Upload progress |
+
+#### `BatchOtaSession` (Aggregate Root)
+
+Coordinates rolling firmware updates across multiple mesh nodes. Prevents all
+nodes from rebooting simultaneously, which would collapse the sensing network.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `Uuid` | Batch session identifier |
+| `firmware` | `FirmwareBinary` | The binary being deployed |
+| `strategy` | `OtaStrategy` | `Sequential`, `TdmSafe`, `Parallel` |
+| `max_concurrent` | `usize` | Max nodes updating at once |
+| `batch_delay_secs` | `u64` | Delay between batches |
+| `fail_fast` | `bool` | Abort remaining on first failure |
+| `node_states` | `Map<MacAddress, BatchNodeState>` | Per-node progress |
+
+**Invariant**: In `TdmSafe` mode, adjacent TDM slots are never updated
+concurrently. Even-slot nodes update first, then odd-slot nodes.
+
+**Lifecycle**: `Planning → InProgress → Completed | PartialFailure | Aborted`
+
+- `BatchNodeState` — enum: `Queued`, `Uploading(Progress)`, `Rebooting`, `Verifying`, `Done`, `Failed(String)`, `Skipped`
+- `OtaStrategy` — enum:
+  - `Sequential` — one node at a time, wait for rejoin
+  - `TdmSafe` — update non-adjacent slots to maintain sensing coverage
+  - `Parallel` — all at once (development only)
+
+### Value Objects
+
+- `SerialPort` — `{ name: String, vid: u16, pid: u16, manufacturer: Option<String> }`
+- `ChipType` — enum: `Esp32`, `Esp32s3`, `Esp32c3`
+- `FlashPhase` — enum: `Connecting`, `Erasing`, `Writing`, `Verifying`, `Completed`, `Failed`
+- `OtaPhase` — enum: `Uploading`, `Rebooting`, `Verifying`, `Completed`, `Failed`
+- `Progress` — `{ bytes_done: u64, bytes_total: u64, speed_bps: u64 }`
+- `Sha256Hash` — 32-byte hash
+- `SecureString` — zeroized-on-drop string for PSK tokens
+
+### Domain Events
+
+| Event | Payload | Consumers |
+|-------|---------|-----------|
+| `FlashStarted` | `{ session_id, port, firmware_version }` | UI (show progress) |
+| `FlashProgress` | `{ session_id, phase, progress }` | UI (update progress bar) |
+| `FlashCompleted` | `{ session_id, duration_secs }` | Configuration (trigger provisioning prompt) |
+| `FlashFailed` | `{ session_id, error }` | UI (show error) |
+| `OtaStarted` | `{ session_id, target_mac, firmware_version }` | Discovery (mark node as updating) |
+| `OtaCompleted` | `{ session_id, target_mac, new_version }` | Discovery (refresh node info) |
+| `OtaFailed` | `{ session_id, target_mac, error }` | UI (show error) |
+| `BatchOtaStarted` | `{ batch_id, strategy, node_count }` | UI (show batch progress) |
+| `BatchNodeUpdated` | `{ batch_id, mac, state }` | UI (update per-node status), Discovery (refresh) |
+| `BatchOtaCompleted` | `{ batch_id, succeeded, failed, skipped }` | UI (show summary), Discovery (full rescan) |
+
+### Anti-Corruption Layer
+
+The `espflash` crate has its own error types and progress reporting model. The
+ACL translates these into domain events:
+
+```rust
+/// ACL: Translate espflash progress callbacks to domain FlashProgress events.
+impl From<espflash::ProgressCallbackMessage> for FlashProgress {
+    fn from(msg: espflash::ProgressCallbackMessage) -> Self {
+        match msg {
+            espflash::ProgressCallbackMessage::Connecting => FlashProgress {
+                phase: FlashPhase::Connecting,
+                progress: Progress::indeterminate(),
+            },
+            espflash::ProgressCallbackMessage::Erasing { addr, total } => FlashProgress {
+                phase: FlashPhase::Erasing,
+                progress: Progress::new(addr as u64, total as u64),
+            },
+            // ... etc
+        }
+    }
+}
+```
+
+---
+
+## 3. Configuration / Provisioning Context
+
+**Purpose**: Manage NVS configuration for ESP32 nodes — WiFi credentials, network
+targets, TDM mesh settings, edge intelligence parameters, WASM security keys.
+
+**Downstream of**: Device Discovery (needs serial port), Firmware Management (post-flash provisioning)
+
+### Aggregates
+
+#### `ProvisioningSession` (Aggregate Root)
+
+Represents a single NVS write or read operation on a connected ESP32.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `Uuid` | Session identifier |
+| `port` | `SerialPort` (VO) | Target serial port |
+| `config` | `NodeConfig` (Entity) | Configuration to write |
+| `direction` | `Direction` | Read or Write |
+| `phase` | `ProvisionPhase` | Generating / Flashing / Verifying / Done |
+
+#### `NodeConfig` (Entity)
+
+The full set of NVS key-value pairs for a single node. Maps directly to the
+firmware's `nvs_config_t` struct (see `firmware/esp32-csi-node/main/nvs_config.h`).
+
+| Field | Type | NVS Key | Description |
+|-------|------|---------|-------------|
+| `wifi_ssid` | `Option<String>` | `ssid` | WiFi SSID |
+| `wifi_password` | `Option<SecureString>` | `password` | WiFi password |
+| `target_ip` | `Option<IpAddr>` | `target_ip` | Aggregator IP |
+| `target_port` | `Option<u16>` | `target_port` | Aggregator UDP port |
+| `node_id` | `Option<u8>` | `node_id` | Node identifier |
+| `tdm_slot` | `Option<u8>` | `tdm_slot` | TDM slot index |
+| `tdm_total` | `Option<u8>` | `tdm_nodes` | Total TDM nodes |
+| `edge_tier` | `Option<u8>` | `edge_tier` | Processing tier |
+| `hop_count` | `Option<u8>` | `hop_count` | Channel hop count |
+| `channel_list` | `Option<Vec<u8>>` | `chan_list` | Channel sequence |
+| `dwell_ms` | `Option<u32>` | `dwell_ms` | Hop dwell time |
+| `power_duty` | `Option<u8>` | `power_duty` | Power duty cycle |
+| `presence_thresh` | `Option<u16>` | `pres_thresh` | Presence threshold |
+| `fall_thresh` | `Option<u16>` | `fall_thresh` | Fall detection threshold |
+| `vital_window` | `Option<u16>` | `vital_win` | Vital sign window |
+| `vital_interval_ms` | `Option<u16>` | `vital_int` | Vital sign interval |
+| `top_k_count` | `Option<u8>` | `subk_count` | Top-K subcarriers |
+| `wasm_max_modules` | `Option<u8>` | `wasm_max` | Max WASM modules |
+| `wasm_verify` | `Option<bool>` | `wasm_verify` | Require WASM signature |
+| `wasm_pubkey` | `Option<[u8; 32]>` | `wasm_pubkey` | Ed25519 public key |
+| `ota_psk` | `Option<SecureString>` | `ota_psk` | OTA pre-shared key |
+
+**Invariant**: `tdm_slot < tdm_total` when both are set.
+**Invariant**: `channel_list.len() == hop_count` when both are set.
+**Invariant**: `10 <= power_duty <= 100`.
+
+#### `MeshConfig` (Entity)
+
+A mesh-level configuration that generates per-node `NodeConfig` instances.
+Corresponds to ADR-044 Phase 2 (config file provisioning).
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `common` | `NodeConfig` | Shared settings (WiFi, target IP, edge tier) |
+| `nodes` | `Vec<MeshNodeEntry>` | Per-node overrides (port, node_id, tdm_slot) |
+
+```rust
+pub struct MeshNodeEntry {
+    pub port: String,
+    pub node_id: u8,
+    pub tdm_slot: u8,
+    // All other fields inherited from common
+}
+```
+
+**Invariant**: `tdm_total` is automatically computed as `nodes.len()`.
+
+### Value Objects
+
+- `ProvisionPhase` — enum: `Generating`, `Flashing`, `Verifying`, `Completed`, `Failed`
+- `Direction` — enum: `Read`, `Write`
+- `Preset` — enum: `Basic`, `Vitals`, `Mesh3`, `Mesh6Vitals` (ADR-044 Phase 3)
+
+### Domain Events
+
+| Event | Payload | Consumers |
+|-------|---------|-----------|
+| `NodeProvisioned` | `{ port, node_id, config_summary }` | Discovery (trigger re-scan), UI (show success) |
+| `NvsReadCompleted` | `{ port, config: NodeConfig }` | UI (populate form) |
+| `ProvisionFailed` | `{ port, error }` | UI (show error) |
+| `MeshProvisionStarted` | `{ node_count }` | UI (show batch progress) |
+| `MeshProvisionCompleted` | `{ success_count, fail_count }` | UI (show summary) |
+
+---
+
+## 4. Sensing Pipeline Context
+
+**Purpose**: Control the sensing server process, receive real-time CSI data, and
+manage the signal processing pipeline.
+
+**Downstream of**: Device Discovery (needs node IPs for data attribution)
+
+### Aggregates
+
+#### `SensingServer` (Aggregate Root)
+
+Represents the managed sensing server child process.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `state` | `ServerState` (VO) | Stopped / Starting / Running / Stopping / Crashed |
+| `config` | `ServerConfig` (VO) | Port configuration, log level, model paths |
+| `pid` | `Option<u32>` | OS process ID when running |
+| `started_at` | `Option<DateTime<Utc>>` | Start timestamp |
+| `log_buffer` | `RingBuffer<LogEntry>` | Last N log lines |
+| `ws_url` | `Option<Url>` | WebSocket URL for live data |
+
+**Invariant**: Only one `SensingServer` process may be managed at a time.
+
+#### `SensingSession` (Entity)
+
+An active connection to the sensing server's WebSocket for receiving real-time data.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `connection_state` | `WsState` | Connecting / Connected / Disconnected |
+| `frames_received` | `u64` | Total CSI frames received this session |
+| `last_frame_at` | `Option<DateTime<Utc>>` | Timestamp of last received frame |
+| `subscriptions` | `HashSet<DataChannel>` | Which data streams are active |
+
+### Value Objects
+
+- `ServerState` — enum: `Stopped`, `Starting`, `Running`, `Stopping`, `Crashed(exit_code: i32)`
+- `ServerConfig` — `{ http_port: u16, ws_port: u16, udp_port: u16, model_dir: PathBuf, log_level: Level }`
+- `LogEntry` — `{ timestamp: DateTime, level: Level, target: String, message: String }`
+- `DataChannel` — enum: `CsiFrames`, `PoseUpdates`, `VitalSigns`, `ActivityClassification`
+- `WsState` — enum: `Connecting`, `Connected`, `Disconnected(reason: String)`
+
+### Domain Events
+
+| Event | Payload | Consumers |
+|-------|---------|-----------|
+| `ServerStarted` | `{ pid, ports: ServerConfig }` | UI (enable sensing view), Discovery (start health polling via WS) |
+| `ServerStopped` | `{ exit_code, uptime_secs }` | UI (disable sensing view) |
+| `ServerCrashed` | `{ exit_code, last_log_lines }` | UI (show crash report) |
+| `CsiFrameReceived` | `{ node_id, timestamp, subcarrier_count }` | Visualization (update charts) |
+| `PoseUpdated` | `{ persons: Vec<PersonPose> }` | Visualization (draw skeletons) |
+| `VitalSignUpdate` | `{ node_id, bpm, breath_rate }` | Visualization (update vitals chart) |
+| `ActivityDetected` | `{ label, confidence }` | Visualization (show activity) |
+
+---
+
+## 5. Edge Module (WASM) Context
+
+**Purpose**: Upload, manage, and monitor WASM edge processing modules running
+on ESP32 nodes.
+
+**Downstream of**: Device Discovery (needs node IPs and WASM capability info)
+**Upstream of**: Sensing Pipeline (WASM modules emit edge-processed events)
+
+### Aggregates
+
+#### `ModuleRegistry` (Aggregate Root)
+
+Tracks all WASM modules across all nodes.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `modules` | `Map<(MacAddress, ModuleId), WasmModule>` | Per-node module inventory |
+
+#### `WasmModule` (Entity)
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `ModuleId` (VO) | Node-assigned module identifier |
+| `name` | `String` | Filename of the uploaded `.wasm` |
+| `size_bytes` | `u64` | Module size |
+| `status` | `ModuleStatus` (VO) | Loaded / Running / Stopped / Error |
+| `node_mac` | `MacAddress` | Which node this module runs on |
+| `uploaded_at` | `DateTime<Utc>` | Upload timestamp |
+| `signed` | `bool` | Whether the module has an Ed25519 signature |
+
+### Value Objects
+
+- `ModuleId` — string identifier assigned by the node firmware
+- `ModuleStatus` — enum: `Loaded`, `Running`, `Stopped`, `Error(String)`
+
+### Domain Events
+
+| Event | Payload | Consumers |
+|-------|---------|-----------|
+| `ModuleUploaded` | `{ node_mac, module_id, name, size }` | UI (refresh list) |
+| `ModuleStarted` | `{ node_mac, module_id }` | UI (update status) |
+| `ModuleStopped` | `{ node_mac, module_id }` | UI (update status) |
+| `ModuleUnloaded` | `{ node_mac, module_id }` | UI (remove from list) |
+| `ModuleError` | `{ node_mac, module_id, error }` | UI (show error) |
+
+### Anti-Corruption Layer
+
+The ESP32 WASM management HTTP API (`/wasm/*` on port 8032) returns raw JSON
+with firmware-specific field names. The ACL normalizes these:
+
+```rust
+/// ACL: Translate ESP32 WASM list response to domain WasmModule entities.
+fn translate_wasm_list(raw: &[serde_json::Value]) -> Vec<WasmModule> {
+    raw.iter().filter_map(|entry| {
+        Some(WasmModule {
+            id: ModuleId(entry["id"].as_str()?.to_string()),
+            name: entry["name"].as_str().unwrap_or("unknown").to_string(),
+            size_bytes: entry["size"].as_u64().unwrap_or(0),
+            status: match entry["state"].as_str() {
+                Some("running") => ModuleStatus::Running,
+                Some("stopped") => ModuleStatus::Stopped,
+                Some("loaded")  => ModuleStatus::Loaded,
+                other => ModuleStatus::Error(
+                    format!("Unknown state: {:?}", other)
+                ),
+            },
+            // ...
+        })
+    }).collect()
+}
+```
+
+---
+
+## 6. Visualization Context
+
+**Purpose**: Render real-time and historical sensing data — CSI heatmaps, pose
+skeletons, vital sign charts, mesh topology graphs.
+
+**Downstream of**: Sensing Pipeline (receives data events), Device Discovery (needs
+node metadata for labeling)
+
+This context is **purely presentational** and contains no domain logic. It
+transforms domain events from other contexts into visual representations.
+
+### Aggregates
+
+None — this context is a **Query Model** (CQRS read side). It subscribes to
+domain events and projects them into view models.
+
+### View Models
+
+#### `DashboardView`
+
+| Field | Source Context | Description |
+|-------|---------------|-------------|
+| `nodes` | Device Discovery | Node cards with health, version, signal quality |
+| `server` | Sensing Pipeline | Server status, uptime, port info |
+| `recent_activity` | All contexts | Timeline of recent events |
+
+#### `SignalView`
+
+| Field | Source Context | Description |
+|-------|---------------|-------------|
+| `csi_heatmap` | Sensing Pipeline | Subcarrier amplitude x time matrix |
+| `signal_field` | Sensing Pipeline | 2D signal strength grid |
+| `activity_label` | Sensing Pipeline | Current classification |
+| `confidence` | Sensing Pipeline | Classification confidence |
+
+#### `PoseView`
+
+| Field | Source Context | Description |
+|-------|---------------|-------------|
+| `persons` | Sensing Pipeline | Array of detected person skeletons |
+| `zones` | Sensing Pipeline | Active zones in the sensing area |
+
+#### `VitalsView`
+
+| Field | Source Context | Description |
+|-------|---------------|-------------|
+| `breathing_rate_bpm` | Sensing Pipeline | Per-node breathing rate time series |
+| `heart_rate_bpm` | Sensing Pipeline | Per-node heart rate time series |
+
+#### `MeshView`
+
+| Field | Source Context | Description |
+|-------|---------------|-------------|
+| `nodes` | Device Discovery | Positioned nodes for graph layout |
+| `edges` | Device Discovery | Inter-node visibility/connectivity |
+| `tdm_timeline` | Device Discovery | TDM slot schedule visualization |
+| `sync_status` | Sensing Pipeline | Per-node sync status with server |
+
+---
+
+## Cross-Context Event Flow
+
+```
+                            NodeDiscovered
+Device Discovery  ─────────────────────────────────> Firmware Management
+        │                                                    │
+        │  NodeDiscovered                                    │ FlashCompleted
+        │  NodeHealthChanged                                 │
+        ├──────────────────> Visualization                   v
+        │                                           Configuration
+        │  NodeDiscovered                                    │
+        ├──────────────────> Sensing Pipeline                │ NodeProvisioned
+        │                                                    │
+        │                                                    v
+        │                                           Device Discovery
+        │                                           (re-scan triggered)
+        │
+        │  NodeDiscovered
+        └──────────────────> Edge Module (WASM)
+                                    │
+                                    │ ModuleUploaded, ModuleStarted
+                                    │
+                                    v
+                             Sensing Pipeline
+                                    │
+                                    │ CsiFrameReceived, PoseUpdated, VitalSignUpdate
+                                    │
+                                    v
+                             Visualization
+```
+
+## Implementation Notes
+
+1. **Event Bus**: Domain events are dispatched via Tauri's event system
+   (`app_handle.emit("event-name", payload)`). The frontend subscribes using
+   `listen("event-name", callback)`. This provides natural cross-context
+   communication without coupling contexts directly.
+
+2. **State Isolation**: Each bounded context maintains its own `State<'_, T>`
+   managed by Tauri. Contexts do not share mutable state directly — they
+   communicate exclusively through events.
+
+3. **Module Organization**: Each bounded context maps to a Rust module under
+   `src/commands/` and `src/domain/`:
+
+   ```
+   src/
+     commands/           # Tauri command handlers (application layer)
+       discovery.rs      # Device Discovery context commands
+       flash.rs          # Firmware Management context commands
+       ota.rs            # Firmware Management context commands
+       provision.rs      # Configuration context commands
+       server.rs         # Sensing Pipeline context commands
+       wasm.rs           # Edge Module context commands
+     domain/             # Domain models (pure Rust, no Tauri dependency)
+       discovery/
+         mod.rs
+         node.rs         # Node entity, MacAddress VO
+         registry.rs     # NodeRegistry aggregate
+         events.rs       # Discovery domain events
+       firmware/
+         mod.rs
+         binary.rs       # FirmwareBinary entity
+         flash.rs        # FlashSession aggregate
+         ota.rs          # OtaSession aggregate
+         events.rs
+       config/
+         mod.rs
+         nvs.rs          # NodeConfig entity
+         mesh.rs         # MeshConfig entity
+         provision.rs    # ProvisioningSession aggregate
+         events.rs
+       sensing/
+         mod.rs
+         server.rs       # SensingServer aggregate
+         session.rs      # SensingSession entity
+         events.rs
+       wasm/
+         mod.rs
+         module.rs       # WasmModule entity
+         registry.rs     # ModuleRegistry aggregate
+         events.rs
+     acl/                # Anti-corruption layers
+       ota_status.rs     # ESP32 OTA status response translator
+       wasm_api.rs       # ESP32 WASM API response translator
+       espflash.rs       # espflash crate adapter
+   ```
+
+4. **Testing Strategy**: Domain modules under `src/domain/` have no Tauri
+   dependency and can be tested with standard `cargo test`. Command handlers
+   under `src/commands/` require Tauri test utilities for integration testing.
+
+5. **Shared Kernel**: The `MacAddress`, `SemVer`, and `SecureString` value objects
+   are shared across contexts. They live in a `src/domain/shared.rs` module.
+   This is acceptable because they are immutable value objects with no behavior
+   beyond validation and formatting.
@@ -0,0 +1,810 @@
+# ADR-052: Tauri Desktop Frontend — RuView Hardware Management & Visualization
+
+| Field | Value |
+|-------|-------|
+| Status | Proposed |
+| Date | 2026-03-06 |
+| Deciders | ruv |
+| Depends on | ADR-012 (ESP32 CSI Mesh), ADR-039 (Edge Intelligence), ADR-040 (WASM Programmable Sensing), ADR-044 (Provisioning Enhancements), ADR-050 (Security Hardening), ADR-051 (Server Decomposition) |
+| Issue | [#177](https://github.com/ruvnet/RuView/issues/177) |
+
+## Context
+
+RuView currently requires users to interact with multiple disconnected tools to manage a WiFi DensePose deployment:
+
+| Task | Current Tool | Pain Point |
+|------|-------------|------------|
+| Flash firmware | `esptool.py` CLI | Requires Python, pip, correct chip/baud flags |
+| Provision NVS | `provision.py` CLI | 13+ flags, no GUI, no read-back |
+| OTA update | `curl POST :8032/ota` | Manual HTTP, PSK header construction |
+| WASM modules | `curl` to `:8032/wasm/*` | No visibility into module state |
+| Start sensing server | `cargo run` or binary | Manual port configuration, no log viewer |
+| View sensing data | Browser at `localhost:8080` | Separate window, no hardware context |
+| Mesh topology | Mental model | No visualization of TDM slots, sync, health |
+| Node discovery | Manual IP tracking | No mDNS/UDP broadcast discovery |
+
+There is no single tool that provides a unified view of the entire deployment — from ESP32 hardware through the sensing pipeline to pose visualization. Field operators deploying multi-node meshes must context-switch between terminals, browsers, and serial monitors.
+
+### Why a Desktop App
+
+A browser-based UI cannot access serial ports (for flashing), raw UDP sockets (for node discovery), or the local filesystem (for firmware binaries). A desktop application is required for hardware management. Tauri v2 is the natural choice because:
+
+1. **Rust backend** — integrates directly with the existing Rust workspace (`wifi-densepose-rs`). Crates like `wifi-densepose-hardware` (serial port parsing), `wifi-densepose-config`, and `wifi-densepose-sensing-server` can be linked as library dependencies.
+2. **Small binary** — Tauri bundles the system webview rather than shipping Chromium (~150 MB savings vs Electron).
+3. **Cross-platform** — Windows, macOS, Linux from the same codebase.
+4. **Security model** — Tauri's capability-based permissions system restricts frontend access to explicitly allowed Rust commands.
+
+### Why Not Electron / Flutter / Native
+
+| Option | Rejected Because |
+|--------|-----------------|
+| Electron | 150+ MB bundle, no Rust integration, duplicates webview |
+| Flutter | No serial port plugins, Dart FFI to Rust is awkward |
+| Native (GTK/Qt) | Platform-specific UI code, no web component reuse |
+| Web-only (PWA) | Cannot access serial ports or raw UDP |
+
+## Decision
+
+Build a Tauri v2 desktop application as a new crate in the Rust workspace. The frontend uses TypeScript with React and Vite. The Rust backend exposes Tauri commands that bridge the frontend to serial ports, UDP sockets, HTTP management endpoints, and the sensing server process.
+
+### 1. Workspace Integration
+
+Add a new crate to the workspace:
+
+```
+rust-port/wifi-densepose-rs/
+  Cargo.toml                          # Add "crates/wifi-densepose-desktop" to members
+  crates/
+    wifi-densepose-desktop/           # NEW — Tauri app crate
+      Cargo.toml
+      tauri.conf.json
+      capabilities/
+        default.json                  # Tauri v2 capability permissions
+      icons/                          # App icons (all platforms)
+      src/
+        main.rs                       # Tauri entry point
+        lib.rs                        # Command module re-exports
+        commands/
+          mod.rs
+          discovery.rs                # Node discovery commands
+          flash.rs                    # Firmware flashing commands
+          ota.rs                      # OTA update commands
+          wasm.rs                     # WASM module management commands
+          server.rs                   # Sensing server lifecycle commands
+          provision.rs                # NVS provisioning commands
+          serial.rs                   # Serial port enumeration
+        state.rs                      # Tauri managed state
+        discovery/
+          mod.rs
+          mdns.rs                     # mDNS service discovery
+          udp_broadcast.rs            # UDP broadcast probe
+        flash/
+          mod.rs
+          espflash.rs                 # Rust-native ESP32 flashing (via espflash crate)
+          esptool.rs                  # Fallback: bundled esptool.py wrapper
+      frontend/
+        package.json
+        tsconfig.json
+        vite.config.ts
+        index.html
+        src/
+          main.tsx
+          App.tsx
+          routes.tsx
+          hooks/
+            useNodes.ts               # Node discovery and status polling
+            useServer.ts              # Sensing server state
+            useWebSocket.ts           # WS connection to sensing server
+          stores/
+            nodeStore.ts              # Zustand store for discovered nodes
+            serverStore.ts            # Sensing server process state
+            settingsStore.ts          # User preferences (dark mode, ports)
+          pages/
+            Dashboard.tsx             # Hardware management overview
+            NodeDetail.tsx            # Single node detail + config
+            FlashFirmware.tsx         # Firmware flashing wizard
+            WasmModules.tsx           # WASM module manager
+            SensingView.tsx           # Live sensing data visualization
+            MeshTopology.tsx          # Multi-node mesh topology view
+            Settings.tsx              # App settings and preferences
+          components/
+            NodeCard.tsx              # Node status card (health, version, signal)
+            NodeList.tsx              # Discovered node list
+            FirmwareProgress.tsx      # Flash/OTA progress indicator
+            LogViewer.tsx             # Scrolling log output
+            SignalChart.tsx           # Real-time CSI signal chart
+            PoseOverlay.tsx           # Pose skeleton overlay
+            MeshGraph.tsx             # D3/force-graph mesh topology
+            SerialPortSelect.tsx      # Serial port dropdown
+            ProvisionForm.tsx         # NVS provisioning form
+          lib/
+            tauri.ts                  # Typed Tauri invoke wrappers
+            types.ts                  # Shared TypeScript types
+```
+
+### 2. Rust Backend — Tauri Commands
+
+#### 2.1 Node Discovery
+
+```rust
+// commands/discovery.rs
+
+/// Discover ESP32 CSI nodes on the local network.
+/// Strategy 1: mDNS — nodes announce _ruview._tcp service
+/// Strategy 2: UDP broadcast probe on port 5005 (CSI aggregator port)
+/// Strategy 3: HTTP health check sweep on port 8032 (OTA server)
+#[tauri::command]
+async fn discover_nodes(timeout_ms: u64) -> Result<Vec<DiscoveredNode>, String>;
+
+/// Get detailed status from a specific node via HTTP.
+/// Calls GET /ota/status on port 8032.
+#[tauri::command]
+async fn get_node_status(ip: String) -> Result<NodeStatus, String>;
+
+/// Subscribe to node health updates (periodic polling).
+#[tauri::command]
+async fn watch_nodes(interval_ms: u64, state: State<'_, AppState>) -> Result<(), String>;
+```
+
+The `DiscoveredNode` struct:
+
+```rust
+#[derive(Serialize, Deserialize, Clone)]
+pub struct DiscoveredNode {
+    pub ip: String,
+    pub mac: Option<String>,
+    pub hostname: Option<String>,
+    pub node_id: u8,
+    pub firmware_version: Option<String>,
+    pub tdm_slot: Option<u8>,
+    pub tdm_total: Option<u8>,
+    pub edge_tier: Option<u8>,
+    pub uptime_secs: Option<u64>,
+    pub discovery_method: DiscoveryMethod, // Mdns | UdpProbe | HttpSweep
+    pub last_seen: chrono::DateTime<chrono::Utc>,
+}
+```
+
+#### 2.2 Firmware Flashing
+
+```rust
+// commands/flash.rs
+
+/// List available serial ports with chip detection.
+#[tauri::command]
+async fn list_serial_ports() -> Result<Vec<SerialPortInfo>, String>;
+
+/// Flash firmware binary to an ESP32 via serial port.
+/// Uses the `espflash` crate for Rust-native flashing (no Python dependency).
+/// Falls back to bundled esptool.py if espflash fails.
+/// Emits progress events via Tauri event system.
+#[tauri::command]
+async fn flash_firmware(
+    port: String,
+    firmware_path: String,
+    chip: Chip, // Esp32, Esp32s3, Esp32c3
+    baud: Option<u32>,
+    app_handle: AppHandle,
+) -> Result<FlashResult, String>;
+
+/// Read firmware info from a connected ESP32 (chip type, flash size, MAC).
+#[tauri::command]
+async fn read_chip_info(port: String) -> Result<ChipInfo, String>;
+```
+
+Flash progress is emitted as Tauri events:
+
+```rust
+#[derive(Serialize, Clone)]
+pub struct FlashProgress {
+    pub phase: FlashPhase,   // Connecting | Erasing | Writing | Verifying
+    pub progress_pct: f32,   // 0.0 - 100.0
+    pub bytes_written: u64,
+    pub bytes_total: u64,
+    pub speed_bps: u64,
+}
+```
+
+#### 2.3 OTA Updates
+
+```rust
+// commands/ota.rs
+
+/// Push firmware to a node via HTTP OTA (port 8032).
+/// Includes PSK authentication per ADR-050.
+#[tauri::command]
+async fn ota_update(
+    node_ip: String,
+    firmware_path: String,
+    psk: Option<String>,
+    app_handle: AppHandle,
+) -> Result<OtaResult, String>;
+
+/// Get OTA status from a node (current version, partition info).
+#[tauri::command]
+async fn ota_status(node_ip: String, psk: Option<String>) -> Result<OtaStatus, String>;
+
+/// Batch OTA update — push firmware to multiple nodes sequentially.
+/// Skips nodes already running the target version.
+#[tauri::command]
+async fn ota_batch_update(
+    nodes: Vec<String>, // IPs
+    firmware_path: String,
+    psk: Option<String>,
+    app_handle: AppHandle,
+) -> Result<Vec<OtaResult>, String>;
+```
+
+#### 2.4 WASM Module Management
+
+```rust
+// commands/wasm.rs
+
+/// List WASM modules loaded on a node.
+/// Calls GET /wasm/list on port 8032.
+#[tauri::command]
+async fn wasm_list(node_ip: String) -> Result<Vec<WasmModule>, String>;
+
+/// Upload a WASM module to a node.
+/// Calls POST /wasm/upload on port 8032 with binary payload.
+#[tauri::command]
+async fn wasm_upload(
+    node_ip: String,
+    wasm_path: String,
+    app_handle: AppHandle,
+) -> Result<WasmUploadResult, String>;
+
+/// Start/stop a WASM module on a node.
+#[tauri::command]
+async fn wasm_control(
+    node_ip: String,
+    module_id: String,
+    action: WasmAction, // Start | Stop | Unload
+) -> Result<(), String>;
+```
+
+#### 2.5 Sensing Server Lifecycle
+
+```rust
+// commands/server.rs
+
+/// Start the sensing server as a managed child process.
+/// The server binary is either bundled with the Tauri app (sidecar)
+/// or discovered on PATH.
+#[tauri::command]
+async fn start_server(
+    config: ServerConfig,
+    state: State<'_, AppState>,
+    app_handle: AppHandle,
+) -> Result<(), String>;
+
+/// Stop the managed sensing server process.
+#[tauri::command]
+async fn stop_server(state: State<'_, AppState>) -> Result<(), String>;
+
+/// Get sensing server status (running/stopped, PID, ports, uptime).
+#[tauri::command]
+async fn server_status(state: State<'_, AppState>) -> Result<ServerStatus, String>;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct ServerConfig {
+    pub http_port: u16,       // Default: 8080
+    pub ws_port: u16,         // Default: 8765
+    pub udp_port: u16,        // Default: 5005
+    pub static_dir: Option<String>, // Path to UI static files
+    pub model_dir: Option<String>,  // Path to ML models
+    pub log_level: String,    // trace, debug, info, warn, error
+}
+```
+
+The sensing server is bundled as a Tauri sidecar binary. Tauri v2 supports sidecar binaries via `externalBin` in `tauri.conf.json`:
+
+```json
+{
+  "bundle": {
+    "externalBin": ["sensing-server"]
+  }
+}
+```
+
+#### 2.6 NVS Provisioning
+
+```rust
+// commands/provision.rs
+
+/// Provision NVS configuration to an ESP32 via serial port.
+/// Replaces the Python provision.py script with a Rust-native implementation.
+/// Generates NVS partition binary and flashes it to the NVS partition offset.
+#[tauri::command]
+async fn provision_node(
+    port: String,
+    config: NvsConfig,
+    app_handle: AppHandle,
+) -> Result<ProvisionResult, String>;
+
+/// Read current NVS configuration from a connected ESP32.
+/// Reads the NVS partition and parses key-value pairs.
+#[tauri::command]
+async fn read_nvs(port: String) -> Result<NvsConfig, String>;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct NvsConfig {
+    pub wifi_ssid: Option<String>,
+    pub wifi_password: Option<String>,
+    pub target_ip: Option<String>,
+    pub target_port: Option<u16>,
+    pub node_id: Option<u8>,
+    pub tdm_slot: Option<u8>,
+    pub tdm_total: Option<u8>,
+    pub edge_tier: Option<u8>,
+    pub presence_thresh: Option<u16>,
+    pub fall_thresh: Option<u16>,
+    pub vital_window: Option<u16>,
+    pub vital_interval_ms: Option<u16>,
+    pub top_k_count: Option<u8>,
+    pub hop_count: Option<u8>,
+    pub channel_list: Option<Vec<u8>>,
+    pub dwell_ms: Option<u32>,
+    pub power_duty: Option<u8>,
+    pub wasm_max_modules: Option<u8>,
+    pub wasm_verify: Option<bool>,
+    pub wasm_pubkey: Option<Vec<u8>>,
+    pub ota_psk: Option<String>,
+}
+```
+
+### 3. Frontend Architecture
+
+#### 3.1 Tech Stack
+
+| Layer | Choice | Rationale |
+|-------|--------|-----------|
+| Framework | React 19 | Component model, ecosystem, team familiarity |
+| Build | Vite 6 | Fast HMR, Tauri plugin support |
+| State | Zustand | Lightweight, no boilerplate, works with Tauri events |
+| Routing | React Router v7 | File-based routes, type-safe |
+| UI Components | shadcn/ui + Tailwind CSS | Accessible, customizable, no runtime CSS-in-JS |
+| Charts | Recharts or visx | Real-time signal visualization |
+| Topology Graph | D3 force-directed | Mesh network visualization |
+| Serial UI | Custom | Tauri command integration |
+| Icons | Lucide React | Consistent, tree-shakeable |
+
+#### 3.2 Page Layout
+
+```
+------------------------------------------+
+|  RuView                    [Settings] [?] |
+-------+----------------------------------+
+|       |                                  |
+| Nav   |  Dashboard / Active Page         |
+|       |                                  |
+| [D]   |  +--------+ +--------+ +------+ |
+| [F]   |  | Node 1 | | Node 2 | | +Add | |
+| [W]   |  +--------+ +--------+ +------+ |
+| [S]   |                                  |
+| [M]   |  Server Status: Running          |
+| [T]   |  +--------------------------+   |
+|       |  | Live Signal / Pose View  |   |
+|       |  +--------------------------+   |
+-------+----------------------------------+
+|  Status Bar: 3 nodes | Server: :8080     |
+------------------------------------------+
+
+Nav items:
+  [D] Dashboard — overview of all nodes and server
+  [F] Flash — firmware flashing wizard
+  [W] WASM — edge module management
+  [S] Sensing — live sensing data view
+  [M] Mesh — topology visualization
+  [T] Settings — ports, paths, preferences
+```
+
+#### 3.3 Dashboard Page
+
+The dashboard is the primary landing page showing:
+
+1. **Node Grid** — cards for each discovered ESP32 node showing:
+   - IP address and hostname
+   - Firmware version (with update indicator if newer available)
+   - Node ID and TDM slot assignment
+   - Edge processing tier (raw / stats / vitals)
+   - Signal quality indicator (last CSI frame age)
+   - Health status (online/offline/degraded)
+   - Quick actions: OTA update, configure, view logs
+
+2. **Sensing Server Panel** — start/stop button, port configuration, log tail
+
+3. **Discovery Controls** — scan button, auto-discovery toggle, network range filter
+
+#### 3.4 Flash Firmware Page
+
+A wizard-style flow:
+
+1. **Select Port** — dropdown of detected serial ports with chip info
+2. **Select Firmware** — file picker for `.bin` files, or select from bundled builds
+3. **Configure** — chip type, baud rate, flash mode
+4. **Flash** — progress bar with phase indicators (connecting, erasing, writing, verifying)
+5. **Provision** — optional NVS provisioning form (WiFi, target IP, TDM, edge tier)
+6. **Verify** — serial monitor showing boot log, success/fail indicator
+
+#### 3.5 WASM Module Manager Page
+
+| Column | Content |
+|--------|---------|
+| Module ID | Auto-assigned by node |
+| Name | Filename of uploaded `.wasm` |
+| Size | Module size in KB |
+| Status | Running / Stopped / Error |
+| Node | Which ESP32 node it runs on |
+| Actions | Start / Stop / Unload / View Logs |
+
+Upload panel: drag-and-drop `.wasm` file, select target node(s), upload button.
+
+#### 3.6 Sensing View Page
+
+Embeds the existing web UI (`ui/`) via an iframe pointing at the sensing server's static file route, or builds native React components that connect to the same WebSocket API. The native approach is preferred because it allows:
+
+- Tighter integration with the node status sidebar
+- Shared state between hardware management and visualization
+- Offline access to recorded data
+
+Key visualization components:
+- **CSI Heatmap** — subcarrier amplitude over time
+- **Signal Field** — 2D signal strength visualization
+- **Pose Skeleton** — detected body keypoints and connections
+- **Vital Signs** — real-time breathing rate and heart rate charts
+- **Activity Classification** — current activity label with confidence
+
+#### 3.7 Mesh Topology Page
+
+A force-directed graph showing:
+- Nodes as circles (color = health status, size = edge tier)
+- Edges between nodes that can see each other
+- TDM slot labels on each node
+- Sync status indicators (in-sync / drifting / lost)
+- Click a node to navigate to its detail page
+
+### 4. Platform-Specific Considerations
+
+#### 4.1 macOS
+
+- **Serial driver signing**: CP210x and CH340 drivers require user approval in System Preferences > Security
+- **App signing**: Tauri apps must be signed and notarized for distribution outside the App Store
+- **USB permissions**: No special permissions needed beyond driver installation
+- **CoreWLAN**: The sensing server can use CoreWLAN for WiFi scanning (ADR-025); the desktop app inherits this capability
+
+#### 4.2 Windows
+
+- **COM port access**: Windows assigns COM port numbers; the app lists them via the Windows Registry or `SetupDi` API
+- **Driver installation**: USB-to-serial drivers (CP210x, CH340, FTDI) must be installed; the app can detect missing drivers and link to downloads
+- **Firewall**: The sensing server's UDP listener may trigger Windows Firewall prompts; the app should pre-configure rules or guide the user
+- **Code signing**: EV certificate required for SmartScreen trust; unsigned apps trigger warnings
+
+#### 4.3 Linux
+
+- **udev rules**: ESP32 serial ports (`/dev/ttyUSB*`, `/dev/ttyACM*`) require udev rules for non-root access. The app bundles a `99-ruview-esp32.rules` file and offers to install it:
+  ```
+  SUBSYSTEM=="tty", ATTRS{idVendor}=="10c4", MODE="0666"  # CP210x
+  SUBSYSTEM=="tty", ATTRS{idVendor}=="1a86", MODE="0666"  # CH340
+  ```
+- **AppImage/deb/rpm**: Tauri supports all three packaging formats
+- **Wayland vs X11**: Tauri uses webkit2gtk which works on both
+
+### 5. Cargo.toml for the Desktop Crate
+
+```toml
+[package]
+name = "wifi-densepose-desktop"
+version.workspace = true
+edition.workspace = true
+description = "Tauri desktop frontend for RuView WiFi DensePose"
+license.workspace = true
+authors.workspace = true
+
+[lib]
+name = "wifi_densepose_desktop"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = [] }
+tauri-plugin-shell = "2"        # Sidecar process management
+tauri-plugin-dialog = "2"       # File picker dialogs
+tauri-plugin-fs = "2"           # Filesystem access
+tauri-plugin-process = "2"      # Process management
+tauri-plugin-notification = "2" # Desktop notifications
+
+# Workspace crates
+wifi-densepose-hardware = { workspace = true }
+wifi-densepose-config = { workspace = true }
+wifi-densepose-core = { workspace = true }
+
+# Serial port access
+serialport = { workspace = true }
+
+# ESP32 flashing (Rust-native, replaces esptool.py)
+espflash = "3"
+
+# Network discovery
+mdns-sd = "0.11"               # mDNS/DNS-SD service discovery
+
+# HTTP client for OTA and WASM management
+reqwest = { version = "0.12", features = ["json", "multipart", "stream"] }
+
+# Async runtime
+tokio = { workspace = true }
+
+# Serialization
+serde = { workspace = true }
+serde_json = { workspace = true }
+
+# Logging
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+
+# Time
+chrono = { version = "0.4", features = ["serde"] }
+```
+
+### 6. Tauri Configuration
+
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/crates/tauri-config-schema/schema.json",
+  "productName": "RuView",
+  "version": "0.3.0",
+  "identifier": "net.ruv.ruview",
+  "build": {
+    "frontendDist": "../frontend/dist",
+    "devUrl": "http://localhost:5173",
+    "beforeDevCommand": "cd frontend && npm run dev",
+    "beforeBuildCommand": "cd frontend && npm run build"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "RuView - WiFi DensePose",
+        "width": 1280,
+        "height": 800,
+        "minWidth": 900,
+        "minHeight": 600
+      }
+    ]
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "externalBin": ["sensing-server"],
+    "linux": {
+      "deb": { "depends": ["libwebkit2gtk-4.1-0"] },
+      "appimage": { "bundleMediaFramework": true }
+    },
+    "windows": {
+      "wix": { "language": "en-US" }
+    }
+  }
+}
+```
+
+### 7. Tauri v2 Capabilities (Permissions)
+
+```json
+{
+  "identifier": "default",
+  "description": "RuView default capability set",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "shell:allow-execute",
+    "shell:allow-open",
+    "dialog:allow-open",
+    "dialog:allow-save",
+    "fs:allow-read",
+    "fs:allow-write",
+    "process:allow-exit",
+    "notification:default"
+  ]
+}
+```
+
+### 8. Development Workflow
+
+```bash
+# Prerequisites
+cargo install tauri-cli@^2
+cd rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/frontend
+npm install
+
+# Development (hot-reload frontend + Rust rebuild)
+cd rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop
+cargo tauri dev
+
+# Production build
+cargo tauri build
+
+# Build sensing-server sidecar (must be done before tauri build)
+cargo build --release -p wifi-densepose-sensing-server
+# Copy to sidecar location:
+# target/release/sensing-server -> crates/wifi-densepose-desktop/binaries/sensing-server-{arch}
+```
+
+### 9. Persistent Node Registry
+
+Discovery alone is transient — nodes appear when they broadcast, disappear when they don't. A persistent local registry transforms discovery into **reconciliation**.
+
+```
+~/.ruview/nodes.db   (SQLite via rusqlite)
+```
+
+**Schema:**
+
+```sql
+CREATE TABLE nodes (
+    mac         TEXT PRIMARY KEY,        -- e.g. "AA:BB:CC:DD:EE:FF"
+    last_ip     TEXT,                    -- last known IP
+    last_seen   INTEGER NOT NULL,        -- Unix timestamp
+    firmware    TEXT,                    -- e.g. "0.3.1"
+    chip        TEXT DEFAULT 'esp32s3',  -- esp32, esp32s3, esp32c3
+    mesh_role   TEXT DEFAULT 'node',     -- 'coordinator' | 'node' | 'aggregator'
+    tdm_slot    INTEGER,                -- assigned TDM slot index
+    capabilities TEXT,                  -- JSON: {"wasm": true, "ota": true, "csi": true}
+    friendly_name TEXT,                 -- user-assigned label
+    notes       TEXT                    -- free-form notes
+);
+```
+
+**Behavior:**
+
+- On discovery broadcast, upsert into registry (update `last_ip`, `last_seen`, `firmware`)
+- Dashboard shows **all registered nodes**, dimming those not seen recently
+- User can manually add nodes by MAC/IP (for networks without mDNS)
+- Export/import registry as JSON for fleet management across machines
+- Node health history (uptime, last OTA, error count) tracked over time
+
+This means the desktop app **remembers the mesh** across restarts, which is critical for field deployments where nodes may be offline temporarily.
+
+### 10. OTA Safety Gate — Rolling Updates
+
+Mesh deployments cannot tolerate all nodes rebooting simultaneously. The OTA subsystem includes a **rolling update mode** that preserves sensing continuity:
+
+```rust
+#[derive(Serialize, Deserialize)]
+pub struct BatchOtaConfig {
+    /// Update strategy
+    pub strategy: OtaStrategy,
+    /// Max nodes updating concurrently
+    pub max_concurrent: usize,
+    /// Delay between batches (seconds)
+    pub batch_delay_secs: u64,
+    /// Abort if any node fails
+    pub fail_fast: bool,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum OtaStrategy {
+    /// Update one node at a time, wait for it to rejoin mesh
+    Sequential,
+    /// Update non-adjacent TDM slots to maintain coverage
+    TdmSafe,
+    /// Update all nodes simultaneously (development only)
+    Parallel,
+}
+```
+
+**`TdmSafe` strategy:**
+
+1. Sort nodes by TDM slot index
+2. Update even-slot nodes first (slots 0, 2, 4...)
+3. Wait for each to reboot and rejoin mesh (verified via beacon)
+4. Then update odd-slot nodes (slots 1, 3, 5...)
+5. At no point are adjacent nodes offline simultaneously
+
+**UI flow:**
+
+- User selects target firmware + target nodes
+- App shows pre-update diff (current vs new version per node)
+- Progress bar per node with states: `queued → uploading → rebooting → verifying → done`
+- Abort button halts remaining updates without rolling back completed ones
+- Post-update health check confirms all nodes are sensing
+
+### 11. Plugin Architecture (Future)
+
+This desktop tool is quietly becoming the **control plane for RuView**. Once it manages discovery, firmware, OTA, WASM, sensing, and mesh topology, plugin extensibility becomes inevitable:
+
+- **Firmware management** today → **swarm orchestration** tomorrow
+- **WASM upload** today → **edge module marketplace** tomorrow
+- **Sensing view** today → **activity classification dashboard** tomorrow
+
+The Tauri command surface should be designed with this trajectory in mind:
+
+- Commands are grouped by bounded context (already done)
+- Each context can be extended by loading additional Tauri plugins
+- The node registry becomes the source of truth for all plugins
+- Event bus (Tauri's `emit`/`listen`) provides cross-plugin communication
+
+This does NOT mean building a plugin system in Phase 1. It means keeping the architecture open to it: no hardcoded views, state flows through the registry, commands are typed and versioned.
+
+### 12. Security Considerations
+
+1. **PSK Storage**: OTA PSK tokens are stored in the OS keychain via `tauri-plugin-stronghold` or the platform's native credential store, never in plaintext config files.
+
+2. **Serial Port Access**: Tauri's capability system restricts which commands the frontend can invoke. Serial port access is only available through the typed `flash_firmware` and `provision_node` commands, not raw serial I/O.
+
+3. **Network Requests**: OTA and WASM management commands only communicate with nodes on the local network. The app does not make external network requests except for update checks (opt-in).
+
+4. **Firmware Validation**: Before flashing, the app validates the firmware binary header (ESP32 image magic bytes, partition table offset) to prevent bricking.
+
+5. **WASM Signature Verification**: The desktop app can sign WASM modules before upload using a locally stored Ed25519 key pair, complementing the node-side verification (ADR-040).
+
+### 13. Implementation Phases
+
+| Phase | Scope | Effort | Priority |
+|-------|-------|--------|----------|
+| **Phase 1: Skeleton** | Tauri project scaffolding, workspace integration, basic window with React | 1 week | P0 |
+| **Phase 2: Discovery** | Serial port listing, UDP/mDNS node discovery, dashboard with node cards | 1 week | P0 |
+| **Phase 3: Flash** | espflash integration, firmware flashing wizard with progress events | 1 week | P0 |
+| **Phase 4: Server** | Sidecar sensing server start/stop, log viewer, status panel | 1 week | P1 |
+| **Phase 5: OTA** | HTTP OTA with PSK auth, batch update, version comparison | 1 week | P1 |
+| **Phase 6: Provisioning** | NVS read/write via serial, provisioning form, mesh config file | 1 week | P1 |
+| **Phase 7: WASM** | Module upload/list/start/stop, drag-and-drop, per-module logs | 1 week | P2 |
+| **Phase 8: Sensing** | WebSocket integration, live signal charts, pose overlay | 2 weeks | P2 |
+| **Phase 9: Mesh View** | Force-directed topology graph, TDM slot visualization, sync status | 1 week | P2 |
+| **Phase 10: Polish** | App signing, auto-update, udev rules installer, onboarding wizard | 1 week | P3 |
+
+Total estimated effort: ~11 weeks for a single developer.
+
+## Consequences
+
+### Positive
+
+- **Single pane of glass** — all hardware management, sensing, and visualization in one app
+- **No Python dependency** — Rust-native `espflash` replaces `esptool.py` for firmware flashing
+- **Replaces 6+ CLI tools** — flash, provision, OTA, WASM management, server control, visualization
+- **Accessible to non-developers** — GUI replaces CLI flags and curl commands
+- **Cross-platform** — one codebase for Windows, macOS, Linux
+- **Workspace integration** — shares types, config, and hardware crates with sensing server
+- **Small binary** — ~15-20 MB vs ~150 MB for Electron equivalent
+
+### Negative
+
+- **New frontend dependency** — introduces Node.js/npm build step into the Rust workspace
+- **Tauri version churn** — Tauri v2 is recent; API stability is not yet proven at scale
+- **webkit2gtk on Linux** — depends on system webview version; old distros may have stale webkit
+- **espflash limitations** — the `espflash` crate may not support all chip variants or flash modes that `esptool.py` handles; fallback to bundled Python is needed
+- **Maintenance surface** — adds ~5,000 lines of TypeScript and ~2,000 lines of Rust
+
+### Risks
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| espflash cannot flash all ESP32 variants | Medium | High | Bundle esptool.py as fallback sidecar |
+| Tauri v2 breaking changes | Low | Medium | Pin to specific Tauri version; update in dedicated PRs |
+| Serial port access fails on macOS Sequoia+ | Medium | Medium | Test on latest macOS; document driver requirements |
+| webkit2gtk version mismatch on Linux | Medium | Low | Set minimum version in deb/rpm dependencies |
+| Sidecar sensing server fails to start | Low | Medium | Detect failure and show manual start instructions |
+
+## References
+
+- Tauri v2 documentation: https://v2.tauri.app/
+- espflash crate: https://crates.io/crates/espflash
+- mdns-sd crate: https://crates.io/crates/mdns-sd
+- ADR-012: ESP32 CSI Sensor Mesh
+- ADR-039: ESP32 Edge Intelligence
+- ADR-040: WASM Programmable Sensing
+- ADR-044: Provisioning Tool Enhancements
+- ADR-050: Quality Engineering — Security Hardening
+- ADR-051: Sensing Server Decomposition
+- `firmware/esp32-csi-node/` — ESP32 firmware source
+- `firmware/esp32-csi-node/provision.py` — Current provisioning script
+- `rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/` — Sensing server
+- `rust-port/wifi-densepose-rs/crates/wifi-densepose-hardware/` — Hardware crate
+- `ui/` — Existing web UI
@@ -0,0 +1,274 @@
+# ADR-053: UI Design System — Dark Professional + Unity-Inspired Interface
+
+| Field | Value |
+|-------|-------|
+| Status | Accepted |
+| Date | 2026-03-06 |
+| Deciders | ruv |
+| Depends on | ADR-052 (Tauri Desktop Frontend) |
+
+## Context
+
+RuView Desktop (ADR-052) needs a UI design system that communicates precision and control — befitting a hardware management control plane for embedded sensing infrastructure. The interface must handle dense data (CSI heatmaps, node registries, log streams, mesh topologies) without feeling overwhelming, while remaining usable by both engineers and field operators.
+
+Two design inspirations:
+
+1. **Data-first professional tools** — Dense information displays where data speaks for itself. Clean typography, structured layouts, and deliberate use of color for status. The interface shows what matters and hides what doesn't. Think: network monitoring dashboards, embedded systems IDEs, infrastructure control panels.
+
+2. **Unity Editor** — Dockable panel system, inspector/hierarchy/scene separation, property grids, dark professional theme, and dense-but-organized data display. Unity's UI is purpose-built for managing complex real-time systems — exactly what RuView needs.
+
+The combination yields a professional control panel for WiFi sensing infrastructure. Data is organized into scannable panels with clear hierarchy. Status is communicated through consistent color coding. The layout adapts from high-level overview down to individual node details through progressive disclosure.
+
+## Decision
+
+### Design Principles
+
+1. **Data is the interface** — The system reveals patterns through visualization, not through explanation. Every pixel earns its place.
+2. **Precision typography** — Typography is clean and authoritative. Technical values are displayed without ambiguity. Labels are concise.
+3. **Panel-based layout** — Dockable regions inspired by Unity's panel system. The operator can see the entire mesh at a glance, then drill into any node.
+4. **Status through color** — Deliberate color coding: green (online), amber (degraded), red (offline/failed), blue (scanning/new). No gratuitous color.
+5. **Progressive disclosure** — Dashboard shows the overview. Clicking a node reveals its details. Summary first, detail on interaction.
+6. **Dual typography** — Monospace for all technical values (MAC addresses, firmware versions, CSI amplitudes). Sans-serif for labels and descriptions. The contrast signals "data vs. context."
+7. **Powered by rUv** — Subtle branding: footer tagline, about dialog, splash screen.
+
+### Color System
+
+```css
+:root {
+  /* Background layers */
+  --bg-base:        #0d1117;     /* App background */
+  --bg-surface:     #161b22;     /* Panel backgrounds */
+  --bg-elevated:    #1c2333;     /* Cards, modals, dropdowns */
+  --bg-hover:       #242d3d;     /* Hover state */
+  --bg-active:      #2d3748;     /* Active/selected state */
+
+  /* Text hierarchy */
+  --text-primary:   #e6edf3;     /* Headings, primary content */
+  --text-secondary: #8b949e;     /* Labels, descriptions */
+  --text-muted:     #484f58;     /* Disabled, hints, placeholders */
+
+  /* Status indicators */
+  --status-online:  #3fb950;     /* Node online, healthy */
+  --status-warning: #d29922;     /* Degraded, needs attention */
+  --status-error:   #f85149;     /* Offline, failed, critical */
+  --status-info:    #58a6ff;     /* Scanning, discovering, info */
+
+  /* Accent */
+  --accent:         #7c3aed;     /* rUv purple — primary actions */
+  --accent-hover:   #6d28d9;
+
+  /* Borders */
+  --border:         #30363d;
+  --border-active:  #58a6ff;
+
+  /* Data display */
+  --font-mono:      'JetBrains Mono', 'Fira Code', 'Consolas', monospace;
+  --font-sans:      'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+}
+```
+
+### Typography Scale
+
+```css
+/* Typographic hierarchy */
+.heading-xl   { font: 600 28px/1.2 var(--font-sans); }   /* Page titles */
+.heading-lg   { font: 600 20px/1.3 var(--font-sans); }   /* Section titles */
+.heading-md   { font: 600 16px/1.4 var(--font-sans); }   /* Card titles */
+.heading-sm   { font: 600 13px/1.4 var(--font-sans); }   /* Panel labels */
+.body         { font: 400 14px/1.6 var(--font-sans); }   /* Body text */
+.body-sm      { font: 400 12px/1.5 var(--font-sans); }   /* Captions */
+.data         { font: 400 13px/1.4 var(--font-mono); }   /* Technical values */
+.data-lg      { font: 500 18px/1.2 var(--font-mono); }   /* Key metrics */
+```
+
+### Layout System
+
+Three-region layout: navigation sidebar, node list, and detail inspector. Unity's docking system provides the mechanical framework.
+
+```
+--[ Sidebar ]--+--[ Main ]-------------------------------------+
+|               |                                                 |
+| [Nav Items]   |  +--[ Command Bar ]---------------------------+ |
+|               |  | Breadcrumb    | Actions | Search           | |
+| Dashboard     |  +-------+-----------------------------------+ |
+| Nodes         |  |       |                                   | |
+| Flash         |  | Node  |  Detail Inspector                 | |
+| OTA           |  | List  |  (selected node properties)       | |
+| Edge Modules  |  |       |                                   | |
+| Sensing       |  |       |  [Property Grid]                  | |
+| Mesh View     |  |       |  [Status Indicators]              | |
+| Settings      |  |       |  [Action Buttons]                 | |
+|               |  |       |                                   | |
+-[ Status Bar ]+--+-------+-----------------------------------+ |
+| rUv | 3 nodes online | Server: running | Port: 8080           |
+---------------------------------------------------------------+
+```
+
+**Panel behaviors:**
+- Sidebar collapses to icon-only on narrow windows
+- Node List / Inspector split is resizable via drag handle
+- Inspector scrolls independently — drill into any node without losing the list
+- Status Bar shows global system state at a glance (node count, server status, port)
+
+### Component Library
+
+#### 1. NodeCard
+
+```
+-- NodeCard -----------------------------------------------+
+|  [●] ESP32-S3 Node #2              firmware: 0.3.1       |
+|  MAC: AA:BB:CC:DD:EE:FF            TDM Slot: 2/4        |
+|  IP:  192.168.1.42                  Edge Tier: 1          |
+|  Last seen: 3s ago                  [Flash] [OTA] [···]  |
+-----------------------------------------------------------+
+```
+
+Status dot uses `--status-online/warning/error`. Card background shifts on hover.
+
+#### 2. FlashProgress
+
+```
+-- Flash Progress -----------------------------------------+
+|  Flashing firmware to COM3 (ESP32-S3)                     |
+|                                                           |
+|  Phase: Writing                                           |
+|  [████████████████████░░░░░░░░░░]  67.3%                 |
+|  412 KB / 612 KB  •  38.2 KB/s  •  ~5s remaining        |
+-----------------------------------------------------------+
+```
+
+Progress bar uses `--accent` fill with subtle pulse animation during active writes.
+
+#### 3. Mesh Topology View (Three.js)
+
+Interactive 3D visualization of the sensing network. Each node is a sphere. Edges are lines representing signal paths. The coordinator node is visually distinct (larger, outlined ring). Built with **Three.js**, consistent with the existing visualization stack in `ui/observatory/js/` and `ui/components/`.
+
+```
+-- Mesh Topology ------------------------------------------+
+|                                                           |
+|         [Node 0]----[Node 1]                              |
+|            |    \   /   |                                 |
+|            | [Coordinator] |   Coordinator = TDM master    |
+|            |    /   \   |                                 |
+|         [Node 2]----[Node 3]                              |
+|                                                           |
+|  Drift: ±0.3ms  |  Cycle: 50ms  |  4/4 nodes online     |
+-----------------------------------------------------------+
+```
+
+**Three.js implementation details:**
+- Force-directed layout computed on CPU, rendered as `THREE.Group` with `THREE.Mesh` (spheres) and `THREE.Line` (edges)
+- Node spheres use `THREE.MeshPhongMaterial` with emissive color matching `--status-online/warning/error`
+- Edge lines use `THREE.LineBasicMaterial` with opacity mapped to signal strength
+- Coordinator node rendered with `THREE.RingGeometry` outline
+- Camera: `OrbitControls` for pan/zoom/rotate, reset button returns to default view
+- Follows existing patterns: `BufferGeometry` + `BufferAttribute` for dynamic updates (see `ui/observatory/js/subcarrier-manifold.js`)
+- Raycasting for node click → opens detail in Inspector panel
+- Real-time updates as nodes join, leave, or change status — geometry attributes updated per frame
+
+#### 4. PropertyGrid (Unity Inspector-style)
+
+```
+-- Node Inspector -----------------------------------------+
+|  General                                            [▼]  |
+|    MAC Address      AA:BB:CC:DD:EE:FF                    |
+|    IP Address       192.168.1.42                         |
+|    Firmware         0.3.1                                |
+|    Chip             ESP32-S3                             |
+|  TDM Configuration                                 [▼]  |
+|    Slot Index       2                                    |
+|    Total Nodes      4                                    |
+|    Cycle Period     50 ms                                |
+|    Sync Drift       +0.12 ms                             |
+|  WASM Modules                                      [▼]  |
+|    [0] activity_detect  running    12.4 KB    83 us/f    |
+|    [1] vital_monitor    stopped     8.1 KB     — us/f   |
+-----------------------------------------------------------+
+```
+
+Collapsible sections with alternating row backgrounds for scanability.
+
+#### 5. StatusBadge
+
+```
+[● Online]    [◐ Degraded]    [○ Offline]    [↻ Updating]
+```
+
+Small inline badges with status dot, label, and optional tooltip.
+
+#### 6. LogViewer
+
+```
+-- Server Log (auto-scroll) -----------[ Clear ] [ ⏸ ]---+
+| 19:42:01.234 INFO  sensing-server  HTTP on 127.0.0.1:8080|
+| 19:42:01.235 INFO  sensing-server  WS on 127.0.0.1:8765  |
+| 19:42:01.890 INFO  udp_receiver    CSI frame from .42    |
+| 19:42:02.003 WARN  vital_signs     Low signal quality    |
+-----------------------------------------------------------+
+```
+
+Monospace, color-coded by log level (INFO=text, WARN=amber, ERROR=red). Virtual scrolling for performance.
+
+### Spacing and Grid
+
+```css
+/* 4px base grid */
+--space-1: 4px;    /* Tight spacing (within components) */
+--space-2: 8px;    /* Component internal padding */
+--space-3: 12px;   /* Between related elements */
+--space-4: 16px;   /* Card padding, section gaps */
+--space-5: 24px;   /* Between sections */
+--space-6: 32px;   /* Page-level spacing */
+--space-8: 48px;   /* Major section breaks */
+
+/* Panel dimensions */
+--sidebar-width: 220px;
+--sidebar-collapsed: 52px;
+--statusbar-height: 28px;
+--toolbar-height: 44px;
+```
+
+### Animations
+
+Minimal and purposeful:
+- Panel collapse/expand: 200ms ease-out
+- Node card health transition: 300ms (color fade, not flash)
+- Progress bar fill: smooth 60fps CSS transition
+- Mesh graph: Three.js render loop at 60fps, force simulation on requestAnimationFrame
+- No loading spinners — use skeleton placeholders instead
+
+### Branding
+
+- **Splash screen**: rUv logo + "RuView Desktop" + version, 1.5s duration
+- **Status bar**: "Powered by rUv" in `--text-muted`, left-aligned
+- **About dialog**: rUv logo, version, license, links to GitHub and docs
+- **App icon**: Stylized WiFi signal + human silhouette in rUv purple (#7c3aed)
+
+## Consequences
+
+### Positive
+
+- Professional, data-dense UI suitable for hardware management
+- Consistent design language across all 7 pages
+- Dual typography (mono + sans-serif) ensures readability at all information densities
+- Unity-inspired panels feel natural to engineers familiar with IDE/editor tools
+- Dark theme reduces eye strain for extended monitoring sessions
+
+### Negative
+
+- Custom design system means no off-the-shelf component library (shadcn/ui partially usable)
+- Dockable panels add complexity to the layout system
+- Dark-only theme may not suit all users (could add light mode later)
+
+### Neutral
+
+- The design system is CSS-only with React components — no heavy UI framework dependency
+- Component library can be extracted as a separate package if other rUv projects need it
+
+## References
+
+- ADR-052: Tauri Desktop Frontend
+- Unity Editor UI Guidelines: https://docs.unity3d.com/Manual/UIE-USS.html
+- Three.js (existing project dependency): `ui/observatory/js/`, `ui/components/`
+- Inter font: https://rsms.me/inter/
+- JetBrains Mono: https://www.jetbrains.com/lp/mono/
@@ -0,0 +1,115 @@
+# Architecture Decision Records
+
+This folder contains 44 Architecture Decision Records (ADRs) that document every significant technical choice in the RuView / WiFi-DensePose project.
+
+## Why ADRs?
+
+Building a system that turns WiFi signals into human pose estimation involves hundreds of non-obvious decisions: which signal processing algorithms to use, how to bridge ESP32 firmware to a Rust pipeline, whether to run inference on-device or on a server, how to handle multi-person separation with limited subcarriers.
+
+ADRs capture the **context**, **options considered**, **decision made**, and **consequences** for each of these choices. They serve three purposes:
+
+1. **Institutional memory** — Six months from now, anyone (human or AI) can read *why* we chose IIR bandpass filters over FIR for vital sign extraction, not just see the code.
+
+2. **AI-assisted development** — When an AI agent works on this codebase, ADRs give it the constraints and rationale it needs to make changes that align with the existing architecture. Without them, AI-generated code tends to drift — reinventing patterns that already exist, contradicting earlier decisions, or optimizing for the wrong tradeoffs.
+
+3. **Review checkpoints** — Each ADR is a reviewable artifact. When a proposed change touches the architecture, the ADR forces the author to articulate tradeoffs *before* writing code, not after.
+
+### ADRs and Domain-Driven Design
+
+The project uses [Domain-Driven Design](../ddd/) (DDD) to organize code into bounded contexts — each with its own language, types, and responsibilities. ADRs and DDD work together:
+
+- **ADRs define boundaries**: ADR-029 (RuvSense) established multistatic sensing as a separate bounded context from single-node CSI. ADR-042 (CHCI) defined a new aggregate root for coherent channel imaging.
+- **DDD models define the language**: The [RuvSense domain model](../ddd/ruvsense-domain-model.md) defines terms like "coherence gate", "dwell time", and "TDM slot" that ADRs reference precisely.
+- **Together they prevent drift**: An AI agent reading ADR-039 knows that edge processing tiers are configured via NVS keys, not compile-time flags — because the ADR says so. The DDD model tells it which aggregate owns that configuration.
+
+### How ADRs are structured
+
+Each ADR follows a consistent format:
+
+- **Context** — What problem or gap prompted this decision
+- **Decision** — What we chose to do and how
+- **Consequences** — What improved, what got harder, and what risks remain
+- **References** — Related ADRs, papers, and code paths
+
+Statuses: **Proposed** (under discussion), **Accepted** (approved and/or implemented), **Superseded** (replaced by a later ADR).
+
+---
+
+## ADR Index
+
+### Hardware and firmware
+
+| ADR | Title | Status |
+|-----|-------|--------|
+| [ADR-012](ADR-012-esp32-csi-sensor-mesh.md) | ESP32 CSI Sensor Mesh for Distributed Sensing | Accepted (partial) |
+| [ADR-018](ADR-018-esp32-dev-implementation.md) | ESP32 Development Implementation Path | Proposed |
+| [ADR-028](ADR-028-esp32-capability-audit.md) | ESP32 Capability Audit and Witness Record | Accepted |
+| [ADR-029](ADR-029-ruvsense-multistatic-sensing-mode.md) | RuvSense Multistatic Sensing Mode (TDM, channel hopping) | Proposed |
+| [ADR-032](ADR-032-multistatic-mesh-security-hardening.md) | Multistatic Mesh Security Hardening | Accepted |
+| [ADR-039](ADR-039-esp32-edge-intelligence.md) | ESP32-S3 Edge Intelligence Pipeline (on-device vitals) | Accepted (hardware-validated) |
+| [ADR-040](ADR-040-wasm-programmable-sensing.md) | WASM Programmable Sensing (Tier 3) | Accepted |
+| [ADR-041](ADR-041-wasm-module-collection.md) | WASM Module Collection (65 edge modules) | Accepted (hardware-validated) |
+| [ADR-044](ADR-044-provisioning-tool-enhancements.md) | Provisioning Tool Enhancements | Proposed |
+
+### Signal processing and sensing
+
+| ADR | Title | Status |
+|-----|-------|--------|
+| [ADR-013](ADR-013-feature-level-sensing-commodity-gear.md) | Feature-Level Sensing on Commodity Gear | Accepted |
+| [ADR-014](ADR-014-sota-signal-processing.md) | SOTA Signal Processing Algorithms | Accepted |
+| [ADR-021](ADR-021-vital-sign-detection-rvdna-pipeline.md) | Vital Sign Detection (breathing, heart rate) | Partial |
+| [ADR-030](ADR-030-ruvsense-persistent-field-model.md) | Persistent Field Model and Drift Detection | Proposed |
+| [ADR-033](ADR-033-crv-signal-line-sensing-integration.md) | CRV Signal Line Sensing Integration | Proposed |
+| [ADR-037](ADR-037-multi-person-pose-detection.md) | Multi-Person Pose Detection from Single ESP32 | Proposed |
+| [ADR-042](ADR-042-coherent-human-channel-imaging.md) | Coherent Human Channel Imaging (beyond CSI) | Proposed |
+
+### Machine learning and training
+
+| ADR | Title | Status |
+|-----|-------|--------|
+| [ADR-005](ADR-005-sona-self-learning-pose-estimation.md) | SONA Self-Learning for Pose Estimation | Partial |
+| [ADR-006](ADR-006-gnn-enhanced-csi-pattern-recognition.md) | GNN-Enhanced CSI Pattern Recognition | Partial |
+| [ADR-015](ADR-015-public-dataset-training-strategy.md) | Public Dataset Strategy (MM-Fi, Wi-Pose) | Accepted |
+| [ADR-016](ADR-016-ruvector-integration.md) | RuVector Training Pipeline Integration | Accepted |
+| [ADR-017](ADR-017-ruvector-signal-mat-integration.md) | RuVector Signal + MAT Integration | Proposed |
+| [ADR-020](ADR-020-rust-ruvector-ai-model-migration.md) | Migrate AI Inference to Rust (ONNX Runtime) | Accepted |
+| [ADR-023](ADR-023-trained-densepose-model-ruvector-pipeline.md) | Trained DensePose Model with RuVector Pipeline | Proposed |
+| [ADR-024](ADR-024-contrastive-csi-embedding-model.md) | Project AETHER: Contrastive CSI Embeddings | Required |
+| [ADR-027](ADR-027-cross-environment-domain-generalization.md) | Project MERIDIAN: Cross-Environment Generalization | Proposed |
+
+### Platform and UI
+
+| ADR | Title | Status |
+|-----|-------|--------|
+| [ADR-019](ADR-019-sensing-only-ui-mode.md) | Sensing-Only UI with Gaussian Splats | Accepted |
+| [ADR-022](ADR-022-windows-wifi-enhanced-fidelity-ruvector.md) | Windows WiFi Enhanced Fidelity (multi-BSSID) | Partial |
+| [ADR-025](ADR-025-macos-corewlan-wifi-sensing.md) | macOS CoreWLAN WiFi Sensing | Proposed |
+| [ADR-031](ADR-031-ruview-sensing-first-rf-mode.md) | RuView Sensing-First RF Mode | Proposed |
+| [ADR-034](ADR-034-expo-mobile-app.md) | Expo React Native Mobile App | Accepted |
+| [ADR-035](ADR-035-live-sensing-ui-accuracy.md) | Live Sensing UI Accuracy and Data Transparency | Accepted |
+| [ADR-036](ADR-036-rvf-training-pipeline-ui.md) | Training Pipeline UI Integration | Proposed |
+| [ADR-043](ADR-043-sensing-server-ui-api-completion.md) | Sensing Server UI API Completion (14 endpoints) | Accepted |
+
+### Architecture and infrastructure
+
+| ADR | Title | Status |
+|-----|-------|--------|
+| [ADR-001](ADR-001-wifi-mat-disaster-detection.md) | WiFi-Mat Disaster Detection Architecture | Accepted |
+| [ADR-002](ADR-002-ruvector-rvf-integration-strategy.md) | RuVector RVF Integration Strategy | Superseded |
+| [ADR-003](ADR-003-rvf-cognitive-containers-csi.md) | RVF Cognitive Containers for CSI | Proposed |
+| [ADR-004](ADR-004-hnsw-vector-search-fingerprinting.md) | HNSW Vector Search for Fingerprinting | Partial |
+| [ADR-007](ADR-007-post-quantum-cryptography-secure-sensing.md) | Post-Quantum Cryptography for Sensing | Proposed |
+| [ADR-008](ADR-008-distributed-consensus-multi-ap.md) | Distributed Consensus for Multi-AP | Proposed |
+| [ADR-009](ADR-009-rvf-wasm-runtime-edge-deployment.md) | RVF WASM Runtime for Edge Deployment | Proposed |
+| [ADR-010](ADR-010-witness-chains-audit-trail-integrity.md) | Witness Chains for Audit Trail Integrity | Proposed |
+| [ADR-011](ADR-011-python-proof-of-reality-mock-elimination.md) | Proof-of-Reality and Mock Elimination | Proposed |
+| [ADR-026](ADR-026-survivor-track-lifecycle.md) | Survivor Track Lifecycle (MAT crate) | Accepted |
+| [ADR-038](ADR-038-sublinear-goal-oriented-action-planning.md) | Sublinear GOAP for Roadmap Optimization | Proposed |
+
+---
+
+## Related
+
+- [DDD Domain Models](../ddd/) — Bounded context definitions, aggregate roots, and ubiquitous language
+- [User Guide](../user-guide.md) — Setup, API reference, and hardware instructions
+- [Build Guide](../build-guide.md) — Building from source
@@ -0,0 +1,34 @@
+# Domain Models
+
+This folder contains Domain-Driven Design (DDD) specifications for each major subsystem in RuView.
+
+DDD organizes the codebase around the problem being solved — not around technical layers. Each *bounded context* owns its own data, rules, and language. Contexts communicate through domain events, not by sharing mutable state. This makes the system easier to reason about, test, and extend — whether you're a person or an AI agent.
+
+## Models
+
+| Model | What it covers | Bounded Contexts |
+|-------|---------------|------------------|
+| [RuvSense](ruvsense-domain-model.md) | Multistatic WiFi sensing, pose tracking, vital signs, edge intelligence | 7 contexts: Sensing, Coherence, Tracking, Field Model, Longitudinal, Spatial Identity, Edge Intelligence |
+| [Signal Processing](signal-processing-domain-model.md) | SOTA signal processing: phase cleaning, feature extraction, motion analysis | 3 contexts: CSI Preprocessing, Feature Extraction, Motion Analysis |
+| [Training Pipeline](training-pipeline-domain-model.md) | ML training: datasets, model architecture, embeddings, domain generalization | 4 contexts: Dataset Management, Model Architecture, Training Orchestration, Embedding & Transfer |
+| [Hardware Platform](hardware-platform-domain-model.md) | ESP32 firmware, edge intelligence, WASM runtime, aggregation, provisioning | 5 contexts: Sensor Node, Edge Processing, WASM Runtime, Aggregation, Provisioning |
+| [Sensing Server](sensing-server-domain-model.md) | Single-binary Axum server: CSI ingestion, model management, recording, training, visualization | 5 contexts: CSI Ingestion, Model Management, CSI Recording, Training Pipeline, Visualization |
+| [WiFi-Mat](wifi-mat-domain-model.md) | Disaster response: survivor detection, START triage, mass casualty assessment | 3 contexts: Detection, Localization, Alerting |
+| [CHCI](chci-domain-model.md) | Coherent Human Channel Imaging: sub-millimeter body surface reconstruction | 3 contexts: Sounding, Channel Estimation, Imaging |
+
+## How to read these
+
+Each model defines:
+
+- **Ubiquitous Language** — Terms with precise meanings used in both code and conversation
+- **Bounded Contexts** — Independent subsystems with clear responsibilities and boundaries
+- **Aggregates** — Clusters of objects that enforce business rules (e.g., a PoseTrack owns its keypoints)
+- **Value Objects** — Immutable data with meaning (e.g., a CoherenceScore is not just a float)
+- **Domain Events** — Things that happened that other contexts may care about
+- **Invariants** — Rules that must always be true (e.g., "drift alert requires >2sigma for >3 days")
+- **Anti-Corruption Layers** — Adapters that translate between contexts without leaking internals
+
+## Related
+
+- [Architecture Decision Records](../adr/README.md) — Why each technical choice was made
+- [User Guide](../user-guide.md) — Setup and API reference
@@ -0,0 +1,648 @@
+# Deployment Platform Domain Model
+
+The Deployment Platform domain covers everything from cross-compiling the sensing server for ARM targets to managing TV box appliances running Armbian: provisioning devices, deploying binaries, configuring kiosk displays, and coordinating multi-room installations. It bridges the gap between the Sensing Server domain (which produces the binary) and the physical hardware it runs on.
+
+This document defines the system using [Domain-Driven Design](https://martinfowler.com/bliki/DomainDrivenDesign.html) (DDD): bounded contexts that own their data and rules, aggregate roots that enforce invariants, value objects that carry meaning, and domain events that connect everything.
+
+**Bounded Contexts:**
+
+| # | Context | Responsibility | Key ADRs | Code |
+|---|---------|----------------|----------|------|
+| 1 | [Appliance Management](#1-appliance-management-context) | Device inventory, provisioning, health monitoring, OTA updates for TV box deployments | [ADR-046](../adr/ADR-046-android-tv-box-armbian-deployment.md) | `scripts/deploy/`, `config/armbian/` |
+| 2 | [Cross-Compilation](#2-cross-compilation-context) | Build pipeline for aarch64, binary packaging, CI/CD release artifacts | [ADR-046](../adr/ADR-046-android-tv-box-armbian-deployment.md) | `.github/workflows/`, `Cross.toml` |
+| 3 | [Display Kiosk](#3-display-kiosk-context) | HDMI output management, Chromium kiosk mode, screen rotation, auto-start | [ADR-046](../adr/ADR-046-android-tv-box-armbian-deployment.md) | `config/armbian/kiosk/` |
+| 4 | [WiFi CSI Bridge](#4-wifi-csi-bridge-context) | Custom WiFi driver CSI extraction, protocol translation to ESP32 binary format | [ADR-046](../adr/ADR-046-android-tv-box-armbian-deployment.md) | `tools/csi-bridge/` |
+| 5 | [Network Topology](#5-network-topology-context) | ESP32 mesh ↔ TV box connectivity, dedicated AP mode, multi-room routing | [ADR-046](../adr/ADR-046-android-tv-box-armbian-deployment.md), [ADR-012](../adr/ADR-012-esp32-csi-sensor-mesh.md) | `config/armbian/network/` |
+
+---
+
+## Domain-Driven Design Specification
+
+### Ubiquitous Language
+
+| Term | Definition |
+|------|------------|
+| **Appliance** | A TV box running Armbian with the sensing server deployed, treated as a managed device in the fleet |
+| **Fleet** | The set of all appliances across a multi-room or multi-site installation |
+| **Deployment Package** | A self-contained archive containing the sensing-server binary, systemd unit, configuration, and setup script for a target architecture |
+| **Kiosk Mode** | Chromium running in full-screen, no-UI mode pointing at `localhost:3000`, auto-started by systemd on HDMI-connected appliances |
+| **CSI Bridge** | A userspace daemon that reads CSI data from a patched WiFi driver and re-encodes it as ESP32-compatible UDP frames for the sensing server |
+| **Dedicated AP** | An optional `hostapd`-managed WiFi access point on the TV box that creates an isolated network for ESP32 nodes |
+| **OTA Update** | Over-the-air binary replacement: download new sensing-server binary, validate checksum, swap via atomic rename, restart service |
+| **Reference Device** | A TV box model that has been tested and validated for Armbian + sensing-server deployment (e.g., T95 Max+ / S905X3) |
+| **Provisioning** | First-time setup of an appliance: flash Armbian to SD, deploy package, configure WiFi, start services |
+| **Health Beacon** | Periodic JSON payload sent by each appliance to a central coordinator (if multi-room) containing uptime, CPU temp, memory usage, inference latency, connected ESP32 count |
+
+---
+
+## Bounded Contexts
+
+### 1. Appliance Management Context
+
+**Responsibility:** Track deployed TV box appliances, provision new devices, monitor health, and coordinate OTA updates across the fleet.
+
+```
+------------------------------------------------------------+
+|            Appliance Management Context                    |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  Device        |    |  Provisioning  |                  |
+|  |  Registry      |    |  Service       |                  |
+|  |  (fleet state) |    |  (first-time   |                  |
+|  |                |    |   setup)       |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Health Monitor   |                             |
+|          |  (beacon receiver,|                             |
+|          |   thermal alerts, |                             |
+|          |   connectivity)   |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  OTA Updater      |                             |
+|          |  (binary swap,    |                             |
+|          |   rollback,       |                             |
+|          |   checksum verify)|                             |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Aggregates:**
+
+```rust
+/// Aggregate Root: A managed TV box appliance in the fleet.
+/// Identified by MAC address of the primary Ethernet interface.
+pub struct Appliance {
+    /// Unique device identifier (Ethernet MAC address).
+    pub device_id: DeviceId,
+    /// Human-readable name (e.g., "living-room", "bedroom-1").
+    pub name: String,
+    /// Hardware model (e.g., "T95 Max+ S905X3").
+    pub hardware_model: HardwareModel,
+    /// Current deployment state.
+    pub state: ApplianceState,
+    /// Installed sensing-server version.
+    pub server_version: SemanticVersion,
+    /// Network configuration.
+    pub network: NetworkConfig,
+    /// Last received health beacon.
+    pub last_health: Option<HealthBeacon>,
+    /// Provisioning timestamp.
+    pub provisioned_at: DateTime<Utc>,
+    /// Connected ESP32 node IDs (from last beacon).
+    pub connected_nodes: Vec<u8>,
+}
+
+/// Lifecycle states for an appliance.
+pub enum ApplianceState {
+    /// SD card prepared, not yet booted.
+    Provisioned,
+    /// Booted and running, health beacons received.
+    Online,
+    /// No health beacon for >5 minutes.
+    Unreachable,
+    /// OTA update in progress.
+    Updating,
+    /// Manual maintenance / stopped.
+    Offline,
+    /// Thermal throttling or hardware issue detected.
+    Degraded,
+}
+```
+
+**Value Objects:**
+
+```rust
+/// Hardware model specification for a TV box.
+pub struct HardwareModel {
+    /// Marketing name (e.g., "T95 Max+").
+    pub name: String,
+    /// SoC identifier (e.g., "Amlogic S905X3").
+    pub soc: String,
+    /// WiFi chipset (e.g., "RTL8822CS").
+    pub wifi_chipset: String,
+    /// Total RAM in MB.
+    pub ram_mb: u32,
+    /// eMMC storage in GB.
+    pub emmc_gb: u32,
+    /// Whether CSI bridge is supported for this WiFi chipset.
+    pub csi_bridge_supported: bool,
+    /// Armbian device tree name (e.g., "meson-sm1-sei610").
+    pub armbian_dtb: String,
+}
+
+/// Periodic health report from an appliance.
+pub struct HealthBeacon {
+    pub device_id: DeviceId,
+    pub timestamp: DateTime<Utc>,
+    pub uptime_secs: u64,
+    pub cpu_temp_celsius: f32,
+    pub cpu_usage_percent: f32,
+    pub memory_used_mb: u32,
+    pub memory_total_mb: u32,
+    pub disk_used_percent: f32,
+    pub inference_latency_ms: f32,
+    pub connected_esp32_nodes: Vec<u8>,
+    pub server_version: SemanticVersion,
+    pub csi_frames_per_sec: f32,
+    pub websocket_clients: u32,
+}
+
+/// Network configuration for an appliance.
+pub struct NetworkConfig {
+    /// Primary IP address (Ethernet or WiFi client).
+    pub ip_address: IpAddr,
+    /// Whether the appliance runs a dedicated AP for ESP32 nodes.
+    pub dedicated_ap: Option<DedicatedApConfig>,
+    /// UDP port for ESP32 CSI reception.
+    pub csi_udp_port: u16,  // default: 5005
+    /// HTTP port for sensing server.
+    pub http_port: u16,     // default: 3000
+}
+
+/// Configuration for a dedicated WiFi AP hosted by the appliance.
+pub struct DedicatedApConfig {
+    /// SSID for the ESP32 mesh network.
+    pub ssid: String,
+    /// WPA2 passphrase.
+    pub passphrase: String,
+    /// Channel (1-11 for 2.4 GHz).
+    pub channel: u8,
+    /// DHCP range for connected ESP32 nodes.
+    pub dhcp_range: (IpAddr, IpAddr),
+}
+
+/// Unique device identifier (Ethernet MAC).
+pub struct DeviceId(pub [u8; 6]);
+
+/// Semantic version for tracking installed software.
+pub struct SemanticVersion {
+    pub major: u16,
+    pub minor: u16,
+    pub patch: u16,
+    pub pre: Option<String>,
+}
+```
+
+**Domain Services:**
+- `ProvisioningService` — Generates Armbian SD card image with pre-configured deployment package, WiFi credentials, and systemd units
+- `HealthMonitorService` — Listens for UDP health beacons from fleet appliances, triggers alerts on thermal throttling (>80°C), unreachable (>5 min), or high memory usage (>90%)
+- `OtaUpdateService` — Downloads new binary from release URL, verifies SHA-256 checksum, performs atomic swap (`rename(new, current)`), restarts systemd service, rolls back if health beacon fails within 60s
+
+**Invariants:**
+- Device ID (MAC address) is immutable after provisioning
+- OTA update refuses to proceed if current CPU temperature >75°C (thermal headroom)
+- Rollback is automatic if no healthy beacon is received within 60 seconds of restart
+- Dedicated AP SSID must not match the upstream WiFi SSID
+
+---
+
+### 2. Cross-Compilation Context
+
+**Responsibility:** Build the sensing-server binary for ARM64 targets, package deployment archives, and manage CI/CD release artifacts.
+
+```
+------------------------------------------------------------+
+|           Cross-Compilation Context                        |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  Cross.toml    |    |  GitHub Actions|                  |
+|  |  (target cfg)  |    |  CI Matrix     |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Build Pipeline   |                             |
+|          |  (cross build     |                             |
+|          |   --target        |                             |
+|          |   aarch64-unknown-|                             |
+|          |   linux-gnu)      |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  Binary Packager  |                             |
+|          |  (strip, compress,|---> .tar.gz artifact        |
+|          |   bundle assets,  |                             |
+|          |   systemd units)  |                             |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Value Objects:**
+
+```rust
+/// A packaged deployment archive for a target platform.
+pub struct DeploymentPackage {
+    /// Target triple (e.g., "aarch64-unknown-linux-gnu").
+    pub target: String,
+    /// Sensing server binary (stripped).
+    pub binary: PathBuf,
+    /// Binary size in bytes.
+    pub binary_size: u64,
+    /// SHA-256 checksum of the binary.
+    pub checksum: String,
+    /// Systemd service unit file.
+    pub service_unit: String,
+    /// Static web UI assets directory.
+    pub ui_assets: PathBuf,
+    /// Armbian configuration files (kiosk, network, etc.).
+    pub config_files: Vec<PathBuf>,
+    /// Setup script (runs on first boot).
+    pub setup_script: PathBuf,
+    /// Version being packaged.
+    pub version: SemanticVersion,
+}
+
+/// Build target specification.
+pub struct BuildTarget {
+    /// Rust target triple.
+    pub triple: String,
+    /// CPU architecture description.
+    pub arch: String,
+    /// Whether NEON SIMD is available.
+    pub has_neon: bool,
+    /// Cross-compilation Docker image.
+    pub cross_image: String,
+    /// Binary size limit in bytes.
+    pub size_limit: u64,
+}
+```
+
+**Supported Targets:**
+
+| Target Triple | Architecture | Use Case | Size Limit |
+|---------------|-------------|----------|------------|
+| `x86_64-unknown-linux-gnu` | x86-64 | PC/laptop (existing) | 30 MB |
+| `aarch64-unknown-linux-gnu` | ARM64 | TV box (Armbian) | 15 MB |
+| `armv7-unknown-linux-gnueabihf` | ARMv7 | Older TV boxes (32-bit) | 12 MB |
+| `x86_64-pc-windows-msvc` | x86-64 | Windows (existing) | 30 MB |
+
+**Invariants:**
+- Stripped binary must be under size limit for target
+- SHA-256 checksum is computed and included in every deployment package
+- UI assets are embedded in binary via `include_dir!` or bundled alongside
+- No native GPU dependencies — CPU-only inference (candle or ONNX Runtime)
+
+---
+
+### 3. Display Kiosk Context
+
+**Responsibility:** Manage HDMI output on TV box appliances, running Chromium in kiosk mode to display the sensing dashboard full-screen on boot.
+
+```
+------------------------------------------------------------+
+|              Display Kiosk Context                         |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  systemd       |    |  Chromium      |                  |
+|  |  autologin +   |    |  Kiosk Launch  |                  |
+|  |  X11/Wayland   |    |  (full-screen, |                  |
+|  |  session       |    |   no-UI bars)  |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Display Manager  |                             |
+|          |  (resolution,     |                             |
+|          |   rotation,       |                             |
+|          |   overscan,       |                             |
+|          |   sleep/wake)     |                             |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Value Objects:**
+
+```rust
+/// Display configuration for kiosk mode.
+pub struct KioskConfig {
+    /// URL to display (default: "http://localhost:3000").
+    pub url: String,
+    /// Screen rotation in degrees (0, 90, 180, 270).
+    pub rotation: u16,
+    /// Whether to hide the mouse cursor.
+    pub hide_cursor: bool,
+    /// Auto-refresh interval in seconds (0 = disabled).
+    pub auto_refresh_secs: u32,
+    /// Display sleep schedule (e.g., off 23:00-06:00).
+    pub sleep_schedule: Option<SleepSchedule>,
+    /// Overscan compensation percentage (0-10).
+    pub overscan_percent: u8,
+}
+
+/// Sleep schedule for display power management.
+pub struct SleepSchedule {
+    /// Time to turn display off (HH:MM local time).
+    pub sleep_time: String,
+    /// Time to turn display on (HH:MM local time).
+    pub wake_time: String,
+}
+```
+
+**Invariants:**
+- Chromium kiosk starts only after sensing-server systemd unit is `active`
+- If Chromium crashes, systemd restarts it within 5 seconds (`Restart=always`)
+- Display sleep/wake uses CEC commands (HDMI-CEC) to control TV power when available
+- No browser UI elements are visible (address bar, scrollbars, etc.)
+
+---
+
+### 4. WiFi CSI Bridge Context
+
+**Responsibility:** Extract CSI data from patched WiFi drivers on the TV box and translate it into ESP32-compatible binary frames for the sensing server. This is the Phase 2 custom firmware path.
+
+```
+------------------------------------------------------------+
+|              WiFi CSI Bridge Context                       |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  Patched WiFi  |    |  CSI Reader    |                  |
+|  |  Driver        |    |  (Netlink /    |                  |
+|  |  (kernel space)|    |   procfs /     |                  |
+|  |  CSI hooks     |    |   UDP socket)  |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Protocol         |                             |
+|          |  Translator       |                             |
+|          |  (chipset CSI →   |                             |
+|          |   ESP32 binary    |                             |
+|          |   0xC5100001)     |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  UDP Sender       |                             |
+|          |  (localhost:5005) |---> sensing-server           |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Value Objects:**
+
+```rust
+/// Raw CSI extraction from a WiFi chipset.
+pub struct ChipsetCsiFrame {
+    /// Source chipset type.
+    pub chipset: WifiChipset,
+    /// Timestamp of extraction (kernel monotonic clock).
+    pub timestamp_us: u64,
+    /// Number of subcarriers (varies by chipset and bandwidth).
+    pub n_subcarriers: u16,
+    /// Number of spatial streams / antennas.
+    pub n_streams: u8,
+    /// Channel frequency in MHz.
+    pub freq_mhz: u16,
+    /// Bandwidth (20/40/80/160 MHz).
+    pub bandwidth_mhz: u16,
+    /// RSSI in dBm.
+    pub rssi_dbm: i8,
+    /// Noise floor estimate in dBm.
+    pub noise_floor_dbm: i8,
+    /// Complex CSI values (I/Q pairs) per subcarrier per stream.
+    pub csi_matrix: Vec<Complex<f32>>,
+    /// Source MAC address (BSSID of the AP being measured).
+    pub source_mac: [u8; 6],
+}
+
+/// Supported WiFi chipsets for CSI extraction.
+pub enum WifiChipset {
+    /// Broadcom BCM43455 via Nexmon CSI patches.
+    BroadcomBcm43455,
+    /// Realtek RTL8822CS via modified rtw88 driver.
+    RealtekRtl8822cs,
+    /// MediaTek MT7661 via mt76 driver modification.
+    MediatekMt7661,
+}
+
+/// Translated frame in ESP32 binary protocol (ADR-018).
+pub struct Esp32CompatFrame {
+    /// Magic: 0xC5100001
+    pub magic: u32,
+    /// Virtual node ID assigned to this WiFi interface.
+    pub node_id: u8,
+    /// Number of antennas / spatial streams.
+    pub n_antennas: u8,
+    /// Number of subcarriers (resampled to match ESP32 format).
+    pub n_subcarriers: u8,
+    /// Frequency in MHz.
+    pub freq_mhz: u16,
+    /// Sequence number (monotonic counter).
+    pub sequence: u32,
+    /// RSSI in dBm.
+    pub rssi: i8,
+    /// Noise floor in dBm.
+    pub noise_floor: i8,
+    /// Amplitude values (extracted from complex CSI).
+    pub amplitudes: Vec<f32>,
+    /// Phase values (extracted from complex CSI).
+    pub phases: Vec<f32>,
+}
+```
+
+**Domain Services:**
+- `CsiExtractionService` — Reads raw CSI from patched driver via Netlink socket (BCM43455), procfs (RTL8822CS), or UDP (MT7661)
+- `SubcarrierResamplerService` — Resamples chipset-specific subcarrier counts to match ESP32 format (e.g., 256 → 128 via decimation or interpolation)
+- `ProtocolTranslatorService` — Converts `ChipsetCsiFrame` to `Esp32CompatFrame` with ADR-018 binary encoding
+- `CalibrationService` — Compensates for chipset-specific phase offsets, antenna spacing, and gain differences relative to ESP32 CSI
+
+**Invariants:**
+- Bridge assigns virtual `node_id` in range 200-254 (reserved for non-ESP32 sources) to avoid collision with physical ESP32 node IDs (1-199)
+- Subcarrier resampling preserves frequency ordering (lowest to highest)
+- Phase values are unwrapped before encoding (continuous, not wrapped to ±π)
+- Bridge daemon starts only if a compatible patched driver is detected at boot
+
+---
+
+### 5. Network Topology Context
+
+**Responsibility:** Manage network connectivity between ESP32 sensor nodes and TV box appliances, including optional dedicated AP mode and multi-room routing.
+
+```
+------------------------------------------------------------+
+|            Network Topology Context                        |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  hostapd       |    |  DHCP Server   |                  |
+|  |  (dedicated AP |    |  (dnsmasq for  |                  |
+|  |   for ESP32    |    |   ESP32 nodes) |                  |
+|  |   mesh)        |    |                |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Topology Manager |                             |
+|          |  (node discovery, |                             |
+|          |   IP assignment,  |                             |
+|          |   route config)   |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  Firewall Rules   |                             |
+|          |  (iptables/nft:   |                             |
+|          |   allow UDP 5005, |                             |
+|          |   block external  |                             |
+|          |   access to ESP32 |                             |
+|          |   subnet)         |                             |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Value Objects:**
+
+```rust
+/// Network topology for a single-room deployment.
+pub struct RoomTopology {
+    /// Appliance acting as the aggregator.
+    pub appliance: DeviceId,
+    /// Whether the appliance runs a dedicated AP.
+    pub dedicated_ap: bool,
+    /// Connected ESP32 nodes with their assigned IPs.
+    pub nodes: Vec<EspNodeConnection>,
+    /// Upstream network interface (Ethernet or WiFi client).
+    pub uplink_interface: String,
+    /// Sensing network interface (dedicated AP or same as uplink).
+    pub sensing_interface: String,
+}
+
+/// An ESP32 node's network connection to the appliance.
+pub struct EspNodeConnection {
+    /// ESP32 node ID (from firmware NVS).
+    pub node_id: u8,
+    /// MAC address of the ESP32.
+    pub mac: [u8; 6],
+    /// Assigned IP address (via DHCP or static).
+    pub ip: IpAddr,
+    /// Last CSI frame received timestamp.
+    pub last_seen: DateTime<Utc>,
+    /// Average CSI frames per second from this node.
+    pub fps: f32,
+}
+```
+
+**Domain Services:**
+- `DedicatedApService` — Configures `hostapd` to create a WPA2 AP on the TV box's WiFi interface, assigns DHCP range via `dnsmasq`, sets up IP forwarding
+- `NodeDiscoveryService` — Monitors UDP port 5005 for new ESP32 node IDs, registers them in the topology, alerts on node departure (no frames for >30s)
+- `FirewallService` — Configures `nftables`/`iptables` to isolate the ESP32 subnet from the upstream LAN, allowing only UDP 5005 inbound and HTTP 3000 outbound
+
+**Invariants:**
+- Dedicated AP uses a separate WiFi interface or virtual interface (not the uplink)
+- ESP32 subnet is isolated from upstream LAN by default (firewall rules)
+- If dedicated AP is disabled, ESP32 nodes must be on the same LAN subnet as the appliance
+- Node discovery does not require mDNS or any discovery protocol — ESP32 nodes are configured with the appliance's IP via NVS provisioning (ADR-044)
+
+---
+
+## Domain Events
+
+| Event | Published By | Consumed By | Payload |
+|-------|-------------|-------------|---------|
+| `ApplianceProvisioned` | Appliance Mgmt | Fleet Dashboard | `{ device_id, name, hardware_model, ip }` |
+| `ApplianceOnline` | Appliance Mgmt | Fleet Dashboard | `{ device_id, server_version, uptime }` |
+| `ApplianceUnreachable` | Appliance Mgmt | Fleet Dashboard, Alerting | `{ device_id, last_seen, reason }` |
+| `ApplianceDegraded` | Appliance Mgmt | Fleet Dashboard, Alerting | `{ device_id, cpu_temp, reason }` |
+| `OtaUpdateStarted` | Appliance Mgmt | Fleet Dashboard | `{ device_id, from_version, to_version }` |
+| `OtaUpdateCompleted` | Appliance Mgmt | Fleet Dashboard | `{ device_id, new_version, duration_secs }` |
+| `OtaUpdateRolledBack` | Appliance Mgmt | Fleet Dashboard, Alerting | `{ device_id, attempted_version, rollback_version, reason }` |
+| `BinaryBuilt` | Cross-Compilation | Release Pipeline | `{ target, version, binary_size, checksum }` |
+| `DeploymentPackageCreated` | Cross-Compilation | Appliance Mgmt | `{ target, version, package_url }` |
+| `KioskStarted` | Display Kiosk | Appliance Mgmt | `{ device_id, url, resolution }` |
+| `KioskCrashed` | Display Kiosk | Appliance Mgmt | `{ device_id, exit_code, restart_count }` |
+| `CsiBridgeStarted` | WiFi CSI Bridge | Appliance Mgmt, Sensing Server | `{ device_id, chipset, virtual_node_id }` |
+| `CsiBridgeFailed` | WiFi CSI Bridge | Appliance Mgmt | `{ device_id, chipset, error }` |
+| `EspNodeDiscovered` | Network Topology | Appliance Mgmt | `{ appliance_id, node_id, mac, ip }` |
+| `EspNodeLost` | Network Topology | Appliance Mgmt, Alerting | `{ appliance_id, node_id, last_seen }` |
+| `DedicatedApStarted` | Network Topology | Appliance Mgmt | `{ appliance_id, ssid, channel }` |
+
+---
+
+## Context Map
+
+```
+-------------------+          +---------------------+
+| Appliance         |--------->|  Fleet Dashboard    |
+| Management        | events   |  (external UI for   |
+| (fleet state)     | -------> |   multi-room mgmt)  |
+--------+----------+          +---------------------+
+         |
+         | provisions, monitors
+         v
+-------------------+          +---------------------+
+| Cross-Compilation |--------->| GitHub Releases     |
+| (build pipeline)  | uploads  | (binary artifacts)  |
+-------------------+          +---------------------+
+         |
+         | provides binary
+         v
+-------------------+          +---------------------+
+| Display Kiosk     |--------->| Sensing Server      |
+| (Chromium on      | loads    | (upstream domain,   |
+|  HDMI output)     | UI from  |  produces web UI)   |
+-------------------+          +----------+----------+
+                                          ^
+-------------------+                     |
+| WiFi CSI Bridge   |-----UDP 5005------>|
+| (patched driver)  |  ESP32 compat      |
+-------------------+  frames            |
+                                          |
+-------------------+                     |
+| Network Topology  |-----UDP 5005------>|
+| (ESP32 mesh       |  ESP32 frames      |
+|  connectivity)    |                     |
+-------------------+                     |
+```
+
+**Relationships:**
+
+| Upstream | Downstream | Relationship | Mechanism |
+|----------|-----------|--------------|-----------|
+| Cross-Compilation | Appliance Mgmt | Supplier-Consumer | Build produces binary; Appliance Mgmt deploys it |
+| Appliance Mgmt | Display Kiosk | Customer-Supplier | Appliance Mgmt starts kiosk after server is healthy |
+| WiFi CSI Bridge | Sensing Server (external) | Conformist | Bridge adapts its output to match ESP32 binary protocol (ADR-018) |
+| Network Topology | Sensing Server (external) | Shared Kernel | Both depend on UDP port 5005 and ESP32 node ID scheme |
+| Appliance Mgmt | Network Topology | Customer-Supplier | Appliance config determines whether dedicated AP is enabled |
+
+---
+
+## Anti-Corruption Layers
+
+### ESP32 Protocol ACL (CSI Bridge)
+
+The WiFi CSI Bridge translates chipset-specific CSI formats (Nexmon, rtw88, mt76) into the ESP32 binary protocol (ADR-018). The sensing server never knows whether frames came from a real ESP32 or a TV box WiFi chipset. Virtual node IDs (200-254) prevent collision with physical ESP32 IDs but are otherwise treated identically by the ingestion context.
+
+### Armbian Platform ACL
+
+Appliance Management abstracts over Armbian specifics (device tree names, boot configuration, dtb overlays) through the `HardwareModel` value object. Higher-level contexts (Cross-Compilation, Display Kiosk) depend only on the target triple (`aarch64-unknown-linux-gnu`) and systemd service interface, not on Amlogic/Allwinner/Rockchip kernel specifics.
+
+### Fleet Coordination ACL
+
+For multi-room deployments, each appliance is self-contained (runs its own sensing server, display, and network). The fleet dashboard reads health beacons but never controls individual appliances directly. OTA updates are pulled by each appliance (not pushed), maintaining the appliance as the authority over its own state.
+
+---
+
+## Related
+
+- [ADR-046: Android TV Box / Armbian Deployment](../adr/ADR-046-android-tv-box-armbian-deployment.md) — Primary architectural decision
+- [ADR-012: ESP32 CSI Sensor Mesh](../adr/ADR-012-esp32-csi-sensor-mesh.md) — ESP32 mesh network design
+- [ADR-018: Dev Implementation](../adr/ADR-018-dev-implementation.md) — ESP32 binary CSI protocol
+- [ADR-039: Edge Intelligence](../adr/ADR-039-esp32-edge-intelligence.md) — On-device processing tiers
+- [ADR-044: Provisioning Tool](../adr/ADR-044-provisioning-tool-enhancements.md) — NVS provisioning for ESP32 nodes
+- [Hardware Platform Domain Model](hardware-platform-domain-model.md) — Upstream domain (ESP32 hardware)
+- [Sensing Server Domain Model](sensing-server-domain-model.md) — Upstream domain (server software)
@@ -1,12 +1,32 @@
 # RuvSense Domain Model

+RuvSense is the multistatic WiFi sensing subsystem of RuView. It turns raw radio signals from multiple ESP32 sensors into tracked human poses, vital signs, and spatial awareness — all without cameras.
+
+This document defines the system using [Domain-Driven Design](https://martinfowler.com/bliki/DomainDrivenDesign.html) (DDD): bounded contexts that own their data and rules, aggregate roots that enforce invariants, value objects that carry meaning, and domain events that connect everything. The goal is to make the system's structure match the physics it models — so that anyone reading the code (or an AI agent modifying it) understands *why* each piece exists, not just *what* it does.
+
+**Bounded Contexts:**
+
+| # | Context | Responsibility | Key ADRs | Code |
+|---|---------|----------------|----------|------|
+| 1 | [Multistatic Sensing](#1-multistatic-sensing-context) | Collect and fuse CSI from multiple nodes and channels | [ADR-029](../adr/ADR-029-ruvsense-multistatic-sensing-mode.md) | `signal/src/ruvsense/{multiband,phase_align,multistatic}.rs` |
+| 2 | [Coherence](#2-coherence-context) | Monitor signal quality, gate bad data | [ADR-029](../adr/ADR-029-ruvsense-multistatic-sensing-mode.md) | `signal/src/ruvsense/{coherence,coherence_gate}.rs` |
+| 3 | [Pose Tracking](#3-pose-tracking-context) | Track people as persistent skeletons with re-ID | [ADR-024](../adr/ADR-024-contrastive-csi-embedding-model.md), [ADR-037](../adr/ADR-037-multi-person-pose-detection.md) | `signal/src/ruvsense/pose_tracker.rs` |
+| 4 | [Field Model](#4-field-model-context) | Learn room baselines, extract body perturbations | [ADR-030](../adr/ADR-030-ruvsense-persistent-field-model.md) | `signal/src/ruvsense/{field_model,tomography}.rs` |
+| 5 | [Longitudinal Monitoring](#5-longitudinal-monitoring-context) | Track health trends over days/weeks | [ADR-030](../adr/ADR-030-ruvsense-persistent-field-model.md) | `signal/src/ruvsense/longitudinal.rs` |
+| 6 | [Spatial Identity](#6-spatial-identity-context) | Cross-room tracking via environment fingerprints | [ADR-030](../adr/ADR-030-ruvsense-persistent-field-model.md) | `signal/src/ruvsense/cross_room.rs` |
+| 7 | [Edge Intelligence](#7-edge-intelligence-context) | On-device sensing (no server needed) | [ADR-039](../adr/ADR-039-esp32-edge-intelligence.md), [ADR-040](../adr/ADR-040-wasm-programmable-sensing.md) | `firmware/esp32-csi-node/main/edge_processing.c` |
+
+All code paths shown are relative to `rust-port/wifi-densepose-rs/crates/wifi-densepose-` unless otherwise noted.
+
+---
+
 ## Domain-Driven Design Specification

 ### Ubiquitous Language

 | Term | Definition |
 |------|------------|
-| **Sensing Cycle** | One complete TDMA round (all nodes TX once): 50ms at 20 Hz |
+| **Sensing Cycle** | One complete TDMA round (all nodes TX once): ~35ms at 28.5 Hz (measured) |
 | **Link** | A single TX-RX pair; with N nodes there are N×(N-1) directed links |
 | **Multi-Band Frame** | Fused CSI from one node hopping across multiple channels in one dwell cycle |
 | **Fused Sensing Frame** | Aggregated observation from all nodes at one sensing cycle, ready for inference |
@@ -15,6 +35,8 @@
 | **Pose Track** | A temporally persistent per-person 17-keypoint trajectory with Kalman state |
 | **Track Lifecycle** | State machine: Tentative → Active → Lost → Terminated |
 | **Re-ID Embedding** | 128-dim AETHER contrastive vector encoding body identity |
+| **Edge Tier** | Processing level on the ESP32: 0 = raw passthrough, 1 = signal cleanup, 2 = vitals, 3 = WASM modules |
+| **WASM Module** | A small program compiled to WebAssembly that runs on the ESP32 for custom on-device sensing |
 | **Node** | An ESP32-S3 device acting as both TX and RX in the multistatic mesh |
 | **Aggregator** | Central device (ESP32/RPi/x86) that collects CSI from all nodes and runs fusion |
 | **Sensing Schedule** | TDMA slot assignment: which node transmits when |
@@ -194,7 +216,7 @@
 **Domain Services:**
 - `PersonSeparationService` — Min-cut partitioning of cross-link correlation graph
 - `TrackAssignmentService` — Bipartite matching of detections to existing tracks
- `KalmanPredictionService` — Predict step at 20 Hz (decoupled from measurement rate)
+- `KalmanPredictionService` — Predict step at 28 Hz (decoupled from measurement rate)
 - `KalmanUpdateService` — Gated measurement update (subject to coherence gate)
 - `EmbeddingIdentifierService` — AETHER cosine similarity for re-ID

@@ -575,7 +597,7 @@ pub trait MeshRepository {
 ### Multistatic Sensing
 - At least 2 nodes must be active for multistatic fusion (fallback to single-node mode otherwise)
 - Channel hop sequence must contain at least 1 non-overlapping channel
- TDMA cycle period must be ≤50ms for 20 Hz output
+- TDMA cycle period must be ≤50ms for 28 Hz output
 - Guard interval must be ≥2× clock drift budget (≥1ms for 50ms cycle)

 ### Coherence
@@ -1005,7 +1027,7 @@ pub trait SpatialIdentityRepository {
 ### Extended Invariants

 #### Field Model
- Baseline calibration requires ≥10 minutes of empty-room CSI (≥12,000 frames at 20 Hz)
+- Baseline calibration requires ≥10 minutes of empty-room CSI (≥12,000 frames at 28 Hz)
 - Environmental modes capped at K=5 (more modes overfit to noise)
 - Tomographic inversion only valid with ≥8 links (4 nodes minimum)
 - Baseline expires after 24 hours if not refreshed during quiet period
@@ -1025,3 +1047,154 @@ pub trait SpatialIdentityRepository {
 - Transition graph is append-only (immutable audit trail)
 - No image data stored — only 128-dim embeddings and structural events
 - Maximum 100 rooms indexed per deployment (HNSW scaling constraint)
+
+---
+
+## Part III: Edge Intelligence Bounded Context (ADR-039, ADR-040, ADR-041)
+
+### 7. Edge Intelligence Context
+
+**Responsibility:** Run signal processing and sensing algorithms directly on the ESP32-S3, without requiring a server. The node detects presence, measures breathing and heart rate, alerts on falls, and runs custom WASM modules — all locally with instant response.
+
+This is the only bounded context that runs on the microcontroller rather than the aggregator. It operates independently: the server is optional for visualization, but the ESP32 handles real-time sensing on its own.
+
+```
+┌──────────────────────────────────────────────────────────┐
+│              Edge Intelligence Context                     │
+│              (runs on ESP32-S3, Core 1)                    │
+├──────────────────────────────────────────────────────────┤
+│                                                            │
+│  ┌───────────────┐    ┌───────────────┐                   │
+│  │  Phase        │    │  Welford      │                   │
+│  │  Extractor    │    │  Variance     │                   │
+│  │  (I/Q → φ,   │    │  Tracker      │                   │
+│  │   unwrap)     │    │  (per-subk)   │                   │
+│  └───────┬───────┘    └───────┬───────┘                   │
+│          │                    │                            │
+│          └────────┬───────────┘                           │
+│                   ▼                                        │
+│          ┌────────────────┐                               │
+│          │  Top-K Select  │                               │
+│          │  + Bandpass     │                               │
+│          │  (breathing:    │                               │
+│          │   0.1-0.5 Hz,   │                               │
+│          │   HR: 0.8-2 Hz) │                               │
+│          └────────┬───────┘                               │
+│                   ▼                                        │
+│     ┌─────────────┼─────────────┐                        │
+│     ▼             ▼             ▼                        │
+│  ┌────────┐  ┌──────────┐  ┌──────────┐                 │
+│  │Presence│  │ Vitals   │  │  Fall    │                  │
+│  │Detector│  │ (BPM via │  │ Detector │                  │
+│  │(motion │  │  zero-   │  │ (phase   │                  │
+│  │ energy)│  │  crossing)│  │  accel)  │                  │
+│  └────┬───┘  └────┬─────┘  └────┬─────┘                 │
+│       └───────────┼──────────────┘                       │
+│                   ▼                                        │
+│          ┌────────────────┐                               │
+│          │  Vitals Packet │──▶ UDP 32-byte (0xC5110002)   │
+│          │  Assembler     │    at 1 Hz to aggregator      │
+│          └────────┬───────┘                               │
+│                   │                                        │
+│          ┌────────▼───────┐                               │
+│          │  WASM3 Runtime │                               │
+│          │  (Tier 3: hot- │──▶ Custom module outputs      │
+│          │   loadable     │                               │
+│          │   modules)     │                               │
+│          └────────────────┘                               │
+│                                                            │
+└──────────────────────────────────────────────────────────┘
+```
+
+**Aggregates:**
+- `EdgeProcessingState` (Aggregate Root) — Holds all per-subcarrier state, filter history, and detection flags
+
+**Value Objects:**
+- `VitalsPacket` — 32-byte UDP packet: presence, motion, breathing BPM, heart rate BPM, confidence, fall flag, occupancy
+- `EdgeTier` — Off (0) / BasicSignal (1) / FullVitals (2) / WasmExtended (3)
+- `PresenceState` — Empty / Present / Moving
+- `BandpassOutput` — Filtered signal in breathing or heart rate band
+- `FallAlert` — Phase acceleration exceeding configurable threshold
+
+**Entities:**
+- `WasmModule` — A loaded WASM binary with its own memory arena (160 KB), frame budget (10 ms), and timer interval
+
+**Domain Services:**
+- `PhaseExtractionService` — Converts raw I/Q to unwrapped phase per subcarrier
+- `VarianceTrackingService` — Welford running stats for subcarrier selection
+- `TopKSelectionService` — Picks highest-variance subcarriers for downstream analysis
+- `BandpassFilterService` — Biquad IIR filters for breathing (0.1-0.5 Hz) and heart rate (0.8-2.0 Hz)
+- `PresenceDetectionService` — Adaptive threshold calibration (3-sigma over 1200-frame window)
+- `VitalSignService` — Zero-crossing BPM estimation from filtered phase signals
+- `FallDetectionService` — Phase acceleration exceeding threshold triggers alert
+- `WasmRuntimeService` — WASM3 interpreter: load, execute, and sandbox custom modules
+
+**NVS Configuration (runtime, no reflash needed):**
+
+| Key | Type | Default | Purpose |
+|-----|------|---------|---------|
+| `edge_tier` | u8 | 0 | Processing tier (0/1/2/3) |
+| `pres_thresh` | u16 | 0 | Presence threshold (0 = auto-calibrate) |
+| `fall_thresh` | u16 | 2000 | Fall detection threshold (rad/s^2 x 1000) |
+| `vital_win` | u16 | 256 | Phase history window (frames) |
+| `vital_int` | u16 | 1000 | Vitals packet interval (ms) |
+| `subk_count` | u8 | 8 | Top-K subcarrier count |
+| `wasm_max` | u8 | 4 | Max concurrent WASM modules |
+| `wasm_verify` | u8 | 0 | Require Ed25519 signature for uploads |
+
+**Implementation files:**
+- `firmware/esp32-csi-node/main/edge_processing.c` — DSP pipeline (~750 lines)
+- `firmware/esp32-csi-node/main/edge_processing.h` — Types and API
+- `firmware/esp32-csi-node/main/nvs_config.c` — NVS key reader (20 keys)
+- `firmware/esp32-csi-node/provision.py` — CLI provisioning tool
+
+**Invariants:**
+- Edge processing runs on Core 1; WiFi and CSI callbacks run on Core 0 (no contention)
+- CSI data flows from Core 0 to Core 1 via a lock-free SPSC ring buffer
+- UDP sends are rate-limited to 50 Hz to prevent lwIP buffer exhaustion (Issue #127)
+- ENOMEM backoff suppresses sends for 100 ms if lwIP runs out of packet buffers
+- WASM modules are sandboxed: 160 KB arena, 10 ms frame budget, no direct hardware access
+- Tier changes via NVS take effect on next reboot — no hot-reconfiguration of the DSP pipeline
+- Fall detection threshold should be tuned per deployment (default 2000 causes false positives in static environments)
+
+**Domain Events:**
+```rust
+pub enum EdgeEvent {
+    /// Presence state changed
+    PresenceChanged {
+        node_id: u8,
+        state: PresenceState,  // Empty / Present / Moving
+        motion_energy: f32,
+        timestamp_ms: u32,
+    },
+
+    /// Fall detected on-device
+    FallDetected {
+        node_id: u8,
+        acceleration: f32,  // rad/s^2
+        timestamp_ms: u32,
+    },
+
+    /// Vitals packet emitted
+    VitalsEmitted {
+        node_id: u8,
+        breathing_bpm: f32,
+        heart_rate_bpm: f32,
+        confidence: f32,
+        timestamp_ms: u32,
+    },
+
+    /// WASM module loaded or failed
+    WasmModuleLoaded {
+        slot: u8,
+        module_name: String,
+        success: bool,
+        timestamp_ms: u32,
+    },
+}
+```
+
+**Relationship to other contexts:**
+- Edge Intelligence → Multistatic Sensing: **Alternative** (edge runs on-device; multistatic runs on aggregator — same physics, different compute location)
+- Edge Intelligence → Pose Tracking: **Upstream** (edge provides presence/vitals; aggregator can skip detection if edge already confirmed occupancy)
+- Edge Intelligence → Coherence: **Simplified** (edge uses simple variance thresholds instead of full coherence gating)
@@ -0,0 +1,842 @@
+# Sensing Server Domain Model
+
+The Sensing Server is the single-binary deployment surface of WiFi-DensePose. It receives raw CSI frames from ESP32 nodes, processes them into sensing features, streams live data to a web UI, and provides a self-contained workflow for recording data, training models, and running inference -- all without external dependencies.
+
+This document defines the system using [Domain-Driven Design](https://martinfowler.com/bliki/DomainDrivenDesign.html) (DDD): bounded contexts that own their data and rules, aggregate roots that enforce invariants, value objects that carry meaning, and domain events that connect everything. The server is implemented as a single Axum binary (`wifi-densepose-sensing-server`) with all state managed through `Arc<RwLock<AppStateInner>>`.
+
+**Bounded Contexts:**
+
+| # | Context | Responsibility | Key ADRs | Code |
+|---|---------|----------------|----------|------|
+| 1 | [CSI Ingestion](#1-csi-ingestion-context) | Receive, decode, and feature-extract CSI frames from ESP32 UDP | [ADR-019](../adr/ADR-019-sensing-only-ui-mode.md), [ADR-035](../adr/ADR-035-live-sensing-ui-accuracy.md) | `sensing-server/src/main.rs` |
+| 2 | [Model Management](#2-model-management-context) | Load, unload, list RVF models; LoRA profile activation | [ADR-043](../adr/ADR-043-sensing-server-ui-api-completion.md) | `sensing-server/src/model_manager.rs` |
+| 3 | [CSI Recording](#3-csi-recording-context) | Record CSI frames to .jsonl files, manage recording sessions | [ADR-043](../adr/ADR-043-sensing-server-ui-api-completion.md) | `sensing-server/src/recording.rs` |
+| 4 | [Training Pipeline](#4-training-pipeline-context) | Background training runs, progress streaming, contrastive pretraining | [ADR-043](../adr/ADR-043-sensing-server-ui-api-completion.md) | `sensing-server/src/training_api.rs` |
+| 5 | [Visualization](#5-visualization-context) | WebSocket streaming to web UI, Gaussian splat rendering, data transparency | [ADR-019](../adr/ADR-019-sensing-only-ui-mode.md), [ADR-035](../adr/ADR-035-live-sensing-ui-accuracy.md) | `ui/` |
+
+All code paths shown are relative to `rust-port/wifi-densepose-rs/crates/wifi-densepose-` unless otherwise noted.
+
+---
+
+## Domain-Driven Design Specification
+
+### Ubiquitous Language
+
+| Term | Definition |
+|------|------------|
+| **Sensing Update** | A complete JSON message broadcast to WebSocket clients each tick, containing node data, features, classification, signal field, and optional vital signs |
+| **Tick** | One processing cycle of the sensing loop (default 100ms = 10 fps, configurable via `--tick-ms`) |
+| **Data Source** | Origin of CSI data: `esp32` (UDP port 5005), `wifi` (Windows RSSI), `simulated` (synthetic), or `auto` (try ESP32 then fall back) |
+| **RVF Model** | A `.rvf` container file holding trained weights, manifest metadata, optional LoRA adapters, and vital sign configuration |
+| **LoRA Profile** | A lightweight adapter applied on top of a base RVF model for environment-specific fine-tuning without retraining the full model |
+| **Recording Session** | A period during which CSI frames are appended to a `.csi.jsonl` file, identified by a session ID and optional activity label |
+| **Training Run** | A background task that loads recorded CSI data, extracts features, trains a regularised linear model, and exports a `.rvf` container |
+| **Frame History** | A circular buffer of the last 100 CSI amplitude vectors used for temporal analysis (sliding-window variance, Goertzel breathing estimation) |
+| **Goertzel Filter** | A frequency-domain estimator applied to the frame history to detect breathing rate (0.1--0.5 Hz) via a 9-candidate filter bank |
+| **Signal Field** | A 20x1x20 grid of interpolated signal intensity values rendered as Gaussian splats in the UI |
+| **Pose Source** | Whether pose keypoints are `signal_derived` (analytical from CSI features) or `model_inference` (from a loaded RVF model) |
+| **Progressive Loader** | A two-layer model loading strategy: Layer A loads instantly for basic inference, Layer B loads in background for full accuracy |
+| **Sensing-Only Mode** | UI mode when the DensePose backend is unavailable; suppresses DensePose tabs, shows only sensing and signal visualization |
+| **AppStateInner** | The single shared state struct holding all server state, accessed via `Arc<RwLock<AppStateInner>>` |
+| **PCK Score** | Percentage of Correct Keypoints -- the primary accuracy metric for pose estimation models |
+| **Contrastive Pretraining** | Self-supervised training on unlabeled CSI data that learns signal representations before supervised fine-tuning (ADR-024) |
+
+---
+
+## Bounded Contexts
+
+### 1. CSI Ingestion Context
+
+**Responsibility:** Receive raw CSI frames from ESP32 nodes via UDP (port 5005), decode the binary protocol, extract temporal and frequency-domain features, and produce a `SensingUpdate` each tick.
+
+```
+------------------------------------------------------------+
+|                  CSI Ingestion Context                      |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  UDP Listener  |    |  Data Source   |                  |
+|  |  (port 5005)   |    |  Selector      |                  |
+|  |  Esp32Frame    |    |  (auto/esp32/  |                  |
+|  |  parser        |    |   wifi/sim)    |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Frame History    |                             |
+|          |  Buffer           |                             |
+|          |  (VecDeque<Vec>,  |                             |
+|          |   100 frames)     |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  Feature          |                             |
+|          |  Extractor        |                             |
+|          |  (Welford stats,  |                             |
+|          |   Goertzel FFT,   |                             |
+|          |   L2 motion)      |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  Vital Sign       |                             |
+|          |  Detector         |---> SensingUpdate           |
+|          |  (HR, RR,         |                             |
+|          |   breathing)      |                             |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Aggregates:**
+
+```rust
+/// Aggregate Root: The central shared state of the sensing server.
+/// All mutations go through RwLock. All handler functions receive
+/// State<Arc<RwLock<AppStateInner>>>.
+pub struct AppStateInner {
+    /// Most recent sensing update broadcast to clients.
+    latest_update: Option<SensingUpdate>,
+    /// RSSI history for sparkline display.
+    rssi_history: VecDeque<f64>,
+    /// Circular buffer of recent CSI amplitude vectors (100 frames).
+    frame_history: VecDeque<Vec<f64>>,
+    /// Monotonic tick counter.
+    tick: u64,
+    /// Active data source identifier ("esp32", "wifi", "simulated").
+    source: String,
+    /// Broadcast channel for WebSocket fan-out.
+    tx: broadcast::Sender<String>,
+    /// Vital sign detector instance.
+    vital_detector: VitalSignDetector,
+    /// Most recent vital signs reading.
+    latest_vitals: VitalSigns,
+    /// Smoothed person count (EMA) for hysteresis.
+    smoothed_person_score: f64,
+    // ... model, recording, training fields (see other contexts)
+}
+```
+
+**Value Objects:**
+
+```rust
+/// A complete sensing update broadcast to WebSocket clients each tick.
+pub struct SensingUpdate {
+    pub msg_type: String,         // always "sensing_update"
+    pub timestamp: f64,           // Unix timestamp with ms precision
+    pub source: String,           // "esp32" | "wifi" | "simulated"
+    pub tick: u64,                // monotonic tick counter
+    pub nodes: Vec<NodeInfo>,     // per-node CSI data
+    pub features: FeatureInfo,    // extracted signal features
+    pub classification: ClassificationInfo,
+    pub signal_field: SignalField,
+    pub vital_signs: Option<VitalSigns>,
+    pub persons: Option<Vec<PersonDetection>>,
+    pub estimated_persons: Option<usize>,
+}
+
+/// Per-node CSI data received from one ESP32.
+pub struct NodeInfo {
+    pub node_id: u8,
+    pub rssi_dbm: f64,
+    pub position: [f64; 3],
+    pub amplitude: Vec<f64>,
+    pub subcarrier_count: usize,
+}
+
+/// Extracted signal features from the frame history buffer.
+pub struct FeatureInfo {
+    pub mean_rssi: f64,
+    pub variance: f64,
+    pub motion_band_power: f64,
+    pub breathing_band_power: f64,
+    pub dominant_freq_hz: f64,
+    pub change_points: usize,
+    pub spectral_power: f64,
+}
+
+/// Motion classification derived from features.
+pub struct ClassificationInfo {
+    pub motion_level: String,  // "empty" | "static" | "active"
+    pub presence: bool,
+    pub confidence: f64,
+}
+
+/// Interpolated signal field for Gaussian splat visualization.
+pub struct SignalField {
+    pub grid_size: [usize; 3],  // [20, 1, 20]
+    pub values: Vec<f64>,
+}
+
+/// ESP32 binary CSI frame (ADR-018 protocol, 20-byte header).
+pub struct Esp32Frame {
+    pub magic: u32,           // 0xC5100001
+    pub node_id: u8,
+    pub n_antennas: u8,
+    pub n_subcarriers: u8,
+    pub freq_mhz: u16,
+    pub sequence: u32,
+    pub rssi: i8,
+    pub noise_floor: i8,
+    pub amplitudes: Vec<f64>,
+    pub phases: Vec<f64>,
+}
+
+/// Data source selection enum.
+pub enum DataSource {
+    Esp32Udp,     // Real ESP32 CSI via UDP port 5005
+    WindowsRssi,  // Windows WiFi RSSI via netsh
+    Simulated,    // Synthetic sine-wave data
+    Auto,         // Try ESP32, fall back to Windows, then simulated
+}
+```
+
+**Domain Services:**
+- `FeatureExtractionService` -- Computes temporal variance (Welford), Goertzel breathing estimation (9-band filter bank), L2 frame-to-frame motion score, SNR-based signal quality
+- `VitalSignDetectionService` -- Estimates breathing rate, heart rate, and confidence from CSI phase history
+- `DataSourceSelectionService` -- Probes UDP port 5005 for ESP32 frames; falls back through Windows RSSI then simulation
+
+**Invariants:**
+- Frame history buffer never exceeds 100 entries (oldest dropped on push)
+- Goertzel breathing estimate requires 3x SNR above noise to be reported
+- Source type is determined once at startup and does not change during runtime
+
+---
+
+### 2. Model Management Context
+
+**Responsibility:** Discover `.rvf` model files from `data/models/`, load weights into memory for inference, manage the active model lifecycle, and support LoRA profile activation.
+
+```
+------------------------------------------------------------+
+|               Model Management Context                     |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  Model Scanner |    |  RVF Reader    |                  |
+|  |  (data/models/ |    |  (parse .rvf   |                  |
+|  |   *.rvf enum)  |    |   manifest)    |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Model Registry   |                             |
+|          |  (Vec<ModelInfo>) |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  Model Loader     |                             |
+|          |  (RvfReader ->    |---> LoadedModelState        |
+|          |   weights,        |                             |
+|          |   LoRA profiles)  |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  LoRA Activator   |                             |
+|          |  (profile switch) |                             |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Aggregates:**
+
+```rust
+/// Aggregate Root: Runtime state for a loaded RVF model.
+/// At most one LoadedModelState exists at any time.
+pub struct LoadedModelState {
+    /// Model identifier (derived from filename without .rvf extension).
+    pub model_id: String,
+    /// Original filename on disk.
+    pub filename: String,
+    /// Version string from the RVF manifest.
+    pub version: String,
+    /// Description from the RVF manifest.
+    pub description: String,
+    /// LoRA profiles available in this model.
+    pub lora_profiles: Vec<String>,
+    /// Currently active LoRA profile (if any).
+    pub active_lora_profile: Option<String>,
+    /// Model weights (f32 parameters).
+    pub weights: Vec<f32>,
+    /// Number of frames processed since load.
+    pub frames_processed: u64,
+    /// Cumulative inference time for avg calculation.
+    pub total_inference_ms: f64,
+    /// When the model was loaded.
+    pub loaded_at: Instant,
+}
+```
+
+**Value Objects:**
+
+```rust
+/// Summary information for a model discovered on disk.
+pub struct ModelInfo {
+    pub id: String,
+    pub filename: String,
+    pub version: String,
+    pub description: String,
+    pub size_bytes: u64,
+    pub created_at: String,
+    pub pck_score: Option<f64>,
+    pub has_quantization: bool,
+    pub lora_profiles: Vec<String>,
+    pub segment_count: usize,
+}
+
+/// Information about the currently loaded model with runtime stats.
+pub struct ActiveModelInfo {
+    pub model_id: String,
+    pub filename: String,
+    pub version: String,
+    pub description: String,
+    pub avg_inference_ms: f64,
+    pub frames_processed: u64,
+    pub pose_source: String,      // "model_inference"
+    pub lora_profiles: Vec<String>,
+    pub active_lora_profile: Option<String>,
+}
+
+/// Request to load a model by ID.
+pub struct LoadModelRequest {
+    pub model_id: String,
+}
+
+/// Request to activate a LoRA profile.
+pub struct ActivateLoraRequest {
+    pub model_id: String,
+    pub profile_name: String,
+}
+```
+
+**Domain Services:**
+- `ModelScanService` -- Scans `data/models/` at startup for `.rvf` files, parses each with `RvfReader` to extract manifest metadata
+- `ModelLoadService` -- Reads model weights from an RVF container into memory, sets `model_loaded = true`
+- `LoraActivationService` -- Switches the active LoRA adapter on a loaded model without full reload
+
+**Invariants:**
+- Only one model can be loaded at a time; loading a new model implicitly unloads the previous one
+- A model must be loaded before a LoRA profile can be activated
+- The `active_lora_profile` must be one of the model's declared `lora_profiles`
+- Model deletion is refused if the model is currently loaded (must unload first)
+- `data/models/` directory is created at startup if it does not exist
+
+---
+
+### 3. CSI Recording Context
+
+**Responsibility:** Capture CSI frames to `.csi.jsonl` files during active recording sessions, manage session lifecycle, and provide download/delete operations on stored recordings.
+
+```
+------------------------------------------------------------+
+|               CSI Recording Context                        |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  Start/Stop    |    |  Auto-Stop     |                  |
+|  |  Controller    |    |  Timer         |                  |
+|  |  (REST API)    |    |  (duration_    |                  |
+|  |                |    |   secs check)  |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|          +-------------------+                             |
+|          |  Recording State  |                             |
+|          |  (session_id,     |                             |
+|          |   frame_count,    |                             |
+|          |   file_path)      |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  Frame Writer     |                             |
+|          |  (maybe_record_   |---> .csi.jsonl file         |
+|          |   frame on each   |                             |
+|          |   tick)           |                             |
+|          +--------+----------+                             |
+|                   v                                        |
+|          +-------------------+                             |
+|          |  Metadata Writer  |                             |
+|          |  (.meta.json on   |                             |
+|          |   stop)           |                             |
+|          +-------------------+                             |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Aggregates:**
+
+```rust
+/// Aggregate Root: Runtime state for the active CSI recording session.
+/// At most one RecordingState can be active at any time.
+pub struct RecordingState {
+    /// Whether a recording is currently active.
+    pub active: bool,
+    /// Session ID of the active recording.
+    pub session_id: String,
+    /// Session display name.
+    pub session_name: String,
+    /// Optional label / activity tag (e.g., "walking", "standing").
+    pub label: Option<String>,
+    /// Path to the JSONL file being written.
+    pub file_path: PathBuf,
+    /// Number of frames written so far.
+    pub frame_count: u64,
+    /// When the recording started (monotonic clock).
+    pub start_time: Instant,
+    /// ISO-8601 start timestamp for metadata.
+    pub started_at: String,
+    /// Optional auto-stop duration in seconds.
+    pub duration_secs: Option<u64>,
+}
+```
+
+**Value Objects:**
+
+```rust
+/// Metadata for a completed or active recording session.
+pub struct RecordingSession {
+    pub id: String,
+    pub name: String,
+    pub label: Option<String>,
+    pub started_at: String,
+    pub ended_at: Option<String>,
+    pub frame_count: u64,
+    pub file_size_bytes: u64,
+    pub file_path: String,
+}
+
+/// A single recorded CSI frame line (JSONL format).
+pub struct RecordedFrame {
+    pub timestamp: f64,
+    pub subcarriers: Vec<f64>,
+    pub rssi: f64,
+    pub noise_floor: f64,
+    pub features: serde_json::Value,
+}
+
+/// Request to start a new recording session.
+pub struct StartRecordingRequest {
+    pub session_name: String,
+    pub label: Option<String>,
+    pub duration_secs: Option<u64>,
+}
+```
+
+**Domain Services:**
+- `RecordingLifecycleService` -- Creates a new `.csi.jsonl` file, generates session ID, manages start/stop transitions
+- `FrameWriterService` -- Called on each tick via `maybe_record_frame()`, appends a `RecordedFrame` JSON line to the active file
+- `AutoStopService` -- Checks elapsed time against `duration_secs` on each tick; triggers stop when exceeded
+- `RecordingScanService` -- Enumerates `data/recordings/` for `.csi.jsonl` files and reads companion `.meta.json` for session metadata
+
+**Invariants:**
+- Only one recording session can be active at a time; starting a new recording while one is active returns HTTP 409 Conflict
+- Recording with `duration_secs` set auto-stops after the specified elapsed time
+- A `.meta.json` companion file is written when a recording stops, capturing final frame count and duration
+- `data/recordings/` directory is created at startup if it does not exist
+- Frame writer acquires a read lock on `AppStateInner` per tick; stop acquires a write lock
+
+---
+
+### 4. Training Pipeline Context
+
+**Responsibility:** Run background training against recorded CSI data, stream epoch-level progress via WebSocket, and export trained models as `.rvf` containers. Supports supervised training, contrastive pretraining (ADR-024), and LoRA fine-tuning.
+
+```
+------------------------------------------------------------+
+|              Training Pipeline Context                     |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  Training API  |    |  WebSocket     |                  |
+|  |  (start/stop/  |    |  Progress      |                  |
+|  |   status)      |    |  Streamer      |                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     ^                           |
+|          v                     |                           |
+|  +-------------------+        |                            |
+|  |  Training         |        |                            |
+|  |  Orchestrator     +--------+                            |
+|  |  (tokio::spawn)   |  broadcast::Sender                  |
+|  +--------+----------+                                     |
+|           v                                                |
+|  +-------------------+                                     |
+|  |  Feature          |                                     |
+|  |  Extractor        |                                     |
+|  |  (subcarrier var, |                                     |
+|  |   Goertzel power, |                                     |
+|  |   temporal grad)  |                                     |
+|  +--------+----------+                                     |
+|           v                                                |
+|  +-------------------+                                     |
+|  |  Gradient Descent |                                     |
+|  |  Trainer          |                                     |
+|  |  (batch SGD,      |---> TrainingProgress                |
+|  |   early stopping, |                                     |
+|  |   warmup)         |                                     |
+|  +--------+----------+                                     |
+|           v                                                |
+|  +-------------------+                                     |
+|  |  RVF Exporter     |                                     |
+|  |  (RvfBuilder ->   |---> data/models/*.rvf               |
+|  |   .rvf container) |                                     |
+|  +-------------------+                                     |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Aggregates:**
+
+```rust
+/// Aggregate Root: Runtime training state stored in AppStateInner.
+/// At most one training run can be active at any time.
+pub struct TrainingState {
+    /// Current status snapshot.
+    pub status: TrainingStatus,
+    /// Handle to the background training task (for cancellation).
+    pub task_handle: Option<tokio::task::JoinHandle<()>>,
+}
+```
+
+**Value Objects:**
+
+```rust
+/// Current training status (returned by GET /api/v1/train/status).
+pub struct TrainingStatus {
+    pub active: bool,
+    pub epoch: u32,
+    pub total_epochs: u32,
+    pub train_loss: f64,
+    pub val_pck: f64,         // Percentage of Correct Keypoints
+    pub val_oks: f64,         // Object Keypoint Similarity
+    pub lr: f64,              // current learning rate
+    pub best_pck: f64,
+    pub best_epoch: u32,
+    pub patience_remaining: u32,
+    pub eta_secs: Option<u64>,
+    pub phase: String,        // "idle" | "training" | "complete" | "failed"
+}
+
+/// Progress update sent over WebSocket to connected UI clients.
+pub struct TrainingProgress {
+    pub epoch: u32,
+    pub batch: u32,
+    pub total_batches: u32,
+    pub train_loss: f64,
+    pub val_pck: f64,
+    pub val_oks: f64,
+    pub lr: f64,
+    pub phase: String,
+}
+
+/// Training configuration submitted with a start request.
+pub struct TrainingConfig {
+    pub epochs: u32,                    // default: 100
+    pub batch_size: u32,               // default: 8
+    pub learning_rate: f64,            // default: 0.001
+    pub weight_decay: f64,             // default: 1e-4
+    pub early_stopping_patience: u32,  // default: 20
+    pub warmup_epochs: u32,            // default: 5
+    pub pretrained_rvf: Option<String>,
+    pub lora_profile: Option<String>,
+}
+
+/// Request to start supervised training.
+pub struct StartTrainingRequest {
+    pub dataset_ids: Vec<String>,  // recording session IDs
+    pub config: TrainingConfig,
+}
+
+/// Request to start contrastive pretraining (ADR-024).
+pub struct PretrainRequest {
+    pub dataset_ids: Vec<String>,
+    pub epochs: u32,    // default: 50
+    pub lr: f64,        // default: 0.001
+}
+
+/// Request to start LoRA fine-tuning.
+pub struct LoraTrainRequest {
+    pub base_model_id: String,
+    pub dataset_ids: Vec<String>,
+    pub profile_name: String,
+    pub rank: u8,       // default: 8
+    pub epochs: u32,    // default: 30
+}
+```
+
+**Domain Services:**
+- `TrainingOrchestrationService` -- Spawns a background `tokio::task`, loads recorded frames, runs feature extraction, executes gradient descent with early stopping and warmup
+- `FeatureExtractionService` -- Computes per-subcarrier sliding-window variance, temporal gradients, Goertzel frequency-domain power across 9 bands, and 3 global scalar features (mean amplitude, std, motion score)
+- `ProgressBroadcastService` -- Sends `TrainingProgress` messages through a `broadcast::Sender` channel that WebSocket handlers subscribe to
+- `RvfExportService` -- Uses `RvfBuilder` to write the best checkpoint as a `.rvf` container to `data/models/`
+
+**Invariants:**
+- Only one training run can be active at a time; starting training while one is running returns HTTP 409 Conflict
+- Training requires at least one recording with a minimum frame count before starting
+- Early stopping halts training after `patience` epochs with no improvement in `val_pck`
+- Learning rate warmup ramps linearly from 0 to `learning_rate` over `warmup_epochs`
+- On completion, the best model (by `val_pck`) is automatically exported as `.rvf`
+- Training status phase transitions: `idle` -> `training` -> `complete` | `failed` -> `idle`
+- Stopping an active training run aborts the background task via `JoinHandle::abort()` and resets phase to `idle`
+
+---
+
+### 5. Visualization Context
+
+**Responsibility:** Stream sensing data to web UI clients via WebSocket, render Gaussian splat visualizations, display data source transparency indicators, and manage UI mode (full vs. sensing-only).
+
+```
+------------------------------------------------------------+
+|               Visualization Context                        |
+------------------------------------------------------------+
+|                                                            |
+|  +----------------+    +----------------+                  |
+|  |  WebSocket     |    |  Sensing       |                  |
+|  |  Hub           |    |  Service (JS)  |                  |
+|  |  (/ws/sensing) |    |  (client-side  |                  |
+|  |  broadcast::   |    |   reconnect +  |                  |
+|  |  Receiver      |    |   sim fallback)|                  |
+|  +-------+--------+    +-------+--------+                  |
+|          |                     |                           |
+|          +----------+----------+                           |
+|                     v                                      |
+|  +----------------------------------------------+         |
+|  |  UI Components                                |         |
+|  |                                               |         |
+|  |  +----------+  +----------+  +----------+    |         |
+|  |  | Sensing  |  | Live     |  | Models   |    |         |
+|  |  | Tab      |  | Demo Tab |  | Tab      |    |         |
+|  |  | (splats) |  | (pose)   |  | (manage) |    |         |
+|  |  +----------+  +----------+  +----------+    |         |
+|  |  +----------+  +----------+                   |         |
+|  |  | Recording|  | Training |                   |         |
+|  |  | Tab      |  | Tab      |                   |         |
+|  |  | (capture)|  | (train)  |                   |         |
+|  |  +----------+  +----------+                   |         |
+|  +----------------------------------------------+         |
+|                                                            |
+------------------------------------------------------------+
+```
+
+**Value Objects:**
+
+```rust
+/// Data source indicator shown in the UI (ADR-035).
+pub enum DataSourceIndicator {
+    LiveEsp32,     // Green banner: "LIVE - ESP32"
+    Reconnecting,  // Yellow banner: "RECONNECTING..."
+    Simulated,     // Red banner: "SIMULATED DATA"
+}
+
+/// Pose estimation mode badge (ADR-035).
+pub enum EstimationMode {
+    SignalDerived,    // Green badge: analytical pose from CSI features
+    ModelInference,   // Blue badge: neural network inference from loaded RVF
+}
+
+/// Render mode for pose visualization (ADR-035).
+pub enum RenderMode {
+    Skeleton,   // Green lines connecting joints + red keypoint dots
+    Keypoints,  // Large colored dots with glow and labels
+    Heatmap,    // Gaussian radial blobs per keypoint, faint skeleton overlay
+    Dense,      // Body region segmentation with colored filled polygons
+}
+```
+
+**Domain Services:**
+- `WebSocketBroadcastService` -- Subscribes to `broadcast::Sender<String>`, forwards each `SensingUpdate` JSON to all connected WebSocket clients
+- `SensingServiceJS` -- Client-side JavaScript that manages WebSocket connection, tracks `dataSource` state, falls back to simulation after 5 failed reconnect attempts (~30s delay)
+- `GaussianSplatRenderer` -- Custom GLSL `ShaderMaterial` rendering point-cloud splats on a 20x20 floor grid, colored by signal intensity
+- `PoseRenderer` -- Renders skeleton, keypoints, heatmap, or dense body segmentation modes
+- `BackendDetector` -- Auto-detects whether the full DensePose backend is available; sets `sensingOnlyMode = true` if unreachable
+
+**Invariants:**
+- WebSocket sensing service is started on application init, not lazily on tab visit (ADR-043 fix)
+- Simulation fallback is delayed to 5 failed reconnect attempts (~30 seconds) to avoid premature synthetic data
+- `pose_source` field is passed through data conversion so the Estimation Mode badge displays correctly
+- Dashboard and Live Demo tabs read `sensingService.dataSource` at load time -- the service must already be connected
+
+---
+
+## Domain Events
+
+| Event | Published By | Consumed By | Payload |
+|-------|-------------|-------------|---------|
+| `ServerStarted` | CSI Ingestion | Visualization | `{ http_port, udp_port, source_type }` |
+| `CsiFrameIngested` | CSI Ingestion | Recording, Visualization | `{ source, node_id, subcarrier_count, tick }` |
+| `SensingUpdateBroadcast` | CSI Ingestion | Visualization (WebSocket) | Full `SensingUpdate` JSON |
+| `ModelLoaded` | Model Management | CSI Ingestion (inference path) | `{ model_id, weight_count, version }` |
+| `ModelUnloaded` | Model Management | CSI Ingestion | `{ model_id }` |
+| `LoraProfileActivated` | Model Management | CSI Ingestion | `{ model_id, profile_name }` |
+| `RecordingStarted` | Recording | Visualization | `{ session_id, session_name, file_path }` |
+| `RecordingStopped` | Recording | Visualization | `{ session_id, frame_count, duration_secs }` |
+| `TrainingStarted` | Training Pipeline | Visualization | `{ run_id, config, recording_ids }` |
+| `TrainingEpochComplete` | Training Pipeline | Visualization (WebSocket) | `{ epoch, total_epochs, train_loss, val_pck, lr }` |
+| `TrainingComplete` | Training Pipeline | Model Management, Visualization | `{ run_id, final_pck, model_path }` |
+| `TrainingFailed` | Training Pipeline | Visualization | `{ run_id, error_message }` |
+| `WebSocketClientConnected` | Visualization | -- | `{ endpoint, client_addr }` |
+| `WebSocketClientDisconnected` | Visualization | -- | `{ endpoint, client_addr }` |
+
+In the current implementation, events are realized through two mechanisms:
+1. **`broadcast::Sender<String>`** for WebSocket fan-out of sensing updates
+2. **`broadcast::Sender<TrainingProgress>`** for training progress streaming
+3. **State mutations via RwLock** where other contexts read state changes on their next tick
+
+---
+
+## Context Map
+
+```
+-------------------+          +---------------------+
+|   CSI Ingestion   |--------->|   Visualization     |
+|   (produces       | publish  |   (WebSocket        |
+|    SensingUpdate)  | -------> |    consumers)       |
+--------+----------+          +----------+----------+
+         |                                |
+         | maybe_record_frame()           | reads dataSource
+         v                                |
+-------------------+                     |
+|   CSI Recording   |                     |
+|   (hooks into     |                     |
+|    tick loop)      |                     |
+--------+----------+                     |
+         |                                |
+         | provides dataset_ids           |
+         v                                |
+-------------------+          +----------+----------+
+| Training Pipeline |--------->| Model Management    |
+| (reads .jsonl,    | exports  | (loads .rvf for     |
+|  trains model)    | .rvf --> |  inference)         |
+-------------------+          +----------+----------+
+                                          |
+                                          | model weights
+                                          v
+                               +----------+----------+
+                               |   CSI Ingestion      |
+                               |   (inference path    |
+                               |    uses loaded model)|
+                               +----------------------+
+```
+
+**Relationships:**
+
+| Upstream | Downstream | Relationship | Mechanism |
+|----------|-----------|--------------|-----------|
+| CSI Ingestion | Visualization | Published Language | `broadcast::Sender<String>` with `SensingUpdate` JSON schema |
+| CSI Ingestion | CSI Recording | Shared Kernel | `maybe_record_frame()` called from the ingestion tick loop |
+| CSI Recording | Training Pipeline | Conformist | Training reads `.csi.jsonl` files produced by recording; no negotiation on format |
+| Training Pipeline | Model Management | Supplier-Consumer | Training exports `.rvf` to `data/models/`; Model Management scans and loads |
+| Model Management | CSI Ingestion | Shared Kernel | Loaded weights stored in `AppStateInner`; ingestion reads them for inference |
+| Training Pipeline | Visualization | Published Language | `broadcast::Sender<TrainingProgress>` with progress JSON schema |
+
+---
+
+## Anti-Corruption Layers
+
+### ESP32 Binary Protocol ACL
+
+The ESP32 sends CSI frames using a compact binary protocol (ADR-018): 20-byte header with magic `0xC5100001`, followed by amplitude and phase arrays. The `Esp32Frame` parser in the ingestion context decodes this binary format into domain value objects (`NodeInfo`, amplitude/phase vectors) before any downstream processing. No other context handles raw UDP bytes.
+
+### RVF Container ACL
+
+The `.rvf` container format encapsulates model weights, manifest metadata, vital sign configuration, and optional LoRA adapters. The `RvfReader` and `RvfBuilder` types in the `rvf_container` module provide the anti-corruption layer between the on-disk binary format and the domain types (`ModelInfo`, `LoadedModelState`). The training pipeline writes through `RvfBuilder`; the model management context reads through `RvfReader`.
+
+### Sensing-Only Mode ACL (Client-Side)
+
+When the DensePose backend (port 8000) is unreachable, the client-side `BackendDetector` sets `sensingOnlyMode = true`. The `ApiService.request()` method short-circuits all requests to the DensePose backend, returning empty responses instead of `ERR_CONNECTION_REFUSED`. This prevents DensePose-specific concerns from leaking into the sensing UI.
+
+### JSONL Recording Format ACL
+
+CSI frames are recorded as newline-delimited JSON (`.csi.jsonl`). The `RecordedFrame` struct defines the schema: `{timestamp, subcarriers, rssi, noise_floor, features}`. The training pipeline reads through this schema, extracting subcarrier arrays for feature computation. If the internal sensing representation changes, only the `maybe_record_frame()` serializer needs updating -- the training pipeline depends only on the `RecordedFrame` contract.
+
+---
+
+## REST API Surface
+
+All endpoints share `AppStateInner` via `Arc<RwLock<AppStateInner>>`.
+
+### CSI Ingestion & Sensing
+
+| Method | Path | Context | Description |
+|--------|------|---------|-------------|
+| GET | `/api/v1/sensing/latest` | Ingestion | Latest sensing update |
+| WS | `/ws/sensing` | Visualization | Streaming sensing updates |
+
+### Model Management
+
+| Method | Path | Context | Description |
+|--------|------|---------|-------------|
+| GET | `/api/v1/models` | Model Mgmt | List all discovered `.rvf` models |
+| GET | `/api/v1/models/:id` | Model Mgmt | Detailed info for a specific model |
+| GET | `/api/v1/models/active` | Model Mgmt | Active model with runtime stats |
+| POST | `/api/v1/models/load` | Model Mgmt | Load model weights into memory |
+| POST | `/api/v1/models/unload` | Model Mgmt | Unload the active model |
+| DELETE | `/api/v1/models/:id` | Model Mgmt | Delete a model file from disk |
+| GET | `/api/v1/models/lora/profiles` | Model Mgmt | List LoRA profiles for active model |
+| POST | `/api/v1/models/lora/activate` | Model Mgmt | Activate a LoRA adapter |
+
+### CSI Recording
+
+| Method | Path | Context | Description |
+|--------|------|---------|-------------|
+| POST | `/api/v1/recording/start` | Recording | Start a new recording session |
+| POST | `/api/v1/recording/stop` | Recording | Stop the active recording |
+| GET | `/api/v1/recording/list` | Recording | List all recording sessions |
+| GET | `/api/v1/recording/download/:id` | Recording | Download a `.csi.jsonl` file |
+| DELETE | `/api/v1/recording/:id` | Recording | Delete a recording |
+
+### Training Pipeline
+
+| Method | Path | Context | Description |
+|--------|------|---------|-------------|
+| POST | `/api/v1/train/start` | Training | Start supervised training |
+| POST | `/api/v1/train/stop` | Training | Stop the active training run |
+| GET | `/api/v1/train/status` | Training | Current training phase and metrics |
+| POST | `/api/v1/train/pretrain` | Training | Start contrastive pretraining |
+| POST | `/api/v1/train/lora` | Training | Start LoRA fine-tuning |
+| WS | `/ws/train/progress` | Training | Streaming training progress |
+
+---
+
+## File Layout
+
+```
+data/
+-- models/                              # RVF model files
+|   +-- wifi-densepose-v1.rvf           # Trained model container
+|   +-- wifi-densepose-field-v2.rvf     # Environment-calibrated model
+-- recordings/                          # CSI recording sessions
+    +-- walking-20260303_140000.csi.jsonl       # Raw CSI frames (JSONL)
+    +-- walking-20260303_140000.csi.meta.json   # Session metadata
+    +-- standing-20260303_141500.csi.jsonl
+    +-- standing-20260303_141500.csi.meta.json
+
+crates/wifi-densepose-sensing-server/
+-- src/
+    +-- main.rs            # Server entry, CLI args, AppStateInner, sensing loop
+    +-- model_manager.rs   # Model Management bounded context
+    +-- recording.rs       # CSI Recording bounded context
+    +-- training_api.rs    # Training Pipeline bounded context
+    +-- rvf_container.rs   # RVF format ACL (RvfReader, RvfBuilder)
+    +-- rvf_pipeline.rs    # Progressive loader for model inference
+    +-- vital_signs.rs     # Vital sign detection from CSI phase
+    +-- dataset.rs         # Dataset loading for training
+    +-- trainer.rs         # Core training loop implementation
+    +-- embedding.rs       # Contrastive embedding extraction
+    +-- graph_transformer.rs # Graph transformer architecture
+    +-- sona.rs            # SONA self-optimizing profile
+    +-- sparse_inference.rs # Sparse inference engine
+    +-- lib.rs             # Public module re-exports
+```
+
+---
+
+## Related
+
+- [ADR-019: Sensing-Only UI Mode](../adr/ADR-019-sensing-only-ui-mode.md) -- Decoupled sensing UI, Gaussian splats, Python WebSocket bridge
+- [ADR-035: Live Sensing UI Accuracy](../adr/ADR-035-live-sensing-ui-accuracy.md) -- Data transparency, Goertzel breathing estimation, signal-responsive pose
+- [ADR-043: Sensing Server UI API Completion](../adr/ADR-043-sensing-server-ui-api-completion.md) -- Model, recording, training endpoints; single-binary deployment
+- [RuvSense Domain Model](ruvsense-domain-model.md) -- Upstream signal processing domain (multistatic sensing, coherence, tracking)
+- [WiFi-Mat Domain Model](wifi-mat-domain-model.md) -- Downstream disaster response domain
@@ -0,0 +1,663 @@
+# Signal Processing Domain Model
+
+## Domain-Driven Design Specification
+
+Based on ADR-014 (SOTA Signal Processing) and the `wifi-densepose-signal` crate.
+
+### Ubiquitous Language
+
+| Term | Definition |
+|------|------------|
+| **CsiFrame** | A single CSI measurement: amplitude + phase per antenna per subcarrier at one timestamp |
+| **Conjugate Multiplication** | `H_ref[k] * conj(H_target[k])` — cancels CFO/SFO/PDD, isolating environment-induced phase |
+| **CSI Ratio** | The complex result of conjugate multiplication between two antenna streams |
+| **Hampel Filter** | Running median +/- scaled MAD outlier detector; resists up to 50% contamination |
+| **Phase Sanitization** | Pipeline of unwrapping, outlier removal, smoothing, and noise filtering on raw CSI phase |
+| **Spectrogram** | 2D time-frequency matrix from STFT, standard CNN input for WiFi activity recognition |
+| **Subcarrier Sensitivity** | Variance ratio (motion var / static var) ranking how responsive a subcarrier is to motion |
+| **Body Velocity Profile (BVP)** | Doppler-derived velocity x time 2D matrix; domain-independent motion representation |
+| **Fresnel Zone** | Ellipsoidal region between TX and RX where signal reflection/diffraction occurs |
+| **Breathing Estimate** | BPM + amplitude + confidence derived from Fresnel zone boundary crossings |
+| **Motion Score** | Composite (0.0-1.0) from variance, correlation, phase, and optional Doppler components |
+| **Presence State** | Binary detection result: human present/absent with smoothed confidence |
+| **Calibration** | Recording baseline variance during a known-empty period for adaptive detection |
+
+---
+
+## Bounded Contexts
+
+### 1. CSI Preprocessing Context
+
+**Responsibility**: Produce clean, hardware-artifact-free CSI data from raw measurements.
+
+```
+-----------------------------------------------------------+
+|               CSI Preprocessing Context                    |
+-----------------------------------------------------------+
+|                                                            |
+|  +--------------+    +--------------+    +------------+    |
+|  |  Conjugate   |    |   Hampel     |    |   Phase    |    |
+|  | Multiplication|   |   Filter     |    | Sanitizer  |    |
+|  +------+-------+    +------+-------+    +-----+------+    |
+|         |                   |                  |           |
+|         v                   v                  v           |
+|  +------+-------+    +------+-------+    +-----+------+    |
+|  |  CsiRatio    |    | HampelResult |    | Sanitized  |    |
+|  | (clean phase)|    |(outlier-free)|    |   Phase    |    |
+|  +--------------+    +--------------+    +------------+    |
+|         |                   |                  |           |
+|         +-------------------+------------------+           |
+|                             |                              |
+|                             v                              |
+|                     +-------+--------+                     |
+|                     |  CsiProcessor  |--> CleanedCsiData   |
+|                     +----------------+                     |
+|                                                            |
+-----------------------------------------------------------+
+```
+
+**Aggregates**: `CsiProcessor` (Aggregate Root)
+
+**Value Objects**: `CsiData`, `CsiRatio`, `HampelResult`, `HampelConfig`, `PhaseSanitizerConfig`
+
+**Domain Services**: `CsiPreprocessor`, `PhaseSanitizer`
+
+---
+
+### 2. Feature Extraction Context
+
+**Responsibility**: Transform clean CSI data into ML-ready feature representations.
+
+```
+-----------------------------------------------------------+
+|              Feature Extraction Context                    |
+-----------------------------------------------------------+
+|                                                            |
+|  +--------------+    +--------------+    +------------+    |
+|  |    STFT      |    | Subcarrier   |    |  Doppler   |    |
+|  | Spectrogram  |    |  Selection   |    | BVP Engine |    |
+|  +------+-------+    +------+-------+    +-----+------+    |
+|         |                   |                  |           |
+|         v                   v                  v           |
+|  +------+-------+    +------+-------+    +-----+------+    |
+|  | Spectrogram  |    | Subcarrier   |    |  BodyVel   |    |
+|  |   (2D TF)    |    |  Selection   |    |  Profile   |    |
+|  +--------------+    +--------------+    +------------+    |
+|         |                   |                  |           |
+|         +-------------------+------------------+           |
+|                             |                              |
+|                             v                              |
+|                  +----------+----------+                   |
+|                  | FeatureExtractor    |--> CsiFeatures     |
+|                  +---------------------+                   |
+|                                                            |
+-----------------------------------------------------------+
+```
+
+**Aggregates**: `FeatureExtractor` (Aggregate Root)
+
+**Value Objects**: `Spectrogram`, `SubcarrierSelection`, `BodyVelocityProfile`, `CsiFeatures`
+
+**Domain Services**: `SpectrogramConfig`, `SubcarrierSelectionConfig`, `BvpConfig`
+
+---
+
+### 3. Motion Analysis Context
+
+**Responsibility**: Detect and classify human motion and vital signs from CSI features.
+
+```
+-----------------------------------------------------------+
+|               Motion Analysis Context                      |
+-----------------------------------------------------------+
+|                                                            |
+|  +--------------+    +--------------+                      |
+|  |   Motion     |    |   Fresnel    |                      |
+|  |  Detector    |    |  Breathing   |                      |
+|  +------+-------+    +------+-------+                      |
+|         |                   |                              |
+|         v                   v                              |
+|  +------+-------+    +------+-------+                      |
+|  | MotionScore  |    | Breathing    |                      |
+|  |+ Detection   |    |  Estimate    |                      |
+|  +--------------+    +--------------+                      |
+|         |                   |                              |
+|         +-------------------+                              |
+|                   |                                        |
+|                   v                                        |
+|          +--------+--------+                               |
+|          | HumanDetection  |--> PresenceState              |
+|          |    Result       |                               |
+|          +-----------------+                               |
+|                                                            |
+-----------------------------------------------------------+
+```
+
+**Aggregates**: `MotionDetector` (Aggregate Root)
+
+**Value Objects**: `MotionScore`, `MotionAnalysis`, `HumanDetectionResult`, `BreathingEstimate`, `FresnelGeometry`
+
+**Domain Services**: `FresnelBreathingEstimator`
+
+---
+
+## Aggregates
+
+### CsiProcessor (CSI Preprocessing Root)
+
+```rust
+pub struct CsiProcessor {
+    config: CsiProcessorConfig,
+    preprocessor: CsiPreprocessor,
+    history: VecDeque<CsiData>,
+    previous_detection_confidence: f64,
+    statistics: ProcessingStatistics,
+}
+
+impl CsiProcessor {
+    /// Create with validated configuration
+    pub fn new(config: CsiProcessorConfig) -> Result<Self, CsiProcessorError>;
+
+    /// Full preprocessing pipeline: noise removal -> windowing -> normalization
+    pub fn preprocess(&self, csi_data: &CsiData) -> Result<CsiData, CsiProcessorError>;
+
+    /// Maintain temporal history for downstream feature extraction
+    pub fn add_to_history(&mut self, csi_data: CsiData);
+
+    /// Apply exponential moving average to detection confidence
+    pub fn apply_temporal_smoothing(&mut self, raw_confidence: f64) -> f64;
+}
+```
+
+### FeatureExtractor (Feature Extraction Root)
+
+```rust
+pub struct FeatureExtractor {
+    config: FeatureExtractorConfig,
+}
+
+impl FeatureExtractor {
+    /// Extract all feature types from a single CsiData snapshot
+    pub fn extract(&self, csi_data: &CsiData) -> CsiFeatures;
+}
+```
+
+### MotionDetector (Motion Analysis Root)
+
+```rust
+pub struct MotionDetector {
+    config: MotionDetectorConfig,
+    previous_confidence: f64,
+    motion_history: VecDeque<MotionScore>,
+    baseline_variance: Option<f64>,
+}
+
+impl MotionDetector {
+    /// Analyze motion from extracted features
+    pub fn analyze_motion(&self, features: &CsiFeatures) -> MotionAnalysis;
+
+    /// Full detection pipeline: analyze -> score -> smooth -> threshold
+    pub fn detect_human(&mut self, features: &CsiFeatures) -> HumanDetectionResult;
+
+    /// Record baseline variance for adaptive detection
+    pub fn calibrate(&mut self, features: &CsiFeatures);
+}
+```
+
+---
+
+## Value Objects
+
+### CsiData
+
+```rust
+pub struct CsiData {
+    pub timestamp: DateTime<Utc>,
+    pub amplitude: Array2<f64>,     // (num_antennas x num_subcarriers)
+    pub phase: Array2<f64>,         // (num_antennas x num_subcarriers), radians
+    pub frequency: f64,             // center frequency in Hz
+    pub bandwidth: f64,             // bandwidth in Hz
+    pub num_subcarriers: usize,
+    pub num_antennas: usize,
+    pub snr: f64,                   // signal-to-noise ratio in dB
+    pub metadata: CsiMetadata,
+}
+```
+
+### Spectrogram
+
+```rust
+pub struct Spectrogram {
+    pub data: Array2<f64>,          // (n_freq x n_time) power/magnitude
+    pub n_freq: usize,             // frequency bins (window_size/2 + 1)
+    pub n_time: usize,             // time frames
+    pub freq_resolution: f64,      // Hz per bin
+    pub time_resolution: f64,      // seconds per frame
+}
+```
+
+### SubcarrierSelection
+
+```rust
+pub struct SubcarrierSelection {
+    pub selected_indices: Vec<usize>,       // ranked by sensitivity, descending
+    pub sensitivity_scores: Vec<f64>,       // variance ratio for ALL subcarriers
+    pub selected_data: Option<Array2<f64>>, // filtered matrix (optional)
+}
+```
+
+### BodyVelocityProfile
+
+```rust
+pub struct BodyVelocityProfile {
+    pub data: Array2<f64>,          // (n_velocity_bins x n_time_frames)
+    pub velocity_bins: Vec<f64>,   // velocity value for each row (m/s)
+    pub n_time: usize,
+    pub time_resolution: f64,      // seconds per frame
+    pub velocity_resolution: f64,  // m/s per bin
+}
+```
+
+### BreathingEstimate
+
+```rust
+pub struct BreathingEstimate {
+    pub rate_bpm: f64,              // breaths per minute
+    pub confidence: f64,           // combined confidence (0.0-1.0)
+    pub period_seconds: f64,       // estimated breathing period
+    pub autocorrelation_peak: f64, // periodicity quality
+    pub fresnel_confidence: f64,   // Fresnel model match
+    pub amplitude_variation: f64,  // observed amplitude variation
+}
+```
+
+### MotionScore
+
+```rust
+pub struct MotionScore {
+    pub total: f64,                 // weighted composite (0.0-1.0)
+    pub variance_component: f64,
+    pub correlation_component: f64,
+    pub phase_component: f64,
+    pub doppler_component: Option<f64>,
+}
+```
+
+### HampelResult
+
+```rust
+pub struct HampelResult {
+    pub filtered: Vec<f64>,         // outliers replaced with local median
+    pub outlier_indices: Vec<usize>,
+    pub medians: Vec<f64>,         // local median at each sample
+    pub sigma_estimates: Vec<f64>, // estimated local sigma at each sample
+}
+```
+
+### FresnelGeometry
+
+```rust
+pub struct FresnelGeometry {
+    pub d_tx_body: f64,             // TX to body distance (meters)
+    pub d_body_rx: f64,             // body to RX distance (meters)
+    pub frequency: f64,            // carrier frequency (Hz)
+}
+
+impl FresnelGeometry {
+    pub fn wavelength(&self) -> f64;
+    pub fn fresnel_radius(&self, n: u32) -> f64;
+    pub fn phase_change(&self, displacement_m: f64) -> f64;
+    pub fn expected_amplitude_variation(&self, displacement_m: f64) -> f64;
+}
+```
+
+---
+
+## Domain Events
+
+### Preprocessing Events
+
+```rust
+pub enum PreprocessingEvent {
+    /// Raw CSI frame cleaned through the full pipeline
+    FrameCleaned {
+        timestamp: DateTime<Utc>,
+        num_antennas: usize,
+        num_subcarriers: usize,
+        noise_filtered: bool,
+        windowed: bool,
+        normalized: bool,
+    },
+
+    /// Outliers detected and replaced by Hampel filter
+    OutliersDetected {
+        subcarrier_indices: Vec<usize>,
+        replacement_values: Vec<f64>,
+        contamination_ratio: f64,
+    },
+
+    /// Phase sanitization completed
+    PhaseSanitized {
+        method: UnwrappingMethod,
+        outliers_removed: usize,
+        smoothing_applied: bool,
+    },
+}
+```
+
+### Feature Extraction Events
+
+```rust
+pub enum FeatureExtractionEvent {
+    /// Spectrogram computed from temporal CSI stream
+    SpectrogramGenerated {
+        n_time: usize,
+        n_freq: usize,
+        window_size: usize,
+        window_fn: WindowFunction,
+    },
+
+    /// Top-K sensitive subcarriers selected
+    SubcarriersSelected {
+        top_k_indices: Vec<usize>,
+        sensitivity_scores: Vec<f64>,
+        min_sensitivity_threshold: f64,
+    },
+
+    /// Body Velocity Profile extracted
+    BvpExtracted {
+        n_velocity_bins: usize,
+        n_time_frames: usize,
+        max_velocity: f64,
+        carrier_frequency: f64,
+    },
+}
+```
+
+### Motion Analysis Events
+
+```rust
+pub enum MotionAnalysisEvent {
+    /// Human motion detected above threshold
+    MotionDetected {
+        score: MotionScore,
+        confidence: f64,
+        threshold: f64,
+        timestamp: DateTime<Utc>,
+    },
+
+    /// Breathing detected via Fresnel zone model
+    BreathingDetected {
+        rate_bpm: f64,
+        amplitude_variation: f64,
+        fresnel_confidence: f64,
+        autocorrelation_peak: f64,
+    },
+
+    /// Presence state changed (entered or left)
+    PresenceChanged {
+        previous: bool,
+        current: bool,
+        smoothed_confidence: f64,
+        timestamp: DateTime<Utc>,
+    },
+
+    /// Detector calibrated with baseline variance
+    BaselineCalibrated {
+        baseline_variance: f64,
+        timestamp: DateTime<Utc>,
+    },
+}
+```
+
+---
+
+## Invariants
+
+### CSI Preprocessing Invariants
+
+1. **Conjugate multiplication requires >= 2 antenna elements.** `compute_ratio_matrix` returns `CsiRatioError::InsufficientAntennas` if `n_ant < 2`. Without two antennas, there is no pair to cancel common-mode offsets.
+
+2. **Hampel filter window must be >= 1 (half_window > 0).** A zero-width window cannot compute a local median. Enforced by `HampelError::InvalidWindow`.
+
+3. **Phase data must be within configured range before sanitization.** Default range is `[-pi, pi]`. Enforced by `PhaseSanitizer::validate_phase_data`.
+
+4. **Antenna stream lengths must match for conjugate multiplication.** `conjugate_multiply` returns `CsiRatioError::LengthMismatch` if `h_ref.len() != h_target.len()`.
+
+### Feature Extraction Invariants
+
+5. **Spectrogram window size must be > 0 and signal must be >= window_size samples.** Enforced by `SpectrogramError::SignalTooShort` and `SpectrogramError::InvalidWindowSize`.
+
+6. **Subcarrier selection must receive matching subcarrier counts.** Motion and static data must have the same number of columns. Enforced by `SelectionError::SubcarrierCountMismatch`.
+
+7. **BVP requires >= window_size temporal samples.** Insufficient history prevents STFT computation. Enforced by `BvpError::InsufficientSamples`.
+
+8. **BVP carrier frequency must be > 0 for wavelength calculation.** Zero frequency would produce a division-by-zero in the Doppler-to-velocity mapping.
+
+### Motion Analysis Invariants
+
+9. **Fresnel geometry requires positive distances (d_tx_body > 0, d_body_rx > 0).** Zero or negative distances are physically impossible. Enforced by `FresnelError::InvalidDistance`.
+
+10. **Fresnel frequency must be positive.** Required for wavelength computation. Enforced by `FresnelError::InvalidFrequency`.
+
+11. **Breathing estimation requires >= 10 amplitude samples.** Fewer samples cannot support autocorrelation analysis. Enforced by `FresnelError::InsufficientData`.
+
+12. **Motion detector history does not exceed configured max size.** Oldest entries are evicted via `VecDeque::pop_front` when capacity is reached.
+
+---
+
+## Domain Services
+
+### CsiPreprocessor
+
+Orchestrates the cleaning pipeline for a single CSI frame.
+
+```rust
+pub struct CsiPreprocessor {
+    noise_threshold: f64,
+}
+
+impl CsiPreprocessor {
+    /// Remove subcarriers below noise floor (amplitude in dB < threshold)
+    pub fn remove_noise(&self, csi_data: &CsiData) -> Result<CsiData, CsiProcessorError>;
+
+    /// Apply Hamming window to reduce spectral leakage
+    pub fn apply_windowing(&self, csi_data: &CsiData) -> Result<CsiData, CsiProcessorError>;
+
+    /// Normalize amplitude to unit variance
+    pub fn normalize_amplitude(&self, csi_data: &CsiData) -> Result<CsiData, CsiProcessorError>;
+}
+```
+
+### PhaseSanitizer
+
+Full phase cleaning pipeline: unwrap -> outlier removal -> smoothing -> noise filtering.
+
+```rust
+pub struct PhaseSanitizer {
+    config: PhaseSanitizerConfig,
+    statistics: SanitizationStatistics,
+}
+
+impl PhaseSanitizer {
+    /// Complete sanitization pipeline (all four stages)
+    pub fn sanitize_phase(
+        &mut self,
+        phase_data: &Array2<f64>,
+    ) -> Result<Array2<f64>, PhaseSanitizationError>;
+}
+```
+
+### FresnelBreathingEstimator
+
+Physics-based breathing detection using Fresnel zone geometry.
+
+```rust
+pub struct FresnelBreathingEstimator {
+    geometry: FresnelGeometry,
+    min_displacement: f64,  // 3mm default
+    max_displacement: f64,  // 15mm default
+}
+
+impl FresnelBreathingEstimator {
+    /// Check if amplitude variation matches Fresnel breathing model
+    pub fn breathing_confidence(&self, observed_amplitude_variation: f64) -> f64;
+
+    /// Estimate breathing rate via autocorrelation + Fresnel validation
+    pub fn estimate_breathing_rate(
+        &self,
+        amplitude_signal: &[f64],
+        sample_rate: f64,
+    ) -> Result<BreathingEstimate, FresnelError>;
+}
+```
+
+---
+
+## Context Map
+
+```
+--------------------------------------------------------------+
+|              Signal Processing System                         |
+--------------------------------------------------------------+
+|                                                               |
+|  +----------------+  Published   +------------------+         |
+|  |     CSI        | Language     | Feature          |         |
+|  | Preprocessing  |------------>| Extraction       |         |
+|  |    Context     |  CsiData    |    Context        |         |
+|  +-------+--------+             +--------+---------+         |
+|          |                               |                    |
+|          | Publishes                     | Publishes          |
+|          | CleanedCsiData               | CsiFeatures        |
+|          v                               v                    |
+|  +-------+-------------------------------+---------+         |
+|  |              Event Bus (Domain Events)           |         |
+|  +---------------------------+---------------------+         |
+|                              |                                |
+|                              | Subscribes                     |
+|                              v                                |
+|                    +---------+---------+                      |
+|                    |    Motion         |                      |
+|                    |    Analysis       |                      |
+|                    |    Context        |                      |
+|                    +-------------------+                      |
+|                                                               |
+---------------------------------------------------------------+
+|                   DOWNSTREAM (Customer/Supplier)              |
+|  +-----------------+  +------------------+ +--------------+   |
+|  | wifi-densepose  |  | wifi-densepose   | |wifi-densepose|   |
+|  |      -nn        |  |      -mat        | |   -train     |   |
+|  | (consumes       |  | (consumes        | |(consumes     |   |
+|  |  CsiFeatures,   |  |  BreathingEst,   | | CsiFeatures) |   |
+|  |  Spectrogram)   |  |  MotionScore)    | |              |   |
+|  +-----------------+  +------------------+ +--------------+   |
+---------------------------------------------------------------+
+|                   UPSTREAM (Conformist)                        |
+|  +-----------------+  +------------------+                    |
+|  | wifi-densepose  |  | wifi-densepose   |                    |
+|  |     -core       |  |    -hardware     |                    |
+|  | (CsiFrame       |  | (ESP32 raw CSI   |                    |
+|  |  primitives)    |  |  data ingestion) |                    |
+|  +-----------------+  +------------------+                    |
+---------------------------------------------------------------+
+```
+
+**Relationship Types**:
+- Preprocessing -> Feature Extraction: **Published Language** (CsiData is the shared contract)
+- Preprocessing -> Motion Analysis: **Customer/Supplier** (Preprocessing supplies cleaned data)
+- Feature Extraction -> Motion Analysis: **Customer/Supplier** (Features supplies CsiFeatures)
+- Signal -> wifi-densepose-nn: **Customer/Supplier** (Signal publishes Spectrogram, BVP)
+- Signal -> wifi-densepose-mat: **Customer/Supplier** (Signal publishes BreathingEstimate, MotionScore)
+- Signal <- wifi-densepose-core: **Conformist** (Signal adapts to core CsiFrame types)
+- Signal <- wifi-densepose-hardware: **Conformist** (Signal adapts to raw ESP32 CSI format)
+
+---
+
+## Anti-Corruption Layers
+
+### Hardware ACL (Upstream)
+
+Translates raw ESP32 CSI packets into the signal crate's `CsiData` value object, normalizing hardware-specific quirks (LLTF/HT-LTF format differences, antenna mapping, null subcarrier handling).
+
+```rust
+/// Normalizes vendor-specific CSI frames to canonical CsiData
+pub struct HardwareNormalizer {
+    hardware_type: HardwareType,
+}
+
+impl HardwareNormalizer {
+    /// Convert raw hardware bytes to canonical CsiData
+    pub fn normalize(
+        &self,
+        raw_csi: &[u8],
+        hardware_type: HardwareType,
+    ) -> Result<CanonicalCsiFrame, HardwareNormError>;
+}
+
+pub enum HardwareType {
+    Esp32S3,
+    Intel5300,
+    AtherosAr9580,
+    Simulation,
+}
+```
+
+### Neural Network ACL (Downstream)
+
+Adapts signal processing outputs (Spectrogram, BVP, CsiFeatures) into tensor formats expected by the `wifi-densepose-nn` crate. This boundary prevents neural network model details from leaking into the signal processing domain.
+
+```rust
+/// Adapts signal crate types to neural network tensor format
+pub struct SignalToTensorAdapter;
+
+impl SignalToTensorAdapter {
+    /// Convert Spectrogram to CNN-ready 2D tensor
+    pub fn spectrogram_to_tensor(spec: &Spectrogram) -> Array2<f32> {
+        spec.data.mapv(|v| v as f32)
+    }
+
+    /// Convert BVP to domain-independent velocity tensor
+    pub fn bvp_to_tensor(bvp: &BodyVelocityProfile) -> Array2<f32> {
+        bvp.data.mapv(|v| v as f32)
+    }
+
+    /// Convert selected subcarrier data to reduced-dimension input
+    pub fn selected_csi_to_tensor(
+        selection: &SubcarrierSelection,
+        data: &Array2<f64>,
+    ) -> Result<Array2<f32>, SelectionError> {
+        let extracted = extract_selected(data, selection)?;
+        Ok(extracted.mapv(|v| v as f32))
+    }
+}
+```
+
+### MAT ACL (Downstream)
+
+Adapts motion analysis outputs for the Mass Casualty Assessment Tool, translating domain-generic motion scores and breathing estimates into disaster-context vital signs.
+
+```rust
+/// Adapts signal processing outputs for disaster assessment
+pub struct SignalToMatAdapter;
+
+impl SignalToMatAdapter {
+    /// Convert BreathingEstimate to MAT-domain BreathingPattern
+    pub fn to_breathing_pattern(est: &BreathingEstimate) -> BreathingPattern {
+        BreathingPattern {
+            rate_bpm: est.rate_bpm as f32,
+            amplitude: est.amplitude_variation as f32,
+            regularity: est.autocorrelation_peak as f32,
+            pattern_type: classify_breathing_type(est.rate_bpm),
+        }
+    }
+
+    /// Convert MotionScore to MAT-domain presence indicator
+    pub fn to_presence_indicator(score: &MotionScore) -> PresenceIndicator {
+        PresenceIndicator {
+            detected: score.total > 0.3,
+            confidence: score.total,
+            motion_level: classify_motion_level(score),
+        }
+    }
+}
+```
@@ -26,15 +26,20 @@ WiFi DensePose turns commodity WiFi signals into real-time human pose estimation
 7. [Web UI](#web-ui)
 8. [Vital Sign Detection](#vital-sign-detection)
 9. [CLI Reference](#cli-reference)
-10. [Training a Model](#training-a-model)
+10. [Observatory Visualization](#observatory-visualization)
+11. [Adaptive Classifier](#adaptive-classifier)
+    - [Recording Training Data](#recording-training-data)
+    - [Training the Model](#training-the-model)
+    - [Using the Trained Model](#using-the-trained-model)
+12. [Training a Model](#training-a-model)
    - [CRV Signal-Line Protocol](#crv-signal-line-protocol)
-11. [RVF Model Containers](#rvf-model-containers)
-12. [Hardware Setup](#hardware-setup)
+13. [RVF Model Containers](#rvf-model-containers)
+14. [Hardware Setup](#hardware-setup)
    - [ESP32-S3 Mesh](#esp32-s3-mesh)
    - [Intel 5300 / Atheros NIC](#intel-5300--atheros-nic)
-13. [Docker Compose (Multi-Service)](#docker-compose-multi-service)
-14. [Troubleshooting](#troubleshooting)
-15. [FAQ](#faq)
+15. [Docker Compose (Multi-Service)](#docker-compose-multi-service)
+16. [Troubleshooting](#troubleshooting)
+17. [FAQ](#faq)

 ---

@@ -42,12 +47,12 @@ WiFi DensePose turns commodity WiFi signals into real-time human pose estimation

 | Requirement | Minimum | Recommended |
 |-------------|---------|-------------|
-| **OS** | Windows 10, macOS 10.15, Ubuntu 18.04 | Latest stable |
+| **OS** | Windows 10/11, macOS 10.15, Ubuntu 18.04 | Latest stable |
 | **RAM** | 4 GB | 8 GB+ |
 | **Disk** | 2 GB free | 5 GB free |
 | **Docker** (for Docker path) | Docker 20+ | Docker 24+ |
 | **Rust** (for source build) | 1.70+ | 1.85+ |
-| **Python** (for legacy v1) | 3.8+ | 3.11+ |
+| **Python** (for legacy v1) | 3.10+ | 3.13+ |

 **Hardware for live sensing (optional):**

@@ -71,26 +76,26 @@ The fastest path. No toolchain installation needed.
 docker pull ruvnet/wifi-densepose:latest
 ```

-Image size: ~132 MB. Contains the Rust sensing server, Three.js UI, and all signal processing.
+Multi-architecture image (amd64 + arm64). Works on Intel/AMD and Apple Silicon Macs. Contains the Rust sensing server, Three.js UI, and all signal processing.

 ### From Source (Rust)

 ```bash
-git clone https://github.com/ruvnet/wifi-densepose.git
-cd wifi-densepose/rust-port/wifi-densepose-rs
+git clone https://github.com/ruvnet/RuView.git
+cd RuView/rust-port/wifi-densepose-rs

 # Build
 cargo build --release

-# Verify (runs 1,100+ tests)
-cargo test --workspace
+# Verify (runs 1,400+ tests)
+cargo test --workspace --no-default-features
 ```

 The compiled binary is at `target/release/sensing-server`.

 ### From crates.io (Individual Crates)

-All 15 crates are published to crates.io at v0.3.0. Add individual crates to your own Rust project:
+All 16 crates are published to crates.io at v0.3.0. Add individual crates to your own Rust project:

 ```bash
 # Core types and traits
@@ -113,6 +118,9 @@ cargo add wifi-densepose-ruvector --features crv

 # WebAssembly bindings
 cargo add wifi-densepose-wasm
+
+# WASM edge runtime (lightweight, for embedded/IoT)
+cargo add wifi-densepose-wasm-edge
 ```

 See the full crate list and dependency order in [CLAUDE.md](../CLAUDE.md#crate-publishing-order).
@@ -120,8 +128,8 @@ See the full crate list and dependency order in [CLAUDE.md](../CLAUDE.md#crate-p
 ### From Source (Python)

 ```bash
-git clone https://github.com/ruvnet/wifi-densepose.git
-cd wifi-densepose
+git clone https://github.com/ruvnet/RuView.git
+cd RuView

 pip install -r requirements.txt
 pip install -e .
@@ -137,8 +145,8 @@ pip install wifi-densepose[all]   # All optional deps
 An interactive installer that detects your hardware and recommends a profile:

 ```bash
-git clone https://github.com/ruvnet/wifi-densepose.git
-cd wifi-densepose
+git clone https://github.com/ruvnet/RuView.git
+cd RuView
 ./install.sh
 ```

@@ -206,25 +214,27 @@ Default in Docker. Generates synthetic CSI data exercising the full pipeline.
 ```bash
 # Docker
 docker run -p 3000:3000 ruvnet/wifi-densepose:latest
-# (--source simulated is the default)
+# (--source auto is the default; falls back to simulate when no hardware detected)

 # From source
-./target/release/sensing-server --source simulated --http-port 3000 --ws-port 3001
+./target/release/sensing-server --source simulate --http-port 3000 --ws-port 3001
 ```

 ### Windows WiFi (RSSI Only)

-Uses `netsh wlan` to capture RSSI from nearby access points. No special hardware needed, but capabilities are limited to coarse presence and motion detection (no pose estimation or vital signs).
+Uses `netsh wlan` to capture RSSI from nearby access points. No special hardware needed. Supports presence detection, motion classification, and coarse breathing rate estimation. No pose estimation (requires CSI).

 ```bash
 # From source (Windows only)
-./target/release/sensing-server --source windows --http-port 3000 --ws-port 3001 --tick-ms 500
+./target/release/sensing-server --source wifi --http-port 3000 --ws-port 3001 --tick-ms 500

 # Docker (requires --network host on Windows)
-docker run --network host ruvnet/wifi-densepose:latest --source windows --tick-ms 500
+docker run --network host ruvnet/wifi-densepose:latest --source wifi --tick-ms 500
 ```

-See [Tutorial #36](https://github.com/ruvnet/wifi-densepose/issues/36) for a walkthrough.
+> **Community verified:** Tested on Windows 10 (10.0.26200) with Intel Wi-Fi 6 AX201 160MHz, Python 3.14, StormFiber 5 GHz network. All 7 tutorial steps passed with stable RSSI readings at -48 dBm. See [Tutorial #36](https://github.com/ruvnet/RuView/issues/36) for the full walkthrough and test results.
+
+**Vital signs from RSSI:** The sensing server now supports breathing rate estimation from RSSI variance patterns (requires stationary subject near AP) and motion classification with confidence scoring. RSSI-based vital sign detection has lower fidelity than ESP32 CSI — it is best for presence detection and coarse motion classification.

 ### macOS WiFi (RSSI Only)

@@ -301,6 +311,23 @@ Base URL: `http://localhost:3000` (Docker) or `http://localhost:8080` (binary de
 | `GET` | `/api/v1/model/layers` | Progressive model loading status | Layer A/B/C load state |
 | `GET` | `/api/v1/model/sona/profiles` | SONA adaptation profiles | List of environment profiles |
 | `POST` | `/api/v1/model/sona/activate` | Activate a SONA profile for a specific room | `{"profile":"kitchen"}` |
+| `GET` | `/api/v1/models` | List available RVF model files | `{"models":[...],"count":0}` |
+| `GET` | `/api/v1/models/active` | Currently loaded model (or null) | `{"model":null}` |
+| `POST` | `/api/v1/models/load` | Load a model by ID | `{"status":"loaded","model_id":"..."}` |
+| `POST` | `/api/v1/models/unload` | Unload the active model | `{"status":"unloaded"}` |
+| `DELETE` | `/api/v1/models/:id` | Delete a model file from disk | `{"status":"deleted"}` |
+| `GET` | `/api/v1/models/lora/profiles` | List LoRA adapter profiles | `{"profiles":[]}` |
+| `POST` | `/api/v1/models/lora/activate` | Activate a LoRA profile | `{"status":"activated"}` |
+| `GET` | `/api/v1/recording/list` | List CSI recording sessions | `{"recordings":[...],"count":0}` |
+| `POST` | `/api/v1/recording/start` | Start recording CSI frames to JSONL | `{"status":"recording","session_id":"..."}` |
+| `POST` | `/api/v1/recording/stop` | Stop the active recording | `{"status":"stopped","duration_secs":...}` |
+| `DELETE` | `/api/v1/recording/:id` | Delete a recording file | `{"status":"deleted"}` |
+| `GET` | `/api/v1/train/status` | Training run status | `{"phase":"idle"}` |
+| `POST` | `/api/v1/train/start` | Start a training run | `{"status":"started"}` |
+| `POST` | `/api/v1/train/stop` | Stop the active training run | `{"status":"stopped"}` |
+| `POST` | `/api/v1/adaptive/train` | Train adaptive classifier from recordings | `{"success":true,"accuracy":0.85}` |
+| `GET` | `/api/v1/adaptive/status` | Adaptive model status and accuracy | `{"loaded":true,"accuracy":0.85}` |
+| `POST` | `/api/v1/adaptive/unload` | Unload adaptive model | `{"success":true}` |

 ### Example: Get Vital Signs

@@ -347,7 +374,9 @@ curl -s http://localhost:3000/api/v1/pose/current | python -m json.tool

 Real-time sensing data is available via WebSocket.

-**URL:** `ws://localhost:3001/ws/sensing` (Docker) or `ws://localhost:8765/ws/sensing` (binary default).
+**URL:** `ws://localhost:3000/ws/sensing` (same port as HTTP — recommended) or `ws://localhost:3001/ws/sensing` (dedicated WS port).
+
+> **Note:** The `/ws/sensing` WebSocket endpoint is available on both the HTTP port (3000) and the dedicated WebSocket port (3001/8765). The web UI uses the HTTP port so only one port needs to be exposed. The dedicated WS port remains available for backward compatibility.

 ### Python Example

@@ -394,9 +423,16 @@ wscat -c ws://localhost:3001/ws/sensing

 ## Web UI

-The built-in Three.js UI is served at `http://localhost:3000/` (Docker) or the configured HTTP port.
+The built-in Three.js UI is served at `http://localhost:3000/ui/` (Docker) or the configured HTTP port.

-**What you see:**
+**Two visualization modes:**
+
+| Page | URL | Purpose |
+|------|-----|---------|
+| **Dashboard** | `/ui/index.html` | Tabbed monitoring dashboard with body model, signal heatmap, phase plot, vital signs |
+| **Observatory** | `/ui/observatory.html` | Immersive 3D room visualization with cinematic lighting and wireframe figures |
+
+**Dashboard panels:**

 | Panel | Description |
 |-------|-------------|
@@ -407,7 +443,7 @@ The built-in Three.js UI is served at `http://localhost:3000/` (Docker) or the c
 | Vital Signs | Live breathing rate (BPM) and heart rate (BPM) |
 | Dashboard | System stats, throughput, connected WebSocket clients |

-The UI updates in real-time via the WebSocket connection.
+Both UIs update in real-time via WebSocket and auto-detect the sensing server on the same origin.

 ---

@@ -425,6 +461,8 @@ The system extracts breathing rate and heart rate from CSI signal fluctuations u
 - Subject within ~3-5 meters of an access point (up to ~8 m with multistatic mesh)
 - Relatively stationary subject (large movements mask vital sign oscillations)

+**Signal smoothing:** Vital sign estimates pass through a three-stage smoothing pipeline (ADR-048): outlier rejection (±8 BPM HR, ±2 BPM BR per frame), 21-frame trimmed mean, and EMA with α=0.02. This produces stable readings that hold steady for 5-10+ seconds instead of jumping every frame. See [Adaptive Classifier](#adaptive-classifier) for details.
+
 **Simulated mode** produces synthetic vital sign data for testing.

 ---
@@ -435,7 +473,7 @@ The Rust sensing server binary accepts the following flags:

 | Flag | Default | Description |
 |------|---------|-------------|
-| `--source` | `auto` | Data source: `auto`, `simulated`, `windows`, `esp32` |
+| `--source` | `auto` | Data source: `auto`, `simulate`, `wifi`, `esp32` |
 | `--http-port` | `8080` | HTTP port for REST API and UI |
 | `--ws-port` | `8765` | WebSocket port |
 | `--udp-port` | `5005` | UDP port for ESP32 CSI frames |
@@ -456,13 +494,13 @@ The Rust sensing server binary accepts the following flags:

 ```bash
 # Simulated mode with UI (development)
-./target/release/sensing-server --source simulated --http-port 3000 --ws-port 3001 --ui-path ../../ui
+./target/release/sensing-server --source simulate --http-port 3000 --ws-port 3001 --ui-path ../../ui

 # ESP32 hardware mode
 ./target/release/sensing-server --source esp32 --udp-port 5005

 # Windows WiFi RSSI
-./target/release/sensing-server --source windows --tick-ms 500
+./target/release/sensing-server --source wifi --tick-ms 500

 # Run benchmark
 ./target/release/sensing-server --benchmark
@@ -476,6 +514,149 @@ The Rust sensing server binary accepts the following flags:

 ---

+## Observatory Visualization
+
+The Observatory is an immersive Three.js visualization that renders WiFi sensing data as a cinematic 3D experience. It features room-scale props, wireframe human figures, WiFi signal animations, and a live data HUD.
+
+**URL:** `http://localhost:3000/ui/observatory.html`
+
+**Features:**
+
+| Feature | Description |
+|---------|-------------|
+| Room scene | Furniture, walls, floor with emissive materials and 6-point lighting |
+| Wireframe figures | Up to 4 human skeletons with joint pulsation synced to breathing |
+| Signal field | Volumetric WiFi wave visualization |
+| Live HUD | Heart rate, breathing rate, confidence, RSSI, motion level |
+| Auto-detect | Automatically connects to live ESP32 data when sensing server is running |
+| Scenario cycling | 6 preset scenarios with smooth transitions (demo mode) |
+
+**Keyboard shortcuts:**
+
+| Key | Action |
+|-----|--------|
+| `1-6` | Switch scenario |
+| `A` | Toggle auto-cycle |
+| `P` | Pause/resume |
+| `S` | Open settings |
+| `R` | Reset camera |
+
+**Live data auto-detect:** When served by the sensing server, the Observatory probes `/health` on the same origin and automatically connects via WebSocket. The HUD badge switches from `DEMO` to `LIVE`. No configuration needed.
+
+---
+
+## Adaptive Classifier
+
+The adaptive classifier (ADR-048) learns your environment's specific WiFi signal patterns from labeled recordings. It replaces static threshold-based classification with a trained logistic regression model that uses 15 features (7 server-computed + 8 subcarrier-derived statistics).
+
+### Signal Smoothing Pipeline
+
+All CSI-derived metrics pass through a three-stage pipeline before reaching the UI:
+
+| Stage | What It Does | Key Parameters |
+|-------|-------------|----------------|
+| **Adaptive baseline** | Learns quiet-room noise floor, subtracts drift | α=0.003, 50-frame warm-up |
+| **EMA + median filter** | Smooths motion score and vital signs | Motion α=0.15; Vitals: 21-frame trimmed mean, α=0.02 |
+| **Hysteresis debounce** | Prevents rapid state flickering | 4 frames (~0.4s) required for state transition |
+
+Vital signs use additional stabilization:
+
+| Parameter | Value | Effect |
+|-----------|-------|--------|
+| HR dead-band | ±2 BPM | Prevents micro-drift |
+| BR dead-band | ±0.5 BPM | Prevents micro-drift |
+| HR max jump | 8 BPM/frame | Rejects noise spikes |
+| BR max jump | 2 BPM/frame | Rejects noise spikes |
+
+### Recording Training Data
+
+Record labeled CSI sessions while performing distinct activities. Each recording captures full sensing frames (features + raw subcarrier amplitudes) at ~10-25 FPS.
+
+```bash
+# 1. Record empty room (leave the room for 30 seconds)
+curl -X POST http://localhost:3000/api/v1/recording/start \
+  -H "Content-Type: application/json" -d '{"id":"train_empty_room"}'
+# ... wait 30 seconds ...
+curl -X POST http://localhost:3000/api/v1/recording/stop
+
+# 2. Record sitting still (sit near ESP32 for 30 seconds)
+curl -X POST http://localhost:3000/api/v1/recording/start \
+  -H "Content-Type: application/json" -d '{"id":"train_sitting_still"}'
+# ... wait 30 seconds ...
+curl -X POST http://localhost:3000/api/v1/recording/stop
+
+# 3. Record walking (walk around the room for 30 seconds)
+curl -X POST http://localhost:3000/api/v1/recording/start \
+  -H "Content-Type: application/json" -d '{"id":"train_walking"}'
+# ... wait 30 seconds ...
+curl -X POST http://localhost:3000/api/v1/recording/stop
+
+# 4. Record active movement (jumping jacks, arm waving for 30 seconds)
+curl -X POST http://localhost:3000/api/v1/recording/start \
+  -H "Content-Type: application/json" -d '{"id":"train_active"}'
+# ... wait 30 seconds ...
+curl -X POST http://localhost:3000/api/v1/recording/stop
+```
+
+Recordings are saved as JSONL files in `data/recordings/`. Filenames must start with `train_` and contain a class keyword:
+
+| Filename pattern | Class |
+|-----------------|-------|
+| `*empty*` or `*absent*` | absent |
+| `*still*` or `*sitting*` | present_still |
+| `*walking*` or `*moving*` | present_moving |
+| `*active*` or `*exercise*` | active |
+
+### Training the Model
+
+Train the adaptive classifier from your labeled recordings:
+
+```bash
+curl -X POST http://localhost:3000/api/v1/adaptive/train
+```
+
+The server trains a multiclass logistic regression on 15 features using mini-batch SGD (200 epochs). Training completes in under 1 second for typical recording sets. The trained model is saved to `data/adaptive_model.json` and automatically loaded on server restart.
+
+**Check model status:**
+
+```bash
+curl http://localhost:3000/api/v1/adaptive/status
+```
+
+**Unload the model (revert to threshold-based classification):**
+
+```bash
+curl -X POST http://localhost:3000/api/v1/adaptive/unload
+```
+
+### Using the Trained Model
+
+Once trained, the adaptive model runs automatically:
+
+1. Each CSI frame is classified using the learned weights instead of static thresholds
+2. Model confidence is blended with smoothed threshold confidence (70/30 split)
+3. The model persists across server restarts (loaded from `data/adaptive_model.json`)
+
+**Tips for better accuracy:**
+
+- Record with clearly distinct activities (actually leave the room for "empty")
+- Record 30-60 seconds per activity (more data = better model)
+- Re-record and retrain if you move the ESP32 or rearrange the room
+- The model is environment-specific — retrain when the physical setup changes
+
+### Adaptive Classifier API
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `POST` | `/api/v1/adaptive/train` | Train from `train_*` recordings |
+| `GET` | `/api/v1/adaptive/status` | Model status, accuracy, class stats |
+| `POST` | `/api/v1/adaptive/unload` | Unload model, revert to thresholds |
+| `POST` | `/api/v1/recording/start` | Start recording CSI frames |
+| `POST` | `/api/v1/recording/stop` | Stop recording |
+| `GET` | `/api/v1/recording/list` | List recordings |
+
+---
+
 ## Training a Model

 The training pipeline is implemented in pure Rust (7,832 lines, zero external ML dependencies).
@@ -612,12 +793,12 @@ A 3-6 node ESP32-S3 mesh provides full CSI at 20 Hz. Total cost: ~$54 for a 3-no

 **Flashing firmware:**

-Pre-built binaries are available at [Releases](https://github.com/ruvnet/wifi-densepose/releases):
+Pre-built binaries are available at [Releases](https://github.com/ruvnet/RuView/releases):

 | Release | What It Includes | Tag |
 |---------|-----------------|-----|
-| [v0.2.0](https://github.com/ruvnet/wifi-densepose/releases/tag/v0.2.0-esp32) | Stable — raw CSI streaming, TDM, channel hopping, QUIC mesh | `v0.2.0-esp32` |
-| [v0.3.0-alpha](https://github.com/ruvnet/wifi-densepose/releases/tag/v0.3.0-alpha-esp32) | Alpha — adds on-device edge intelligence (ADR-039) | `v0.3.0-alpha-esp32` |
+| [v0.2.0](https://github.com/ruvnet/RuView/releases/tag/v0.2.0-esp32) | Stable — raw CSI streaming, TDM, channel hopping, QUIC mesh | `v0.2.0-esp32` |
+| [v0.3.0-alpha](https://github.com/ruvnet/RuView/releases/tag/v0.3.0-alpha-esp32) | Alpha — adds on-device edge intelligence (ADR-039) | `v0.3.0-alpha-esp32` |

 ```bash
 # Flash an ESP32-S3 (requires esptool: pip install esptool)
@@ -708,7 +889,7 @@ Binary size: 777 KB (24% free in the 1 MB app partition).
 docker run -p 3000:3000 -p 3001:3001 -p 5005:5005/udp ruvnet/wifi-densepose:latest --source esp32
 ```

-See [ADR-018](../docs/adr/ADR-018-esp32-dev-implementation.md), [ADR-029](../docs/adr/ADR-029-ruvsense-multistatic-sensing-mode.md), and [Tutorial #34](https://github.com/ruvnet/wifi-densepose/issues/34).
+See [ADR-018](../docs/adr/ADR-018-esp32-dev-implementation.md), [ADR-029](../docs/adr/ADR-029-ruvsense-multistatic-sensing-mode.md), and [Tutorial #34](https://github.com/ruvnet/RuView/issues/34).

 ### Intel 5300 / Atheros NIC

@@ -740,6 +921,20 @@ This starts:

 ## Troubleshooting

+### Docker: "no matching manifest for linux/arm64" on macOS
+
+The `latest` tag supports both amd64 and arm64. Pull the latest image:
+
+```bash
+docker pull ruvnet/wifi-densepose:latest
+```
+
+If you still see this error, your local Docker may have a stale cached manifest. Try:
+
+```bash
+docker pull --platform linux/arm64 ruvnet/wifi-densepose:latest
+```
+
 ### Docker: "Connection refused" on localhost:3000

 Make sure you're mapping the ports correctly:
@@ -775,13 +970,28 @@ rustc --version

 ### Windows: RSSI mode shows no data

-Run the terminal as Administrator (required for `netsh wlan` access).
+Run the terminal as Administrator (required for `netsh wlan` access). Verified working on Windows 10 and 11 with Intel AX201 and Intel BE201 adapters.

 ### Vital signs show 0 BPM

 - Vital sign detection requires CSI-capable hardware (ESP32 or research NIC)
 - RSSI-only mode (Windows WiFi) does not have sufficient resolution for vital signs
 - In simulated mode, synthetic vital signs are generated after a few seconds of warm-up
+- With real ESP32 data, vital signs take ~5 seconds to stabilize (smoothing pipeline warm-up)
+
+### Vital signs jumping around
+
+The server applies a 3-stage smoothing pipeline (ADR-048). If readings are still unstable:
+- Ensure the subject is relatively still (large movements mask vital sign oscillations)
+- Train the adaptive classifier for your specific environment: `curl -X POST http://localhost:3000/api/v1/adaptive/train`
+- Check signal quality: `curl http://localhost:3000/api/v1/sensing/latest` — look for `signal_quality > 0.4`
+
+### Observatory shows DEMO instead of LIVE
+
+- Verify the sensing server is running: `curl http://localhost:3000/health`
+- Access Observatory via the server URL: `http://localhost:3000/ui/observatory.html` (not a file:// URL)
+- Hard refresh with Ctrl+Shift+R to clear cached settings
+- The auto-detect probes `/health` on the same origin — cross-origin won't work

 ---

@@ -808,11 +1018,20 @@ The system uses WiFi radio signals, not cameras. No images or video are captured
 **Q: What's the Python vs Rust difference?**
 The Rust implementation (v2) is 810x faster than Python (v1) for the full CSI pipeline. The Docker image is 132 MB vs 569 MB. Rust is the primary and recommended runtime. Python v1 remains available for legacy workflows.

+**Q: Can I use an ESP8266 instead of ESP32-S3?**
+No. The ESP8266 does not expose WiFi Channel State Information (CSI) through its SDK, has insufficient RAM (~80 KB vs 512 KB), and runs a single-core 80 MHz CPU that cannot handle the signal processing pipeline. The ESP32-S3 is the minimum supported CSI capture device. See [Issue #138](https://github.com/ruvnet/RuView/issues/138) for alternatives including using cheap Android TV boxes as aggregation hubs.
+
+**Q: Does the Windows WiFi tutorial work on Windows 10?**
+Yes. Community-tested on Windows 10 (build 26200) with an Intel Wi-Fi 6 AX201 160MHz adapter on a 5 GHz network. All 7 tutorial steps passed with Python 3.14. See [Issue #36](https://github.com/ruvnet/RuView/issues/36) for full test results.
+
+**Q: Can I run the sensing server on an ARM device (Raspberry Pi, TV box)?**
+ARM64 deployment is planned ([ADR-046](adr/ADR-046-android-tv-box-armbian-deployment.md)) but not yet available as a pre-built binary. You can cross-compile from source using `cross build --release --target aarch64-unknown-linux-gnu -p wifi-densepose-sensing-server` if you have the Rust cross-compilation toolchain set up.
+
 ---

 ## Further Reading

- [Architecture Decision Records](../docs/adr/) - 33 ADRs covering all design decisions
+- [Architecture Decision Records](../docs/adr/) - 48 ADRs covering all design decisions
 - [WiFi-Mat Disaster Response Guide](wifi-mat-user-guide.md) - Search & rescue module
 - [Build Guide](build-guide.md) - Detailed build instructions
 - [RuVector](https://github.com/ruvnet/ruvector) - Signal intelligence crate ecosystem
@@ -1,6 +1,19 @@
-idf_component_register(
-    SRCS "main.c" "csi_collector.c" "stream_sender.c" "nvs_config.c"
-         "edge_processing.c" "ota_update.c" "power_mgmt.c"
-         "wasm_runtime.c" "wasm_upload.c" "rvf_parser.c"
-    INCLUDE_DIRS "."
+set(SRCS
+    "main.c" "csi_collector.c" "stream_sender.c" "nvs_config.c"
+    "edge_processing.c" "ota_update.c" "power_mgmt.c"
+    "wasm_runtime.c" "wasm_upload.c" "rvf_parser.c"
+)
+
+set(REQUIRES "")
+
+# ADR-045: AMOLED display support (compile-time optional)
+if(CONFIG_DISPLAY_ENABLE)
+    list(APPEND SRCS "display_hal.c" "display_ui.c" "display_task.c")
+    set(REQUIRES esp_lcd esp_lcd_touch lvgl)
+endif()
+
+idf_component_register(
+    SRCS ${SRCS}
+    INCLUDE_DIRS "."
+    REQUIRES ${REQUIRES}
 )
@@ -85,6 +85,87 @@ menu "Edge Intelligence (ADR-039)"

 endmenu

+menu "AMOLED Display (ADR-045)"
+
+    config DISPLAY_ENABLE
+        bool "Enable AMOLED display support"
+        default y
+        help
+            Enable RM67162 QSPI AMOLED display and LVGL UI.
+            Auto-detects at boot; gracefully skips if no display hardware.
+            Requires SPIRAM for frame buffers.
+
+    config DISPLAY_FPS_LIMIT
+        int "Display refresh rate limit (FPS)"
+        default 30
+        range 10 60
+        depends on DISPLAY_ENABLE
+        help
+            Maximum display refresh rate. Lower values save CPU.
+
+    config DISPLAY_BRIGHTNESS
+        int "Default backlight brightness (%)"
+        default 80
+        range 0 100
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_QSPI_CS
+        int "QSPI CS GPIO"
+        default 6
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_QSPI_CLK
+        int "QSPI CLK GPIO"
+        default 47
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_QSPI_D0
+        int "QSPI D0 GPIO"
+        default 18
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_QSPI_D1
+        int "QSPI D1 GPIO"
+        default 7
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_QSPI_D2
+        int "QSPI D2 GPIO"
+        default 48
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_QSPI_D3
+        int "QSPI D3 GPIO"
+        default 5
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_TOUCH_SDA
+        int "Touch I2C SDA GPIO"
+        default 3
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_TOUCH_SCL
+        int "Touch I2C SCL GPIO"
+        default 2
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_TOUCH_INT
+        int "Touch INT GPIO"
+        default 21
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_TOUCH_RST
+        int "Touch RST GPIO"
+        default 17
+        depends on DISPLAY_ENABLE
+
+    config DISPLAY_BL_PIN
+        int "Backlight PWM GPIO"
+        default 38
+        depends on DISPLAY_ENABLE
+
+endmenu
+
 menu "WASM Programmable Sensing (ADR-040)"

    config WASM_ENABLE
@@ -27,6 +27,16 @@ static uint32_t s_sequence = 0;
 static uint32_t s_cb_count = 0;
 static uint32_t s_send_ok = 0;
 static uint32_t s_send_fail = 0;
+static uint32_t s_rate_skip = 0;
+
+/**
+ * Minimum interval between UDP sends in microseconds.
+ * CSI callbacks can fire hundreds of times per second in promiscuous mode.
+ * We cap the send rate to avoid exhausting lwIP packet buffers (ENOMEM).
+ * Default: 20 ms = 50 Hz max send rate.
+ */
+#define CSI_MIN_SEND_INTERVAL_US  (20 * 1000)
+static int64_t s_last_send_us = 0;

 /* ---- ADR-029: Channel-hop state ---- */

@@ -143,14 +153,23 @@ static void wifi_csi_callback(void *ctx, wifi_csi_info_t *info)
    size_t frame_len = csi_serialize_frame(info, frame_buf, sizeof(frame_buf));

    if (frame_len > 0) {
-        int ret = stream_sender_send(frame_buf, frame_len);
-        if (ret > 0) {
-            s_send_ok++;
-        } else {
-            s_send_fail++;
-            if (s_send_fail <= 5) {
-                ESP_LOGW(TAG, "sendto failed (fail #%lu)", (unsigned long)s_send_fail);
+        /* Rate-limit UDP sends to avoid ENOMEM from lwIP pbuf exhaustion.
+         * In promiscuous mode, CSI callbacks can fire 100-500+ times/sec.
+         * We only need 20-50 Hz for the sensing pipeline. */
+        int64_t now = esp_timer_get_time();
+        if ((now - s_last_send_us) >= CSI_MIN_SEND_INTERVAL_US) {
+            int ret = stream_sender_send(frame_buf, frame_len);
+            if (ret > 0) {
+                s_send_ok++;
+                s_last_send_us = now;
+            } else {
+                s_send_fail++;
+                if (s_send_fail <= 5) {
+                    ESP_LOGW(TAG, "sendto failed (fail #%lu)", (unsigned long)s_send_fail);
+                }
            }
+        } else {
+            s_rate_skip++;
        }
    }

@@ -0,0 +1,382 @@
+/**
+ * @file display_hal.c
+ * @brief ADR-045: SH8601 QSPI AMOLED HAL for Waveshare ESP32-S3-Touch-AMOLED-1.8.
+ *
+ * Uses ESP-IDF esp_lcd_panel_io_spi in QSPI mode (quad_mode=true, lcd_cmd_bits=32).
+ * The panel_io layer handles the 0x02/0x32 QSPI command encoding.
+ *
+ * Hardware: SH8601 368x448, FT3168 touch, TCA9554 I/O expander for power/reset.
+ *
+ * Pin assignments (Waveshare ESP32-S3-Touch-AMOLED-1.8):
+ *   QSPI: CS=12, CLK=11, D0=4, D1=5, D2=6, D3=7
+ *   I2C:  SDA=15, SCL=14  (shared: touch FT3168 + TCA9554 expander)
+ *   Touch INT=21
+ */
+
+#include "display_hal.h"
+#include "sdkconfig.h"
+
+#if CONFIG_DISPLAY_ENABLE
+
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "esp_lcd_panel_io.h"
+#include "driver/spi_master.h"
+#include "driver/gpio.h"
+#include "driver/i2c.h"
+#include "esp_heap_caps.h"
+
+static const char *TAG = "disp_hal";
+
+/* ---- QSPI Pin Definitions (Waveshare board) ---- */
+#define DISP_QSPI_CS       12
+#define DISP_QSPI_CLK      11
+#define DISP_QSPI_D0       4
+#define DISP_QSPI_D1       5
+#define DISP_QSPI_D2       6
+#define DISP_QSPI_D3       7
+
+/* ---- I2C (shared: touch + TCA9554 expander) ---- */
+#define I2C_SDA             15
+#define I2C_SCL             14
+#define TOUCH_INT_PIN       21
+#define I2C_MASTER_NUM      I2C_NUM_0
+#define I2C_MASTER_FREQ_HZ  400000
+
+/* ---- TCA9554 I/O expander ---- */
+#define TCA9554_ADDR        0x20
+#define TCA9554_REG_OUTPUT  0x01
+#define TCA9554_REG_CONFIG  0x03
+
+/* ---- FT3168 touch controller ---- */
+#define FT3168_ADDR         0x38
+
+/* ---- Display dimensions ---- */
+#define DISP_H_RES          368
+#define DISP_V_RES          448
+
+/* ---- QSPI opcodes (packed into lcd_cmd bits [31:24]) ---- */
+#define LCD_OPCODE_WRITE_CMD   0x02
+#define LCD_OPCODE_WRITE_COLOR 0x32
+
+/* ---- State ---- */
+static esp_lcd_panel_io_handle_t s_io_handle = NULL;
+static bool s_i2c_initialized = false;
+static bool s_touch_initialized = false;
+
+/* ---- I2C helpers ---- */
+
+static esp_err_t i2c_write_reg(uint8_t dev_addr, uint8_t reg, const uint8_t *data, size_t len)
+{
+    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+    i2c_master_start(cmd);
+    i2c_master_write_byte(cmd, (dev_addr << 1) | I2C_MASTER_WRITE, true);
+    i2c_master_write_byte(cmd, reg, true);
+    if (data && len > 0) {
+        i2c_master_write(cmd, data, len, true);
+    }
+    i2c_master_stop(cmd);
+    esp_err_t ret = i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, pdMS_TO_TICKS(100));
+    i2c_cmd_link_delete(cmd);
+    return ret;
+}
+
+static esp_err_t i2c_read_reg(uint8_t dev_addr, uint8_t reg, uint8_t *data, size_t len)
+{
+    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+    i2c_master_start(cmd);
+    i2c_master_write_byte(cmd, (dev_addr << 1) | I2C_MASTER_WRITE, true);
+    i2c_master_write_byte(cmd, reg, true);
+    i2c_master_start(cmd);
+    i2c_master_write_byte(cmd, (dev_addr << 1) | I2C_MASTER_READ, true);
+    i2c_master_read(cmd, data, len, I2C_MASTER_LAST_NACK);
+    i2c_master_stop(cmd);
+    esp_err_t ret = i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, pdMS_TO_TICKS(100));
+    i2c_cmd_link_delete(cmd);
+    return ret;
+}
+
+static esp_err_t init_i2c_bus(void)
+{
+    if (s_i2c_initialized) return ESP_OK;
+
+    i2c_config_t i2c_cfg = {
+        .mode             = I2C_MODE_MASTER,
+        .sda_io_num       = I2C_SDA,
+        .scl_io_num       = I2C_SCL,
+        .sda_pullup_en    = GPIO_PULLUP_ENABLE,
+        .scl_pullup_en    = GPIO_PULLUP_ENABLE,
+        .master.clk_speed = I2C_MASTER_FREQ_HZ,
+    };
+
+    esp_err_t ret = i2c_param_config(I2C_MASTER_NUM, &i2c_cfg);
+    if (ret != ESP_OK) return ret;
+
+    ret = i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, 0, 0, 0);
+    if (ret != ESP_OK) return ret;
+
+    s_i2c_initialized = true;
+    ESP_LOGI(TAG, "I2C bus init OK (SDA=%d, SCL=%d)", I2C_SDA, I2C_SCL);
+    return ESP_OK;
+}
+
+/* ---- TCA9554 I/O expander: toggle pins for display power/reset ---- */
+
+static esp_err_t tca9554_init_display_power(void)
+{
+    /* Set pins 0, 1, 2 as outputs */
+    uint8_t cfg = 0xF8;
+    esp_err_t ret = i2c_write_reg(TCA9554_ADDR, TCA9554_REG_CONFIG, &cfg, 1);
+    if (ret != ESP_OK) {
+        ESP_LOGW(TAG, "TCA9554 not found at 0x%02X: %s", TCA9554_ADDR, esp_err_to_name(ret));
+        return ret;
+    }
+
+    /* Set pins 0,1,2 LOW (reset state) */
+    uint8_t out = 0x00;
+    i2c_write_reg(TCA9554_ADDR, TCA9554_REG_OUTPUT, &out, 1);
+    vTaskDelay(pdMS_TO_TICKS(200));
+
+    /* Set pins 0,1,2 HIGH (power on + release reset) */
+    out = 0x07;
+    i2c_write_reg(TCA9554_ADDR, TCA9554_REG_OUTPUT, &out, 1);
+    vTaskDelay(pdMS_TO_TICKS(200));
+
+    ESP_LOGI(TAG, "TCA9554 display power/reset toggled");
+    return ESP_OK;
+}
+
+/* ---- Panel IO helpers: send commands via esp_lcd QSPI panel IO ---- */
+
+static esp_err_t panel_write_cmd(uint8_t dcs_cmd, const void *data, size_t data_len)
+{
+    /* Pack as 32-bit lcd_cmd: [31:24]=opcode, [23:8]=dcs_cmd, [7:0]=0 */
+    uint32_t lcd_cmd = ((uint32_t)LCD_OPCODE_WRITE_CMD << 24) | ((uint32_t)dcs_cmd << 8);
+    return esp_lcd_panel_io_tx_param(s_io_handle, (int)lcd_cmd, data, data_len);
+}
+
+static esp_err_t panel_write_color(const void *color_data, size_t data_len)
+{
+    /* RAMWR (0x2C) packed as 32-bit lcd_cmd with quad opcode */
+    uint32_t lcd_cmd = ((uint32_t)LCD_OPCODE_WRITE_COLOR << 24) | (0x2C << 8);
+    return esp_lcd_panel_io_tx_color(s_io_handle, (int)lcd_cmd, color_data, data_len);
+}
+
+/* ---- SH8601 init sequence (from Waveshare reference) ---- */
+
+typedef struct {
+    uint8_t cmd;
+    uint8_t data[4];
+    uint8_t data_len;
+    uint16_t delay_ms;
+} sh8601_init_cmd_t;
+
+static const sh8601_init_cmd_t sh8601_init_cmds[] = {
+    {0x11, {0x00},                   0, 120},  /* Sleep Out + 120ms */
+    {0x44, {0x01, 0xD1},             2, 0},    /* Partial area */
+    {0x35, {0x00},                   1, 0},    /* Tearing Effect ON */
+    {0x53, {0x20},                   1, 10},   /* Write CTRL Display */
+    {0x2A, {0x00, 0x00, 0x01, 0x6F}, 4, 0},   /* CASET: 0-367 */
+    {0x2B, {0x00, 0x00, 0x01, 0xBF}, 4, 0},   /* RASET: 0-447 */
+    {0x51, {0x00},                   1, 10},   /* Brightness: 0 */
+    {0x29, {0x00},                   0, 10},   /* Display ON */
+    {0x51, {0xFF},                   1, 0},    /* Brightness: max */
+    {0x00, {0x00},                   0xFF, 0}, /* End sentinel */
+};
+
+static esp_err_t send_init_sequence(void)
+{
+    for (int i = 0; sh8601_init_cmds[i].data_len != 0xFF; i++) {
+        const sh8601_init_cmd_t *cmd = &sh8601_init_cmds[i];
+        esp_err_t ret = panel_write_cmd(
+            cmd->cmd,
+            cmd->data_len > 0 ? cmd->data : NULL,
+            cmd->data_len);
+        if (ret != ESP_OK) {
+            ESP_LOGE(TAG, "CMD 0x%02X failed: %s", cmd->cmd, esp_err_to_name(ret));
+            return ret;
+        }
+        if (cmd->delay_ms > 0) {
+            vTaskDelay(pdMS_TO_TICKS(cmd->delay_ms));
+        }
+    }
+    return ESP_OK;
+}
+
+/* ---- Public API ---- */
+
+esp_err_t display_hal_init_panel(void)
+{
+    ESP_LOGI(TAG, "Initializing Waveshare AMOLED 1.8\" (SH8601 368x448)...");
+
+    /* Step 1: Init I2C bus */
+    esp_err_t ret = init_i2c_bus();
+    if (ret != ESP_OK) {
+        ESP_LOGW(TAG, "I2C bus init failed");
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    /* Step 2: TCA9554 display power/reset (optional — only present on Waveshare board) */
+    ret = tca9554_init_display_power();
+    if (ret != ESP_OK) {
+        ESP_LOGW(TAG, "TCA9554 not found — assuming display power is always-on (direct wiring)");
+        /* Continue without TCA9554 — the display may be powered directly */
+    }
+
+    /* Step 3: Initialize SPI bus */
+    spi_bus_config_t bus_cfg = {
+        .sclk_io_num     = DISP_QSPI_CLK,
+        .data0_io_num    = DISP_QSPI_D0,
+        .data1_io_num    = DISP_QSPI_D1,
+        .data2_io_num    = DISP_QSPI_D2,
+        .data3_io_num    = DISP_QSPI_D3,
+        .max_transfer_sz = DISP_H_RES * DISP_V_RES * 2,
+    };
+
+    ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
+    if (ret != ESP_OK) {
+        ESP_LOGW(TAG, "SPI bus init failed: %s", esp_err_to_name(ret));
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    /* Step 4: Create panel IO with QSPI mode */
+    esp_lcd_panel_io_spi_config_t io_config = {
+        .dc_gpio_num       = -1,       /* No DC pin in QSPI mode */
+        .cs_gpio_num       = DISP_QSPI_CS,
+        .pclk_hz           = 40 * 1000 * 1000,
+        .lcd_cmd_bits      = 32,       /* 32-bit command: [opcode|dcs_cmd|0x00] */
+        .lcd_param_bits    = 8,
+        .spi_mode          = 0,
+        .trans_queue_depth = 10,
+        .flags = {
+            .quad_mode = true,
+        },
+    };
+
+    ret = esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)SPI2_HOST, &io_config, &s_io_handle);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Panel IO init failed: %s", esp_err_to_name(ret));
+        spi_bus_free(SPI2_HOST);
+        return ESP_ERR_NOT_FOUND;
+    }
+    ESP_LOGI(TAG, "QSPI panel IO created (40MHz, quad mode)");
+
+    /* Step 5: Send SH8601 init sequence */
+    ret = send_init_sequence();
+    if (ret != ESP_OK) {
+        ESP_LOGW(TAG, "SH8601 init sequence failed");
+        esp_lcd_panel_io_del(s_io_handle);
+        spi_bus_free(SPI2_HOST);
+        s_io_handle = NULL;
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    /* Step 6: Draw test pattern — cyan bar at top */
+    ESP_LOGI(TAG, "Drawing test pattern...");
+    uint16_t *line_buf = heap_caps_malloc(DISP_H_RES * 2, MALLOC_CAP_DMA);
+    if (line_buf) {
+        uint8_t caset[4] = {0, 0, (DISP_H_RES - 1) >> 8, (DISP_H_RES - 1) & 0xFF};
+        uint8_t raset[4] = {0, 0, (DISP_V_RES - 1) >> 8, (DISP_V_RES - 1) & 0xFF};
+        panel_write_cmd(0x2A, caset, 4);
+        panel_write_cmd(0x2B, raset, 4);
+
+        for (int y = 0; y < DISP_V_RES; y++) {
+            uint16_t color = (y < 30) ? 0x07FF : 0x0841;
+            for (int x = 0; x < DISP_H_RES; x++) {
+                line_buf[x] = color;
+            }
+            panel_write_color(line_buf, DISP_H_RES * 2);
+        }
+        free(line_buf);
+        ESP_LOGI(TAG, "Test pattern drawn");
+    }
+
+    ESP_LOGI(TAG, "SH8601 panel init OK (%dx%d)", DISP_H_RES, DISP_V_RES);
+    return ESP_OK;
+}
+
+void display_hal_draw(int x_start, int y_start, int x_end, int y_end,
+                      const void *color_data)
+{
+    if (!s_io_handle) return;
+
+    /* SH8601 requires coordinates divisible by 2 */
+    x_start &= ~1;
+    y_start &= ~1;
+    if (x_end & 1) x_end++;
+    if (y_end & 1) y_end++;
+    if (x_end > DISP_H_RES) x_end = DISP_H_RES;
+    if (y_end > DISP_V_RES) y_end = DISP_V_RES;
+
+    uint8_t caset[4] = {
+        (x_start >> 8) & 0xFF, x_start & 0xFF,
+        ((x_end - 1) >> 8) & 0xFF, (x_end - 1) & 0xFF,
+    };
+    panel_write_cmd(0x2A, caset, 4);
+
+    uint8_t raset[4] = {
+        (y_start >> 8) & 0xFF, y_start & 0xFF,
+        ((y_end - 1) >> 8) & 0xFF, (y_end - 1) & 0xFF,
+    };
+    panel_write_cmd(0x2B, raset, 4);
+
+    size_t len = (x_end - x_start) * (y_end - y_start) * 2;
+    panel_write_color(color_data, len);
+}
+
+esp_err_t display_hal_init_touch(void)
+{
+    ESP_LOGI(TAG, "Probing FT3168 touch controller...");
+
+    if (!s_i2c_initialized) {
+        esp_err_t ret = init_i2c_bus();
+        if (ret != ESP_OK) return ESP_ERR_NOT_FOUND;
+    }
+
+    gpio_config_t int_cfg = {
+        .pin_bit_mask = (1ULL << TOUCH_INT_PIN),
+        .mode         = GPIO_MODE_INPUT,
+        .pull_up_en   = GPIO_PULLUP_ENABLE,
+        .intr_type    = GPIO_INTR_DISABLE,
+    };
+    gpio_config(&int_cfg);
+
+    uint8_t chip_id = 0;
+    esp_err_t ret = i2c_read_reg(FT3168_ADDR, 0xA8, &chip_id, 1);
+    if (ret != ESP_OK || chip_id == 0x00 || chip_id == 0xFF) {
+        ESP_LOGW(TAG, "FT3168 not found (ret=%s, id=0x%02X)", esp_err_to_name(ret), chip_id);
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    s_touch_initialized = true;
+    ESP_LOGI(TAG, "FT3168 touch init OK (chip_id=0x%02X)", chip_id);
+    return ESP_OK;
+}
+
+bool display_hal_touch_read(uint16_t *x, uint16_t *y)
+{
+    if (!s_touch_initialized) return false;
+
+    uint8_t buf[7] = {0};
+    esp_err_t ret = i2c_read_reg(FT3168_ADDR, 0x01, buf, 7);
+    if (ret != ESP_OK) return false;
+
+    uint8_t num_points = buf[1];
+    if (num_points == 0 || num_points > 2) return false;
+
+    *x = ((buf[2] & 0x0F) << 8) | buf[3];
+    *y = ((buf[4] & 0x0F) << 8) | buf[5];
+    return true;
+}
+
+void display_hal_set_brightness(uint8_t percent)
+{
+    if (!s_io_handle) return;
+    if (percent > 100) percent = 100;
+    uint8_t val = (uint8_t)((uint32_t)percent * 255 / 100);
+    panel_write_cmd(0x51, &val, 1);
+}
+
+#endif /* CONFIG_DISPLAY_ENABLE */
@@ -0,0 +1,71 @@
+/**
+ * @file display_hal.h
+ * @brief ADR-045: RM67162 QSPI AMOLED + CST816S touch HAL.
+ *
+ * Hardware abstraction for the LilyGO T-Display-S3 AMOLED panel.
+ * Probes hardware at boot; returns ESP_ERR_NOT_FOUND if absent.
+ */
+
+#ifndef DISPLAY_HAL_H
+#define DISPLAY_HAL_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Probe and initialize the RM67162 QSPI AMOLED panel.
+ *
+ * Configures QSPI bus, sends panel init sequence, and fills
+ * the screen with dark background to confirm it works.
+ * Returns ESP_ERR_NOT_FOUND if the panel does not respond.
+ *
+ * @return ESP_OK on success, ESP_ERR_NOT_FOUND if no display detected.
+ */
+esp_err_t display_hal_init_panel(void);
+
+/**
+ * Draw a rectangle of pixels to the AMOLED.
+ * Sends CASET + RASET + RAMWR directly via QSPI.
+ *
+ * @param x_start  Left column (inclusive).
+ * @param y_start  Top row (inclusive).
+ * @param x_end    Right column (exclusive).
+ * @param y_end    Bottom row (exclusive).
+ * @param color_data  RGB565 pixel data, (x_end-x_start)*(y_end-y_start) pixels.
+ */
+void display_hal_draw(int x_start, int y_start, int x_end, int y_end,
+                      const void *color_data);
+
+/**
+ * Probe and initialize the CST816S capacitive touch controller.
+ *
+ * @return ESP_OK on success, ESP_ERR_NOT_FOUND if no touch IC detected.
+ */
+esp_err_t display_hal_init_touch(void);
+
+/**
+ * Read touch point (non-blocking).
+ *
+ * @param[out] x  Touch X coordinate (0..535).
+ * @param[out] y  Touch Y coordinate (0..239).
+ * @return true if touch is active, false if released.
+ */
+bool display_hal_touch_read(uint16_t *x, uint16_t *y);
+
+/**
+ * Set AMOLED brightness via MIPI DCS command.
+ *
+ * @param percent  Brightness 0-100.
+ */
+void display_hal_set_brightness(uint8_t percent);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DISPLAY_HAL_H */
@@ -0,0 +1,169 @@
+/**
+ * @file display_task.c
+ * @brief ADR-045: FreeRTOS display task — LVGL pump on Core 0, priority 1.
+ *
+ * Gracefully skips if RM67162 panel or SPIRAM is absent.
+ * Reads from edge_get_vitals() / edge_get_multi_person() (thread-safe).
+ */
+
+#include "display_task.h"
+#include "sdkconfig.h"
+
+#if CONFIG_DISPLAY_ENABLE
+
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "esp_heap_caps.h"
+#include "lvgl.h"
+
+#include "display_hal.h"
+#include "display_ui.h"
+
+#define DISP_H_RES  368
+#define DISP_V_RES  448
+
+static const char *TAG = "disp_task";
+
+/* ---- Config ---- */
+#ifdef CONFIG_DISPLAY_FPS_LIMIT
+#define DISP_FPS_LIMIT      CONFIG_DISPLAY_FPS_LIMIT
+#else
+#define DISP_FPS_LIMIT      30
+#endif
+
+#define DISP_TASK_STACK      (8 * 1024)
+#define DISP_TASK_PRIORITY   1
+#define DISP_TASK_CORE       0
+
+#define DISP_BUF_LINES       40
+
+/* ---- LVGL flush callback — calls display_hal_draw directly ---- */
+static void lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_p)
+{
+    display_hal_draw(area->x1, area->y1, area->x2 + 1, area->y2 + 1, color_p);
+    lv_disp_flush_ready(drv);
+}
+
+/* ---- LVGL touch input callback ---- */
+static void lvgl_touch_cb(lv_indev_drv_t *drv, lv_indev_data_t *data)
+{
+    uint16_t x, y;
+    if (display_hal_touch_read(&x, &y)) {
+        data->point.x = x;
+        data->point.y = y;
+        data->state = LV_INDEV_STATE_PRESSED;
+    } else {
+        data->state = LV_INDEV_STATE_RELEASED;
+    }
+}
+
+/* ---- Display task ---- */
+static void display_task(void *arg)
+{
+    const TickType_t frame_period = pdMS_TO_TICKS(1000 / DISP_FPS_LIMIT);
+
+    ESP_LOGI(TAG, "Display task running on Core %d, %d fps limit",
+             xPortGetCoreID(), DISP_FPS_LIMIT);
+
+    display_ui_create(lv_scr_act());
+
+    TickType_t last_wake = xTaskGetTickCount();
+    while (1) {
+        display_ui_update();
+        lv_timer_handler();
+        vTaskDelayUntil(&last_wake, frame_period);
+    }
+}
+
+/* ---- Public API ---- */
+
+esp_err_t display_task_start(void)
+{
+    ESP_LOGI(TAG, "Initializing display subsystem...");
+
+    bool use_psram = false;
+#if CONFIG_SPIRAM
+    size_t psram_free = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
+    if (psram_free >= 64 * 1024) {
+        use_psram = true;
+        ESP_LOGI(TAG, "PSRAM available: %u KB — using PSRAM buffers", (unsigned)(psram_free / 1024));
+    } else {
+        ESP_LOGW(TAG, "PSRAM too small (%u bytes) — falling back to internal DMA memory", (unsigned)psram_free);
+    }
+#else
+    ESP_LOGW(TAG, "SPIRAM not enabled — using internal DMA memory (smaller buffers)");
+#endif
+
+    /* Probe display hardware */
+    esp_err_t ret = display_hal_init_panel();
+    if (ret != ESP_OK) {
+        ESP_LOGW(TAG, "Display not available — running headless");
+        return ESP_OK;
+    }
+
+    /* Init touch (optional) */
+    esp_err_t touch_ret = display_hal_init_touch();
+
+    /* Initialize LVGL */
+    lv_init();
+
+    /* Double-buffered draw buffers — prefer PSRAM, fall back to internal DMA */
+    size_t buf_lines = use_psram ? DISP_BUF_LINES : 10;  /* Smaller buffers without PSRAM */
+    size_t buf_size = DISP_H_RES * buf_lines * sizeof(lv_color_t);
+    uint32_t alloc_caps = use_psram ? MALLOC_CAP_SPIRAM : (MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
+    lv_color_t *buf1 = heap_caps_malloc(buf_size, alloc_caps);
+    lv_color_t *buf2 = heap_caps_malloc(buf_size, alloc_caps);
+    if (!buf1 || !buf2) {
+        ESP_LOGE(TAG, "Failed to allocate LVGL buffers (%u bytes, caps=0x%lx)",
+                 (unsigned)buf_size, (unsigned long)alloc_caps);
+        if (buf1) free(buf1);
+        if (buf2) free(buf2);
+        return ESP_OK;
+    }
+    ESP_LOGI(TAG, "LVGL buffers: 2x %u bytes (%u lines, %s)",
+             (unsigned)buf_size, (unsigned)buf_lines, use_psram ? "PSRAM" : "internal DMA");
+
+    static lv_disp_draw_buf_t draw_buf;
+    lv_disp_draw_buf_init(&draw_buf, buf1, buf2, DISP_H_RES * buf_lines);
+
+    static lv_disp_drv_t disp_drv;
+    lv_disp_drv_init(&disp_drv);
+    disp_drv.hor_res  = DISP_H_RES;
+    disp_drv.ver_res  = DISP_V_RES;
+    disp_drv.flush_cb = lvgl_flush_cb;
+    disp_drv.draw_buf = &draw_buf;
+    lv_disp_drv_register(&disp_drv);
+
+    if (touch_ret == ESP_OK) {
+        static lv_indev_drv_t indev_drv;
+        lv_indev_drv_init(&indev_drv);
+        indev_drv.type    = LV_INDEV_TYPE_POINTER;
+        indev_drv.read_cb = lvgl_touch_cb;
+        lv_indev_drv_register(&indev_drv);
+        ESP_LOGI(TAG, "Touch input registered");
+    }
+
+    BaseType_t xret = xTaskCreatePinnedToCore(
+        display_task, "display", DISP_TASK_STACK,
+        NULL, DISP_TASK_PRIORITY, NULL, DISP_TASK_CORE);
+
+    if (xret != pdPASS) {
+        ESP_LOGE(TAG, "Failed to create display task");
+        return ESP_OK;
+    }
+
+    ESP_LOGI(TAG, "Display task started (Core %d, priority %d, %d fps)",
+             DISP_TASK_CORE, DISP_TASK_PRIORITY, DISP_FPS_LIMIT);
+    return ESP_OK;
+}
+
+#else /* !CONFIG_DISPLAY_ENABLE */
+
+esp_err_t display_task_start(void)
+{
+    return ESP_OK;
+}
+
+#endif /* CONFIG_DISPLAY_ENABLE */
@@ -0,0 +1,29 @@
+/**
+ * @file display_task.h
+ * @brief ADR-045: FreeRTOS display task — LVGL pump on Core 0.
+ */
+
+#ifndef DISPLAY_TASK_H
+#define DISPLAY_TASK_H
+
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Start the display task on Core 0, priority 1.
+ *
+ * Probes for RM67162 panel and SPIRAM. If either is absent,
+ * logs a warning and returns ESP_OK (graceful skip).
+ *
+ * @return ESP_OK always (display is optional).
+ */
+esp_err_t display_task_start(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DISPLAY_TASK_H */
@@ -0,0 +1,387 @@
+/**
+ * @file display_ui.c
+ * @brief ADR-045: LVGL 4-view swipeable UI — Dashboard | Vitals | Presence | System.
+ *
+ * Dark theme (#0a0a0f background) with cyan (#00d4ff) accent.
+ * Glowing line effects via layered semi-transparent chart series.
+ */
+
+#include "display_ui.h"
+#include "sdkconfig.h"
+
+#if CONFIG_DISPLAY_ENABLE
+
+#include <stdio.h>
+#include <string.h>
+#include "esp_log.h"
+#include "esp_system.h"
+#include "esp_timer.h"
+#include "esp_heap_caps.h"
+#include "edge_processing.h"
+
+static const char *TAG = "disp_ui";
+
+/* ---- Theme colors ---- */
+#define COLOR_BG        lv_color_make(0x0A, 0x0A, 0x0F)
+#define COLOR_CYAN      lv_color_make(0x00, 0xD4, 0xFF)
+#define COLOR_AMBER     lv_color_make(0xFF, 0xB0, 0x00)
+#define COLOR_GREEN     lv_color_make(0x00, 0xFF, 0x80)
+#define COLOR_RED       lv_color_make(0xFF, 0x40, 0x40)
+#define COLOR_DIM       lv_color_make(0x30, 0x30, 0x40)
+#define COLOR_TEXT       lv_color_make(0xCC, 0xCC, 0xDD)
+#define COLOR_TEXT_DIM   lv_color_make(0x66, 0x66, 0x77)
+
+/* ---- Chart data points ---- */
+#define CHART_POINTS    60
+
+/* ---- View handles ---- */
+static lv_obj_t *s_tileview = NULL;
+
+/* Dashboard */
+static lv_obj_t *s_dash_chart      = NULL;
+static lv_chart_series_t *s_csi_series = NULL;
+static lv_obj_t *s_dash_persons    = NULL;
+static lv_obj_t *s_dash_rssi       = NULL;
+static lv_obj_t *s_dash_motion     = NULL;
+
+/* Vitals */
+static lv_obj_t *s_vital_chart     = NULL;
+static lv_chart_series_t *s_breath_series = NULL;
+static lv_chart_series_t *s_hr_series     = NULL;
+static lv_obj_t *s_vital_bpm_br    = NULL;
+static lv_obj_t *s_vital_bpm_hr    = NULL;
+
+/* Presence */
+#define GRID_COLS  4
+#define GRID_ROWS  4
+static lv_obj_t *s_grid_cells[GRID_COLS * GRID_ROWS];
+static lv_obj_t *s_presence_label = NULL;
+
+/* System */
+static lv_obj_t *s_sys_cpu         = NULL;
+static lv_obj_t *s_sys_heap        = NULL;
+static lv_obj_t *s_sys_psram       = NULL;
+static lv_obj_t *s_sys_rssi        = NULL;
+static lv_obj_t *s_sys_uptime      = NULL;
+static lv_obj_t *s_sys_fps         = NULL;
+static lv_obj_t *s_sys_node        = NULL;
+
+/* ---- Style helpers ---- */
+static lv_style_t s_style_bg;
+static lv_style_t s_style_label;
+static lv_style_t s_style_label_big;
+static bool s_styles_inited = false;
+
+static void init_styles(void)
+{
+    if (s_styles_inited) return;
+    s_styles_inited = true;
+
+    lv_style_init(&s_style_bg);
+    lv_style_set_bg_color(&s_style_bg, COLOR_BG);
+    lv_style_set_bg_opa(&s_style_bg, LV_OPA_COVER);
+    lv_style_set_border_width(&s_style_bg, 0);
+    lv_style_set_pad_all(&s_style_bg, 4);
+
+    lv_style_init(&s_style_label);
+    lv_style_set_text_color(&s_style_label, COLOR_TEXT);
+    lv_style_set_text_font(&s_style_label, &lv_font_montserrat_14);
+
+    lv_style_init(&s_style_label_big);
+    lv_style_set_text_color(&s_style_label_big, COLOR_CYAN);
+    lv_style_set_text_font(&s_style_label_big, &lv_font_montserrat_14);
+}
+
+static lv_obj_t *make_label(lv_obj_t *parent, const char *text, const lv_style_t *style)
+{
+    lv_obj_t *lbl = lv_label_create(parent);
+    lv_label_set_text(lbl, text);
+    if (style) lv_obj_add_style(lbl, (lv_style_t *)style, 0);
+    return lbl;
+}
+
+static lv_obj_t *make_tile(lv_obj_t *tv, uint8_t col, uint8_t row)
+{
+    lv_obj_t *tile = lv_tileview_add_tile(tv, col, row, LV_DIR_HOR);
+    lv_obj_add_style(tile, &s_style_bg, 0);
+    return tile;
+}
+
+/* ---- View 0: Dashboard ---- */
+static void create_dashboard(lv_obj_t *tile)
+{
+    make_label(tile, "CSI Dashboard", &s_style_label);
+
+    /* CSI amplitude chart */
+    s_dash_chart = lv_chart_create(tile);
+    lv_obj_set_size(s_dash_chart, 400, 130);
+    lv_obj_align(s_dash_chart, LV_ALIGN_TOP_LEFT, 0, 24);
+    lv_chart_set_type(s_dash_chart, LV_CHART_TYPE_LINE);
+    lv_chart_set_point_count(s_dash_chart, CHART_POINTS);
+    lv_chart_set_range(s_dash_chart, LV_CHART_AXIS_PRIMARY_Y, 0, 100);
+    lv_obj_set_style_bg_color(s_dash_chart, COLOR_BG, 0);
+    lv_obj_set_style_border_color(s_dash_chart, COLOR_DIM, 0);
+    lv_obj_set_style_line_width(s_dash_chart, 0, LV_PART_TICKS);
+
+    s_csi_series = lv_chart_add_series(s_dash_chart, COLOR_CYAN, LV_CHART_AXIS_PRIMARY_Y);
+
+    /* Stats panel on the right */
+    lv_obj_t *panel = lv_obj_create(tile);
+    lv_obj_set_size(panel, 120, 130);
+    lv_obj_align(panel, LV_ALIGN_TOP_RIGHT, 0, 24);
+    lv_obj_set_style_bg_color(panel, lv_color_make(0x12, 0x12, 0x1A), 0);
+    lv_obj_set_style_border_width(panel, 1, 0);
+    lv_obj_set_style_border_color(panel, COLOR_DIM, 0);
+    lv_obj_set_style_pad_all(panel, 8, 0);
+    lv_obj_set_flex_flow(panel, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(panel, LV_FLEX_ALIGN_SPACE_EVENLY, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+
+    make_label(panel, "Persons", &s_style_label);
+    s_dash_persons = make_label(panel, "0", &s_style_label_big);
+
+    s_dash_rssi = make_label(panel, "RSSI: --", &s_style_label);
+    s_dash_motion = make_label(panel, "Motion: 0.0", &s_style_label);
+}
+
+/* ---- View 1: Vitals ---- */
+static void create_vitals(lv_obj_t *tile)
+{
+    make_label(tile, "Vital Signs", &s_style_label);
+
+    s_vital_chart = lv_chart_create(tile);
+    lv_obj_set_size(s_vital_chart, 480, 150);
+    lv_obj_align(s_vital_chart, LV_ALIGN_TOP_LEFT, 0, 24);
+    lv_chart_set_type(s_vital_chart, LV_CHART_TYPE_LINE);
+    lv_chart_set_point_count(s_vital_chart, CHART_POINTS);
+    lv_chart_set_range(s_vital_chart, LV_CHART_AXIS_PRIMARY_Y, 0, 120);
+    lv_obj_set_style_bg_color(s_vital_chart, COLOR_BG, 0);
+    lv_obj_set_style_border_color(s_vital_chart, COLOR_DIM, 0);
+    lv_obj_set_style_line_width(s_vital_chart, 0, LV_PART_TICKS);
+
+    /* Breathing series (cyan) */
+    s_breath_series = lv_chart_add_series(s_vital_chart, COLOR_CYAN, LV_CHART_AXIS_PRIMARY_Y);
+    /* Heart rate series (amber) */
+    s_hr_series = lv_chart_add_series(s_vital_chart, COLOR_AMBER, LV_CHART_AXIS_PRIMARY_Y);
+
+    /* BPM readouts */
+    s_vital_bpm_br = make_label(tile, "Breathing: -- BPM", &s_style_label);
+    lv_obj_align(s_vital_bpm_br, LV_ALIGN_BOTTOM_LEFT, 4, -8);
+    lv_obj_set_style_text_color(s_vital_bpm_br, COLOR_CYAN, 0);
+
+    s_vital_bpm_hr = make_label(tile, "Heart Rate: -- BPM", &s_style_label);
+    lv_obj_align(s_vital_bpm_hr, LV_ALIGN_BOTTOM_RIGHT, -4, -8);
+    lv_obj_set_style_text_color(s_vital_bpm_hr, COLOR_AMBER, 0);
+}
+
+/* ---- View 2: Presence Grid ---- */
+static void create_presence(lv_obj_t *tile)
+{
+    make_label(tile, "Occupancy Map", &s_style_label);
+
+    int cell_w = 50;
+    int cell_h = 45;
+    int x_off  = (368 - GRID_COLS * (cell_w + 4)) / 2;
+    int y_off  = 30;
+
+    for (int r = 0; r < GRID_ROWS; r++) {
+        for (int c = 0; c < GRID_COLS; c++) {
+            lv_obj_t *cell = lv_obj_create(tile);
+            lv_obj_set_size(cell, cell_w, cell_h);
+            lv_obj_set_pos(cell, x_off + c * (cell_w + 4), y_off + r * (cell_h + 4));
+            lv_obj_set_style_bg_color(cell, COLOR_DIM, 0);
+            lv_obj_set_style_bg_opa(cell, LV_OPA_COVER, 0);
+            lv_obj_set_style_border_color(cell, COLOR_DIM, 0);
+            lv_obj_set_style_border_width(cell, 1, 0);
+            lv_obj_set_style_radius(cell, 4, 0);
+            s_grid_cells[r * GRID_COLS + c] = cell;
+        }
+    }
+
+    s_presence_label = make_label(tile, "Persons: 0", &s_style_label);
+    lv_obj_align(s_presence_label, LV_ALIGN_BOTTOM_MID, 0, -8);
+}
+
+/* ---- View 3: System ---- */
+static void create_system(lv_obj_t *tile)
+{
+    make_label(tile, "System Info", &s_style_label);
+
+    lv_obj_t *panel = lv_obj_create(tile);
+    lv_obj_set_size(panel, 500, 180);
+    lv_obj_align(panel, LV_ALIGN_TOP_LEFT, 0, 24);
+    lv_obj_set_style_bg_color(panel, lv_color_make(0x12, 0x12, 0x1A), 0);
+    lv_obj_set_style_border_width(panel, 1, 0);
+    lv_obj_set_style_border_color(panel, COLOR_DIM, 0);
+    lv_obj_set_style_pad_all(panel, 10, 0);
+    lv_obj_set_flex_flow(panel, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(panel, LV_FLEX_ALIGN_SPACE_EVENLY, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+
+    s_sys_node   = make_label(panel, "Node: --",        &s_style_label);
+    s_sys_cpu    = make_label(panel, "CPU: --%",         &s_style_label);
+    s_sys_heap   = make_label(panel, "Heap: -- KB free", &s_style_label);
+    s_sys_psram  = make_label(panel, "PSRAM: -- KB free",&s_style_label);
+    s_sys_rssi   = make_label(panel, "WiFi RSSI: --",   &s_style_label);
+    s_sys_uptime = make_label(panel, "Uptime: --",      &s_style_label);
+    s_sys_fps    = make_label(panel, "FPS: --",          &s_style_label);
+}
+
+/* ---- Public API ---- */
+
+void display_ui_create(lv_obj_t *parent)
+{
+    init_styles();
+
+    s_tileview = lv_tileview_create(parent);
+    lv_obj_add_style(s_tileview, &s_style_bg, 0);
+    lv_obj_set_style_bg_color(s_tileview, COLOR_BG, 0);
+
+    lv_obj_t *t0 = make_tile(s_tileview, 0, 0);
+    lv_obj_t *t1 = make_tile(s_tileview, 1, 0);
+    lv_obj_t *t2 = make_tile(s_tileview, 2, 0);
+    lv_obj_t *t3 = make_tile(s_tileview, 3, 0);
+
+    create_dashboard(t0);
+    create_vitals(t1);
+    create_presence(t2);
+    create_system(t3);
+
+    ESP_LOGI(TAG, "UI created: 4 views (Dashboard|Vitals|Presence|System)");
+}
+
+/* ---- FPS tracking ---- */
+static uint32_t s_frame_count = 0;
+static uint32_t s_last_fps_time = 0;
+static uint32_t s_current_fps = 0;
+
+void display_ui_update(void)
+{
+    /* FPS counter */
+    s_frame_count++;
+    uint32_t now_ms = (uint32_t)(esp_timer_get_time() / 1000);
+    if (now_ms - s_last_fps_time >= 1000) {
+        s_current_fps = s_frame_count;
+        s_frame_count = 0;
+        s_last_fps_time = now_ms;
+    }
+
+    /* Read edge data (thread-safe) */
+    edge_vitals_pkt_t vitals;
+    bool has_vitals = edge_get_vitals(&vitals);
+
+    edge_person_vitals_t persons[EDGE_MAX_PERSONS];
+    uint8_t n_active = 0;
+    edge_get_multi_person(persons, &n_active);
+
+    /* ---- Dashboard update ---- */
+    if (s_dash_chart && has_vitals) {
+        /* Push motion energy as amplitude proxy (scaled 0-100) */
+        int val = (int)(vitals.motion_energy * 10.0f);
+        if (val > 100) val = 100;
+        if (val < 0) val = 0;
+        lv_chart_set_next_value(s_dash_chart, s_csi_series, val);
+    }
+
+    if (s_dash_persons) {
+        char buf[8];
+        snprintf(buf, sizeof(buf), "%u", has_vitals ? vitals.n_persons : 0);
+        lv_label_set_text(s_dash_persons, buf);
+    }
+
+    if (s_dash_rssi && has_vitals) {
+        char buf[16];
+        snprintf(buf, sizeof(buf), "RSSI: %d", vitals.rssi);
+        lv_label_set_text(s_dash_rssi, buf);
+    }
+
+    if (s_dash_motion && has_vitals) {
+        char buf[24];
+        snprintf(buf, sizeof(buf), "Motion: %.1f", (double)vitals.motion_energy);
+        lv_label_set_text(s_dash_motion, buf);
+    }
+
+    /* ---- Vitals update ---- */
+    if (s_vital_chart && has_vitals) {
+        int br = (int)(vitals.breathing_rate / 100);  /* Fixed-point to int BPM */
+        int hr = (int)(vitals.heartrate / 10000);
+        if (br > 120) br = 120;
+        if (hr > 120) hr = 120;
+        lv_chart_set_next_value(s_vital_chart, s_breath_series, br);
+        lv_chart_set_next_value(s_vital_chart, s_hr_series, hr);
+
+        char buf[32];
+        snprintf(buf, sizeof(buf), "Breathing: %d BPM", br);
+        lv_label_set_text(s_vital_bpm_br, buf);
+
+        snprintf(buf, sizeof(buf), "Heart Rate: %d BPM", hr);
+        lv_label_set_text(s_vital_bpm_hr, buf);
+    }
+
+    /* ---- Presence grid update ---- */
+    if (has_vitals) {
+        /* Simple visualization: color cells based on motion energy distribution */
+        float energy = vitals.motion_energy;
+        uint8_t active_cells = (uint8_t)(energy * 2);  /* Scale for visibility */
+        if (active_cells > GRID_COLS * GRID_ROWS) active_cells = GRID_COLS * GRID_ROWS;
+
+        for (int i = 0; i < GRID_COLS * GRID_ROWS; i++) {
+            if (i < active_cells) {
+                /* Color gradient: green → amber → red based on intensity */
+                if (energy > 5.0f) {
+                    lv_obj_set_style_bg_color(s_grid_cells[i], COLOR_RED, 0);
+                } else if (energy > 2.0f) {
+                    lv_obj_set_style_bg_color(s_grid_cells[i], COLOR_AMBER, 0);
+                } else {
+                    lv_obj_set_style_bg_color(s_grid_cells[i], COLOR_GREEN, 0);
+                }
+            } else {
+                lv_obj_set_style_bg_color(s_grid_cells[i], COLOR_DIM, 0);
+            }
+        }
+
+        char buf[20];
+        snprintf(buf, sizeof(buf), "Persons: %u", vitals.n_persons);
+        lv_label_set_text(s_presence_label, buf);
+    }
+
+    /* ---- System info update ---- */
+    {
+        char buf[48];
+
+#ifdef CONFIG_CSI_NODE_ID
+        snprintf(buf, sizeof(buf), "Node: %d", CONFIG_CSI_NODE_ID);
+#else
+        snprintf(buf, sizeof(buf), "Node: --");
+#endif
+        lv_label_set_text(s_sys_node, buf);
+
+        snprintf(buf, sizeof(buf), "Heap: %lu KB free",
+                 (unsigned long)(esp_get_free_heap_size() / 1024));
+        lv_label_set_text(s_sys_heap, buf);
+
+#if CONFIG_SPIRAM
+        snprintf(buf, sizeof(buf), "PSRAM: %lu KB free",
+                 (unsigned long)(heap_caps_get_free_size(MALLOC_CAP_SPIRAM) / 1024));
+#else
+        snprintf(buf, sizeof(buf), "PSRAM: N/A");
+#endif
+        lv_label_set_text(s_sys_psram, buf);
+
+        if (has_vitals) {
+            snprintf(buf, sizeof(buf), "WiFi RSSI: %d dBm", vitals.rssi);
+            lv_label_set_text(s_sys_rssi, buf);
+        }
+
+        uint32_t uptime_s = (uint32_t)(esp_timer_get_time() / 1000000);
+        uint32_t h = uptime_s / 3600;
+        uint32_t m = (uptime_s % 3600) / 60;
+        uint32_t s = uptime_s % 60;
+        snprintf(buf, sizeof(buf), "Uptime: %luh %02lum %02lus",
+                 (unsigned long)h, (unsigned long)m, (unsigned long)s);
+        lv_label_set_text(s_sys_uptime, buf);
+
+        snprintf(buf, sizeof(buf), "FPS: %lu", (unsigned long)s_current_fps);
+        lv_label_set_text(s_sys_fps, buf);
+    }
+}
+
+#endif /* CONFIG_DISPLAY_ENABLE */
@@ -0,0 +1,31 @@
+/**
+ * @file display_ui.h
+ * @brief ADR-045: LVGL 4-view swipeable UI for CSI node stats.
+ *
+ * Views: Dashboard | Vitals | Presence | System
+ * Dark theme with cyan (#00d4ff) accent.
+ */
+
+#ifndef DISPLAY_UI_H
+#define DISPLAY_UI_H
+
+#include "lvgl.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Create all LVGL views on the given tileview parent. */
+void display_ui_create(lv_obj_t *parent);
+
+/**
+ * Update all views with latest data. Called every display refresh cycle.
+ * Reads from edge_get_vitals() and edge_get_multi_person() internally.
+ */
+void display_ui_update(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DISPLAY_UI_H */
@@ -0,0 +1,10 @@
+## ESP-IDF Managed Component Dependencies (ADR-045)
+dependencies:
+  ## LVGL graphics library
+  lvgl/lvgl: "~8.3"
+
+  ## CST816S capacitive touch driver
+  espressif/esp_lcd_touch_cst816s: "^1.0"
+
+  ## LCD touch abstraction
+  espressif/esp_lcd_touch: "^1.0"
@@ -0,0 +1,94 @@
+/**
+ * @file lv_conf.h
+ * @brief LVGL compile-time configuration for ESP32-S3 AMOLED display (ADR-045).
+ *
+ * Tuned for RM67162 536x240 QSPI AMOLED with 8MB PSRAM.
+ * Color depth: RGB565 (16-bit) for QSPI bandwidth.
+ * Double-buffered in SPIRAM, 30fps target.
+ */
+
+#ifndef LV_CONF_H
+#define LV_CONF_H
+
+#include <stdint.h>
+
+/* ---- Core ---- */
+#define LV_COLOR_DEPTH          16
+#define LV_COLOR_16_SWAP        1   /* Byte-swap for SPI/QSPI displays */
+#define LV_MEM_CUSTOM           1   /* Use ESP-IDF heap instead of LVGL's internal allocator */
+#define LV_MEM_CUSTOM_INCLUDE   <stdlib.h>
+#define LV_MEM_CUSTOM_ALLOC     malloc
+#define LV_MEM_CUSTOM_FREE      free
+#define LV_MEM_CUSTOM_REALLOC   realloc
+
+/* ---- Display ---- */
+#define LV_HOR_RES_MAX          368
+#define LV_VER_RES_MAX          448
+#define LV_DPI_DEF              200
+
+/* ---- Tick (provided by esp_timer in display_task.c) ---- */
+#define LV_TICK_CUSTOM           1
+#define LV_TICK_CUSTOM_INCLUDE   "esp_timer.h"
+#define LV_TICK_CUSTOM_SYS_TIME_EXPR ((uint32_t)(esp_timer_get_time() / 1000))
+
+/* ---- Drawing ---- */
+#define LV_DRAW_COMPLEX         1
+#define LV_SHADOW_CACHE_SIZE    0
+#define LV_CIRCLE_CACHE_SIZE    4
+#define LV_IMG_CACHE_DEF_SIZE   0
+
+/* ---- Fonts ---- */
+#define LV_FONT_MONTSERRAT_14   1
+#define LV_FONT_MONTSERRAT_20   1
+#define LV_FONT_DEFAULT         &lv_font_montserrat_14
+
+/* ---- Widgets ---- */
+#define LV_USE_ARC              1
+#define LV_USE_BAR              1
+#define LV_USE_BTN              0
+#define LV_USE_BTNMATRIX        0
+#define LV_USE_CANVAS           0
+#define LV_USE_CHECKBOX         0
+#define LV_USE_DROPDOWN         0
+#define LV_USE_IMG              0
+#define LV_USE_LABEL            1
+#define LV_USE_LINE             1
+#define LV_USE_ROLLER           0
+#define LV_USE_SLIDER           0
+#define LV_USE_SWITCH           0
+#define LV_USE_TEXTAREA         0
+#define LV_USE_TABLE            0
+
+/* ---- Extra widgets ---- */
+#define LV_USE_CHART            1
+#define LV_CHART_AXIS_TICK_LABEL_MAX_LEN 32
+#define LV_USE_METER            0
+#define LV_USE_SPINBOX          0
+#define LV_USE_SPAN             0
+#define LV_USE_TILEVIEW         1   /* Used for swipeable page navigation */
+#define LV_USE_TABVIEW          0
+#define LV_USE_WIN              0
+
+/* ---- Themes ---- */
+#define LV_USE_THEME_DEFAULT    1
+#define LV_THEME_DEFAULT_DARK   1
+
+/* ---- Logging ---- */
+#define LV_USE_LOG              0
+#define LV_USE_ASSERT_NULL      1
+#define LV_USE_ASSERT_MALLOC    1
+
+/* ---- GPU / render ---- */
+#define LV_USE_GPU_ESP32_S3     0   /* No parallel LCD interface — we use QSPI */
+
+/* ---- Animation ---- */
+#define LV_USE_ANIM             1
+#define LV_ANIM_DEF_TIME        200
+
+/* ---- Misc ---- */
+#define LV_USE_GROUP            1   /* For touch/input device routing */
+#define LV_USE_PERF_MONITOR     0
+#define LV_USE_MEM_MONITOR      0
+#define LV_SPRINTF_CUSTOM       0
+
+#endif /* LV_CONF_H */
@@ -26,6 +26,7 @@
 #include "power_mgmt.h"
 #include "wasm_runtime.h"
 #include "wasm_upload.h"
+#include "display_task.h"

 #include "esp_timer.h"

@@ -203,6 +204,12 @@ void app_main(void)
    /* Initialize power management. */
    power_mgmt_init(g_nvs_config.power_duty);

+    /* ADR-045: Start AMOLED display task (gracefully skips if no display). */
+    esp_err_t disp_ret = display_task_start();
+    if (disp_ret != ESP_OK) {
+        ESP_LOGW(TAG, "Display init returned: %s", esp_err_to_name(disp_ret));
+    }
+
    ESP_LOGI(TAG, "CSI streaming active → %s:%d (edge_tier=%u, OTA=%s, WASM=%s)",
             g_nvs_config.target_ip, g_nvs_config.target_port,
             g_nvs_config.edge_tier,
@@ -15,6 +15,8 @@
 #include "esp_ota_ops.h"
 #include "esp_http_server.h"
 #include "esp_app_desc.h"
+#include "nvs_flash.h"
+#include "nvs.h"

 static const char *TAG = "ota_update";

@@ -24,6 +26,52 @@ static const char *TAG = "ota_update";
 /** Maximum firmware size (900 KB — matches CI binary size gate). */
 #define OTA_MAX_SIZE (900 * 1024)

+/** NVS namespace and key for the OTA pre-shared key. */
+#define OTA_NVS_NAMESPACE "security"
+#define OTA_NVS_KEY       "ota_psk"
+
+/** Maximum PSK length (hex-encoded SHA-256). */
+#define OTA_PSK_MAX_LEN   65
+
+/** Cached PSK loaded from NVS at init time. Empty = auth disabled. */
+static char s_ota_psk[OTA_PSK_MAX_LEN] = {0};
+
+/**
+ * ADR-050: Verify the Authorization header contains the correct PSK.
+ * Returns true if auth is disabled (no PSK provisioned) or if the
+ * Bearer token matches the stored PSK.
+ */
+static bool ota_check_auth(httpd_req_t *req)
+{
+    if (s_ota_psk[0] == '\0') {
+        /* No PSK provisioned — auth disabled (permissive for dev). */
+        return true;
+    }
+
+    char auth_header[128] = {0};
+    if (httpd_req_get_hdr_value_str(req, "Authorization", auth_header,
+                                     sizeof(auth_header)) != ESP_OK) {
+        return false;
+    }
+
+    /* Expect "Bearer <psk>" */
+    const char *prefix = "Bearer ";
+    if (strncmp(auth_header, prefix, strlen(prefix)) != 0) {
+        return false;
+    }
+
+    const char *token = auth_header + strlen(prefix);
+    /* Constant-time comparison to prevent timing attacks. */
+    size_t psk_len = strlen(s_ota_psk);
+    size_t tok_len = strlen(token);
+    if (psk_len != tok_len) return false;
+    volatile uint8_t result = 0;
+    for (size_t i = 0; i < psk_len; i++) {
+        result |= (uint8_t)(s_ota_psk[i] ^ token[i]);
+    }
+    return result == 0;
+}
+
 /**
 * GET /ota/status — return firmware version and partition info.
 */
@@ -53,6 +101,14 @@ static esp_err_t ota_status_handler(httpd_req_t *req)
 */
 static esp_err_t ota_upload_handler(httpd_req_t *req)
 {
+    /* ADR-050: Authenticate before accepting firmware upload. */
+    if (!ota_check_auth(req)) {
+        ESP_LOGW(TAG, "OTA upload rejected: authentication failed");
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN,
+                            "Authentication required. Use: Authorization: Bearer <psk>");
+        return ESP_FAIL;
+    }
+
    ESP_LOGI(TAG, "OTA update started, content_length=%d", req->content_len);

    if (req->content_len <= 0 || req->content_len > OTA_MAX_SIZE) {
@@ -187,6 +243,20 @@ static esp_err_t ota_start_server(httpd_handle_t *out_handle)

 esp_err_t ota_update_init(void)
 {
+    /* ADR-050: Load OTA PSK from NVS if provisioned. */
+    nvs_handle_t nvs;
+    if (nvs_open(OTA_NVS_NAMESPACE, NVS_READONLY, &nvs) == ESP_OK) {
+        size_t len = sizeof(s_ota_psk);
+        if (nvs_get_str(nvs, OTA_NVS_KEY, s_ota_psk, &len) == ESP_OK) {
+            ESP_LOGI(TAG, "OTA PSK loaded from NVS (%d chars) — authentication enabled", (int)len - 1);
+        } else {
+            ESP_LOGW(TAG, "No OTA PSK in NVS — OTA authentication DISABLED (provision with nvs_set)");
+        }
+        nvs_close(nvs);
+    } else {
+        ESP_LOGW(TAG, "NVS namespace '%s' not found — OTA authentication DISABLED", OTA_NVS_NAMESPACE);
+    }
+
    return ota_start_server(NULL);
 }

@@ -9,6 +9,7 @@

 #include <string.h>
 #include "esp_log.h"
+#include "esp_timer.h"
 #include "lwip/sockets.h"
 #include "lwip/netdb.h"
 #include "sdkconfig.h"
@@ -18,6 +19,17 @@ static const char *TAG = "stream_sender";
 static int s_sock = -1;
 static struct sockaddr_in s_dest_addr;

+/**
+ * ENOMEM backoff state.
+ * When sendto fails with ENOMEM (errno 12), we suppress further sends for
+ * a cooldown period to let lwIP reclaim packet buffers.  Without this,
+ * rapid-fire CSI callbacks can exhaust the pbuf pool and crash the device.
+ */
+static int64_t s_backoff_until_us = 0;       /* esp_timer timestamp to resume */
+#define ENOMEM_COOLDOWN_MS  100              /* suppress sends for 100 ms */
+#define ENOMEM_LOG_INTERVAL 50               /* log every Nth suppressed send */
+static uint32_t s_enomem_suppressed = 0;
+
 static int sender_init_internal(const char *ip, uint16_t port)
 {
    s_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
@@ -57,10 +69,37 @@ int stream_sender_send(const uint8_t *data, size_t len)
        return -1;
    }

+    /* ENOMEM backoff: if we recently exhausted lwIP buffers, skip sends
+     * until the cooldown expires.  This prevents the cascade of failed
+     * sendto calls that leads to a guru meditation crash. */
+    if (s_backoff_until_us > 0) {
+        int64_t now = esp_timer_get_time();
+        if (now < s_backoff_until_us) {
+            s_enomem_suppressed++;
+            if ((s_enomem_suppressed % ENOMEM_LOG_INTERVAL) == 1) {
+                ESP_LOGW(TAG, "sendto suppressed (ENOMEM backoff, %lu dropped)",
+                         (unsigned long)s_enomem_suppressed);
+            }
+            return -1;
+        }
+        /* Cooldown expired — resume sending */
+        ESP_LOGI(TAG, "ENOMEM backoff expired, resuming sends (%lu were suppressed)",
+                 (unsigned long)s_enomem_suppressed);
+        s_backoff_until_us = 0;
+        s_enomem_suppressed = 0;
+    }
+
    int sent = sendto(s_sock, data, len, 0,
                      (struct sockaddr *)&s_dest_addr, sizeof(s_dest_addr));
    if (sent < 0) {
-        ESP_LOGW(TAG, "sendto failed: errno %d", errno);
+        if (errno == ENOMEM) {
+            /* Start backoff to let lwIP reclaim buffers */
+            s_backoff_until_us = esp_timer_get_time() +
+                                 (int64_t)ENOMEM_COOLDOWN_MS * 1000;
+            ESP_LOGW(TAG, "sendto ENOMEM — backing off for %d ms", ENOMEM_COOLDOWN_MS);
+        } else {
+            ESP_LOGW(TAG, "sendto failed: errno %d", errno);
+        }
        return -1;
    }

@@ -107,8 +107,9 @@ static esp_err_t wasm_upload_handler(httpd_req_t *req)
            return ESP_FAIL;
        }

-        /* Verify signature if wasm_verify is enabled. */
-#ifdef CONFIG_WASM_VERIFY_SIGNATURE
+        /* ADR-050: Verify signature (default-on; skip only if
+         * CONFIG_WASM_SKIP_SIGNATURE is explicitly set for dev/lab). */
+#ifndef CONFIG_WASM_SKIP_SIGNATURE
        {
            /* Load pubkey from NVS config (set via provision.py --wasm-pubkey). */
            extern nvs_config_t g_nvs_config;
@@ -173,11 +174,11 @@ static esp_err_t wasm_upload_handler(httpd_req_t *req)

    } else if (rvf_is_raw_wasm(buf, (uint32_t)total)) {
        /* ── Raw WASM path (dev/lab only) ── */
-#ifdef CONFIG_WASM_VERIFY_SIGNATURE
+#ifndef CONFIG_WASM_SKIP_SIGNATURE
        free(buf);
        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN,
-                            "Raw WASM upload rejected (wasm_verify enabled). "
-                            "Use RVF container with signature.");
+                            "Raw WASM upload rejected (signature verification enabled). "
+                            "Use RVF container with signature, or set CONFIG_WASM_SKIP_SIGNATURE for dev.");
        return ESP_FAIL;
 #else
        format = "raw";
@@ -0,0 +1,8 @@
+# ESP32-S3 CSI Node — 8MB flash partition table (ADR-045)
+# Name,     Type, SubType, Offset,   Size,   Flags
+nvs,        data, nvs,     0x9000,   0x6000,
+otadata,    data, ota,     0xf000,   0x2000,
+phy_init,   data, phy,     0x11000,  0x1000,
+ota_0,      app,  ota_0,   0x20000,  0x200000,
+ota_1,      app,  ota_1,   0x220000, 0x200000,
+spiffs,     data, spiffs,  0x420000, 0x1E0000,
@@ -30,22 +30,40 @@ NVS_PARTITION_OFFSET = 0x9000
 NVS_PARTITION_SIZE = 0x6000  # 24 KiB


-def build_nvs_csv(ssid, password, target_ip, target_port, node_id):
+def build_nvs_csv(args):
    """Build an NVS CSV string for the csi_cfg namespace."""
    buf = io.StringIO()
    writer = csv.writer(buf)
    writer.writerow(["key", "type", "encoding", "value"])
    writer.writerow(["csi_cfg", "namespace", "", ""])
-    if ssid:
-        writer.writerow(["ssid", "data", "string", ssid])
-    if password is not None:
-        writer.writerow(["password", "data", "string", password])
-    if target_ip:
-        writer.writerow(["target_ip", "data", "string", target_ip])
-    if target_port is not None:
-        writer.writerow(["target_port", "data", "u16", str(target_port)])
-    if node_id is not None:
-        writer.writerow(["node_id", "data", "u8", str(node_id)])
+    if args.ssid:
+        writer.writerow(["ssid", "data", "string", args.ssid])
+    if args.password is not None:
+        writer.writerow(["password", "data", "string", args.password])
+    if args.target_ip:
+        writer.writerow(["target_ip", "data", "string", args.target_ip])
+    if args.target_port is not None:
+        writer.writerow(["target_port", "data", "u16", str(args.target_port)])
+    if args.node_id is not None:
+        writer.writerow(["node_id", "data", "u8", str(args.node_id)])
+    # TDM mesh settings
+    if args.tdm_slot is not None:
+        writer.writerow(["tdm_slot", "data", "u8", str(args.tdm_slot)])
+    if args.tdm_total is not None:
+        writer.writerow(["tdm_nodes", "data", "u8", str(args.tdm_total)])
+    # Edge intelligence settings (ADR-039)
+    if args.edge_tier is not None:
+        writer.writerow(["edge_tier", "data", "u8", str(args.edge_tier)])
+    if args.pres_thresh is not None:
+        writer.writerow(["pres_thresh", "data", "u16", str(args.pres_thresh)])
+    if args.fall_thresh is not None:
+        writer.writerow(["fall_thresh", "data", "u16", str(args.fall_thresh)])
+    if args.vital_win is not None:
+        writer.writerow(["vital_win", "data", "u16", str(args.vital_win)])
+    if args.vital_int is not None:
+        writer.writerow(["vital_int", "data", "u16", str(args.vital_int)])
+    if args.subk_count is not None:
+        writer.writerow(["subk_count", "data", "u8", str(args.subk_count)])
    return buf.getvalue()


@@ -127,14 +145,37 @@ def main():
    parser.add_argument("--target-ip", help="Aggregator host IP (e.g. 192.168.1.20)")
    parser.add_argument("--target-port", type=int, help="Aggregator UDP port (default: 5005)")
    parser.add_argument("--node-id", type=int, help="Node ID 0-255 (default: 1)")
+    # TDM mesh settings
+    parser.add_argument("--tdm-slot", type=int, help="TDM slot index for this node (0-based)")
+    parser.add_argument("--tdm-total", type=int, help="Total number of TDM nodes in mesh")
+    # Edge intelligence settings (ADR-039)
+    parser.add_argument("--edge-tier", type=int, choices=[0, 1, 2],
+                        help="Edge processing tier: 0=off, 1=stats, 2=vitals")
+    parser.add_argument("--pres-thresh", type=int, help="Presence detection threshold (default: 50)")
+    parser.add_argument("--fall-thresh", type=int, help="Fall detection threshold (default: 500)")
+    parser.add_argument("--vital-win", type=int, help="Phase history window in frames (default: 300)")
+    parser.add_argument("--vital-int", type=int, help="Vitals packet interval in ms (default: 1000)")
+    parser.add_argument("--subk-count", type=int, help="Top-K subcarrier count (default: 32)")
    parser.add_argument("--dry-run", action="store_true", help="Generate NVS binary but don't flash")

    args = parser.parse_args()

-    if not any([args.ssid, args.password is not None, args.target_ip,
-                args.target_port, args.node_id is not None]):
-        parser.error("At least one config value must be specified "
-                     "(--ssid, --password, --target-ip, --target-port, --node-id)")
+    has_value = any([
+        args.ssid, args.password is not None, args.target_ip,
+        args.target_port, args.node_id is not None,
+        args.tdm_slot is not None, args.tdm_total is not None,
+        args.edge_tier is not None, args.pres_thresh is not None,
+        args.fall_thresh is not None, args.vital_win is not None,
+        args.vital_int is not None, args.subk_count is not None,
+    ])
+    if not has_value:
+        parser.error("At least one config value must be specified")
+
+    # Validate TDM: if one is given, both should be
+    if (args.tdm_slot is not None) != (args.tdm_total is not None):
+        parser.error("--tdm-slot and --tdm-total must be specified together")
+    if args.tdm_slot is not None and args.tdm_slot >= args.tdm_total:
+        parser.error(f"--tdm-slot ({args.tdm_slot}) must be less than --tdm-total ({args.tdm_total})")

    print("Building NVS configuration:")
    if args.ssid:
@@ -147,9 +188,23 @@ def main():
        print(f"  Target Port:   {args.target_port}")
    if args.node_id is not None:
        print(f"  Node ID:       {args.node_id}")
+    if args.tdm_slot is not None:
+        print(f"  TDM Slot:      {args.tdm_slot} of {args.tdm_total}")
+    if args.edge_tier is not None:
+        tier_desc = {0: "off (raw CSI)", 1: "stats", 2: "vitals"}
+        print(f"  Edge Tier:     {args.edge_tier} ({tier_desc.get(args.edge_tier, '?')})")
+    if args.pres_thresh is not None:
+        print(f"  Pres Thresh:   {args.pres_thresh}")
+    if args.fall_thresh is not None:
+        print(f"  Fall Thresh:   {args.fall_thresh}")
+    if args.vital_win is not None:
+        print(f"  Vital Window:  {args.vital_win} frames")
+    if args.vital_int is not None:
+        print(f"  Vital Interval:{args.vital_int} ms")
+    if args.subk_count is not None:
+        print(f"  Top-K Subcarr: {args.subk_count}")

-    csv_content = build_nvs_csv(args.ssid, args.password, args.target_ip,
-                                args.target_port, args.node_id)
+    csv_content = build_nvs_csv(args)

    try:
        nvs_bin = generate_nvs_binary(csv_content, NVS_PARTITION_SIZE)
@@ -485,11 +485,13 @@ recommend_profile() {
    echo "  Available profiles based on your system:"
    echo ""

-    local idx=1
-    declare -A PROFILE_MAP
+    local idx=0
+    # Use indexed array instead of associative array for Bash 3.2 (macOS) compatibility
+    local profile_names=()

    for p in "${available_profiles[@]}"; do
        local marker=""
+        idx=$((idx + 1))
        if [ "$p" == "$recommended" ]; then
            marker=" ${GREEN}(recommended)${RESET}"
        fi
@@ -502,13 +504,13 @@ recommend_profile() {
            iot)     echo -e "    ${BOLD}${idx})${RESET} iot     - ESP32 sensor mesh + aggregator${marker}" ;;
            field)   echo -e "    ${BOLD}${idx})${RESET} field   - WiFi-Mat disaster response kit (~62 MB)${marker}" ;;
        esac
-        PROFILE_MAP[$idx]="$p"
-        idx=$((idx + 1))
+        profile_names+=("$p")
    done

    # Always show full as the last option
+    idx=$((idx + 1))
    echo -e "    ${BOLD}${idx})${RESET} full    - Install everything available"
-    PROFILE_MAP[$idx]="full"
+    profile_names+=("full")

    if [ -n "$PROFILE" ]; then
        echo ""
@@ -525,8 +527,8 @@ recommend_profile() {

    if [ -z "$choice" ]; then
        PROFILE="$recommended"
-    elif [[ -n "${PROFILE_MAP[$choice]+x}" ]]; then
-        PROFILE="${PROFILE_MAP[$choice]}"
+    elif [ "$choice" -ge 1 ] 2>/dev/null && [ "$choice" -le "$idx" ]; then
+        PROFILE="${profile_names[$((choice - 1))]}"
    else
        echo -e "  ${RED}Invalid choice. Using ${recommended}.${RESET}"
        PROFILE="$recommended"
@@ -441,7 +441,7 @@ class WiFiDensePoseTrainer:
        }, path)
    
    def load_model(self, path):
-        checkpoint = torch.load(path)
+        checkpoint = torch.load(path, map_location=self.device, weights_only=True)
        self.model.load_state_dict(checkpoint['model_state_dict'])
        self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])

@@ -16,6 +16,7 @@ members = [
    "crates/wifi-densepose-wifiscan",
    "crates/wifi-densepose-vitals",
    "crates/wifi-densepose-ruvector",
+    "crates/wifi-densepose-desktop",
 ]
 # ADR-040: WASM edge crate targets wasm32-unknown-unknown (no_std),
 # excluded from workspace to avoid breaking `cargo test --workspace`.
@@ -101,7 +102,7 @@ csv = "1.3"
 indicatif = "0.17"

 # CLI
-clap = { version = "4.4", features = ["derive"] }
+clap = { version = "4.4", features = ["derive", "env"] }

 # Testing
 criterion = { version = "0.5", features = ["html_reports"] }
@@ -0,0 +1,25 @@
+[package]
+name = "wifi-densepose-desktop"
+version.workspace = true
+edition.workspace = true
+description = "Tauri v2 desktop frontend for RuView WiFi DensePose"
+license.workspace = true
+authors.workspace = true
+
+[lib]
+name = "wifi_densepose_desktop"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = [] }
+tauri-plugin-shell = "2"
+tauri-plugin-dialog = "2"
+
+serde = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true }
+thiserror = { workspace = true }
+chrono = { version = "0.4", features = ["serde"] }
@@ -0,0 +1,174 @@
+# RuView Desktop
+
+> **Work in Progress** — This crate is under active development. APIs and UI are subject to change.
+
+Cross-platform desktop application for managing ESP32 WiFi sensing networks. Built with **Tauri v2** (Rust backend) and **React + TypeScript** (frontend), following the [ADR-053 design system](../../docs/adr/ADR-053-ui-design-system.md).
+
+## Overview
+
+RuView Desktop provides a unified interface for node discovery, firmware management, over-the-air updates, WASM edge module deployment, real-time sensing data visualization, and mesh network topology monitoring — all from a single native application.
+
+## Pages
+
+| Page | Description | Status |
+|------|-------------|--------|
+| **Dashboard** | System overview with live stat cards, server panel, quick actions, and node grid | Done |
+| **Nodes** | Sortable table of discovered ESP32 nodes with expandable detail rows | Done |
+| **Flash** | 3-step serial firmware flash wizard (select port, pick firmware, flash + verify) | Done |
+| **OTA Update** | Single-node and batch over-the-air firmware updates with strategy selection | Done |
+| **Edge Modules** | WASM module upload, lifecycle management (start/stop/unload) per node | Done |
+| **Sensing** | Server start/stop, live log viewer (pause/clear), activity feed with confidence bars | Done |
+| **Mesh View** | Force-directed canvas graph showing mesh topology with click-to-inspect nodes | Done |
+| **Settings** | Server configuration (ports, bind address, discovery interval, theme) | Done |
+
+## Architecture
+
+```
+wifi-densepose-desktop/
+├── src/
+│   ├── main.rs              # Tauri app entry point
+│   ├── lib.rs               # Command registration
+│   ├── commands/            # Tauri IPC command handlers
+│   │   ├── discovery.rs     # Node discovery (mDNS/UDP probe)
+│   │   ├── flash.rs         # Serial firmware flashing
+│   │   ├── ota.rs           # OTA update (single + batch)
+│   │   ├── wasm.rs          # WASM module management
+│   │   └── server.rs        # Sensing server lifecycle
+│   └── domain/              # DDD domain models
+│       ├── node.rs           # DiscoveredNode, NodeRegistry, HealthStatus
+│       └── config.rs         # ProvisioningConfig with validation
+├── ui/                       # React + TypeScript frontend
+│   ├── src/
+│   │   ├── App.tsx           # Shell with sidebar nav, live status bar
+│   │   ├── design-system.css # ADR-053 design tokens and components
+│   │   ├── types.ts          # TypeScript types mirroring Rust domain
+│   │   ├── components/       # Shared UI components (StatusBadge, NodeCard)
+│   │   ├── hooks/            # React hooks (useServer, useNodes)
+│   │   └── pages/            # 8 page components
+│   └── index.html
+└── tauri.conf.json           # Tauri v2 configuration
+```
+
+## Tauri Commands
+
+| Group | Command | Description |
+|-------|---------|-------------|
+| **Discovery** | `discover_nodes` | Scan network for ESP32 nodes via mDNS/UDP |
+| **Flash** | `list_serial_ports` | List available serial ports |
+| | `detect_chip` | Detect connected chip type |
+| | `start_flash` | Flash firmware via serial |
+| **OTA** | `ota_update` | Push firmware to a single node |
+| | `batch_ota_update` | Push firmware to multiple nodes |
+| **WASM** | `wasm_list` | List loaded WASM modules on a node |
+| | `wasm_upload` | Upload a .wasm module to a node |
+| | `wasm_control` | Start/stop/unload a WASM module |
+| **Server** | `start_server` | Start the sensing HTTP/WS server |
+| | `stop_server` | Stop the sensing server |
+| | `server_status` | Get current server status |
+| **Provision** | `get_provision_config` | Read provisioning configuration |
+| | `save_provision_config` | Save provisioning configuration |
+
+## Design System (ADR-053)
+
+The UI follows a dark professional theme with the following design tokens:
+
+| Token | Value | Usage |
+|-------|-------|-------|
+| `--bg-base` | `#0d1117` | Main background |
+| `--bg-surface` | `#161b22` | Cards, sidebar, panels |
+| `--bg-elevated` | `#1c2333` | Elevated elements |
+| `--accent` | `#7c3aed` | Primary accent (purple) |
+| `--status-online` | `#3fb950` | Online/success indicators |
+| `--status-error` | `#f85149` | Error/offline indicators |
+| `--font-mono` | JetBrains Mono | Technical data, code |
+| `--font-sans` | Inter | UI text, labels |
+
+### UI Features
+
+- **Glassmorphism cards** with `backdrop-filter: blur(12px)`
+- **Count-up animations** on dashboard stat numbers
+- **Page transitions** with fade-in + scale on navigation
+- **Gradient accents** on logo, nav indicator, primary buttons
+- **Status dot glows** with ambient `box-shadow` per health state
+- **Staggered fade-ins** for card grids
+- **Force-directed graph** for mesh topology (pure Canvas 2D)
+
+## Download
+
+Pre-built binaries are available on the [Releases](https://github.com/ruvnet/RuView/releases) page.
+
+| Platform | Download | Status |
+|----------|----------|--------|
+| Windows x64 | [v0.3.0-alpha](https://github.com/ruvnet/RuView/releases/tag/v0.3.0-desktop-alpha) | Debug build |
+| macOS | — | Planned |
+| Linux | — | Planned |
+
+### Running the pre-built exe (Windows)
+
+The current release is a **debug build** that loads the frontend from a local Vite dev server. Follow these steps:
+
+```bash
+# 1. Clone the repo (or download just the ui/ folder)
+git clone https://github.com/ruvnet/RuView.git
+cd RuView/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui
+
+# 2. Install frontend dependencies
+npm install
+
+# 3. Start the Vite dev server
+npx vite --host
+
+# 4. Download and run the exe from the release page
+#    (or run from the repo if you built it locally)
+#    The app window will open and connect to localhost:5173
+```
+
+> **Requirements:** Windows 10 (1803+) or Windows 11. WebView2 runtime is required (pre-installed on Windows 10 1803+ and all Windows 11).
+
+> **Note:** Production builds will bundle the frontend assets directly into the exe, removing the need for a dev server.
+
+## Build from Source
+
+### Prerequisites
+
+- [Rust 1.85+](https://rustup.rs/)
+- [Node.js 20+](https://nodejs.org/)
+- [Tauri v2 CLI](https://v2.tauri.app/start/prerequisites/)
+- **Windows:** MSVC build tools + MinGW-w64 (for `dlltool`)
+- **macOS:** Xcode Command Line Tools
+- **Linux:** `libwebkit2gtk-4.1-dev`, `libappindicator3-dev`, `librsvg2-dev`
+
+### Development mode
+
+```bash
+# Install frontend dependencies
+cd ui && npm install
+
+# Start in dev mode (hot-reload on both Rust and React)
+cargo tauri dev
+```
+
+### Production build
+
+```bash
+# Build optimized release with bundled frontend
+cargo tauri build
+```
+
+The installer/bundle will be in `target/release/bundle/` (`.msi` on Windows, `.dmg` on macOS, `.deb`/`.AppImage` on Linux).
+
+## Domain Types
+
+| Type | Fields | Description |
+|------|--------|-------------|
+| `Node` | ip, mac, hostname, node_id, firmware_version, chip, mesh_role, health, ... | Full node record |
+| `HealthStatus` | online, offline, degraded, unknown | Node health state |
+| `FlashSession` | port, firmware, chip, baud, progress | Active flash operation |
+| `OtaResult` | node_ip, success, previous_version, new_version, duration_ms | OTA outcome |
+| `WasmModule` | module_id, name, size_bytes, state, node_ip | Edge module record |
+| `ServerStatus` | running, pid, http_port, ws_port | Sensing server state |
+| `SensingUpdate` | timestamp, node_id, subcarrier_count, rssi, activity, confidence | Real-time data |
+
+## License
+
+MIT — see [LICENSE](../../LICENSE) for details.
@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build();
+}
@@ -0,0 +1,12 @@
+{
+  "identifier": "default",
+  "description": "RuView default capability set",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "shell:allow-execute",
+    "shell:allow-open",
+    "dialog:allow-open",
+    "dialog:allow-save"
+  ]
+}
@@ -0,0 +1 @@
+{"default":{"identifier":"default","description":"RuView default capability set","local":true,"windows":["main"],"permissions":["core:default","shell:allow-execute","shell:allow-open","dialog:allow-open","dialog:allow-save"]}}
@@ -0,0 +1,34 @@
+use serde::Serialize;
+
+use crate::domain::node::DiscoveredNode;
+
+/// Discover ESP32 CSI nodes on the local network via mDNS / UDP broadcast.
+#[tauri::command]
+pub async fn discover_nodes(timeout_ms: Option<u64>) -> Result<Vec<DiscoveredNode>, String> {
+    let _timeout = timeout_ms.unwrap_or(3000);
+    // Stub: return placeholder data
+    Ok(vec![DiscoveredNode {
+        ip: "192.168.1.100".into(),
+        mac: Some("AA:BB:CC:DD:EE:FF".into()),
+        hostname: Some("ruview-node-1".into()),
+        node_id: 1,
+        firmware_version: Some("0.3.0".into()),
+        health: crate::domain::node::HealthStatus::Online,
+        last_seen: chrono::Utc::now().to_rfc3339(),
+    }])
+}
+
+/// List available serial ports on this machine.
+#[tauri::command]
+pub async fn list_serial_ports() -> Result<Vec<SerialPortInfo>, String> {
+    // Stub: return empty list
+    Ok(vec![])
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct SerialPortInfo {
+    pub name: String,
+    pub vid: Option<u16>,
+    pub pid: Option<u16>,
+    pub manufacturer: Option<String>,
+}
@@ -0,0 +1,44 @@
+use serde::{Deserialize, Serialize};
+
+/// Flash firmware binary to an ESP32 via serial port.
+#[tauri::command]
+pub async fn flash_firmware(
+    port: String,
+    firmware_path: String,
+    chip: Option<String>,
+    baud: Option<u32>,
+) -> Result<FlashResult, String> {
+    let _ = (port, firmware_path, chip, baud);
+    // Stub: return placeholder result
+    Ok(FlashResult {
+        success: true,
+        message: "Stub: flash not yet implemented".into(),
+        duration_secs: 0.0,
+    })
+}
+
+/// Get current flash progress (stub for polling-based approach).
+#[tauri::command]
+pub async fn flash_progress() -> Result<FlashProgress, String> {
+    Ok(FlashProgress {
+        phase: "idle".into(),
+        progress_pct: 0.0,
+        bytes_written: 0,
+        bytes_total: 0,
+    })
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FlashResult {
+    pub success: bool,
+    pub message: String,
+    pub duration_secs: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FlashProgress {
+    pub phase: String,
+    pub progress_pct: f32,
+    pub bytes_written: u64,
+    pub bytes_total: u64,
+}
@@ -0,0 +1,6 @@
+pub mod discovery;
+pub mod flash;
+pub mod ota;
+pub mod provision;
+pub mod server;
+pub mod wasm;
@@ -0,0 +1,41 @@
+use serde::{Deserialize, Serialize};
+
+/// Push firmware to a single node via HTTP OTA (port 8032).
+#[tauri::command]
+pub async fn ota_update(
+    node_ip: String,
+    firmware_path: String,
+    psk: Option<String>,
+) -> Result<OtaResult, String> {
+    let _ = (node_ip, firmware_path, psk);
+    Ok(OtaResult {
+        success: true,
+        node_ip: "stub".into(),
+        message: "Stub: OTA not yet implemented".into(),
+    })
+}
+
+/// Push firmware to multiple nodes with rolling update strategy.
+#[tauri::command]
+pub async fn batch_ota_update(
+    node_ips: Vec<String>,
+    firmware_path: String,
+    psk: Option<String>,
+) -> Result<Vec<OtaResult>, String> {
+    let _ = (firmware_path, psk);
+    Ok(node_ips
+        .into_iter()
+        .map(|ip| OtaResult {
+            success: true,
+            node_ip: ip,
+            message: "Stub: batch OTA not yet implemented".into(),
+        })
+        .collect())
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OtaResult {
+    pub success: bool,
+    pub node_ip: String,
+    pub message: String,
+}
@@ -0,0 +1,29 @@
+use serde::{Deserialize, Serialize};
+
+use crate::domain::config::ProvisioningConfig;
+
+/// Provision NVS configuration to an ESP32 via serial port.
+#[tauri::command]
+pub async fn provision_node(
+    port: String,
+    config: ProvisioningConfig,
+) -> Result<ProvisionResult, String> {
+    let _ = (port, config);
+    Ok(ProvisionResult {
+        success: true,
+        message: "Stub: provisioning not yet implemented".into(),
+    })
+}
+
+/// Read current NVS configuration from a connected ESP32.
+#[tauri::command]
+pub async fn read_nvs(port: String) -> Result<ProvisioningConfig, String> {
+    let _ = port;
+    Ok(ProvisioningConfig::default())
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProvisionResult {
+    pub success: bool,
+    pub message: String,
+}
@@ -0,0 +1,54 @@
+use serde::{Deserialize, Serialize};
+use tauri::State;
+
+use crate::state::AppState;
+
+/// Start the sensing server as a managed child process.
+#[tauri::command]
+pub async fn start_server(
+    config: ServerConfig,
+    state: State<'_, AppState>,
+) -> Result<(), String> {
+    let _ = config;
+    let mut srv = state.server.lock().map_err(|e| e.to_string())?;
+    srv.running = true;
+    srv.pid = Some(0); // Stub PID
+    Ok(())
+}
+
+/// Stop the managed sensing server process.
+#[tauri::command]
+pub async fn stop_server(state: State<'_, AppState>) -> Result<(), String> {
+    let mut srv = state.server.lock().map_err(|e| e.to_string())?;
+    srv.running = false;
+    srv.pid = None;
+    Ok(())
+}
+
+/// Get sensing server status.
+#[tauri::command]
+pub async fn server_status(state: State<'_, AppState>) -> Result<ServerStatusResponse, String> {
+    let srv = state.server.lock().map_err(|e| e.to_string())?;
+    Ok(ServerStatusResponse {
+        running: srv.running,
+        pid: srv.pid,
+        http_port: None,
+        ws_port: None,
+    })
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ServerConfig {
+    pub http_port: Option<u16>,
+    pub ws_port: Option<u16>,
+    pub udp_port: Option<u16>,
+    pub log_level: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ServerStatusResponse {
+    pub running: bool,
+    pub pid: Option<u32>,
+    pub http_port: Option<u16>,
+    pub ws_port: Option<u16>,
+}
@@ -0,0 +1,48 @@
+use serde::{Deserialize, Serialize};
+
+/// List WASM modules loaded on a specific node.
+#[tauri::command]
+pub async fn wasm_list(node_ip: String) -> Result<Vec<WasmModuleInfo>, String> {
+    let _ = node_ip;
+    Ok(vec![])
+}
+
+/// Upload a WASM module to a node.
+#[tauri::command]
+pub async fn wasm_upload(
+    node_ip: String,
+    wasm_path: String,
+) -> Result<WasmUploadResult, String> {
+    let _ = (node_ip, wasm_path);
+    Ok(WasmUploadResult {
+        success: true,
+        module_id: "stub-module-0".into(),
+        message: "Stub: WASM upload not yet implemented".into(),
+    })
+}
+
+/// Start, stop, or unload a WASM module on a node.
+#[tauri::command]
+pub async fn wasm_control(
+    node_ip: String,
+    module_id: String,
+    action: String,
+) -> Result<(), String> {
+    let _ = (node_ip, module_id, action);
+    Ok(())
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WasmModuleInfo {
+    pub id: String,
+    pub name: String,
+    pub size_bytes: u64,
+    pub status: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WasmUploadResult {
+    pub success: bool,
+    pub module_id: String,
+    pub message: String,
+}
@@ -0,0 +1,89 @@
+use serde::{Deserialize, Serialize};
+
+/// NVS provisioning configuration for a single ESP32 node.
+/// Maps to the firmware's nvs_config_t struct.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ProvisioningConfig {
+    pub wifi_ssid: Option<String>,
+    pub wifi_password: Option<String>,
+    pub target_ip: Option<String>,
+    pub target_port: Option<u16>,
+    pub node_id: Option<u8>,
+    pub tdm_slot: Option<u8>,
+    pub tdm_total: Option<u8>,
+    pub edge_tier: Option<u8>,
+    pub presence_thresh: Option<u16>,
+    pub fall_thresh: Option<u16>,
+    pub vital_window: Option<u16>,
+    pub vital_interval_ms: Option<u16>,
+    pub top_k_count: Option<u8>,
+    pub hop_count: Option<u8>,
+    pub channel_list: Option<Vec<u8>>,
+    pub dwell_ms: Option<u32>,
+    pub power_duty: Option<u8>,
+    pub wasm_max_modules: Option<u8>,
+    pub wasm_verify: Option<bool>,
+    pub ota_psk: Option<String>,
+}
+
+impl ProvisioningConfig {
+    /// Validate invariants:
+    /// - tdm_slot < tdm_total when both set
+    /// - channel_list.len() == hop_count when both set
+    /// - 10 <= power_duty <= 100
+    pub fn validate(&self) -> Result<(), String> {
+        if let (Some(slot), Some(total)) = (self.tdm_slot, self.tdm_total) {
+            if slot >= total {
+                return Err(format!(
+                    "tdm_slot ({}) must be less than tdm_total ({})",
+                    slot, total
+                ));
+            }
+        }
+        if let (Some(ref channels), Some(hops)) = (&self.channel_list, self.hop_count) {
+            if channels.len() != hops as usize {
+                return Err(format!(
+                    "channel_list length ({}) must equal hop_count ({})",
+                    channels.len(),
+                    hops
+                ));
+            }
+        }
+        if let Some(duty) = self.power_duty {
+            if !(10..=100).contains(&duty) {
+                return Err(format!(
+                    "power_duty ({}) must be between 10 and 100",
+                    duty
+                ));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Mesh-level configuration that generates per-node ProvisioningConfig instances.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MeshConfig {
+    pub common: ProvisioningConfig,
+    pub nodes: Vec<MeshNodeEntry>,
+}
+
+/// Per-node override within a mesh configuration.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MeshNodeEntry {
+    pub port: String,
+    pub node_id: u8,
+    pub tdm_slot: u8,
+}
+
+impl MeshConfig {
+    /// Generate a ProvisioningConfig for a specific mesh node,
+    /// merging common settings with per-node overrides.
+    pub fn config_for_node(&self, entry: &MeshNodeEntry) -> ProvisioningConfig {
+        let mut cfg = self.common.clone();
+        cfg.node_id = Some(entry.node_id);
+        cfg.tdm_slot = Some(entry.tdm_slot);
+        cfg.tdm_total = Some(self.nodes.len() as u8);
+        cfg
+    }
+}
@@ -0,0 +1,77 @@
+use serde::{Deserialize, Serialize};
+
+/// A firmware binary to be flashed or OTA-pushed.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FirmwareBinary {
+    pub path: String,
+    pub size_bytes: u64,
+    pub version: Option<String>,
+    pub chip_type: Option<String>,
+}
+
+/// Lifecycle of a serial flash operation.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum FlashPhase {
+    Connecting,
+    Erasing,
+    Writing,
+    Verifying,
+    Completed,
+    Failed,
+}
+
+/// A serial flash session aggregate.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FlashSession {
+    pub id: String,
+    pub port: String,
+    pub firmware: FirmwareBinary,
+    pub phase: FlashPhase,
+    pub bytes_written: u64,
+    pub bytes_total: u64,
+}
+
+/// Lifecycle of an OTA update.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum OtaPhase {
+    Uploading,
+    Rebooting,
+    Verifying,
+    Completed,
+    Failed,
+}
+
+/// An OTA update session aggregate.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OtaSession {
+    pub id: String,
+    pub target_ip: String,
+    pub target_mac: Option<String>,
+    pub firmware: FirmwareBinary,
+    pub phase: OtaPhase,
+    pub bytes_uploaded: u64,
+    pub bytes_total: u64,
+}
+
+/// Strategy for batch OTA updates across a mesh.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum OtaStrategy {
+    Sequential,
+    TdmSafe,
+    Parallel,
+}
+
+/// A batch OTA session coordinating updates across multiple nodes.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BatchOtaSession {
+    pub id: String,
+    pub firmware: FirmwareBinary,
+    pub strategy: OtaStrategy,
+    pub max_concurrent: usize,
+    pub node_count: usize,
+    pub completed: usize,
+    pub failed: usize,
+}
@@ -0,0 +1,3 @@
+pub mod config;
+pub mod firmware;
+pub mod node;
@@ -0,0 +1,81 @@
+use serde::{Deserialize, Serialize};
+
+/// MAC address value object (e.g., "AA:BB:CC:DD:EE:FF").
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct MacAddress(pub String);
+
+impl MacAddress {
+    pub fn new(addr: impl Into<String>) -> Self {
+        Self(addr.into())
+    }
+}
+
+impl std::fmt::Display for MacAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Node health status.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum HealthStatus {
+    Online,
+    Offline,
+    Degraded,
+}
+
+impl Default for HealthStatus {
+    fn default() -> Self {
+        Self::Offline
+    }
+}
+
+/// A discovered ESP32 CSI node.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DiscoveredNode {
+    pub ip: String,
+    pub mac: Option<String>,
+    pub hostname: Option<String>,
+    pub node_id: u8,
+    pub firmware_version: Option<String>,
+    pub health: HealthStatus,
+    pub last_seen: String,
+}
+
+/// Aggregate root: maintains the set of all known nodes, keyed by MAC.
+#[derive(Debug, Default)]
+pub struct NodeRegistry {
+    nodes: std::collections::HashMap<MacAddress, DiscoveredNode>,
+}
+
+impl NodeRegistry {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Insert or update a node. Deduplicates by MAC address.
+    pub fn upsert(&mut self, mac: MacAddress, node: DiscoveredNode) {
+        self.nodes.insert(mac, node);
+    }
+
+    /// Get a node by MAC address.
+    pub fn get(&self, mac: &MacAddress) -> Option<&DiscoveredNode> {
+        self.nodes.get(mac)
+    }
+
+    /// List all known nodes.
+    pub fn all(&self) -> Vec<&DiscoveredNode> {
+        self.nodes.values().collect()
+    }
+
+    /// Number of registered nodes.
+    pub fn len(&self) -> usize {
+        self.nodes.len()
+    }
+
+    /// Whether the registry is empty.
+    pub fn is_empty(&self) -> bool {
+        self.nodes.is_empty()
+    }
+}
@@ -0,0 +1,36 @@
+pub mod commands;
+pub mod domain;
+pub mod state;
+
+use commands::{discovery, flash, ota, provision, server, wasm};
+
+pub fn run() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_dialog::init())
+        .manage(state::AppState::default())
+        .invoke_handler(tauri::generate_handler![
+            // Discovery
+            discovery::discover_nodes,
+            discovery::list_serial_ports,
+            // Flash
+            flash::flash_firmware,
+            flash::flash_progress,
+            // OTA
+            ota::ota_update,
+            ota::batch_ota_update,
+            // WASM
+            wasm::wasm_list,
+            wasm::wasm_upload,
+            wasm::wasm_control,
+            // Server
+            server::start_server,
+            server::stop_server,
+            server::server_status,
+            // Provision
+            provision::provision_node,
+            provision::read_nvs,
+        ])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
@@ -0,0 +1,8 @@
+#![cfg_attr(
+    all(not(debug_assertions), target_os = "windows"),
+    windows_subsystem = "windows"
+)]
+
+fn main() {
+    wifi_densepose_desktop::run();
+}
@@ -0,0 +1,23 @@
+use std::sync::Mutex;
+
+use crate::domain::node::DiscoveredNode;
+
+/// Sub-state for discovered nodes.
+#[derive(Default)]
+pub struct DiscoveryState {
+    pub nodes: Vec<DiscoveredNode>,
+}
+
+/// Sub-state for the managed sensing server process.
+#[derive(Default)]
+pub struct ServerState {
+    pub running: bool,
+    pub pid: Option<u32>,
+}
+
+/// Top-level application state managed by Tauri.
+#[derive(Default)]
+pub struct AppState {
+    pub discovery: Mutex<DiscoveryState>,
+    pub server: Mutex<ServerState>,
+}
@@ -0,0 +1,35 @@
+{
+  "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/crates/tauri-config-schema/schema.json",
+  "productName": "RuView Desktop",
+  "version": "0.3.0",
+  "identifier": "net.ruv.ruview",
+  "build": {
+    "frontendDist": "../ui/dist",
+    "devUrl": "http://localhost:5173",
+    "beforeDevCommand": "cd ../ui && npm run dev",
+    "beforeBuildCommand": "cd ../ui && npm run build"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "RuView Desktop",
+        "width": 1200,
+        "height": 800,
+        "minWidth": 900,
+        "minHeight": 600,
+        "resizable": true
+      }
+    ]
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ]
+  }
+}
@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RuView Desktop</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
@@ -0,0 +1,25 @@
+{
+  "name": "ruview-desktop-ui",
+  "private": true,
+  "version": "0.3.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2.0.0",
+    "@tauri-apps/plugin-dialog": "^2.6.0",
+    "@tauri-apps/plugin-shell": "^2.3.5",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "^5.5.0",
+    "vite": "^6.0.0"
+  }
+}
@@ -0,0 +1,354 @@
+import { useState, useEffect, useCallback } from "react";
+import Dashboard from "./pages/Dashboard";
+import { Nodes } from "./pages/Nodes";
+import { FlashFirmware } from "./pages/FlashFirmware";
+import { OtaUpdate } from "./pages/OtaUpdate";
+import { EdgeModules } from "./pages/EdgeModules";
+import { Sensing } from "./pages/Sensing";
+import { MeshView } from "./pages/MeshView";
+import { Settings } from "./pages/Settings";
+
+type Page =
+  | "dashboard"
+  | "nodes"
+  | "flash"
+  | "ota"
+  | "wasm"
+  | "sensing"
+  | "mesh"
+  | "settings";
+
+interface NavItem {
+  id: Page;
+  label: string;
+  icon: string;
+}
+
+const NAV_ITEMS: NavItem[] = [
+  { id: "dashboard", label: "Dashboard", icon: "\u25A6" },
+  { id: "nodes", label: "Nodes", icon: "\u25C9" },
+  { id: "flash", label: "Flash", icon: "\u26A1" },
+  { id: "ota", label: "OTA", icon: "\u2B06" },
+  { id: "wasm", label: "Edge Modules", icon: "\u2B21" },
+  { id: "sensing", label: "Sensing", icon: "\u2248" },
+  { id: "mesh", label: "Mesh View", icon: "\u2B2F" },
+  { id: "settings", label: "Settings", icon: "\u2699" },
+];
+
+interface LiveStatus {
+  nodeCount: number;
+  onlineCount: number;
+  serverRunning: boolean;
+  serverPort: number | null;
+}
+
+const App: React.FC = () => {
+  const [activePage, setActivePage] = useState<Page>("dashboard");
+  const [hoveredNav, setHoveredNav] = useState<Page | null>(null);
+  const [pageKey, setPageKey] = useState(0);
+  const [liveStatus, setLiveStatus] = useState<LiveStatus>({
+    nodeCount: 0,
+    onlineCount: 0,
+    serverRunning: false,
+    serverPort: null,
+  });
+
+  const navigateTo = useCallback((page: Page) => {
+    setActivePage(page);
+    setPageKey((k) => k + 1);
+  }, []);
+
+  // Poll live status every 5 seconds
+  useEffect(() => {
+    const poll = async () => {
+      try {
+        const { invoke } = await import("@tauri-apps/api/core");
+        const [nodes, server] = await Promise.all([
+          invoke<{ health: string }[]>("discover_nodes", { timeoutMs: 2000 }).catch(() => []),
+          invoke<{ running: boolean; http_port: number | null }>("server_status").catch(() => ({
+            running: false,
+            http_port: null,
+          })),
+        ]);
+        setLiveStatus({
+          nodeCount: nodes.length,
+          onlineCount: nodes.filter((n) => n.health === "online").length,
+          serverRunning: server.running,
+          serverPort: server.http_port,
+        });
+      } catch {
+        // Tauri not available (browser preview) — leave defaults
+      }
+    };
+    poll();
+    const id = setInterval(poll, 8000);
+    return () => clearInterval(id);
+  }, []);
+
+  const renderPage = () => {
+    switch (activePage) {
+      case "dashboard": return <Dashboard />;
+      case "nodes": return <Nodes />;
+      case "flash": return <FlashFirmware />;
+      case "ota": return <OtaUpdate />;
+      case "wasm": return <EdgeModules />;
+      case "sensing": return <Sensing />;
+      case "mesh": return <MeshView />;
+      case "settings": return <Settings />;
+    }
+  };
+
+  return (
+    <div style={{ display: "flex", flexDirection: "column", height: "100vh", overflow: "hidden" }}>
+      <div style={{ display: "flex", flex: 1, overflow: "hidden" }}>
+        {/* Sidebar */}
+        <nav
+          style={{
+            width: 220,
+            minWidth: 220,
+            background: "var(--bg-surface)",
+            borderRight: "1px solid var(--border)",
+            display: "flex",
+            flexDirection: "column",
+            userSelect: "none",
+          }}
+        >
+          {/* Brand */}
+          <div
+            style={{
+              padding: "20px 16px 16px",
+              borderBottom: "1px solid var(--border)",
+            }}
+          >
+            <div style={{ display: "flex", alignItems: "center", gap: 8, marginBottom: 2 }}>
+              <div
+                style={{
+                  width: 30,
+                  height: 30,
+                  borderRadius: 8,
+                  background: "linear-gradient(135deg, var(--accent), #a855f7, #ec4899)",
+                  backgroundSize: "200% 200%",
+                  animation: "gradient-shift 4s ease infinite",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  fontSize: 15,
+                  fontWeight: 800,
+                  color: "#fff",
+                  fontFamily: "var(--font-sans)",
+                  boxShadow: "0 2px 12px rgba(124, 58, 237, 0.4)",
+                }}
+              >
+                R
+              </div>
+              <div>
+                <h1
+                  style={{
+                    fontSize: 17,
+                    fontWeight: 700,
+                    color: "var(--text-primary)",
+                    fontFamily: "var(--font-sans)",
+                    margin: 0,
+                    letterSpacing: "-0.01em",
+                    lineHeight: 1.2,
+                  }}
+                >
+                  RuView
+                </h1>
+                <span
+                  style={{
+                    fontSize: 10,
+                    color: "var(--text-muted)",
+                    fontFamily: "var(--font-mono)",
+                    letterSpacing: "0.02em",
+                  }}
+                >
+                  v0.3.0
+                </span>
+              </div>
+            </div>
+          </div>
+
+          {/* Nav items */}
+          <div style={{ flex: 1, paddingTop: 6, paddingBottom: 6, overflowY: "auto" }}>
+            {NAV_ITEMS.map((item) => {
+              const isActive = activePage === item.id;
+              const isHovered = hoveredNav === item.id && !isActive;
+              return (
+                <button
+                  key={item.id}
+                  onClick={() => navigateTo(item.id)}
+                  onMouseEnter={() => setHoveredNav(item.id)}
+                  onMouseLeave={() => setHoveredNav(null)}
+                  style={{
+                    display: "flex",
+                    alignItems: "center",
+                    gap: 10,
+                    width: "100%",
+                    padding: "8px 16px",
+                    background: isActive
+                      ? "linear-gradient(90deg, rgba(124, 58, 237, 0.15), transparent)"
+                      : isHovered
+                        ? "var(--bg-hover)"
+                        : "transparent",
+                    color: isActive ? "var(--text-primary)" : "var(--text-secondary)",
+                    fontSize: 13,
+                    fontWeight: isActive ? 600 : 400,
+                    textAlign: "left",
+                    borderLeft: isActive
+                      ? "3px solid transparent"
+                      : "3px solid transparent",
+                    fontFamily: "var(--font-sans)",
+                    borderRadius: 0,
+                    transition: "all 0.15s ease",
+                    position: "relative",
+                  }}
+                >
+                  {/* Active gradient indicator */}
+                  {isActive && (
+                    <span
+                      style={{
+                        position: "absolute",
+                        left: 0,
+                        top: 4,
+                        bottom: 4,
+                        width: 3,
+                        borderRadius: "0 3px 3px 0",
+                        background: "linear-gradient(180deg, var(--accent), #a855f7)",
+                        boxShadow: "0 0 8px rgba(124, 58, 237, 0.5)",
+                      }}
+                    />
+                  )}
+                  <span
+                    style={{
+                      width: 24,
+                      height: 24,
+                      borderRadius: 6,
+                      background: isActive
+                        ? "linear-gradient(135deg, var(--accent), #a855f7)"
+                        : isHovered
+                          ? "var(--bg-active)"
+                          : "var(--bg-elevated)",
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "center",
+                      fontSize: 12,
+                      color: isActive ? "#fff" : "var(--text-muted)",
+                      transition: "all 0.15s ease",
+                      flexShrink: 0,
+                      boxShadow: isActive ? "0 2px 8px rgba(124, 58, 237, 0.3)" : "none",
+                      transform: isHovered ? "scale(1.1)" : "scale(1)",
+                    }}
+                  >
+                    {item.icon}
+                  </span>
+                  {item.label}
+                </button>
+              );
+            })}
+          </div>
+
+          {/* Live connection footer */}
+          <div
+            style={{
+              padding: "10px 16px",
+              fontSize: 11,
+              color: "var(--text-muted)",
+              borderTop: "1px solid var(--border)",
+              fontFamily: "var(--font-mono)",
+              display: "flex",
+              alignItems: "center",
+              gap: 6,
+            }}
+          >
+            <span className="status-dot status-dot--online" style={{ width: 6, height: 6 }} />
+            <span>Connected</span>
+            {liveStatus.nodeCount > 0 && (
+              <span style={{ marginLeft: "auto", color: "var(--text-muted)" }}>
+                {liveStatus.onlineCount}/{liveStatus.nodeCount}
+              </span>
+            )}
+          </div>
+        </nav>
+
+        {/* Main content */}
+        <main
+          style={{
+            flex: 1,
+            overflow: "auto",
+            background: "var(--bg-base)",
+          }}
+        >
+          <div key={pageKey} className="page-transition">
+            {renderPage()}
+          </div>
+        </main>
+      </div>
+
+      {/* Status Bar */}
+      <footer
+        style={{
+          height: "var(--statusbar-height)",
+          minHeight: "var(--statusbar-height)",
+          background: "var(--bg-surface)",
+          borderTop: "1px solid var(--border)",
+          display: "flex",
+          alignItems: "center",
+          padding: "0 16px",
+          gap: 16,
+          fontSize: 11,
+          fontFamily: "var(--font-sans)",
+          color: "var(--text-muted)",
+          userSelect: "none",
+        }}
+      >
+        <span style={{ color: "var(--text-muted)", fontWeight: 500 }}>
+          Powered by rUv
+        </span>
+
+        <span style={{ color: "var(--border)" }}>{"\u2502"}</span>
+
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span
+            className={`status-dot ${liveStatus.onlineCount > 0 ? "status-dot--online" : "status-dot--error"}`}
+            style={{ width: 6, height: 6 }}
+          />
+          {liveStatus.onlineCount > 0
+            ? `${liveStatus.onlineCount} node${liveStatus.onlineCount !== 1 ? "s" : ""} online`
+            : "No nodes"}
+        </span>
+
+        <span style={{ color: "var(--border)" }}>{"\u2502"}</span>
+
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span
+            className={`status-dot ${liveStatus.serverRunning ? "status-dot--online" : "status-dot--error"}`}
+            style={{ width: 6, height: 6 }}
+          />
+          Server: {liveStatus.serverRunning ? "running" : "stopped"}
+        </span>
+
+        <span style={{ flex: 1 }} />
+
+        {liveStatus.serverPort && (
+          <span style={{ fontFamily: "var(--font-mono)", color: "var(--text-muted)" }}>
+            :{liveStatus.serverPort}
+          </span>
+        )}
+
+        <span
+          style={{
+            fontFamily: "var(--font-mono)",
+            fontSize: 10,
+            color: "var(--text-muted)",
+            opacity: 0.6,
+          }}
+        >
+          {new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
+        </span>
+      </footer>
+    </div>
+  );
+};
+
+export default App;
@@ -0,0 +1,158 @@
+import type { Node } from "../types";
+import { StatusBadge } from "./StatusBadge";
+
+interface NodeCardProps {
+  node: Node;
+  onClick?: (node: Node) => void;
+}
+
+function formatUptime(secs: number | null): string {
+  if (secs == null) return "--";
+  if (secs < 60) return `${secs}s`;
+  if (secs < 3600) return `${Math.floor(secs / 60)}m`;
+  if (secs < 86400) return `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
+  return `${Math.floor(secs / 86400)}d ${Math.floor((secs % 86400) / 3600)}h`;
+}
+
+function formatLastSeen(iso: string): string {
+  try {
+    const d = new Date(iso);
+    const diffMs = Date.now() - d.getTime();
+    if (diffMs < 60_000) return "just now";
+    if (diffMs < 3_600_000) return `${Math.floor(diffMs / 60_000)}m ago`;
+    if (diffMs < 86_400_000) return `${Math.floor(diffMs / 3_600_000)}h ago`;
+    return d.toLocaleDateString();
+  } catch {
+    return "--";
+  }
+}
+
+export function NodeCard({ node, onClick }: NodeCardProps) {
+  const isOnline = node.health === "online";
+
+  return (
+    <div
+      onClick={() => onClick?.(node)}
+      style={{
+        background: "var(--bg-elevated)",
+        border: "1px solid var(--border)",
+        borderRadius: 8,
+        padding: "var(--space-4)",
+        cursor: onClick ? "pointer" : "default",
+        opacity: isOnline ? 1 : 0.6,
+        transition: "border-color 0.15s, background 0.15s",
+      }}
+      onMouseEnter={(e) => {
+        e.currentTarget.style.borderColor = "var(--accent)";
+        e.currentTarget.style.background = "var(--bg-hover)";
+      }}
+      onMouseLeave={(e) => {
+        e.currentTarget.style.borderColor = "var(--border)";
+        e.currentTarget.style.background = "var(--bg-elevated)";
+      }}
+    >
+      {/* Header */}
+      <div
+        style={{
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "flex-start",
+          marginBottom: "var(--space-3)",
+        }}
+      >
+        <div>
+          <div
+            style={{
+              fontSize: 14,
+              fontWeight: 600,
+              color: "var(--text-primary)",
+              fontFamily: "var(--font-sans)",
+              marginBottom: 2,
+            }}
+          >
+            {node.friendly_name || node.hostname || `Node ${node.node_id}`}
+          </div>
+          <div
+            style={{
+              fontSize: 12,
+              color: "var(--text-secondary)",
+              fontFamily: "var(--font-mono)",
+            }}
+          >
+            {node.ip}
+          </div>
+        </div>
+        <StatusBadge status={node.health} />
+      </div>
+
+      {/* Details grid */}
+      <div
+        style={{
+          display: "grid",
+          gridTemplateColumns: "1fr 1fr",
+          gap: "var(--space-2) var(--space-4)",
+          fontSize: 12,
+        }}
+      >
+        <DetailRow label="MAC" value={node.mac ?? "--"} mono />
+        <DetailRow label="Firmware" value={node.firmware_version ?? "--"} mono />
+        <DetailRow label="Chip" value={node.chip?.toUpperCase() ?? "--"} />
+        <DetailRow label="Role" value={node.mesh_role} />
+        <DetailRow
+          label="TDM"
+          value={
+            node.tdm_slot != null && node.tdm_total != null
+              ? `${node.tdm_slot}/${node.tdm_total}`
+              : "--"
+          }
+          mono
+        />
+        <DetailRow
+          label="Edge Tier"
+          value={node.edge_tier != null ? String(node.edge_tier) : "--"}
+        />
+        <DetailRow label="Uptime" value={formatUptime(node.uptime_secs)} mono />
+        <DetailRow label="Seen" value={formatLastSeen(node.last_seen)} />
+      </div>
+    </div>
+  );
+}
+
+function DetailRow({
+  label,
+  value,
+  mono = false,
+}: {
+  label: string;
+  value: string;
+  mono?: boolean;
+}) {
+  return (
+    <div>
+      <div
+        style={{
+          color: "var(--text-muted)",
+          fontSize: 10,
+          textTransform: "uppercase",
+          letterSpacing: "0.05em",
+          marginBottom: 1,
+          fontFamily: "var(--font-sans)",
+        }}
+      >
+        {label}
+      </div>
+      <div
+        style={{
+          color: "var(--text-secondary)",
+          fontFamily: mono ? "var(--font-mono)" : "var(--font-sans)",
+          fontSize: 12,
+          overflow: "hidden",
+          textOverflow: "ellipsis",
+          whiteSpace: "nowrap",
+        }}
+      >
+        {value}
+      </div>
+    </div>
+  );
+}
@@ -0,0 +1,152 @@
+import { type ReactNode } from "react";
+
+export interface NavItem {
+  id: string;
+  label: string;
+  icon: ReactNode;
+}
+
+interface SidebarProps {
+  items: NavItem[];
+  activeId: string;
+  onNavigate: (id: string) => void;
+}
+
+// Minimal SVG icons to avoid external dependency
+const ICONS: Record<string, ReactNode> = {
+  dashboard: (
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <rect x="3" y="3" width="7" height="9" rx="1" />
+      <rect x="14" y="3" width="7" height="5" rx="1" />
+      <rect x="14" y="12" width="7" height="9" rx="1" />
+      <rect x="3" y="16" width="7" height="5" rx="1" />
+    </svg>
+  ),
+  nodes: (
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <circle cx="12" cy="5" r="3" />
+      <circle cx="5" cy="19" r="3" />
+      <circle cx="19" cy="19" r="3" />
+      <line x1="12" y1="8" x2="5" y2="16" />
+      <line x1="12" y1="8" x2="19" y2="16" />
+    </svg>
+  ),
+  flash: (
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2" />
+    </svg>
+  ),
+  server: (
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <rect x="2" y="2" width="20" height="8" rx="2" />
+      <rect x="2" y="14" width="20" height="8" rx="2" />
+      <line x1="6" y1="6" x2="6.01" y2="6" />
+      <line x1="6" y1="18" x2="6.01" y2="18" />
+    </svg>
+  ),
+  settings: (
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <circle cx="12" cy="12" r="3" />
+      <path d="M12 1v2M12 21v2M4.22 4.22l1.42 1.42M18.36 18.36l1.42 1.42M1 12h2M21 12h2M4.22 19.78l1.42-1.42M18.36 5.64l1.42-1.42" />
+    </svg>
+  ),
+};
+
+export const DEFAULT_NAV_ITEMS: NavItem[] = [
+  { id: "dashboard", label: "Dashboard", icon: ICONS.dashboard },
+  { id: "nodes", label: "Nodes", icon: ICONS.nodes },
+  { id: "flash", label: "Flash", icon: ICONS.flash },
+  { id: "server", label: "Server", icon: ICONS.server },
+  { id: "settings", label: "Settings", icon: ICONS.settings },
+];
+
+export function Sidebar({ items, activeId, onNavigate }: SidebarProps) {
+  return (
+    <nav
+      style={{
+        width: "200px",
+        minWidth: "200px",
+        height: "100%",
+        background: "var(--sidebar-bg, #12121a)",
+        borderRight: "1px solid var(--border, #2e2e3e)",
+        display: "flex",
+        flexDirection: "column",
+        padding: "16px 0",
+      }}
+    >
+      {/* App title */}
+      <div
+        style={{
+          padding: "0 20px 20px",
+          fontSize: "18px",
+          fontWeight: 800,
+          color: "var(--text-primary, #e2e8f0)",
+          letterSpacing: "-0.02em",
+        }}
+      >
+        RuView
+      </div>
+
+      {/* Nav items */}
+      <div style={{ display: "flex", flexDirection: "column", gap: "2px", flex: 1 }}>
+        {items.map((item) => {
+          const isActive = item.id === activeId;
+          return (
+            <button
+              key={item.id}
+              onClick={() => onNavigate(item.id)}
+              style={{
+                display: "flex",
+                alignItems: "center",
+                gap: "10px",
+                padding: "10px 20px",
+                border: "none",
+                background: isActive
+                  ? "var(--accent-muted, rgba(99, 102, 241, 0.12))"
+                  : "transparent",
+                color: isActive
+                  ? "var(--accent, #6366f1)"
+                  : "var(--text-secondary, #94a3b8)",
+                cursor: "pointer",
+                fontSize: "13px",
+                fontWeight: isActive ? 600 : 400,
+                textAlign: "left",
+                borderLeft: isActive
+                  ? "3px solid var(--accent, #6366f1)"
+                  : "3px solid transparent",
+                transition: "background 0.1s, color 0.1s",
+              }}
+              onMouseEnter={(e) => {
+                if (!isActive) {
+                  e.currentTarget.style.background =
+                    "var(--hover-bg, rgba(255,255,255,0.04))";
+                  e.currentTarget.style.color = "var(--text-primary, #e2e8f0)";
+                }
+              }}
+              onMouseLeave={(e) => {
+                if (!isActive) {
+                  e.currentTarget.style.background = "transparent";
+                  e.currentTarget.style.color = "var(--text-secondary, #94a3b8)";
+                }
+              }}
+            >
+              {item.icon}
+              {item.label}
+            </button>
+          );
+        })}
+      </div>
+
+      {/* Version footer */}
+      <div
+        style={{
+          padding: "12px 20px",
+          fontSize: "10px",
+          color: "var(--text-muted, #64748b)",
+        }}
+      >
+        v0.3.0
+      </div>
+    </nav>
+  );
+}
@@ -0,0 +1,59 @@
+import type { HealthStatus } from "../types";
+
+interface StatusBadgeProps {
+  status: HealthStatus;
+  size?: "sm" | "md" | "lg";
+}
+
+const STATUS_STYLES: Record<HealthStatus, { color: string; label: string }> = {
+  online:   { color: "var(--status-online)",  label: "Online" },
+  offline:  { color: "var(--status-error)",   label: "Offline" },
+  degraded: { color: "var(--status-warning)", label: "Degraded" },
+  unknown:  { color: "var(--text-muted)",     label: "Unknown" },
+};
+
+const SIZE_STYLES: Record<string, { fontSize: number; padding: string; dot: number }> = {
+  sm: { fontSize: 11, padding: "2px 8px", dot: 6 },
+  md: { fontSize: 13, padding: "4px 12px", dot: 8 },
+  lg: { fontSize: 15, padding: "6px 16px", dot: 10 },
+};
+
+export function StatusBadge({ status, size = "sm" }: StatusBadgeProps) {
+  const { color, label } = STATUS_STYLES[status];
+  const s = SIZE_STYLES[size];
+
+  return (
+    <span
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 6,
+        color,
+        fontSize: s.fontSize,
+        fontWeight: 600,
+        fontFamily: "var(--font-sans)",
+        padding: s.padding,
+        borderRadius: 9999,
+        lineHeight: 1,
+        whiteSpace: "nowrap",
+        background: "rgba(255, 255, 255, 0.04)",
+      }}
+    >
+      <span
+        style={{
+          width: s.dot,
+          height: s.dot,
+          borderRadius: "50%",
+          backgroundColor: color,
+          flexShrink: 0,
+          boxShadow: status === "online"
+            ? `0 0 4px ${color}, 0 0 8px ${color}`
+            : status === "degraded"
+              ? `0 0 4px ${color}`
+              : "none",
+        }}
+      />
+      {label}
+    </span>
+  );
+}
@@ -0,0 +1,532 @@
+/*
+ * RuView Design System (ADR-053)
+ * Dark professional + Unity-inspired interface
+ */
+
+/* ===== Design Tokens ===== */
+:root {
+  /* Background layers */
+  --bg-base:        #0d1117;
+  --bg-surface:     #161b22;
+  --bg-elevated:    #1c2333;
+  --bg-hover:       #242d3d;
+  --bg-active:      #2d3748;
+
+  /* Text hierarchy */
+  --text-primary:   #e6edf3;
+  --text-secondary: #8b949e;
+  --text-muted:     #484f58;
+
+  /* Status indicators */
+  --status-online:  #3fb950;
+  --status-warning: #d29922;
+  --status-error:   #f85149;
+  --status-info:    #58a6ff;
+
+  /* Accent */
+  --accent:         #7c3aed;
+  --accent-hover:   #6d28d9;
+  --accent-glow:    rgba(124, 58, 237, 0.15);
+
+  /* Borders */
+  --border:         #30363d;
+  --border-active:  #58a6ff;
+
+  /* Shadows */
+  --shadow-sm:      0 1px 2px rgba(0, 0, 0, 0.3);
+  --shadow-md:      0 4px 12px rgba(0, 0, 0, 0.4);
+  --shadow-lg:      0 8px 24px rgba(0, 0, 0, 0.5);
+  --shadow-accent:  0 0 0 3px var(--accent-glow);
+
+  /* Fonts */
+  --font-mono: 'JetBrains Mono', 'Fira Code', 'Consolas', monospace;
+  --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+
+  /* Spacing (4px base grid) */
+  --space-1: 4px;
+  --space-2: 8px;
+  --space-3: 12px;
+  --space-4: 16px;
+  --space-5: 24px;
+  --space-6: 32px;
+  --space-8: 48px;
+
+  /* Radius */
+  --radius-sm: 4px;
+  --radius-md: 6px;
+  --radius-lg: 8px;
+  --radius-xl: 12px;
+  --radius-full: 9999px;
+
+  /* Panel dimensions */
+  --sidebar-width: 220px;
+  --sidebar-collapsed: 52px;
+  --statusbar-height: 32px;
+  --toolbar-height: 44px;
+
+  /* Transitions */
+  --transition-fast: 0.1s ease;
+  --transition-normal: 0.15s ease;
+  --transition-slow: 0.25s ease;
+}
+
+/* ===== Reset ===== */
+*, *::before, *::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html, body, #root {
+  height: 100%;
+}
+
+body {
+  font-family: var(--font-sans);
+  font-size: 14px;
+  line-height: 1.6;
+  background: var(--bg-base);
+  color: var(--text-primary);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+/* ===== Typography Scale ===== */
+.heading-xl { font: 600 28px/1.2 var(--font-sans); color: var(--text-primary); letter-spacing: -0.02em; }
+.heading-lg { font: 600 20px/1.3 var(--font-sans); color: var(--text-primary); letter-spacing: -0.01em; }
+.heading-md { font: 600 16px/1.4 var(--font-sans); color: var(--text-primary); }
+.heading-sm { font: 600 13px/1.4 var(--font-sans); color: var(--text-secondary); text-transform: uppercase; letter-spacing: 0.04em; }
+.body       { font: 400 14px/1.6 var(--font-sans); color: var(--text-primary); }
+.body-sm    { font: 400 12px/1.5 var(--font-sans); color: var(--text-secondary); }
+.data       { font: 400 13px/1.4 var(--font-mono); color: var(--text-secondary); }
+.data-lg    { font: 500 24px/1.2 var(--font-mono); color: var(--text-primary); letter-spacing: -0.02em; }
+
+/* ===== Scrollbar ===== */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: var(--border);
+  border-radius: var(--radius-full);
+  border: 2px solid transparent;
+  background-clip: padding-box;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: var(--bg-active);
+  border: 2px solid transparent;
+  background-clip: padding-box;
+}
+::-webkit-scrollbar-corner {
+  background: transparent;
+}
+
+/* ===== Form Controls ===== */
+input, select, textarea {
+  font-family: var(--font-sans);
+  font-size: 13px;
+  color: var(--text-primary);
+  background: var(--bg-base);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+  padding: var(--space-2) var(--space-3);
+  outline: none;
+  width: 100%;
+  box-sizing: border-box;
+  transition: border-color var(--transition-normal), box-shadow var(--transition-normal);
+}
+input:hover, select:hover, textarea:hover {
+  border-color: var(--bg-active);
+}
+input:focus, select:focus, textarea:focus {
+  border-color: var(--accent);
+  box-shadow: var(--shadow-accent);
+}
+input:disabled, select:disabled, textarea:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+input[type="number"] {
+  font-family: var(--font-mono);
+}
+input::placeholder {
+  color: var(--text-muted);
+}
+select {
+  cursor: pointer;
+  appearance: none;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='%238b949e' viewBox='0 0 16 16'%3E%3Cpath d='M4.427 7.427l3.396 3.396a.25.25 0 00.354 0l3.396-3.396A.25.25 0 0011.396 7H4.604a.25.25 0 00-.177.427z'/%3E%3C/svg%3E");
+  background-repeat: no-repeat;
+  background-position: right 10px center;
+  padding-right: 30px;
+}
+
+/* ===== Buttons ===== */
+button {
+  font-family: var(--font-sans);
+  font-size: 13px;
+  cursor: pointer;
+  border: none;
+  outline: none;
+  border-radius: var(--radius-md);
+  transition: background var(--transition-normal), box-shadow var(--transition-normal), transform var(--transition-fast);
+}
+button:focus-visible {
+  box-shadow: var(--shadow-accent);
+}
+button:active:not(:disabled) {
+  transform: scale(0.98);
+}
+button:disabled {
+  cursor: not-allowed;
+  opacity: 0.4;
+}
+
+/* Button variants */
+.btn-primary {
+  padding: var(--space-2) 20px;
+  background: var(--accent);
+  color: #fff;
+  font-weight: 600;
+  border: none;
+}
+.btn-primary:hover:not(:disabled) {
+  background: var(--accent-hover);
+  box-shadow: var(--shadow-sm);
+}
+
+.btn-secondary {
+  padding: var(--space-2) var(--space-4);
+  background: transparent;
+  color: var(--text-secondary);
+  font-weight: 500;
+  border: 1px solid var(--border);
+}
+.btn-secondary:hover:not(:disabled) {
+  background: var(--bg-hover);
+  color: var(--text-primary);
+  border-color: var(--bg-active);
+}
+
+.btn-danger {
+  padding: var(--space-2) var(--space-4);
+  background: rgba(248, 81, 73, 0.1);
+  color: var(--status-error);
+  font-weight: 600;
+  border: 1px solid rgba(248, 81, 73, 0.2);
+}
+.btn-danger:hover:not(:disabled) {
+  background: rgba(248, 81, 73, 0.2);
+  border-color: rgba(248, 81, 73, 0.4);
+}
+
+.btn-ghost {
+  padding: var(--space-2) var(--space-3);
+  background: transparent;
+  color: var(--text-secondary);
+  font-weight: 400;
+  border: none;
+}
+.btn-ghost:hover:not(:disabled) {
+  background: var(--bg-hover);
+  color: var(--text-primary);
+}
+
+.btn-icon {
+  padding: var(--space-2);
+  background: transparent;
+  color: var(--text-secondary);
+  border: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+.btn-icon:hover:not(:disabled) {
+  background: var(--bg-hover);
+  color: var(--text-primary);
+}
+
+/* ===== Card ===== */
+.card {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-lg);
+  padding: var(--space-5);
+  transition: border-color var(--transition-normal), box-shadow var(--transition-normal), transform var(--transition-normal);
+}
+.card:hover {
+  border-color: var(--bg-active);
+  box-shadow: var(--shadow-sm);
+}
+.card-elevated {
+  background: var(--bg-elevated);
+  box-shadow: var(--shadow-sm);
+}
+
+/* Glassmorphism card variant */
+.card-glass {
+  background: rgba(22, 27, 34, 0.7);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  border: 1px solid rgba(48, 54, 61, 0.6);
+  border-radius: var(--radius-lg);
+  padding: var(--space-5);
+  transition: border-color var(--transition-normal), box-shadow var(--transition-normal), transform var(--transition-normal);
+}
+.card-glass:hover {
+  border-color: rgba(124, 58, 237, 0.3);
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3), inset 0 0 0 1px rgba(124, 58, 237, 0.1);
+}
+
+/* Accent-glow card for stat highlights */
+.card-glow {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-lg);
+  padding: var(--space-5);
+  position: relative;
+  overflow: hidden;
+  transition: border-color var(--transition-normal), box-shadow var(--transition-normal);
+}
+.card-glow::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 2px;
+  background: linear-gradient(90deg, var(--accent), #a855f7, var(--accent));
+  background-size: 200% 100%;
+  animation: gradient-shift 3s ease infinite;
+  opacity: 0;
+  transition: opacity var(--transition-normal);
+}
+.card-glow:hover::before {
+  opacity: 1;
+}
+.card-glow:hover {
+  border-color: rgba(124, 58, 237, 0.3);
+  box-shadow: 0 0 20px rgba(124, 58, 237, 0.08);
+}
+
+/* ===== Table ===== */
+table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 13px;
+}
+thead th {
+  padding: 10px var(--space-4);
+  font-size: 10px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-muted);
+  text-align: left;
+  border-bottom: 1px solid var(--border);
+  position: sticky;
+  top: 0;
+  background: var(--bg-surface);
+  z-index: 1;
+}
+tbody td {
+  padding: 10px var(--space-4);
+  color: var(--text-secondary);
+  border-bottom: 1px solid var(--border);
+}
+tbody tr {
+  transition: background var(--transition-fast);
+}
+tbody tr:hover {
+  background: var(--bg-hover);
+}
+tbody tr:last-child td {
+  border-bottom: none;
+}
+
+/* ===== Badge ===== */
+.badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 2px 8px;
+  border-radius: var(--radius-full);
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 1;
+  white-space: nowrap;
+}
+
+/* ===== Divider ===== */
+.divider {
+  height: 1px;
+  background: var(--border);
+  margin: var(--space-4) 0;
+}
+
+/* ===== Animations ===== */
+@keyframes pulse-accent {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.7; }
+}
+
+@keyframes fade-in {
+  from { opacity: 0; transform: translateY(6px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+@keyframes fade-in-scale {
+  from { opacity: 0; transform: scale(0.97) translateY(4px); }
+  to { opacity: 1; transform: scale(1) translateY(0); }
+}
+
+@keyframes skeleton-pulse {
+  0%, 100% { opacity: 0.06; }
+  50% { opacity: 0.12; }
+}
+
+@keyframes glow-pulse {
+  0%, 100% { box-shadow: 0 0 4px currentColor; }
+  50% { box-shadow: 0 0 10px currentColor, 0 0 20px currentColor; }
+}
+
+@keyframes count-up-pop {
+  0% { transform: scale(0.8); opacity: 0; }
+  60% { transform: scale(1.05); }
+  100% { transform: scale(1); opacity: 1; }
+}
+
+@keyframes gradient-shift {
+  0% { background-position: 0% 50%; }
+  50% { background-position: 100% 50%; }
+  100% { background-position: 0% 50%; }
+}
+
+@keyframes slide-in-left {
+  from { opacity: 0; transform: translateX(-8px); }
+  to { opacity: 1; transform: translateX(0); }
+}
+
+.animate-fade-in {
+  animation: fade-in 0.25s ease-out;
+}
+
+/* Page transition wrapper */
+.page-transition {
+  animation: fade-in-scale 0.3s ease-out;
+}
+
+/* Stagger children animation */
+.stagger-children > * {
+  animation: fade-in 0.3s ease-out backwards;
+}
+.stagger-children > *:nth-child(1) { animation-delay: 0ms; }
+.stagger-children > *:nth-child(2) { animation-delay: 50ms; }
+.stagger-children > *:nth-child(3) { animation-delay: 100ms; }
+.stagger-children > *:nth-child(4) { animation-delay: 150ms; }
+.stagger-children > *:nth-child(5) { animation-delay: 200ms; }
+.stagger-children > *:nth-child(6) { animation-delay: 250ms; }
+
+/* Skeleton loader */
+.skeleton {
+  background: var(--text-muted);
+  border-radius: var(--radius-sm);
+  animation: skeleton-pulse 1.5s infinite ease-in-out;
+}
+
+/* ===== Focus ring ===== */
+*:focus-visible {
+  outline: none;
+  box-shadow: var(--shadow-accent);
+}
+
+/* ===== Selection ===== */
+::selection {
+  background: rgba(124, 58, 237, 0.3);
+  color: var(--text-primary);
+}
+
+/* ===== Tooltip-style truncation ===== */
+.truncate {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* ===== Mono data ===== */
+.mono {
+  font-family: var(--font-mono);
+}
+
+/* ===== Status dot with glow ===== */
+.status-dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.status-dot--online {
+  background: var(--status-online);
+  box-shadow: 0 0 6px rgba(63, 185, 80, 0.5), 0 0 12px rgba(63, 185, 80, 0.2);
+}
+.status-dot--error {
+  background: var(--status-error);
+  box-shadow: 0 0 6px rgba(248, 81, 73, 0.5);
+}
+.status-dot--warning {
+  background: var(--status-warning);
+  box-shadow: 0 0 6px rgba(210, 153, 34, 0.5);
+}
+
+/* ===== Gradient button ===== */
+.btn-gradient {
+  padding: var(--space-2) 20px;
+  background: linear-gradient(135deg, var(--accent), #a855f7);
+  background-size: 200% 200%;
+  color: #fff;
+  font-weight: 600;
+  border: none;
+  border-radius: var(--radius-md);
+  box-shadow: 0 2px 8px rgba(124, 58, 237, 0.3);
+  transition: box-shadow var(--transition-normal), background-position 0.4s ease, transform var(--transition-fast);
+}
+.btn-gradient:hover:not(:disabled) {
+  background-position: 100% 0;
+  box-shadow: 0 4px 16px rgba(124, 58, 237, 0.4);
+}
+
+/* ===== Sidebar nav active indicator ===== */
+.nav-indicator {
+  width: 3px;
+  border-radius: 0 3px 3px 0;
+  background: linear-gradient(180deg, var(--accent), #a855f7);
+  box-shadow: 0 0 8px rgba(124, 58, 237, 0.4);
+  transition: height var(--transition-normal);
+}
+
+/* ===== Empty state ===== */
+.empty-state {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: var(--space-8);
+  gap: var(--space-3);
+}
+.empty-state-icon {
+  width: 64px;
+  height: 64px;
+  border-radius: 16px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 28px;
+  color: var(--text-muted);
+  margin-bottom: var(--space-2);
+}
@@ -0,0 +1,91 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import type { Node } from "../types";
+
+interface UseNodesOptions {
+  /** Auto-poll interval in milliseconds. Set to 0 to disable. Default: 10000 */
+  pollInterval?: number;
+  /** Whether to start scanning on mount. Default: false */
+  autoScan?: boolean;
+}
+
+interface UseNodesReturn {
+  nodes: Node[];
+  isScanning: boolean;
+  error: string | null;
+  scan: () => Promise<void>;
+  /** Total nodes discovered */
+  total: number;
+  /** Nodes currently online */
+  onlineCount: number;
+  /** Nodes currently offline */
+  offlineCount: number;
+}
+
+export function useNodes(options: UseNodesOptions = {}): UseNodesReturn {
+  const { pollInterval = 10_000, autoScan = false } = options;
+
+  const [nodes, setNodes] = useState<Node[]>([]);
+  const [isScanning, setIsScanning] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const scan = useCallback(async () => {
+    if (isScanning) return;
+    setIsScanning(true);
+    setError(null);
+
+    try {
+      const discovered = await invoke<Node[]>("discover_nodes", {
+        timeoutMs: 5000,
+      });
+      setNodes(discovered);
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : String(err);
+      setError(message);
+    } finally {
+      setIsScanning(false);
+    }
+  }, [isScanning]);
+
+  // Auto-scan on mount if requested
+  useEffect(() => {
+    if (autoScan) {
+      scan();
+    }
+  }, [autoScan]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Polling interval
+  useEffect(() => {
+    if (pollInterval <= 0) return;
+
+    intervalRef.current = setInterval(() => {
+      scan();
+    }, pollInterval);
+
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [pollInterval]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const onlineCount = nodes.filter(
+    (n) => n.health === "online"
+  ).length;
+  const offlineCount = nodes.filter(
+    (n) => n.health === "offline"
+  ).length;
+
+  return {
+    nodes,
+    isScanning,
+    error,
+    scan,
+    total: nodes.length,
+    onlineCount,
+    offlineCount,
+  };
+}
@@ -0,0 +1,107 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import type { ServerConfig, ServerStatus } from "../types";
+
+const DEFAULT_CONFIG: ServerConfig = {
+  http_port: 8080,
+  ws_port: 8765,
+  udp_port: 5005,
+  static_dir: null,
+  model_dir: null,
+  log_level: "info",
+};
+
+interface UseServerOptions {
+  /** Poll interval for status checks in ms. Default: 5000 */
+  pollInterval?: number;
+}
+
+interface UseServerReturn {
+  status: ServerStatus | null;
+  isRunning: boolean;
+  error: string | null;
+  start: (config?: Partial<ServerConfig>) => Promise<void>;
+  stop: () => Promise<void>;
+  refresh: () => Promise<void>;
+}
+
+export function useServer(options: UseServerOptions = {}): UseServerReturn {
+  const { pollInterval = 5000 } = options;
+
+  const [status, setStatus] = useState<ServerStatus | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const refresh = useCallback(async () => {
+    try {
+      const s = await invoke<ServerStatus>("server_status");
+      setStatus(s);
+      setError(null);
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : String(err);
+      setError(message);
+    }
+  }, []);
+
+  const start = useCallback(
+    async (overrides: Partial<ServerConfig> = {}) => {
+      setError(null);
+      const config: ServerConfig = { ...DEFAULT_CONFIG, ...overrides };
+      try {
+        await invoke("start_server", { config });
+        // Allow the server a moment to start, then refresh status
+        await new Promise((r) => setTimeout(r, 500));
+        await refresh();
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : String(err);
+        setError(message);
+      }
+    },
+    [refresh]
+  );
+
+  const stop = useCallback(async () => {
+    setError(null);
+    try {
+      await invoke("stop_server");
+      await new Promise((r) => setTimeout(r, 300));
+      await refresh();
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : String(err);
+      setError(message);
+    }
+  }, [refresh]);
+
+  // Initial status check
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  // Polling
+  useEffect(() => {
+    if (pollInterval <= 0) return;
+
+    intervalRef.current = setInterval(refresh, pollInterval);
+
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [pollInterval, refresh]);
+
+  const isRunning = status?.running ?? false;
+
+  return {
+    status,
+    isRunning,
+    error,
+    start,
+    stop,
+    refresh,
+  };
+}
@@ -0,0 +1,10 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+import "./design-system.css";
+import App from "./App";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);
@@ -0,0 +1,326 @@
+import React, { useEffect, useState, useRef } from "react";
+import { StatusBadge } from "../components/StatusBadge";
+import type { HealthStatus } from "../types";
+
+interface DiscoveredNode {
+  ip: string;
+  mac: string | null;
+  hostname: string | null;
+  node_id: number;
+  firmware_version: string | null;
+  health: HealthStatus;
+  last_seen: string;
+}
+
+interface ServerStatus {
+  running: boolean;
+  pid: number | null;
+  http_port: number | null;
+  ws_port: number | null;
+}
+
+const Dashboard: React.FC = () => {
+  const [nodes, setNodes] = useState<DiscoveredNode[]>([]);
+  const [serverStatus, setServerStatus] = useState<ServerStatus | null>(null);
+  const [scanning, setScanning] = useState(false);
+
+  const handleScan = async () => {
+    setScanning(true);
+    try {
+      const { invoke } = await import("@tauri-apps/api/core");
+      const found = await invoke<DiscoveredNode[]>("discover_nodes", { timeoutMs: 3000 });
+      setNodes(found);
+    } catch (err) {
+      console.error("Discovery failed:", err);
+    } finally {
+      setScanning(false);
+    }
+  };
+
+  const fetchServerStatus = async () => {
+    try {
+      const { invoke } = await import("@tauri-apps/api/core");
+      const status = await invoke<ServerStatus>("server_status");
+      setServerStatus(status);
+    } catch (err) {
+      console.error("Server status check failed:", err);
+    }
+  };
+
+  useEffect(() => {
+    handleScan();
+    fetchServerStatus();
+  }, []);
+
+  const onlineCount = nodes.filter((n) => n.health === "online").length;
+
+  return (
+    <div style={{ padding: "var(--space-5)", maxWidth: 1100 }}>
+      {/* Header */}
+      <div
+        style={{
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+          marginBottom: "var(--space-5)",
+        }}
+      >
+        <div>
+          <h2 className="heading-lg" style={{ margin: 0 }}>Dashboard</h2>
+          <p style={{ fontSize: 13, color: "var(--text-secondary)", marginTop: 2 }}>
+            System overview and quick actions
+          </p>
+        </div>
+        <button
+          onClick={handleScan}
+          disabled={scanning}
+          className="btn-gradient"
+          style={{ opacity: scanning ? 0.6 : 1 }}
+        >
+          {scanning ? "Scanning..." : "Scan Network"}
+        </button>
+      </div>
+
+      {/* Stats row */}
+      <div
+        className="stagger-children"
+        style={{
+          display: "grid",
+          gridTemplateColumns: "repeat(4, 1fr)",
+          gap: "var(--space-4)",
+          marginBottom: "var(--space-5)",
+        }}
+      >
+        <StatCard label="Total Nodes" value={nodes.length} />
+        <StatCard label="Online" value={onlineCount} color="var(--status-online)" />
+        <StatCard label="Offline" value={nodes.length - onlineCount} color={nodes.length - onlineCount > 0 ? "var(--status-error)" : "var(--text-muted)"} />
+        <StatCard
+          label="Server"
+          value={serverStatus?.running ? "Running" : "Stopped"}
+          color={serverStatus?.running ? "var(--status-online)" : "var(--status-error)"}
+          isText
+        />
+      </div>
+
+      {/* Two-column layout */}
+      <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: "var(--space-4)", marginBottom: "var(--space-5)" }}>
+        {/* Server panel */}
+        <div className="card">
+          <h3 className="heading-sm" style={{ marginBottom: "var(--space-3)" }}>Sensing Server</h3>
+          <div style={{ display: "flex", alignItems: "center", gap: 10 }}>
+            <span
+              className={`status-dot ${serverStatus?.running ? "status-dot--online" : "status-dot--error"}`}
+              style={{ width: 10, height: 10 }}
+            />
+            <span style={{ fontSize: 14, color: "var(--text-primary)", fontWeight: 500 }}>
+              {serverStatus?.running ? "Running" : "Stopped"}
+            </span>
+            {serverStatus?.running && serverStatus.pid && (
+              <span className="data" style={{ marginLeft: "auto" }}>
+                PID {serverStatus.pid}
+              </span>
+            )}
+          </div>
+          {serverStatus?.running && serverStatus.http_port && (
+            <div style={{ marginTop: "var(--space-3)", display: "flex", gap: "var(--space-4)" }}>
+              <PortTag label="HTTP" port={serverStatus.http_port} />
+              {serverStatus.ws_port && <PortTag label="WS" port={serverStatus.ws_port} />}
+            </div>
+          )}
+        </div>
+
+        {/* Quick actions panel */}
+        <div className="card">
+          <h3 className="heading-sm" style={{ marginBottom: "var(--space-3)" }}>Quick Actions</h3>
+          <div style={{ display: "flex", flexDirection: "column", gap: "var(--space-2)" }}>
+            <QuickAction label="Flash Firmware" desc="Flash via serial port" />
+            <QuickAction label="Push OTA Update" desc="Over-the-air to nodes" />
+            <QuickAction label="Upload WASM" desc="Deploy edge modules" />
+          </div>
+        </div>
+      </div>
+
+      {/* Node list */}
+      <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: "var(--space-3)" }}>
+        <h3 className="heading-sm">Discovered Nodes ({nodes.length})</h3>
+      </div>
+
+      {nodes.length === 0 ? (
+        <div className="card empty-state">
+          <div className="empty-state-icon">{"\u25C9"}</div>
+          <div style={{ fontSize: 14, fontWeight: 600, color: "var(--text-secondary)" }}>
+            No nodes discovered
+          </div>
+          <div style={{ fontSize: 13, color: "var(--text-muted)", maxWidth: 280, textAlign: "center", lineHeight: 1.5 }}>
+            Click "Scan Network" to discover ESP32 devices on your local network.
+          </div>
+        </div>
+      ) : (
+        <div
+          style={{
+            display: "grid",
+            gridTemplateColumns: "repeat(auto-fill, minmax(300px, 1fr))",
+            gap: "var(--space-4)",
+          }}
+        >
+          {nodes.map((node, i) => (
+            <NodeDashCard key={node.mac || i} node={node} />
+          ))}
+        </div>
+      )}
+    </div>
+  );
+};
+
+function useCountUp(target: number, duration = 600): number {
+  const [current, setCurrent] = useState(0);
+  const prevTarget = useRef(0);
+  useEffect(() => {
+    const start = prevTarget.current;
+    prevTarget.current = target;
+    if (target === start) return;
+    const startTime = performance.now();
+    const tick = (now: number) => {
+      const elapsed = now - startTime;
+      const progress = Math.min(elapsed / duration, 1);
+      const eased = 1 - Math.pow(1 - progress, 3); // ease-out cubic
+      setCurrent(Math.round(start + (target - start) * eased));
+      if (progress < 1) requestAnimationFrame(tick);
+    };
+    requestAnimationFrame(tick);
+  }, [target, duration]);
+  return current;
+}
+
+function StatCard({
+  label,
+  value,
+  color,
+  isText = false,
+}: {
+  label: string;
+  value: number | string;
+  color?: string;
+  isText?: boolean;
+}) {
+  const animatedValue = useCountUp(typeof value === "number" ? value : 0);
+  const displayValue = isText || typeof value === "string" ? value : animatedValue;
+
+  return (
+    <div
+      className="card-glow"
+      style={{ padding: "var(--space-4)" }}
+    >
+      <div
+        style={{
+          fontSize: 10,
+          textTransform: "uppercase",
+          letterSpacing: "0.06em",
+          color: "var(--text-muted)",
+          marginBottom: "var(--space-2)",
+          fontWeight: 600,
+        }}
+      >
+        {label}
+      </div>
+      <div
+        style={{
+          fontFamily: "var(--font-mono)",
+          fontSize: isText ? 16 : 28,
+          fontWeight: 600,
+          color: color || "var(--text-primary)",
+          letterSpacing: "-0.02em",
+          lineHeight: 1.1,
+        }}
+      >
+        {displayValue}
+      </div>
+    </div>
+  );
+}
+
+function PortTag({ label, port }: { label: string; port: number }) {
+  return (
+    <span
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 6,
+        padding: "4px 10px",
+        background: "var(--bg-base)",
+        borderRadius: "var(--radius-full)",
+        fontSize: 11,
+      }}
+    >
+      <span style={{ color: "var(--text-muted)", fontWeight: 600 }}>{label}</span>
+      <span className="mono" style={{ color: "var(--text-secondary)" }}>:{port}</span>
+    </span>
+  );
+}
+
+function QuickAction({ label, desc }: { label: string; desc: string }) {
+  return (
+    <div
+      style={{
+        display: "flex",
+        justifyContent: "space-between",
+        alignItems: "center",
+        padding: "10px 12px",
+        background: "var(--bg-base)",
+        borderRadius: "var(--radius-md)",
+        cursor: "pointer",
+        transition: "background 0.1s ease",
+      }}
+      onMouseEnter={(e) => (e.currentTarget.style.background = "var(--bg-hover)")}
+      onMouseLeave={(e) => (e.currentTarget.style.background = "var(--bg-base)")}
+    >
+      <div>
+        <div style={{ fontSize: 13, fontWeight: 500, color: "var(--text-primary)" }}>{label}</div>
+        <div style={{ fontSize: 11, color: "var(--text-muted)" }}>{desc}</div>
+      </div>
+      <span style={{ color: "var(--text-muted)", fontSize: 14 }}>{"\u203A"}</span>
+    </div>
+  );
+}
+
+function NodeDashCard({ node }: { node: DiscoveredNode }) {
+  return (
+    <div
+      className="card"
+      style={{
+        padding: "var(--space-4)",
+        cursor: "pointer",
+        opacity: node.health === "online" ? 1 : 0.6,
+      }}
+    >
+      <div style={{ display: "flex", justifyContent: "space-between", alignItems: "start", marginBottom: "var(--space-3)" }}>
+        <div>
+          <div style={{ fontWeight: 600, fontSize: 14, marginBottom: 1 }}>
+            {node.hostname || `Node ${node.node_id}`}
+          </div>
+          <div className="mono" style={{ fontSize: 12, color: "var(--text-muted)" }}>
+            {node.ip}
+          </div>
+        </div>
+        <StatusBadge status={node.health} />
+      </div>
+
+      <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: "6px 16px", fontSize: 12 }}>
+        <KV label="MAC" value={node.mac || "--"} mono />
+        <KV label="Firmware" value={node.firmware_version || "--"} mono />
+        <KV label="Node ID" value={String(node.node_id)} mono />
+      </div>
+    </div>
+  );
+}
+
+function KV({ label, value, mono = false }: { label: string; value: string; mono?: boolean }) {
+  return (
+    <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
+      <span style={{ color: "var(--text-muted)", fontSize: 11 }}>{label}</span>
+      <span className={mono ? "mono" : ""} style={{ color: "var(--text-secondary)", fontSize: 12 }}>{value}</span>
+    </div>
+  );
+}
+
+export default Dashboard;
@@ -0,0 +1,500 @@
+import { useState, useEffect, useCallback } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { open } from "@tauri-apps/plugin-dialog";
+import type { Node, WasmModule, WasmModuleState } from "../types";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const STATE_STYLES: Record<WasmModuleState, { color: string; label: string }> = {
+  running: { color: "var(--status-online)", label: "Running" },
+  stopped: { color: "var(--status-warning)", label: "Stopped" },
+  error: { color: "var(--status-error)", label: "Error" },
+  loading: { color: "var(--status-info)", label: "Loading" },
+};
+
+// ---------------------------------------------------------------------------
+// EdgeModules page
+// ---------------------------------------------------------------------------
+
+export function EdgeModules() {
+  const [nodes, setNodes] = useState<Node[]>([]);
+  const [selectedIp, setSelectedIp] = useState<string>("");
+  const [modules, setModules] = useState<WasmModule[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isUploading, setIsUploading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [success, setSuccess] = useState<string | null>(null);
+
+  // ---- Discover nodes on mount ----
+  useEffect(() => {
+    (async () => {
+      try {
+        const discovered = await invoke<Node[]>("discover_nodes", {
+          timeoutMs: 5000,
+        });
+        setNodes(discovered);
+        if (discovered.length > 0) {
+          setSelectedIp(discovered[0].ip);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+    })();
+  }, []);
+
+  // ---- Fetch modules when selected node changes ----
+  const fetchModules = useCallback(async (ip: string) => {
+    if (!ip) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const list = await invoke<WasmModule[]>("wasm_list", { nodeIp: ip });
+      setModules(list);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setModules([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (selectedIp) {
+      fetchModules(selectedIp);
+    }
+  }, [selectedIp, fetchModules]);
+
+  // ---- Upload .wasm file ----
+  const handleUpload = async () => {
+    if (!selectedIp) return;
+    const filePath = await open({
+      title: "Select WASM Module",
+      filters: [{ name: "WASM Modules", extensions: ["wasm"] }],
+      multiple: false,
+      directory: false,
+    });
+    if (!filePath) return;
+
+    setIsUploading(true);
+    setError(null);
+    setSuccess(null);
+    try {
+      const result = await invoke<{ success: boolean; module_id: string; message: string }>(
+        "wasm_upload",
+        { nodeIp: selectedIp, wasmPath: filePath },
+      );
+      if (result.success) {
+        setSuccess(`Module uploaded: ${result.module_id}`);
+        await fetchModules(selectedIp);
+      } else {
+        setError(result.message);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setIsUploading(false);
+    }
+  };
+
+  // ---- Module actions ----
+  const handleAction = async (moduleId: string, action: "start" | "stop" | "unload") => {
+    setError(null);
+    setSuccess(null);
+    try {
+      await invoke("wasm_control", {
+        nodeIp: selectedIp,
+        moduleId,
+        action,
+      });
+      setSuccess(`Module ${moduleId} ${action === "unload" ? "unloaded" : action === "start" ? "started" : "stopped"}`);
+      await fetchModules(selectedIp);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  };
+
+  return (
+    <div style={{ padding: "var(--space-5)", maxWidth: 1200 }}>
+      {/* Header */}
+      <div
+        style={{
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+          marginBottom: "var(--space-5)",
+        }}
+      >
+        <div>
+          <h1 className="heading-lg" style={{ margin: 0 }}>Edge Modules (WASM)</h1>
+          <p style={{ fontSize: 13, color: "var(--text-secondary)", marginTop: "var(--space-1)" }}>
+            Manage WASM modules deployed to ESP32 nodes
+          </p>
+        </div>
+        <button
+          onClick={handleUpload}
+          disabled={!selectedIp || isUploading}
+          style={{
+            padding: "var(--space-2) var(--space-4)",
+            borderRadius: 6,
+            background: !selectedIp || isUploading ? "var(--bg-active)" : "var(--accent)",
+            color: !selectedIp || isUploading ? "var(--text-muted)" : "#fff",
+            fontSize: 13,
+            fontWeight: 600,
+            cursor: !selectedIp || isUploading ? "not-allowed" : "pointer",
+            border: "none",
+          }}
+        >
+          {isUploading ? "Uploading..." : "Upload Module"}
+        </button>
+      </div>
+
+      {/* Node selector */}
+      <div style={{ marginBottom: "var(--space-4)" }}>
+        <label
+          style={{
+            fontSize: 10,
+            textTransform: "uppercase",
+            letterSpacing: "0.05em",
+            color: "var(--text-muted)",
+            fontFamily: "var(--font-sans)",
+            display: "block",
+            marginBottom: "var(--space-1)",
+          }}
+        >
+          Target Node
+        </label>
+        <select
+          value={selectedIp}
+          onChange={(e) => setSelectedIp(e.target.value)}
+          style={{
+            padding: "var(--space-2) var(--space-3)",
+            borderRadius: 6,
+            background: "var(--bg-elevated)",
+            color: "var(--text-primary)",
+            border: "1px solid var(--border)",
+            fontSize: 13,
+            fontFamily: "var(--font-mono)",
+            minWidth: 260,
+            cursor: "pointer",
+          }}
+        >
+          {nodes.length === 0 && <option value="">No nodes discovered</option>}
+          {nodes.map((node) => (
+            <option key={node.ip} value={node.ip}>
+              {node.ip}{node.hostname ? ` (${node.hostname})` : ""}{node.friendly_name ? ` - ${node.friendly_name}` : ""}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {/* Success banner */}
+      {success && (
+        <Banner
+          type="success"
+          message={success}
+          onDismiss={() => setSuccess(null)}
+        />
+      )}
+
+      {/* Error banner */}
+      {error && (
+        <Banner
+          type="error"
+          message={error}
+          onDismiss={() => setError(null)}
+        />
+      )}
+
+      {/* Module table */}
+      {isLoading ? (
+        <div
+          style={{
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border)",
+            borderRadius: 8,
+            padding: "var(--space-8)",
+            textAlign: "center",
+            color: "var(--text-muted)",
+            fontSize: 13,
+          }}
+        >
+          Loading modules...
+        </div>
+      ) : modules.length === 0 ? (
+        <div
+          style={{
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border)",
+            borderRadius: 8,
+            padding: "var(--space-8)",
+            textAlign: "center",
+            color: "var(--text-muted)",
+            fontSize: 13,
+          }}
+        >
+          {selectedIp
+            ? "No WASM modules loaded on this node. Use \"Upload Module\" to deploy one."
+            : "Select a node to view its WASM modules."}
+        </div>
+      ) : (
+        <div
+          style={{
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border)",
+            borderRadius: 8,
+            overflow: "hidden",
+          }}
+        >
+          <table style={{ width: "100%", borderCollapse: "collapse", fontSize: 13 }}>
+            <thead>
+              <tr style={{ borderBottom: "1px solid var(--border)", textAlign: "left" }}>
+                <Th>Name</Th>
+                <Th>Size</Th>
+                <Th>Status</Th>
+                <Th>Loaded At</Th>
+                <Th>Actions</Th>
+              </tr>
+            </thead>
+            <tbody>
+              {modules.map((mod) => (
+                <ModuleRow
+                  key={mod.module_id}
+                  module={mod}
+                  onAction={handleAction}
+                />
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Sub-components
+// ---------------------------------------------------------------------------
+
+function Th({ children }: { children: React.ReactNode }) {
+  return (
+    <th
+      style={{
+        padding: "10px var(--space-4)",
+        fontSize: 10,
+        fontWeight: 600,
+        textTransform: "uppercase",
+        letterSpacing: "0.05em",
+        color: "var(--text-muted)",
+        fontFamily: "var(--font-sans)",
+      }}
+    >
+      {children}
+    </th>
+  );
+}
+
+function Td({ children, mono = false }: { children: React.ReactNode; mono?: boolean }) {
+  return (
+    <td
+      style={{
+        padding: "10px var(--space-4)",
+        color: "var(--text-secondary)",
+        fontFamily: mono ? "var(--font-mono)" : "var(--font-sans)",
+        whiteSpace: "nowrap",
+        fontSize: 13,
+      }}
+    >
+      {children}
+    </td>
+  );
+}
+
+function ModuleStateBadge({ state }: { state: WasmModuleState }) {
+  const { color, label } = STATE_STYLES[state];
+  return (
+    <span
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 6,
+        color,
+        fontSize: 11,
+        fontWeight: 600,
+        fontFamily: "var(--font-sans)",
+        padding: "2px 8px",
+        borderRadius: 9999,
+        lineHeight: 1,
+        whiteSpace: "nowrap",
+        background: "rgba(255, 255, 255, 0.04)",
+      }}
+    >
+      <span
+        style={{
+          width: 6,
+          height: 6,
+          borderRadius: "50%",
+          backgroundColor: color,
+          flexShrink: 0,
+        }}
+      />
+      {label}
+    </span>
+  );
+}
+
+function ActionButton({
+  label,
+  onClick,
+  variant = "default",
+}: {
+  label: string;
+  onClick: () => void;
+  variant?: "default" | "danger";
+}) {
+  const isDanger = variant === "danger";
+  return (
+    <button
+      onClick={(e) => {
+        e.stopPropagation();
+        onClick();
+      }}
+      style={{
+        padding: "3px 10px",
+        borderRadius: 4,
+        fontSize: 11,
+        fontWeight: 600,
+        fontFamily: "var(--font-sans)",
+        border: `1px solid ${isDanger ? "var(--status-error)" : "var(--border)"}`,
+        background: "transparent",
+        color: isDanger ? "var(--status-error)" : "var(--text-secondary)",
+        cursor: "pointer",
+        transition: "background 0.1s",
+      }}
+      onMouseEnter={(e) => {
+        e.currentTarget.style.background = isDanger
+          ? "rgba(248, 81, 73, 0.1)"
+          : "var(--bg-hover)";
+      }}
+      onMouseLeave={(e) => {
+        e.currentTarget.style.background = "transparent";
+      }}
+    >
+      {label}
+    </button>
+  );
+}
+
+function ModuleRow({
+  module: mod,
+  onAction,
+}: {
+  module: WasmModule;
+  onAction: (moduleId: string, action: "start" | "stop" | "unload") => void;
+}) {
+  return (
+    <tr
+      style={{
+        borderBottom: "1px solid var(--border)",
+        transition: "background 0.1s",
+      }}
+      onMouseEnter={(e) => (e.currentTarget.style.background = "var(--bg-hover)")}
+      onMouseLeave={(e) => (e.currentTarget.style.background = "transparent")}
+    >
+      <Td mono>{mod.name}</Td>
+      <Td mono>{formatBytes(mod.size_bytes)}</Td>
+      <Td><ModuleStateBadge state={mod.state} /></Td>
+      <Td>{formatLoadedAt(mod.loaded_at)}</Td>
+      <td style={{ padding: "10px var(--space-4)", whiteSpace: "nowrap" }}>
+        <div style={{ display: "flex", gap: "var(--space-2)" }}>
+          {mod.state === "stopped" && (
+            <ActionButton label="Start" onClick={() => onAction(mod.module_id, "start")} />
+          )}
+          {mod.state === "running" && (
+            <ActionButton label="Stop" onClick={() => onAction(mod.module_id, "stop")} />
+          )}
+          <ActionButton
+            label="Unload"
+            onClick={() => onAction(mod.module_id, "unload")}
+            variant="danger"
+          />
+        </div>
+      </td>
+    </tr>
+  );
+}
+
+function Banner({
+  type,
+  message,
+  onDismiss,
+}: {
+  type: "error" | "success";
+  message: string;
+  onDismiss: () => void;
+}) {
+  const isError = type === "error";
+  const color = isError ? "var(--status-error)" : "var(--status-online)";
+  const bgAlpha = isError ? "rgba(248, 81, 73, 0.1)" : "rgba(63, 185, 80, 0.1)";
+  const borderAlpha = isError ? "rgba(248, 81, 73, 0.3)" : "rgba(63, 185, 80, 0.3)";
+
+  return (
+    <div
+      style={{
+        background: bgAlpha,
+        border: `1px solid ${borderAlpha}`,
+        borderRadius: 6,
+        padding: "var(--space-3) var(--space-4)",
+        marginBottom: "var(--space-4)",
+        fontSize: 13,
+        color,
+        display: "flex",
+        justifyContent: "space-between",
+        alignItems: "center",
+      }}
+    >
+      <span>{message}</span>
+      <button
+        onClick={onDismiss}
+        style={{
+          background: "none",
+          border: "none",
+          color,
+          cursor: "pointer",
+          fontSize: 16,
+          lineHeight: 1,
+          padding: "0 0 0 var(--space-3)",
+        }}
+      >
+        x
+      </button>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)} KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(2)} MB`;
+}
+
+function formatLoadedAt(iso: string | null): string {
+  if (!iso) return "--";
+  try {
+    const d = new Date(iso);
+    const diff = Date.now() - d.getTime();
+    if (diff < 60_000) return "just now";
+    if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`;
+    if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`;
+    return d.toLocaleDateString();
+  } catch {
+    return "--";
+  }
+}
@@ -0,0 +1,415 @@
+import { useState, useEffect, useCallback } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import type { SerialPort, Chip, FlashProgress, FlashPhase } from "../types";
+
+type WizardStep = 1 | 2 | 3;
+
+export function FlashFirmware() {
+  const [step, setStep] = useState<WizardStep>(1);
+  const [ports, setPorts] = useState<SerialPort[]>([]);
+  const [selectedPort, setSelectedPort] = useState("");
+  const [firmwarePath, setFirmwarePath] = useState("");
+  const [chip, setChip] = useState<Chip>("esp32s3");
+  const [baud, setBaud] = useState(460800);
+  const [isLoadingPorts, setIsLoadingPorts] = useState(false);
+  const [progress, setProgress] = useState<FlashProgress | null>(null);
+  const [isFlashing, setIsFlashing] = useState(false);
+  const [flashResult, setFlashResult] = useState<{ success: boolean; message: string } | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const loadPorts = useCallback(async () => {
+    setIsLoadingPorts(true);
+    setError(null);
+    try {
+      const result = await invoke<SerialPort[]>("list_serial_ports");
+      setPorts(result);
+      if (result.length === 1) setSelectedPort(result[0].name);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setIsLoadingPorts(false);
+    }
+  }, []);
+
+  useEffect(() => { loadPorts(); }, [loadPorts]);
+
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    listen<FlashProgress>("flash-progress", (event) => {
+      setProgress(event.payload);
+    }).then((fn) => { unlisten = fn; });
+    return () => { unlisten?.(); };
+  }, []);
+
+  const pickFirmware = async () => {
+    try {
+      const { open } = await import("@tauri-apps/plugin-dialog");
+      const selected = await open({
+        multiple: false,
+        filters: [
+          { name: "Firmware Binary", extensions: ["bin"] },
+          { name: "All Files", extensions: ["*"] },
+        ],
+      });
+      if (selected && typeof selected === "string") setFirmwarePath(selected);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  };
+
+  const startFlash = async () => {
+    if (!selectedPort || !firmwarePath) return;
+    setIsFlashing(true);
+    setFlashResult(null);
+    setProgress(null);
+    setError(null);
+    try {
+      await invoke("flash_firmware", { port: selectedPort, firmwarePath, chip, baud });
+      setFlashResult({ success: true, message: "Firmware flashed successfully." });
+    } catch (err) {
+      setFlashResult({ success: false, message: err instanceof Error ? err.message : String(err) });
+    } finally {
+      setIsFlashing(false);
+    }
+  };
+
+  const canProceed = (s: WizardStep): boolean => {
+    if (s === 1) return selectedPort !== "";
+    if (s === 2) return firmwarePath !== "";
+    return false;
+  };
+
+  return (
+    <div style={{ padding: "var(--space-5)", maxWidth: 700 }}>
+      <h1 className="heading-lg" style={{ margin: "0 0 var(--space-1)" }}>Flash Firmware</h1>
+      <p style={{ fontSize: 13, color: "var(--text-secondary)", marginBottom: "var(--space-5)" }}>
+        Flash firmware to an ESP32 via serial connection
+      </p>
+
+      <StepIndicator current={step} />
+
+      {error && (
+        <div style={bannerStyle("var(--status-error)")}>
+          {error}
+        </div>
+      )}
+
+      {/* Step 1: Select Serial Port */}
+      {step === 1 && (
+        <div style={cardStyle}>
+          <h2 style={stepTitleStyle}>Step 1: Select Serial Port</h2>
+          <p style={stepDescStyle}>Connect your ESP32 via USB and select the serial port.</p>
+
+          <div style={{ marginBottom: "var(--space-4)" }}>
+            <label style={labelStyle}>Serial Port</label>
+            <div style={{ display: "flex", gap: "var(--space-2)" }}>
+              <select
+                value={selectedPort}
+                onChange={(e) => setSelectedPort(e.target.value)}
+                style={{ flex: 1 }}
+                disabled={isLoadingPorts}
+              >
+                <option value="">
+                  {isLoadingPorts ? "Loading..." : ports.length === 0 ? "No ports detected" : "Select a port..."}
+                </option>
+                {ports.map((p) => (
+                  <option key={p.name} value={p.name}>
+                    {p.name}{p.description ? ` - ${p.description}` : ""}{p.chip ? ` (${p.chip.toUpperCase()})` : ""}
+                  </option>
+                ))}
+              </select>
+              <button onClick={loadPorts} style={secondaryBtn} disabled={isLoadingPorts}>Refresh</button>
+            </div>
+          </div>
+
+          <div style={{ display: "flex", justifyContent: "flex-end" }}>
+            <button onClick={() => setStep(2)} disabled={!canProceed(1)} style={canProceed(1) ? primaryBtn : disabledBtn}>
+              Next
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* Step 2: Select Firmware */}
+      {step === 2 && (
+        <div style={cardStyle}>
+          <h2 style={stepTitleStyle}>Step 2: Select Firmware</h2>
+          <p style={stepDescStyle}>Choose the firmware binary file and chip configuration.</p>
+
+          <div style={{ marginBottom: "var(--space-4)" }}>
+            <label style={labelStyle}>Firmware Binary (.bin)</label>
+            <div style={{ display: "flex", gap: "var(--space-2)" }}>
+              <input type="text" value={firmwarePath} readOnly placeholder="No file selected" style={{ flex: 1 }} />
+              <button onClick={pickFirmware} style={secondaryBtn}>Browse</button>
+            </div>
+          </div>
+
+          <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: "var(--space-4)", marginBottom: "var(--space-4)" }}>
+            <div>
+              <label style={labelStyle}>Chip</label>
+              <select value={chip} onChange={(e) => setChip(e.target.value as Chip)}>
+                <option value="esp32">ESP32</option>
+                <option value="esp32s3">ESP32-S3</option>
+                <option value="esp32c3">ESP32-C3</option>
+              </select>
+            </div>
+            <div>
+              <label style={labelStyle}>Baud Rate</label>
+              <select value={baud} onChange={(e) => setBaud(Number(e.target.value))}>
+                <option value={115200}>115200</option>
+                <option value={230400}>230400</option>
+                <option value={460800}>460800</option>
+                <option value={921600}>921600</option>
+              </select>
+            </div>
+          </div>
+
+          <div style={{ display: "flex", justifyContent: "space-between" }}>
+            <button onClick={() => setStep(1)} style={secondaryBtn}>Back</button>
+            <button onClick={() => setStep(3)} disabled={!canProceed(2)} style={canProceed(2) ? primaryBtn : disabledBtn}>
+              Next
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* Step 3: Flash */}
+      {step === 3 && (
+        <div style={cardStyle}>
+          <h2 style={stepTitleStyle}>Step 3: Flash</h2>
+
+          {/* Summary */}
+          <div
+            style={{
+              background: "var(--bg-base)",
+              borderRadius: 6,
+              padding: "var(--space-3) var(--space-4)",
+              marginBottom: "var(--space-4)",
+              display: "grid",
+              gridTemplateColumns: "1fr 1fr",
+              gap: "var(--space-2)",
+              fontSize: 12,
+            }}
+          >
+            <SummaryField label="Port" value={selectedPort} />
+            <SummaryField label="Firmware" value={firmwarePath.split(/[\\/]/).pop() ?? firmwarePath} />
+            <SummaryField label="Chip" value={chip.toUpperCase()} />
+            <SummaryField label="Baud" value={String(baud)} />
+          </div>
+
+          {/* Progress */}
+          {(isFlashing || progress) && !flashResult && (
+            <div style={{ marginBottom: "var(--space-4)" }}>
+              <ProgressBar progress={progress} />
+            </div>
+          )}
+
+          {/* Result */}
+          {flashResult && (
+            <div style={bannerStyle(flashResult.success ? "var(--status-online)" : "var(--status-error)")}>
+              {flashResult.message}
+            </div>
+          )}
+
+          <div style={{ display: "flex", justifyContent: "space-between" }}>
+            <button
+              onClick={() => { setStep(2); setFlashResult(null); setProgress(null); }}
+              style={secondaryBtn}
+              disabled={isFlashing}
+            >
+              Back
+            </button>
+            {flashResult ? (
+              <button
+                onClick={() => { setStep(1); setFlashResult(null); setProgress(null); setFirmwarePath(""); setSelectedPort(""); }}
+                style={primaryBtn}
+              >
+                Flash Another
+              </button>
+            ) : (
+              <button onClick={startFlash} disabled={isFlashing} style={isFlashing ? disabledBtn : primaryBtn}>
+                {isFlashing ? "Flashing..." : "Start Flash"}
+              </button>
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+// --- Sub-components ---
+
+function StepIndicator({ current }: { current: WizardStep }) {
+  const steps = [
+    { n: 1, label: "Select Port" },
+    { n: 2, label: "Select Firmware" },
+    { n: 3, label: "Flash" },
+  ];
+
+  return (
+    <div style={{ display: "flex", alignItems: "center", marginBottom: "var(--space-5)" }}>
+      {steps.map(({ n, label }, i) => {
+        const isActive = n === current;
+        const isDone = n < current;
+        return (
+          <div key={n} style={{ display: "flex", alignItems: "center" }}>
+            <div style={{ display: "flex", alignItems: "center", gap: "var(--space-2)" }}>
+              <div
+                style={{
+                  width: 28,
+                  height: 28,
+                  borderRadius: "50%",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  fontSize: 12,
+                  fontWeight: 700,
+                  fontFamily: "var(--font-mono)",
+                  background: isActive ? "var(--accent)" : isDone ? "rgba(63, 185, 80, 0.2)" : "var(--border)",
+                  color: isActive ? "#fff" : isDone ? "var(--status-online)" : "var(--text-muted)",
+                }}
+              >
+                {isDone ? "\u2713" : n}
+              </div>
+              <span
+                style={{
+                  fontSize: 12,
+                  fontWeight: isActive ? 600 : 400,
+                  color: isActive ? "var(--text-primary)" : "var(--text-muted)",
+                }}
+              >
+                {label}
+              </span>
+            </div>
+            {i < steps.length - 1 && (
+              <div style={{ width: 40, height: 1, background: "var(--border)", margin: "0 var(--space-3)" }} />
+            )}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+const PHASE_LABELS: Record<FlashPhase, string> = {
+  connecting: "Connecting...",
+  erasing: "Erasing flash...",
+  writing: "Writing firmware...",
+  verifying: "Verifying...",
+  done: "Complete",
+  error: "Error",
+};
+
+function ProgressBar({ progress }: { progress: FlashProgress | null }) {
+  const pct = progress?.progress_pct ?? 0;
+  const phase = progress?.phase ?? "connecting";
+  const speed = progress?.speed_bps ?? 0;
+  const speedKB = speed > 0 ? `${(speed / 1024).toFixed(1)} KB/s` : "";
+
+  return (
+    <div>
+      <div style={{ display: "flex", justifyContent: "space-between", fontSize: 12, marginBottom: 6 }}>
+        <span style={{ color: "var(--text-secondary)" }}>{PHASE_LABELS[phase]}</span>
+        <span style={{ color: "var(--text-muted)", fontFamily: "var(--font-mono)" }}>
+          {pct.toFixed(1)}%{speedKB && ` | ${speedKB}`}
+        </span>
+      </div>
+      <div style={{ width: "100%", height: 8, background: "var(--border)", borderRadius: 4, overflow: "hidden" }}>
+        <div
+          style={{
+            width: `${Math.min(pct, 100)}%`,
+            height: "100%",
+            background: phase === "error" ? "var(--status-error)" : phase === "done" ? "var(--status-online)" : "var(--accent)",
+            borderRadius: 4,
+            transition: "width 0.3s ease",
+            animation: phase === "writing" ? "pulse-accent 2s infinite" : "none",
+          }}
+        />
+      </div>
+    </div>
+  );
+}
+
+function SummaryField({ label, value }: { label: string; value: string }) {
+  return (
+    <div>
+      <div style={{ fontSize: 10, textTransform: "uppercase", letterSpacing: "0.05em", color: "var(--text-muted)", marginBottom: 1 }}>
+        {label}
+      </div>
+      <div style={{ color: "var(--text-secondary)", fontFamily: "var(--font-mono)", fontSize: 12, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>
+        {value}
+      </div>
+    </div>
+  );
+}
+
+// --- Shared styles ---
+
+function bannerStyle(color: string): React.CSSProperties {
+  return {
+    background: `color-mix(in srgb, ${color} 10%, transparent)`,
+    border: `1px solid color-mix(in srgb, ${color} 30%, transparent)`,
+    borderRadius: 6,
+    padding: "var(--space-3) var(--space-4)",
+    marginBottom: "var(--space-4)",
+    fontSize: 13,
+    color,
+  };
+}
+
+const cardStyle: React.CSSProperties = {
+  background: "var(--bg-surface)",
+  border: "1px solid var(--border)",
+  borderRadius: 8,
+  padding: "var(--space-5)",
+};
+
+const stepTitleStyle: React.CSSProperties = {
+  fontSize: 16,
+  fontWeight: 600,
+  color: "var(--text-primary)",
+  margin: "0 0 var(--space-1)",
+  fontFamily: "var(--font-sans)",
+};
+
+const stepDescStyle: React.CSSProperties = {
+  fontSize: 13,
+  color: "var(--text-secondary)",
+  marginBottom: "var(--space-4)",
+};
+
+const labelStyle: React.CSSProperties = {
+  display: "block",
+  fontSize: 12,
+  fontWeight: 600,
+  color: "var(--text-secondary)",
+  marginBottom: 6,
+  fontFamily: "var(--font-sans)",
+};
+
+const primaryBtn: React.CSSProperties = {
+  padding: "var(--space-2) 20px",
+  borderRadius: 6,
+  background: "var(--accent)",
+  color: "#fff",
+  fontSize: 13,
+  fontWeight: 600,
+};
+
+const secondaryBtn: React.CSSProperties = {
+  padding: "var(--space-2) var(--space-4)",
+  border: "1px solid var(--border)",
+  borderRadius: 6,
+  background: "transparent",
+  color: "var(--text-secondary)",
+  fontSize: 13,
+  fontWeight: 500,
+};
+
+const disabledBtn: React.CSSProperties = {
+  ...primaryBtn,
+  background: "var(--bg-active)",
+  color: "var(--text-muted)",
+};
@@ -0,0 +1,703 @@
+import { useState, useRef, useEffect, useCallback } from "react";
+import type { HealthStatus } from "../types";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface DiscoveredNode {
+  ip: string;
+  mac: string | null;
+  hostname: string | null;
+  node_id: number;
+  firmware_version: string | null;
+  health: HealthStatus;
+  last_seen: string;
+}
+
+interface SimNode {
+  id: number;
+  label: string;
+  ip: string;
+  mac: string | null;
+  firmware: string | null;
+  health: HealthStatus;
+  isCoordinator: boolean;
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  radius: number;
+  tdmSlot: number;
+}
+
+interface SimEdge {
+  source: number; // index into nodes
+  target: number;
+  strength: number; // 0.3 - 1.0 opacity
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const CANVAS_HEIGHT = 500;
+const REPULSION = 8000;
+const SPRING_K = 0.005;
+const SPRING_REST = 120;
+const DAMPING = 0.92;
+const VELOCITY_THRESHOLD = 0.15;
+const DT = 1;
+
+const HEALTH_COLORS: Record<HealthStatus, string> = {
+  online: "#3fb950",
+  offline: "#f85149",
+  degraded: "#d29922",
+  unknown: "#8b949e",
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function buildGraph(
+  rawNodes: DiscoveredNode[],
+  canvasWidth: number,
+): { nodes: SimNode[]; edges: SimEdge[] } {
+  const cx = canvasWidth / 2;
+  const cy = CANVAS_HEIGHT / 2;
+
+  const nodes: SimNode[] = rawNodes.map((n, i) => {
+    const isCoord = n.node_id === 0 || i === 0;
+    const angle = (2 * Math.PI * i) / Math.max(rawNodes.length, 1);
+    const spread = Math.min(canvasWidth, CANVAS_HEIGHT) * 0.3;
+    return {
+      id: n.node_id,
+      label: n.hostname || `Node ${n.node_id}`,
+      ip: n.ip,
+      mac: n.mac,
+      firmware: n.firmware_version,
+      health: n.health,
+      isCoordinator: isCoord,
+      x: cx + Math.cos(angle) * spread + (Math.random() - 0.5) * 20,
+      y: cy + Math.sin(angle) * spread + (Math.random() - 0.5) * 20,
+      vx: 0,
+      vy: 0,
+      radius: isCoord ? 30 : 20,
+      tdmSlot: i,
+    };
+  });
+
+  const edges: SimEdge[] = [];
+  const coordIdx = 0;
+
+  for (let i = 1; i < nodes.length; i++) {
+    // Connect every node to coordinator
+    edges.push({
+      source: coordIdx,
+      target: i,
+      strength: 0.3 + Math.random() * 0.7,
+    });
+    // Connect to next neighbor (ring)
+    if (i < nodes.length - 1) {
+      edges.push({
+        source: i,
+        target: i + 1,
+        strength: 0.3 + Math.random() * 0.7,
+      });
+    }
+  }
+  // Close the ring if 3+ non-coordinator nodes
+  if (nodes.length > 3) {
+    edges.push({
+      source: nodes.length - 1,
+      target: 1,
+      strength: 0.3 + Math.random() * 0.7,
+    });
+  }
+
+  return { nodes, edges };
+}
+
+function hitTest(
+  mx: number,
+  my: number,
+  nodes: SimNode[],
+): SimNode | null {
+  // Iterate in reverse so topmost (last-drawn) wins
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const n = nodes[i];
+    const dx = mx - n.x;
+    const dy = my - n.y;
+    if (dx * dx + dy * dy <= n.radius * n.radius) {
+      return n;
+    }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+
+export function MeshView() {
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [canvasWidth, setCanvasWidth] = useState(800);
+  const [nodes, setNodes] = useState<DiscoveredNode[]>([]);
+  const [scanning, setScanning] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [selectedNode, setSelectedNode] = useState<SimNode | null>(null);
+
+  // Track simulation data in a ref so the animation loop can read it without
+  // re-renders triggering a new effect.
+  const simRef = useRef<{ nodes: SimNode[]; edges: SimEdge[] }>({
+    nodes: [],
+    edges: [],
+  });
+  const animRef = useRef<number>(0);
+
+  // -----------------------------------------------------------------------
+  // Fetch nodes from Rust backend
+  // -----------------------------------------------------------------------
+  const fetchNodes = useCallback(async () => {
+    setScanning(true);
+    setError(null);
+    setSelectedNode(null);
+    try {
+      const { invoke } = await import("@tauri-apps/api/core");
+      const found = await invoke<DiscoveredNode[]>("discover_nodes", {
+        timeoutMs: 3000,
+      });
+      setNodes(found);
+    } catch (err) {
+      console.error("Discovery failed:", err);
+      setError(String(err));
+    } finally {
+      setScanning(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchNodes();
+  }, [fetchNodes]);
+
+  // -----------------------------------------------------------------------
+  // Measure container width
+  // -----------------------------------------------------------------------
+  useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+
+    const measure = () => {
+      const w = el.clientWidth;
+      if (w > 0) setCanvasWidth(w);
+    };
+    measure();
+
+    const ro = new ResizeObserver(measure);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, []);
+
+  // -----------------------------------------------------------------------
+  // Build graph + run force simulation whenever nodes or width change
+  // -----------------------------------------------------------------------
+  useEffect(() => {
+    if (nodes.length === 0) {
+      simRef.current = { nodes: [], edges: [] };
+      // Clear canvas
+      const ctx = canvasRef.current?.getContext("2d");
+      if (ctx) {
+        ctx.clearRect(0, 0, canvasWidth, CANVAS_HEIGHT);
+      }
+      return;
+    }
+
+    const { nodes: simNodes, edges } = buildGraph(nodes, canvasWidth);
+    simRef.current = { nodes: simNodes, edges };
+
+    let settled = false;
+
+    const step = () => {
+      const sn = simRef.current.nodes;
+      const se = simRef.current.edges;
+
+      // Coulomb repulsion
+      for (let i = 0; i < sn.length; i++) {
+        for (let j = i + 1; j < sn.length; j++) {
+          let dx = sn[j].x - sn[i].x;
+          let dy = sn[j].y - sn[i].y;
+          let dist = Math.sqrt(dx * dx + dy * dy);
+          if (dist < 1) dist = 1;
+          const force = REPULSION / (dist * dist);
+          const fx = (dx / dist) * force;
+          const fy = (dy / dist) * force;
+          sn[i].vx -= fx;
+          sn[i].vy -= fy;
+          sn[j].vx += fx;
+          sn[j].vy += fy;
+        }
+      }
+
+      // Spring attraction along edges
+      for (const e of se) {
+        const a = sn[e.source];
+        const b = sn[e.target];
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        let dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist < 1) dist = 1;
+        const displacement = dist - SPRING_REST;
+        const force = SPRING_K * displacement;
+        const fx = (dx / dist) * force;
+        const fy = (dy / dist) * force;
+        a.vx += fx;
+        a.vy += fy;
+        b.vx -= fx;
+        b.vy -= fy;
+      }
+
+      // Integrate + damp + clamp to canvas bounds
+      let maxV = 0;
+      for (const n of sn) {
+        n.vx *= DAMPING;
+        n.vy *= DAMPING;
+        n.x += n.vx * DT;
+        n.y += n.vy * DT;
+
+        // Keep nodes within canvas with padding
+        const pad = n.radius + 10;
+        if (n.x < pad) { n.x = pad; n.vx = 0; }
+        if (n.x > canvasWidth - pad) { n.x = canvasWidth - pad; n.vx = 0; }
+        if (n.y < pad) { n.y = pad; n.vy = 0; }
+        if (n.y > CANVAS_HEIGHT - pad) { n.y = CANVAS_HEIGHT - pad; n.vy = 0; }
+
+        const v = Math.sqrt(n.vx * n.vx + n.vy * n.vy);
+        if (v > maxV) maxV = v;
+      }
+
+      if (maxV < VELOCITY_THRESHOLD) settled = true;
+    };
+
+    const draw = () => {
+      const canvas = canvasRef.current;
+      if (!canvas) return;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+
+      const sn = simRef.current.nodes;
+      const se = simRef.current.edges;
+
+      ctx.clearRect(0, 0, canvasWidth, CANVAS_HEIGHT);
+
+      // Edges
+      for (const e of se) {
+        const a = sn[e.source];
+        const b = sn[e.target];
+        ctx.beginPath();
+        ctx.moveTo(a.x, a.y);
+        ctx.lineTo(b.x, b.y);
+        ctx.strokeStyle = `rgba(139, 148, 158, ${e.strength * 0.6})`;
+        ctx.lineWidth = 1.5;
+        ctx.stroke();
+      }
+
+      // Nodes
+      for (const n of sn) {
+        const color = HEALTH_COLORS[n.health] || HEALTH_COLORS.unknown;
+
+        // Coordinator ring
+        if (n.isCoordinator) {
+          ctx.beginPath();
+          ctx.arc(n.x, n.y, n.radius + 5, 0, Math.PI * 2);
+          ctx.strokeStyle = color;
+          ctx.lineWidth = 2;
+          ctx.stroke();
+        }
+
+        // Node circle
+        ctx.beginPath();
+        ctx.arc(n.x, n.y, n.radius, 0, Math.PI * 2);
+        ctx.fillStyle = color;
+        ctx.globalAlpha = n.health === "offline" ? 0.45 : 0.85;
+        ctx.fill();
+        ctx.globalAlpha = 1;
+
+        // Selected highlight
+        if (selectedNode && selectedNode.id === n.id) {
+          ctx.beginPath();
+          ctx.arc(n.x, n.y, n.radius + 3, 0, Math.PI * 2);
+          ctx.strokeStyle = "#ffffff";
+          ctx.lineWidth = 2;
+          ctx.stroke();
+        }
+
+        // Node ID text inside circle
+        ctx.fillStyle = "#ffffff";
+        ctx.font = "bold 11px sans-serif";
+        ctx.textAlign = "center";
+        ctx.textBaseline = "middle";
+        ctx.fillText(String(n.id), n.x, n.y);
+
+        // Label below
+        ctx.fillStyle = "#8b949e";
+        ctx.font = "11px sans-serif";
+        ctx.textBaseline = "top";
+        ctx.fillText(n.label, n.x, n.y + n.radius + 6);
+      }
+    };
+
+    const tick = () => {
+      if (!settled) step();
+      draw();
+      if (!settled) {
+        animRef.current = requestAnimationFrame(tick);
+      }
+    };
+
+    cancelAnimationFrame(animRef.current);
+    animRef.current = requestAnimationFrame(tick);
+
+    return () => cancelAnimationFrame(animRef.current);
+    // selectedNode is intentionally excluded from deps so clicking doesn't
+    // restart the simulation. We redraw via the click handler instead.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [nodes, canvasWidth]);
+
+  // Redraw when selectedNode changes (without restarting simulation)
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || simRef.current.nodes.length === 0) return;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return;
+
+    const sn = simRef.current.nodes;
+    const se = simRef.current.edges;
+
+    ctx.clearRect(0, 0, canvasWidth, CANVAS_HEIGHT);
+
+    for (const e of se) {
+      const a = sn[e.source];
+      const b = sn[e.target];
+      ctx.beginPath();
+      ctx.moveTo(a.x, a.y);
+      ctx.lineTo(b.x, b.y);
+      ctx.strokeStyle = `rgba(139, 148, 158, ${e.strength * 0.6})`;
+      ctx.lineWidth = 1.5;
+      ctx.stroke();
+    }
+
+    for (const n of sn) {
+      const color = HEALTH_COLORS[n.health] || HEALTH_COLORS.unknown;
+
+      if (n.isCoordinator) {
+        ctx.beginPath();
+        ctx.arc(n.x, n.y, n.radius + 5, 0, Math.PI * 2);
+        ctx.strokeStyle = color;
+        ctx.lineWidth = 2;
+        ctx.stroke();
+      }
+
+      ctx.beginPath();
+      ctx.arc(n.x, n.y, n.radius, 0, Math.PI * 2);
+      ctx.fillStyle = color;
+      ctx.globalAlpha = n.health === "offline" ? 0.45 : 0.85;
+      ctx.fill();
+      ctx.globalAlpha = 1;
+
+      if (selectedNode && selectedNode.id === n.id) {
+        ctx.beginPath();
+        ctx.arc(n.x, n.y, n.radius + 3, 0, Math.PI * 2);
+        ctx.strokeStyle = "#ffffff";
+        ctx.lineWidth = 2;
+        ctx.stroke();
+      }
+
+      ctx.fillStyle = "#ffffff";
+      ctx.font = "bold 11px sans-serif";
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      ctx.fillText(String(n.id), n.x, n.y);
+
+      ctx.fillStyle = "#8b949e";
+      ctx.font = "11px sans-serif";
+      ctx.textBaseline = "top";
+      ctx.fillText(n.label, n.x, n.y + n.radius + 6);
+    }
+  }, [selectedNode, canvasWidth]);
+
+  // -----------------------------------------------------------------------
+  // Canvas click handler
+  // -----------------------------------------------------------------------
+  const handleCanvasClick = useCallback(
+    (e: React.MouseEvent<HTMLCanvasElement>) => {
+      const canvas = canvasRef.current;
+      if (!canvas) return;
+      const rect = canvas.getBoundingClientRect();
+      const mx = e.clientX - rect.left;
+      const my = e.clientY - rect.top;
+      const hit = hitTest(mx, my, simRef.current.nodes);
+      setSelectedNode(hit);
+    },
+    [],
+  );
+
+  // -----------------------------------------------------------------------
+  // Derived stats
+  // -----------------------------------------------------------------------
+  const onlineCount = nodes.filter((n) => n.health === "online").length;
+
+  // -----------------------------------------------------------------------
+  // Render
+  // -----------------------------------------------------------------------
+  return (
+    <div style={{ padding: "var(--space-5)", maxWidth: 1200 }}>
+      {/* Header */}
+      <div
+        style={{
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+          marginBottom: "var(--space-5)",
+        }}
+      >
+        <div>
+          <h1 className="heading-lg" style={{ margin: 0 }}>
+            Mesh Topology
+          </h1>
+          <p
+            style={{
+              fontSize: 13,
+              color: "var(--text-secondary)",
+              marginTop: "var(--space-1)",
+            }}
+          >
+            Force-directed view of the ESP32 mesh network
+          </p>
+        </div>
+        <button
+          onClick={fetchNodes}
+          disabled={scanning}
+          style={{
+            padding: "var(--space-2) var(--space-4)",
+            borderRadius: 6,
+            background: scanning ? "var(--bg-active)" : "var(--accent)",
+            color: scanning ? "var(--text-muted)" : "#fff",
+            fontSize: 13,
+            fontWeight: 600,
+            border: "none",
+            cursor: scanning ? "default" : "pointer",
+          }}
+        >
+          {scanning ? "Scanning..." : "Refresh"}
+        </button>
+      </div>
+
+      {/* Error */}
+      {error && (
+        <div
+          style={{
+            background: "rgba(248, 81, 73, 0.1)",
+            border: "1px solid rgba(248, 81, 73, 0.3)",
+            borderRadius: 6,
+            padding: "var(--space-3) var(--space-4)",
+            marginBottom: "var(--space-4)",
+            fontSize: 13,
+            color: "var(--status-error)",
+          }}
+        >
+          {error}
+        </div>
+      )}
+
+      {/* Canvas container */}
+      <div
+        ref={containerRef}
+        style={{
+          background: "var(--bg-elevated)",
+          border: "1px solid var(--border)",
+          borderRadius: 8,
+          overflow: "hidden",
+          marginBottom: "var(--space-4)",
+        }}
+      >
+        {nodes.length === 0 ? (
+          <div
+            style={{
+              height: CANVAS_HEIGHT,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              color: "var(--text-muted)",
+              fontSize: 13,
+            }}
+          >
+            {scanning
+              ? "Scanning for nodes..."
+              : "No nodes found. Click Refresh to discover ESP32 devices."}
+          </div>
+        ) : (
+          <canvas
+            ref={canvasRef}
+            width={canvasWidth}
+            height={CANVAS_HEIGHT}
+            onClick={handleCanvasClick}
+            style={{
+              display: "block",
+              width: "100%",
+              height: CANVAS_HEIGHT,
+              cursor: "pointer",
+            }}
+          />
+        )}
+      </div>
+
+      {/* Stats bar */}
+      <div
+        style={{
+          display: "flex",
+          gap: "var(--space-5)",
+          background: "var(--bg-surface)",
+          border: "1px solid var(--border)",
+          borderRadius: 6,
+          padding: "var(--space-3) var(--space-4)",
+          marginBottom: "var(--space-4)",
+          fontFamily: "var(--font-mono)",
+          fontSize: 12,
+          color: "var(--text-secondary)",
+        }}
+      >
+        <span>
+          <span style={{ color: "var(--text-muted)" }}>Nodes </span>
+          <span style={{ color: "var(--status-online)" }}>{onlineCount}</span>
+          <span style={{ color: "var(--text-muted)" }}>/{nodes.length} online</span>
+        </span>
+        <span>
+          <span style={{ color: "var(--text-muted)" }}>Drift </span>
+          &plusmn;0.3ms
+        </span>
+        <span>
+          <span style={{ color: "var(--text-muted)" }}>Cycle </span>
+          50ms
+        </span>
+      </div>
+
+      {/* Selected node detail card */}
+      {selectedNode && (
+        <div
+          style={{
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border)",
+            borderRadius: 8,
+            padding: "var(--space-4)",
+          }}
+        >
+          <div
+            style={{
+              display: "flex",
+              justifyContent: "space-between",
+              alignItems: "center",
+              marginBottom: "var(--space-3)",
+            }}
+          >
+            <h3
+              style={{
+                margin: 0,
+                fontSize: 14,
+                fontWeight: 600,
+                color: "var(--text-primary)",
+              }}
+            >
+              {selectedNode.label}
+            </h3>
+            <span
+              style={{
+                fontSize: 11,
+                fontWeight: 600,
+                padding: "2px 8px",
+                borderRadius: 10,
+                background:
+                  HEALTH_COLORS[selectedNode.health] + "22",
+                color: HEALTH_COLORS[selectedNode.health],
+                textTransform: "uppercase",
+                letterSpacing: "0.04em",
+              }}
+            >
+              {selectedNode.health}
+            </span>
+          </div>
+          <div
+            style={{
+              display: "grid",
+              gridTemplateColumns: "repeat(auto-fill, minmax(150px, 1fr))",
+              gap: "var(--space-3) var(--space-5)",
+              fontSize: 12,
+            }}
+          >
+            <DetailField label="IP Address" value={selectedNode.ip} mono />
+            <DetailField label="MAC" value={selectedNode.mac ?? "--"} mono />
+            <DetailField
+              label="Firmware"
+              value={selectedNode.firmware ?? "--"}
+              mono
+            />
+            <DetailField
+              label="Role"
+              value={selectedNode.isCoordinator ? "Coordinator" : "Node"}
+            />
+            <DetailField
+              label="TDM Slot"
+              value={`${selectedNode.tdmSlot} / ${nodes.length}`}
+              mono
+            />
+            <DetailField
+              label="Node ID"
+              value={String(selectedNode.id)}
+              mono
+            />
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Sub-components
+// ---------------------------------------------------------------------------
+
+function DetailField({
+  label,
+  value,
+  mono = false,
+}: {
+  label: string;
+  value: string;
+  mono?: boolean;
+}) {
+  return (
+    <div>
+      <div
+        style={{
+          fontSize: 10,
+          textTransform: "uppercase",
+          letterSpacing: "0.05em",
+          color: "var(--text-muted)",
+          marginBottom: 2,
+          fontFamily: "var(--font-sans)",
+        }}
+      >
+        {label}
+      </div>
+      <div
+        style={{
+          color: "var(--text-secondary)",
+          fontFamily: mono ? "var(--font-mono)" : "var(--font-sans)",
+        }}
+      >
+        {value}
+      </div>
+    </div>
+  );
+}
@@ -0,0 +1,286 @@
+import { useState } from "react";
+import { useNodes } from "../hooks/useNodes";
+import { StatusBadge } from "../components/StatusBadge";
+import type { Node } from "../types";
+
+export function Nodes() {
+  const { nodes, isScanning, scan, error } = useNodes({
+    pollInterval: 10_000,
+    autoScan: true,
+  });
+  const [expandedMac, setExpandedMac] = useState<string | null>(null);
+
+  const toggleExpand = (node: Node) => {
+    const key = node.mac ?? node.ip;
+    setExpandedMac((prev) => (prev === key ? null : key));
+  };
+
+  return (
+    <div style={{ padding: "var(--space-5)", maxWidth: 1200 }}>
+      {/* Header */}
+      <div
+        style={{
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+          marginBottom: "var(--space-5)",
+        }}
+      >
+        <div>
+          <h1 className="heading-lg" style={{ margin: 0 }}>Nodes</h1>
+          <p style={{ fontSize: 13, color: "var(--text-secondary)", marginTop: "var(--space-1)" }}>
+            {nodes.length} node{nodes.length !== 1 ? "s" : ""} in registry
+          </p>
+        </div>
+        <button
+          onClick={scan}
+          disabled={isScanning}
+          style={{
+            padding: "var(--space-2) var(--space-4)",
+            borderRadius: 6,
+            background: isScanning ? "var(--bg-active)" : "var(--accent)",
+            color: isScanning ? "var(--text-muted)" : "#fff",
+            fontSize: 13,
+            fontWeight: 600,
+          }}
+        >
+          {isScanning ? "Scanning..." : "Refresh"}
+        </button>
+      </div>
+
+      {/* Error */}
+      {error && (
+        <div
+          style={{
+            background: "rgba(248, 81, 73, 0.1)",
+            border: "1px solid rgba(248, 81, 73, 0.3)",
+            borderRadius: 6,
+            padding: "var(--space-3) var(--space-4)",
+            marginBottom: "var(--space-4)",
+            fontSize: 13,
+            color: "var(--status-error)",
+          }}
+        >
+          {error}
+        </div>
+      )}
+
+      {/* Table */}
+      {nodes.length === 0 ? (
+        <div
+          style={{
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border)",
+            borderRadius: 8,
+            padding: "var(--space-8)",
+            textAlign: "center",
+            color: "var(--text-muted)",
+            fontSize: 13,
+          }}
+        >
+          {isScanning ? "Scanning for nodes..." : "No nodes found. Run a scan to discover ESP32 devices."}
+        </div>
+      ) : (
+        <div
+          style={{
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border)",
+            borderRadius: 8,
+            overflow: "hidden",
+          }}
+        >
+          <table style={{ width: "100%", borderCollapse: "collapse", fontSize: 13 }}>
+            <thead>
+              <tr style={{ borderBottom: "1px solid var(--border)", textAlign: "left" }}>
+                <Th>Status</Th>
+                <Th>MAC</Th>
+                <Th>IP</Th>
+                <Th>Firmware</Th>
+                <Th>Chip</Th>
+                <Th>Last Seen</Th>
+              </tr>
+            </thead>
+            <tbody>
+              {nodes.map((node) => {
+                const key = node.mac ?? node.ip;
+                return (
+                  <NodeRow
+                    key={key}
+                    node={node}
+                    isExpanded={expandedMac === key}
+                    onToggle={() => toggleExpand(node)}
+                  />
+                );
+              })}
+            </tbody>
+          </table>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function Th({ children }: { children: React.ReactNode }) {
+  return (
+    <th
+      style={{
+        padding: "10px var(--space-4)",
+        fontSize: 10,
+        fontWeight: 600,
+        textTransform: "uppercase",
+        letterSpacing: "0.05em",
+        color: "var(--text-muted)",
+        fontFamily: "var(--font-sans)",
+      }}
+    >
+      {children}
+    </th>
+  );
+}
+
+function Td({ children, mono = false }: { children: React.ReactNode; mono?: boolean }) {
+  return (
+    <td
+      style={{
+        padding: "10px var(--space-4)",
+        color: "var(--text-secondary)",
+        fontFamily: mono ? "var(--font-mono)" : "var(--font-sans)",
+        whiteSpace: "nowrap",
+        fontSize: 13,
+      }}
+    >
+      {children}
+    </td>
+  );
+}
+
+function formatLastSeen(iso: string): string {
+  try {
+    const d = new Date(iso);
+    const diff = Date.now() - d.getTime();
+    if (diff < 60_000) return "just now";
+    if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`;
+    if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`;
+    return d.toLocaleDateString();
+  } catch {
+    return "--";
+  }
+}
+
+function NodeRow({
+  node,
+  isExpanded,
+  onToggle,
+}: {
+  node: Node;
+  isExpanded: boolean;
+  onToggle: () => void;
+}) {
+  return (
+    <>
+      <tr
+        onClick={onToggle}
+        style={{
+          borderBottom: isExpanded ? "none" : "1px solid var(--border)",
+          cursor: "pointer",
+          transition: "background 0.1s",
+        }}
+        onMouseEnter={(e) => (e.currentTarget.style.background = "var(--bg-hover)")}
+        onMouseLeave={(e) => (e.currentTarget.style.background = "transparent")}
+      >
+        <Td><StatusBadge status={node.health} /></Td>
+        <Td mono>{node.mac ?? "--"}</Td>
+        <Td mono>{node.ip}</Td>
+        <Td mono>{node.firmware_version ?? "--"}</Td>
+        <Td>{node.chip?.toUpperCase() ?? "--"}</Td>
+        <Td>{formatLastSeen(node.last_seen)}</Td>
+      </tr>
+      {isExpanded && (
+        <tr style={{ borderBottom: "1px solid var(--border)" }}>
+          <td colSpan={6} style={{ padding: "0 var(--space-4) var(--space-4)" }}>
+            <ExpandedDetails node={node} />
+          </td>
+        </tr>
+      )}
+    </>
+  );
+}
+
+function ExpandedDetails({ node }: { node: Node }) {
+  return (
+    <div
+      style={{
+        background: "var(--bg-elevated)",
+        borderRadius: 6,
+        padding: "var(--space-4)",
+        display: "grid",
+        gridTemplateColumns: "repeat(auto-fill, minmax(160px, 1fr))",
+        gap: "var(--space-3) var(--space-5)",
+        fontSize: 12,
+      }}
+    >
+      <DetailField label="Hostname" value={node.hostname ?? "--"} />
+      <DetailField label="Node ID" value={String(node.node_id)} mono />
+      <DetailField label="Mesh Role" value={node.mesh_role} />
+      <DetailField
+        label="TDM Slot"
+        value={
+          node.tdm_slot != null && node.tdm_total != null
+            ? `${node.tdm_slot} / ${node.tdm_total}`
+            : "--"
+        }
+        mono
+      />
+      <DetailField
+        label="Edge Tier"
+        value={node.edge_tier != null ? String(node.edge_tier) : "--"}
+        mono
+      />
+      <DetailField
+        label="Uptime"
+        value={
+          node.uptime_secs != null
+            ? `${Math.floor(node.uptime_secs / 3600)}h ${Math.floor((node.uptime_secs % 3600) / 60)}m`
+            : "--"
+        }
+        mono
+      />
+      <DetailField label="Discovery" value={node.discovery_method} />
+      <DetailField
+        label="Capabilities"
+        value={
+          node.capabilities
+            ? Object.entries(node.capabilities)
+                .filter(([, v]) => v)
+                .map(([k]) => k)
+                .join(", ") || "none"
+            : "--"
+        }
+      />
+      {node.friendly_name && <DetailField label="Name" value={node.friendly_name} />}
+      {node.notes && <DetailField label="Notes" value={node.notes} />}
+    </div>
+  );
+}
+
+function DetailField({ label, value, mono = false }: { label: string; value: string; mono?: boolean }) {
+  return (
+    <div>
+      <div
+        style={{
+          fontSize: 10,
+          textTransform: "uppercase",
+          letterSpacing: "0.05em",
+          color: "var(--text-muted)",
+          marginBottom: 2,
+          fontFamily: "var(--font-sans)",
+        }}
+      >
+        {label}
+      </div>
+      <div style={{ color: "var(--text-secondary)", fontFamily: mono ? "var(--font-mono)" : "var(--font-sans)" }}>
+        {value}
+      </div>
+    </div>
+  );
+}
@@ -0,0 +1,594 @@
+import { useState, useCallback } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import type {
+  Node,
+  OtaStrategy,
+  BatchNodeState,
+  OtaResult,
+} from "../types";
+
+type Mode = "single" | "batch";
+
+interface DiscoveredNode {
+  ip: string;
+  mac: string | null;
+  hostname: string | null;
+  node_id: number;
+  firmware_version: string | null;
+  health: string;
+  last_seen: string;
+}
+
+const STRATEGY_LABELS: Record<OtaStrategy, string> = {
+  sequential: "Sequential",
+  tdm_safe: "TDM-Safe",
+  parallel: "Parallel",
+};
+
+const STATE_CONFIG: Record<BatchNodeState, { label: string; color: string }> = {
+  queued: { label: "Queued", color: "var(--text-muted)" },
+  uploading: { label: "Uploading", color: "var(--status-info)" },
+  rebooting: { label: "Rebooting", color: "var(--status-warning)" },
+  verifying: { label: "Verifying", color: "var(--status-info)" },
+  done: { label: "Done", color: "var(--status-online)" },
+  failed: { label: "Failed", color: "var(--status-error)" },
+  skipped: { label: "Skipped", color: "var(--text-muted)" },
+};
+
+export function OtaUpdate() {
+  const [mode, setMode] = useState<Mode>("single");
+  const [nodes, setNodes] = useState<DiscoveredNode[]>([]);
+  const [isDiscovering, setIsDiscovering] = useState(false);
+  const [firmwarePath, setFirmwarePath] = useState("");
+  const [psk, setPsk] = useState("");
+  const [error, setError] = useState<string | null>(null);
+
+  // Single mode state
+  const [selectedNodeIp, setSelectedNodeIp] = useState("");
+  const [isSingleUpdating, setIsSingleUpdating] = useState(false);
+  const [singleResult, setSingleResult] = useState<OtaResult | null>(null);
+
+  // Batch mode state
+  const [selectedBatchIps, setSelectedBatchIps] = useState<Set<string>>(new Set());
+  const [strategy, setStrategy] = useState<OtaStrategy>("sequential");
+  const [isBatchUpdating, setIsBatchUpdating] = useState(false);
+  const [batchResults, setBatchResults] = useState<OtaResult[]>([]);
+  const [batchNodeStates, setBatchNodeStates] = useState<Map<string, BatchNodeState>>(new Map());
+
+  const discoverNodes = useCallback(async () => {
+    setIsDiscovering(true);
+    setError(null);
+    try {
+      const result = await invoke<DiscoveredNode[]>("discover_nodes", { timeoutMs: 5000 });
+      setNodes(result);
+      if (result.length === 0) {
+        setError("No nodes discovered. Ensure ESP32 nodes are online and reachable.");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setIsDiscovering(false);
+    }
+  }, []);
+
+  const pickFirmware = async () => {
+    try {
+      const { open } = await import("@tauri-apps/plugin-dialog");
+      const selected = await open({
+        multiple: false,
+        filters: [
+          { name: "Firmware Binary", extensions: ["bin"] },
+          { name: "All Files", extensions: ["*"] },
+        ],
+      });
+      if (selected && typeof selected === "string") setFirmwarePath(selected);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  };
+
+  const startSingleOta = async () => {
+    if (!selectedNodeIp || !firmwarePath) return;
+    setIsSingleUpdating(true);
+    setSingleResult(null);
+    setError(null);
+    try {
+      const result = await invoke<OtaResult>("ota_update", {
+        nodeIp: selectedNodeIp,
+        firmwarePath,
+        psk: psk || null,
+      });
+      setSingleResult(result);
+    } catch (err) {
+      setSingleResult({
+        node_ip: selectedNodeIp,
+        success: false,
+        previous_version: null,
+        new_version: null,
+        duration_ms: 0,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    } finally {
+      setIsSingleUpdating(false);
+    }
+  };
+
+  const startBatchOta = async () => {
+    const ips = Array.from(selectedBatchIps);
+    if (ips.length === 0 || !firmwarePath) return;
+    setIsBatchUpdating(true);
+    setBatchResults([]);
+    setError(null);
+
+    // Initialize all nodes as queued
+    const initialStates = new Map<string, BatchNodeState>();
+    ips.forEach((ip) => initialStates.set(ip, "queued"));
+    setBatchNodeStates(new Map(initialStates));
+
+    // Mark all as uploading while the batch runs
+    ips.forEach((ip) => initialStates.set(ip, "uploading"));
+    setBatchNodeStates(new Map(initialStates));
+
+    try {
+      const results = await invoke<OtaResult[]>("batch_ota_update", {
+        nodeIps: ips,
+        firmwarePath,
+        psk: psk || null,
+      });
+      setBatchResults(results);
+
+      // Update per-node states from results
+      const finalStates = new Map<string, BatchNodeState>();
+      results.forEach((r) => {
+        finalStates.set(r.node_ip, r.success ? "done" : "failed");
+      });
+      setBatchNodeStates(finalStates);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      // Mark all as failed on total failure
+      const failStates = new Map<string, BatchNodeState>();
+      ips.forEach((ip) => failStates.set(ip, "failed"));
+      setBatchNodeStates(failStates);
+    } finally {
+      setIsBatchUpdating(false);
+    }
+  };
+
+  const toggleBatchNode = (ip: string) => {
+    setSelectedBatchIps((prev) => {
+      const next = new Set(prev);
+      if (next.has(ip)) next.delete(ip);
+      else next.add(ip);
+      return next;
+    });
+  };
+
+  const toggleAll = () => {
+    if (selectedBatchIps.size === nodes.length) {
+      setSelectedBatchIps(new Set());
+    } else {
+      setSelectedBatchIps(new Set(nodes.map((n) => n.ip)));
+    }
+  };
+
+  const nodeLabel = (n: DiscoveredNode) => {
+    const parts = [n.ip];
+    if (n.hostname) parts.push(n.hostname);
+    if (n.firmware_version) parts.push(`v${n.firmware_version}`);
+    return parts.join(" - ");
+  };
+
+  const canStartSingle = selectedNodeIp !== "" && firmwarePath !== "" && !isSingleUpdating;
+  const canStartBatch = selectedBatchIps.size > 0 && firmwarePath !== "" && !isBatchUpdating;
+
+  return (
+    <div style={{ padding: "var(--space-5)", maxWidth: 800 }}>
+      <h1 className="heading-lg" style={{ margin: "0 0 var(--space-1)" }}>OTA Update</h1>
+      <p style={{ fontSize: 13, color: "var(--text-secondary)", marginBottom: "var(--space-5)" }}>
+        Push firmware updates to ESP32 nodes over the network
+      </p>
+
+      {/* Mode Tabs */}
+      <div style={{ display: "flex", gap: 0, marginBottom: "var(--space-5)" }}>
+        <TabButton label="Single Node" active={mode === "single"} onClick={() => setMode("single")} side="left" />
+        <TabButton label="Batch OTA" active={mode === "batch"} onClick={() => setMode("batch")} side="right" />
+      </div>
+
+      {error && <div style={bannerStyle("var(--status-error)")}>{error}</div>}
+
+      {/* Node Discovery Section */}
+      <div style={{ ...cardStyle, marginBottom: "var(--space-4)" }}>
+        <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: "var(--space-3)" }}>
+          <h2 style={sectionTitleStyle}>Discovered Nodes</h2>
+          <button onClick={discoverNodes} style={secondaryBtn} disabled={isDiscovering}>
+            {isDiscovering ? "Scanning..." : nodes.length > 0 ? "Re-scan" : "Discover Nodes"}
+          </button>
+        </div>
+
+        {nodes.length === 0 && !isDiscovering && (
+          <p style={{ fontSize: 13, color: "var(--text-muted)", margin: 0 }}>
+            No nodes discovered yet. Click Discover Nodes to scan the network.
+          </p>
+        )}
+
+        {nodes.length > 0 && mode === "single" && (
+          <div>
+            <label style={labelStyle}>Target Node</label>
+            <select
+              value={selectedNodeIp}
+              onChange={(e) => setSelectedNodeIp(e.target.value)}
+              style={{ width: "100%" }}
+            >
+              <option value="">Select a node...</option>
+              {nodes.map((n) => (
+                <option key={n.ip} value={n.ip}>{nodeLabel(n)}</option>
+              ))}
+            </select>
+          </div>
+        )}
+
+        {nodes.length > 0 && mode === "batch" && (
+          <div>
+            <div style={{ display: "flex", alignItems: "center", gap: "var(--space-2)", marginBottom: "var(--space-2)" }}>
+              <label style={{ ...labelStyle, marginBottom: 0 }}>Select Nodes</label>
+              <button onClick={toggleAll} style={{ ...linkBtn, fontSize: 11 }}>
+                {selectedBatchIps.size === nodes.length ? "Deselect All" : "Select All"}
+              </button>
+            </div>
+            <div style={{ maxHeight: 200, overflowY: "auto", border: "1px solid var(--border)", borderRadius: 6 }}>
+              {nodes.map((n) => (
+                <label
+                  key={n.ip}
+                  style={{
+                    display: "flex",
+                    alignItems: "center",
+                    gap: "var(--space-3)",
+                    padding: "var(--space-2) var(--space-3)",
+                    borderBottom: "1px solid var(--border)",
+                    cursor: "pointer",
+                    background: selectedBatchIps.has(n.ip) ? "var(--bg-hover)" : "transparent",
+                    fontSize: 13,
+                  }}
+                >
+                  <input
+                    type="checkbox"
+                    checked={selectedBatchIps.has(n.ip)}
+                    onChange={() => toggleBatchNode(n.ip)}
+                    style={{ accentColor: "var(--accent)" }}
+                  />
+                  <span style={{ flex: 1, color: "var(--text-primary)", fontFamily: "var(--font-mono)", fontSize: 12 }}>
+                    {n.ip}
+                  </span>
+                  <span style={{ color: "var(--text-secondary)", fontSize: 12 }}>
+                    {n.hostname ?? "unknown"}
+                  </span>
+                  <span style={{ color: "var(--text-muted)", fontSize: 11, fontFamily: "var(--font-mono)" }}>
+                    {n.firmware_version ? `v${n.firmware_version}` : ""}
+                  </span>
+                  <StatusDot health={n.health} />
+                </label>
+              ))}
+            </div>
+            <p style={{ fontSize: 11, color: "var(--text-muted)", marginTop: "var(--space-1)", marginBottom: 0 }}>
+              {selectedBatchIps.size} of {nodes.length} nodes selected
+            </p>
+          </div>
+        )}
+      </div>
+
+      {/* Firmware & Config Section */}
+      <div style={{ ...cardStyle, marginBottom: "var(--space-4)" }}>
+        <h2 style={{ ...sectionTitleStyle, marginBottom: "var(--space-3)" }}>Firmware & Configuration</h2>
+
+        <div style={{ marginBottom: "var(--space-4)" }}>
+          <label style={labelStyle}>Firmware Binary (.bin)</label>
+          <div style={{ display: "flex", gap: "var(--space-2)" }}>
+            <input type="text" value={firmwarePath} readOnly placeholder="No file selected" style={{ flex: 1 }} />
+            <button onClick={pickFirmware} style={secondaryBtn}>Browse</button>
+          </div>
+        </div>
+
+        <div style={{ display: "grid", gridTemplateColumns: mode === "batch" ? "1fr 1fr" : "1fr", gap: "var(--space-4)", marginBottom: "var(--space-2)" }}>
+          <div>
+            <label style={labelStyle}>Pre-Shared Key (optional)</label>
+            <input
+              type="password"
+              value={psk}
+              onChange={(e) => setPsk(e.target.value)}
+              placeholder="Leave blank if none"
+              style={{ width: "100%" }}
+            />
+          </div>
+          {mode === "batch" && (
+            <div>
+              <label style={labelStyle}>Update Strategy</label>
+              <select value={strategy} onChange={(e) => setStrategy(e.target.value as OtaStrategy)} style={{ width: "100%" }}>
+                {(Object.keys(STRATEGY_LABELS) as OtaStrategy[]).map((s) => (
+                  <option key={s} value={s}>{STRATEGY_LABELS[s]}</option>
+                ))}
+              </select>
+              <p style={{ fontSize: 11, color: "var(--text-muted)", marginTop: 4, marginBottom: 0 }}>
+                {strategy === "sequential" && "Updates nodes one at a time."}
+                {strategy === "tdm_safe" && "Respects TDM slots to avoid overlapping transmissions."}
+                {strategy === "parallel" && "Updates all nodes simultaneously (fastest, highest network load)."}
+              </p>
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Action */}
+      <div style={{ display: "flex", justifyContent: "flex-end", marginBottom: "var(--space-5)" }}>
+        {mode === "single" ? (
+          <button onClick={startSingleOta} disabled={!canStartSingle} style={canStartSingle ? primaryBtn : disabledBtn}>
+            {isSingleUpdating ? "Pushing Update..." : "Push Update"}
+          </button>
+        ) : (
+          <button onClick={startBatchOta} disabled={!canStartBatch} style={canStartBatch ? primaryBtn : disabledBtn}>
+            {isBatchUpdating ? "Updating..." : `Start Batch Update (${selectedBatchIps.size} node${selectedBatchIps.size !== 1 ? "s" : ""})`}
+          </button>
+        )}
+      </div>
+
+      {/* Single Result */}
+      {mode === "single" && singleResult && (
+        <div style={cardStyle}>
+          <h2 style={{ ...sectionTitleStyle, marginBottom: "var(--space-3)" }}>Result</h2>
+          <div style={bannerStyle(singleResult.success ? "var(--status-online)" : "var(--status-error)")}>
+            <div style={{ fontWeight: 600, marginBottom: 4 }}>
+              {singleResult.success ? "Update Successful" : "Update Failed"}
+            </div>
+            <div style={{ fontSize: 12 }}>
+              Node: {singleResult.node_ip}
+              {singleResult.previous_version && ` | Previous: v${singleResult.previous_version}`}
+              {singleResult.new_version && ` | New: v${singleResult.new_version}`}
+              {singleResult.duration_ms > 0 && ` | Duration: ${(singleResult.duration_ms / 1000).toFixed(1)}s`}
+            </div>
+            {singleResult.error && (
+              <div style={{ marginTop: 4, fontSize: 12, fontFamily: "var(--font-mono)" }}>
+                {singleResult.error}
+              </div>
+            )}
+          </div>
+        </div>
+      )}
+
+      {/* Batch Progress & Results */}
+      {mode === "batch" && batchNodeStates.size > 0 && (
+        <div style={cardStyle}>
+          <h2 style={{ ...sectionTitleStyle, marginBottom: "var(--space-3)" }}>
+            {isBatchUpdating ? "Update Progress" : "Results"}
+          </h2>
+          <div style={{ border: "1px solid var(--border)", borderRadius: 6, overflow: "hidden" }}>
+            {/* Table header */}
+            <div style={tableHeaderRow}>
+              <span style={{ ...tableCell, flex: 2 }}>Node IP</span>
+              <span style={{ ...tableCell, flex: 2 }}>Status</span>
+              <span style={{ ...tableCell, flex: 2 }}>Version</span>
+              <span style={{ ...tableCell, flex: 1, textAlign: "right" }}>Duration</span>
+            </div>
+            {/* Table rows */}
+            {Array.from(batchNodeStates.entries()).map(([ip, state]) => {
+              const result = batchResults.find((r) => r.node_ip === ip);
+              const cfg = STATE_CONFIG[state];
+              return (
+                <div key={ip} style={tableRow}>
+                  <span style={{ ...tableCell, flex: 2, fontFamily: "var(--font-mono)" }}>{ip}</span>
+                  <span style={{ ...tableCell, flex: 2 }}>
+                    <NodeStateBadge state={state} />
+                  </span>
+                  <span style={{ ...tableCell, flex: 2, fontSize: 12, color: "var(--text-secondary)" }}>
+                    {result?.previous_version && result?.new_version
+                      ? `v${result.previous_version} -> v${result.new_version}`
+                      : result?.error
+                        ? <span style={{ color: "var(--status-error)", fontFamily: "var(--font-mono)", fontSize: 11 }}>{result.error}</span>
+                        : "--"}
+                  </span>
+                  <span style={{ ...tableCell, flex: 1, textAlign: "right", fontFamily: "var(--font-mono)", fontSize: 12, color: "var(--text-muted)" }}>
+                    {result && result.duration_ms > 0 ? `${(result.duration_ms / 1000).toFixed(1)}s` : "--"}
+                  </span>
+                </div>
+              );
+            })}
+          </div>
+
+          {/* Summary */}
+          {!isBatchUpdating && batchResults.length > 0 && (
+            <div style={{ marginTop: "var(--space-3)", display: "flex", gap: "var(--space-4)", fontSize: 12 }}>
+              <span style={{ color: "var(--status-online)" }}>
+                {batchResults.filter((r) => r.success).length} succeeded
+              </span>
+              <span style={{ color: "var(--status-error)" }}>
+                {batchResults.filter((r) => !r.success).length} failed
+              </span>
+              <span style={{ color: "var(--text-muted)" }}>
+                {batchResults.length} total
+              </span>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Sub-components
+// ---------------------------------------------------------------------------
+
+function TabButton({ label, active, onClick, side }: { label: string; active: boolean; onClick: () => void; side: "left" | "right" }) {
+  return (
+    <button
+      onClick={onClick}
+      style={{
+        flex: 1,
+        padding: "var(--space-2) var(--space-4)",
+        fontSize: 13,
+        fontWeight: active ? 600 : 400,
+        color: active ? "var(--text-primary)" : "var(--text-muted)",
+        background: active ? "var(--bg-surface)" : "transparent",
+        border: `1px solid ${active ? "var(--border-active)" : "var(--border)"}`,
+        borderRadius: side === "left" ? "6px 0 0 6px" : "0 6px 6px 0",
+        cursor: "pointer",
+        transition: "all 0.15s ease",
+      }}
+    >
+      {label}
+    </button>
+  );
+}
+
+function StatusDot({ health }: { health: string }) {
+  const color =
+    health === "online" ? "var(--status-online)" :
+    health === "degraded" ? "var(--status-warning)" :
+    health === "offline" ? "var(--status-error)" :
+    "var(--text-muted)";
+
+  return (
+    <span
+      style={{
+        display: "inline-block",
+        width: 8,
+        height: 8,
+        borderRadius: "50%",
+        background: color,
+        flexShrink: 0,
+      }}
+    />
+  );
+}
+
+function NodeStateBadge({ state }: { state: BatchNodeState }) {
+  const cfg = STATE_CONFIG[state];
+  const isAnimating = state === "uploading" || state === "rebooting" || state === "verifying";
+  return (
+    <span
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 6,
+        fontSize: 12,
+        fontWeight: 500,
+        color: cfg.color,
+      }}
+    >
+      <span
+        style={{
+          display: "inline-block",
+          width: 8,
+          height: 8,
+          borderRadius: "50%",
+          background: cfg.color,
+          animation: isAnimating ? "pulse-accent 1.5s infinite" : "none",
+          flexShrink: 0,
+        }}
+      />
+      {cfg.label}
+    </span>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Shared styles
+// ---------------------------------------------------------------------------
+
+function bannerStyle(color: string): React.CSSProperties {
+  return {
+    background: `color-mix(in srgb, ${color} 10%, transparent)`,
+    border: `1px solid color-mix(in srgb, ${color} 30%, transparent)`,
+    borderRadius: 6,
+    padding: "var(--space-3) var(--space-4)",
+    marginBottom: "var(--space-4)",
+    fontSize: 13,
+    color,
+  };
+}
+
+const cardStyle: React.CSSProperties = {
+  background: "var(--bg-surface)",
+  border: "1px solid var(--border)",
+  borderRadius: 8,
+  padding: "var(--space-5)",
+};
+
+const sectionTitleStyle: React.CSSProperties = {
+  fontSize: 14,
+  fontWeight: 600,
+  color: "var(--text-primary)",
+  margin: 0,
+  fontFamily: "var(--font-sans)",
+};
+
+const labelStyle: React.CSSProperties = {
+  display: "block",
+  fontSize: 12,
+  fontWeight: 600,
+  color: "var(--text-secondary)",
+  marginBottom: 6,
+  fontFamily: "var(--font-sans)",
+};
+
+const primaryBtn: React.CSSProperties = {
+  padding: "var(--space-2) 20px",
+  borderRadius: 6,
+  background: "var(--accent)",
+  color: "#fff",
+  fontSize: 13,
+  fontWeight: 600,
+  cursor: "pointer",
+};
+
+const secondaryBtn: React.CSSProperties = {
+  padding: "var(--space-2) var(--space-4)",
+  border: "1px solid var(--border)",
+  borderRadius: 6,
+  background: "transparent",
+  color: "var(--text-secondary)",
+  fontSize: 13,
+  fontWeight: 500,
+  cursor: "pointer",
+};
+
+const disabledBtn: React.CSSProperties = {
+  ...primaryBtn,
+  background: "var(--bg-active)",
+  color: "var(--text-muted)",
+  cursor: "not-allowed",
+};
+
+const linkBtn: React.CSSProperties = {
+  background: "none",
+  border: "none",
+  color: "var(--accent)",
+  cursor: "pointer",
+  padding: 0,
+  fontWeight: 500,
+};
+
+const tableHeaderRow: React.CSSProperties = {
+  display: "flex",
+  padding: "var(--space-2) var(--space-3)",
+  background: "var(--bg-base)",
+  borderBottom: "1px solid var(--border)",
+  fontSize: 11,
+  fontWeight: 600,
+  color: "var(--text-muted)",
+  textTransform: "uppercase",
+  letterSpacing: "0.05em",
+};
+
+const tableRow: React.CSSProperties = {
+  display: "flex",
+  padding: "var(--space-2) var(--space-3)",
+  borderBottom: "1px solid var(--border)",
+  alignItems: "center",
+};
+
+const tableCell: React.CSSProperties = {
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap",
+  fontSize: 13,
+  color: "var(--text-primary)",
+};
@@ -0,0 +1,536 @@
+import React, { useEffect, useState, useRef, useCallback } from "react";
+import { useServer } from "../hooks/useServer";
+import type { SensingUpdate } from "../types";
+
+// ---------------------------------------------------------------------------
+// Log entry model
+// ---------------------------------------------------------------------------
+
+type LogLevel = "INFO" | "WARN" | "ERROR";
+
+interface LogEntry {
+  id: number;
+  timestamp: string; // HH:MM:SS.mmm
+  level: LogLevel;
+  source: string;
+  message: string;
+}
+
+// ---------------------------------------------------------------------------
+// Mock data generators
+// ---------------------------------------------------------------------------
+
+const MOCK_LOG_TEMPLATES: { level: LogLevel; source: string; message: string }[] = [
+  { level: "INFO", source: "sensing-server", message: "HTTP listening on 127.0.0.1:8080" },
+  { level: "INFO", source: "udp_receiver", message: "CSI frame from 192.168.1.42" },
+  { level: "WARN", source: "vital_signs", message: "Low signal quality on node 2" },
+  { level: "INFO", source: "pose_engine", message: "Activity: walking (confidence: 0.87)" },
+  { level: "ERROR", source: "ws_session", message: "Client disconnected unexpectedly" },
+  { level: "INFO", source: "udp_receiver", message: "CSI frame from 192.168.1.15" },
+  { level: "INFO", source: "pose_engine", message: "Activity: sitting (confidence: 0.93)" },
+  { level: "INFO", source: "sensing-server", message: "WebSocket client connected from 127.0.0.1" },
+  { level: "WARN", source: "mesh_sync", message: "Node 4 heartbeat delayed by 1200ms" },
+  { level: "INFO", source: "pose_engine", message: "Activity: standing (confidence: 0.91)" },
+  { level: "INFO", source: "udp_receiver", message: "CSI frame from 192.168.1.78" },
+  { level: "ERROR", source: "udp_receiver", message: "Malformed CSI payload (len=0)" },
+  { level: "INFO", source: "csi_pipeline", message: "Subcarrier FFT complete (52 bins)" },
+  { level: "WARN", source: "vital_signs", message: "Breathing rate out of range on node 5" },
+  { level: "INFO", source: "pose_engine", message: "Activity: sleeping (confidence: 0.78)" },
+];
+
+const MOCK_ACTIVITIES = [
+  { activity: "walking", confidence: 0.87 },
+  { activity: "sitting", confidence: 0.93 },
+  { activity: "standing", confidence: 0.91 },
+  { activity: "sleeping", confidence: 0.78 },
+  { activity: "exercising", confidence: 0.65 },
+];
+
+function formatTimestamp(d: Date): string {
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${ms}`;
+}
+
+let nextLogId = 1;
+
+function createMockLogEntry(): LogEntry {
+  const template = MOCK_LOG_TEMPLATES[Math.floor(Math.random() * MOCK_LOG_TEMPLATES.length)];
+  return {
+    id: nextLogId++,
+    timestamp: formatTimestamp(new Date()),
+    level: template.level,
+    source: template.source,
+    message: template.message,
+  };
+}
+
+function createMockSensingUpdate(): SensingUpdate {
+  const act = MOCK_ACTIVITIES[Math.floor(Math.random() * MOCK_ACTIVITIES.length)];
+  return {
+    timestamp: new Date().toISOString(),
+    node_id: Math.floor(Math.random() * 6) + 1,
+    subcarrier_count: 52,
+    rssi: -(Math.floor(Math.random() * 40) + 30),
+    activity: act.activity,
+    confidence: parseFloat((act.confidence + (Math.random() * 0.1 - 0.05)).toFixed(2)),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_LOG_ENTRIES = 200;
+const LOG_INTERVAL_MS = 2000;
+
+// ---------------------------------------------------------------------------
+// LogViewer component (ADR-053)
+// ---------------------------------------------------------------------------
+
+const LEVEL_COLOR: Record<LogLevel, string> = {
+  INFO: "var(--text-secondary)",
+  WARN: "var(--status-warning)",
+  ERROR: "var(--status-error)",
+};
+
+function LogViewer({
+  entries,
+  onClear,
+  paused,
+  onTogglePause,
+}: {
+  entries: LogEntry[];
+  onClear: () => void;
+  paused: boolean;
+  onTogglePause: () => void;
+}) {
+  const bottomRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!paused && bottomRef.current) {
+      bottomRef.current.scrollIntoView({ behavior: "smooth" });
+    }
+  }, [entries, paused]);
+
+  return (
+    <div
+      style={{
+        background: "var(--bg-surface)",
+        border: "1px solid var(--border)",
+        borderRadius: 8,
+        display: "flex",
+        flexDirection: "column",
+        overflow: "hidden",
+      }}
+    >
+      {/* Header bar */}
+      <div
+        style={{
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+          padding: "var(--space-2) var(--space-4)",
+          borderBottom: "1px solid var(--border)",
+          background: "var(--bg-elevated)",
+          flexShrink: 0,
+        }}
+      >
+        <span
+          style={{
+            fontSize: 12,
+            fontWeight: 600,
+            textTransform: "uppercase",
+            letterSpacing: "0.05em",
+            color: "var(--text-muted)",
+          }}
+        >
+          Server Log
+        </span>
+        <div style={{ display: "flex", gap: "var(--space-2)" }}>
+          <button
+            onClick={onTogglePause}
+            style={{
+              padding: "var(--space-1) var(--space-3)",
+              fontSize: 12,
+              borderRadius: 4,
+              background: paused ? "var(--status-warning)" : "var(--bg-hover)",
+              color: paused ? "#000" : "var(--text-secondary)",
+              border: "1px solid var(--border)",
+              cursor: "pointer",
+              fontWeight: 500,
+            }}
+          >
+            {paused ? "Resume" : "Pause"}
+          </button>
+          <button
+            onClick={onClear}
+            style={{
+              padding: "var(--space-1) var(--space-3)",
+              fontSize: 12,
+              borderRadius: 4,
+              background: "var(--bg-hover)",
+              color: "var(--text-secondary)",
+              border: "1px solid var(--border)",
+              cursor: "pointer",
+              fontWeight: 500,
+            }}
+          >
+            Clear
+          </button>
+        </div>
+      </div>
+
+      {/* Log entries */}
+      <div
+        style={{
+          height: 320,
+          overflowY: "auto",
+          padding: "var(--space-2) var(--space-3)",
+          fontFamily: "var(--font-mono)",
+          fontSize: 12,
+          lineHeight: 1.7,
+        }}
+      >
+        {entries.length === 0 ? (
+          <div style={{ color: "var(--text-muted)", padding: "var(--space-4)", textAlign: "center" }}>
+            No log entries yet.
+          </div>
+        ) : (
+          entries.map((entry) => (
+            <div key={entry.id} style={{ whiteSpace: "nowrap" }}>
+              <span style={{ color: "var(--text-muted)" }}>{entry.timestamp}</span>{" "}
+              <span
+                style={{
+                  color: LEVEL_COLOR[entry.level],
+                  fontWeight: entry.level === "ERROR" ? 700 : 500,
+                  display: "inline-block",
+                  minWidth: 40,
+                }}
+              >
+                {entry.level}
+              </span>{" "}
+              <span style={{ color: "var(--accent)" }}>{entry.source}</span>{" "}
+              <span style={{ color: LEVEL_COLOR[entry.level] }}>{entry.message}</span>
+            </div>
+          ))
+        )}
+        <div ref={bottomRef} />
+      </div>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Sensing page
+// ---------------------------------------------------------------------------
+
+export const Sensing: React.FC = () => {
+  const { status, isRunning, error, start, stop } = useServer({ pollInterval: 5000 });
+  const [starting, setStarting] = useState(false);
+  const [stopping, setStopping] = useState(false);
+
+  // Log viewer state
+  const [logEntries, setLogEntries] = useState<LogEntry[]>([]);
+  const [paused, setPaused] = useState(false);
+  const pausedRef = useRef(paused);
+  pausedRef.current = paused;
+
+  // Activity feed state
+  const [activities, setActivities] = useState<SensingUpdate[]>([]);
+
+  // Simulated log feed
+  useEffect(() => {
+    const interval = setInterval(() => {
+      if (pausedRef.current) return;
+      const entry = createMockLogEntry();
+      setLogEntries((prev) => {
+        const next = [...prev, entry];
+        return next.length > MAX_LOG_ENTRIES ? next.slice(next.length - MAX_LOG_ENTRIES) : next;
+      });
+
+      // Also push an activity update every ~3rd tick
+      if (Math.random() < 0.35) {
+        setActivities((prev) => {
+          const update = createMockSensingUpdate();
+          const next = [update, ...prev];
+          return next.slice(0, 5);
+        });
+      }
+    }, LOG_INTERVAL_MS);
+
+    return () => clearInterval(interval);
+  }, []);
+
+  const handleClearLog = useCallback(() => setLogEntries([]), []);
+  const handleTogglePause = useCallback(() => setPaused((p) => !p), []);
+
+  const handleStart = async () => {
+    setStarting(true);
+    try {
+      await start();
+    } finally {
+      setStarting(false);
+    }
+  };
+
+  const handleStop = async () => {
+    setStopping(true);
+    try {
+      await stop();
+    } finally {
+      setStopping(false);
+    }
+  };
+
+  return (
+    <div style={{ padding: "var(--space-5)" }}>
+      {/* Page header */}
+      <h2 className="heading-lg" style={{ marginBottom: "var(--space-5)" }}>
+        Sensing
+      </h2>
+
+      {/* ----------------------------------------------------------------- */}
+      {/* Section 1: Server Control                                         */}
+      {/* ----------------------------------------------------------------- */}
+      <div
+        style={{
+          background: "var(--bg-surface)",
+          border: "1px solid var(--border)",
+          borderRadius: 8,
+          padding: "var(--space-4)",
+          marginBottom: "var(--space-5)",
+        }}
+      >
+        <div
+          style={{
+            display: "flex",
+            justifyContent: "space-between",
+            alignItems: "center",
+          }}
+        >
+          {/* Left: status info */}
+          <div style={{ display: "flex", alignItems: "center", gap: "var(--space-3)" }}>
+            {/* Status dot */}
+            <span
+              style={{
+                width: 10,
+                height: 10,
+                borderRadius: "50%",
+                background: isRunning ? "var(--status-online)" : "var(--status-error)",
+                boxShadow: isRunning ? "0 0 6px var(--status-online)" : "none",
+                flexShrink: 0,
+              }}
+            />
+
+            <div>
+              <div style={{ fontSize: 14, fontWeight: 600, color: "var(--text-primary)" }}>
+                Sensing Server
+              </div>
+              <div style={{ fontSize: 12, color: "var(--text-secondary)", marginTop: 2 }}>
+                {isRunning ? "Running" : "Stopped"}
+              </div>
+            </div>
+
+            {/* Running details */}
+            {isRunning && status && (
+              <div
+                style={{
+                  display: "flex",
+                  gap: "var(--space-4)",
+                  marginLeft: "var(--space-3)",
+                  fontFamily: "var(--font-mono)",
+                  fontSize: 12,
+                  color: "var(--text-muted)",
+                }}
+              >
+                {status.pid != null && <span>PID {status.pid}</span>}
+                {status.http_port != null && <span>HTTP :{status.http_port}</span>}
+                {status.ws_port != null && <span>WS :{status.ws_port}</span>}
+              </div>
+            )}
+          </div>
+
+          {/* Right: action button */}
+          <button
+            onClick={isRunning ? handleStop : handleStart}
+            disabled={starting || stopping}
+            style={{
+              padding: "var(--space-2) var(--space-4)",
+              borderRadius: 6,
+              fontSize: 13,
+              fontWeight: 600,
+              cursor: starting || stopping ? "not-allowed" : "pointer",
+              border: "none",
+              background: isRunning ? "var(--status-error)" : "var(--accent)",
+              color: "#fff",
+              opacity: starting || stopping ? 0.6 : 1,
+            }}
+          >
+            {starting ? "Starting..." : stopping ? "Stopping..." : isRunning ? "Stop Server" : "Start Server"}
+          </button>
+        </div>
+
+        {/* Error display */}
+        {error && (
+          <div
+            style={{
+              marginTop: "var(--space-3)",
+              padding: "var(--space-2) var(--space-3)",
+              background: "rgba(255,59,48,0.1)",
+              borderRadius: 4,
+              fontSize: 12,
+              color: "var(--status-error)",
+              fontFamily: "var(--font-mono)",
+            }}
+          >
+            {error}
+          </div>
+        )}
+      </div>
+
+      {/* ----------------------------------------------------------------- */}
+      {/* Section 2: Log Viewer (ADR-053)                                   */}
+      {/* ----------------------------------------------------------------- */}
+      <div style={{ marginBottom: "var(--space-5)" }}>
+        <LogViewer
+          entries={logEntries}
+          onClear={handleClearLog}
+          paused={paused}
+          onTogglePause={handleTogglePause}
+        />
+      </div>
+
+      {/* ----------------------------------------------------------------- */}
+      {/* Section 3: Activity Feed                                          */}
+      {/* ----------------------------------------------------------------- */}
+      <div
+        style={{
+          background: "var(--bg-surface)",
+          border: "1px solid var(--border)",
+          borderRadius: 8,
+          padding: "var(--space-4)",
+        }}
+      >
+        <h3
+          style={{
+            fontSize: 12,
+            fontWeight: 600,
+            textTransform: "uppercase",
+            letterSpacing: "0.05em",
+            color: "var(--text-muted)",
+            marginBottom: "var(--space-3)",
+          }}
+        >
+          Activity Feed
+        </h3>
+
+        {activities.length === 0 ? (
+          <div style={{ fontSize: 13, color: "var(--text-muted)", textAlign: "center", padding: "var(--space-4)" }}>
+            Waiting for sensing data...
+          </div>
+        ) : (
+          <div style={{ display: "flex", flexDirection: "column", gap: "var(--space-3)" }}>
+            {activities.map((update, i) => {
+              const ts = new Date(update.timestamp);
+              const conf = update.confidence ?? 0;
+              return (
+                <div
+                  key={`${update.timestamp}-${i}`}
+                  style={{
+                    display: "flex",
+                    alignItems: "center",
+                    gap: "var(--space-3)",
+                    padding: "var(--space-2) var(--space-3)",
+                    background: "var(--bg-base)",
+                    borderRadius: 6,
+                    border: "1px solid var(--border)",
+                  }}
+                >
+                  {/* Timestamp */}
+                  <span
+                    style={{
+                      fontFamily: "var(--font-mono)",
+                      fontSize: 11,
+                      color: "var(--text-muted)",
+                      flexShrink: 0,
+                      minWidth: 72,
+                    }}
+                  >
+                    {formatTimestamp(ts)}
+                  </span>
+
+                  {/* Node ID */}
+                  <span
+                    style={{
+                      fontSize: 11,
+                      color: "var(--text-muted)",
+                      flexShrink: 0,
+                      minWidth: 48,
+                    }}
+                  >
+                    Node {update.node_id}
+                  </span>
+
+                  {/* Activity */}
+                  <span
+                    style={{
+                      fontSize: 13,
+                      fontWeight: 600,
+                      color: "var(--text-primary)",
+                      flexShrink: 0,
+                      minWidth: 80,
+                      textTransform: "capitalize",
+                    }}
+                  >
+                    {update.activity ?? "unknown"}
+                  </span>
+
+                  {/* Confidence bar */}
+                  <div
+                    style={{
+                      flex: 1,
+                      height: 6,
+                      background: "var(--bg-hover)",
+                      borderRadius: 3,
+                      overflow: "hidden",
+                      minWidth: 60,
+                    }}
+                  >
+                    <div
+                      style={{
+                        width: `${Math.round(conf * 100)}%`,
+                        height: "100%",
+                        background: conf >= 0.8 ? "var(--status-online)" : conf >= 0.6 ? "var(--status-warning)" : "var(--status-error)",
+                        borderRadius: 3,
+                        transition: "width 0.3s ease",
+                      }}
+                    />
+                  </div>
+
+                  {/* Confidence value */}
+                  <span
+                    style={{
+                      fontFamily: "var(--font-mono)",
+                      fontSize: 11,
+                      color: "var(--text-secondary)",
+                      flexShrink: 0,
+                      minWidth: 36,
+                      textAlign: "right",
+                    }}
+                  >
+                    {Math.round(conf * 100)}%
+                  </span>
+                </div>
+              );
+            })}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default Sensing;
@@ -0,0 +1,276 @@
+import { useState, useEffect, useCallback } from "react";
+import type { AppSettings } from "../types";
+
+const DEFAULT_SETTINGS: AppSettings = {
+  server_http_port: 8080,
+  server_ws_port: 8765,
+  server_udp_port: 5005,
+  bind_address: "127.0.0.1",
+  ui_path: "",
+  ota_psk: "",
+  auto_discover: true,
+  discover_interval_ms: 10_000,
+  theme: "dark",
+};
+
+export function Settings() {
+  const [settings, setSettings] = useState<AppSettings>(DEFAULT_SETTINGS);
+  const [saved, setSaved] = useState(false);
+  const [showPsk, setShowPsk] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    (async () => {
+      try {
+        const { invoke } = await import("@tauri-apps/api/core");
+        const persisted = await invoke<AppSettings | null>("get_settings");
+        if (persisted) setSettings(persisted);
+      } catch {
+        // Settings command may not exist yet
+      }
+    })();
+  }, []);
+
+  const update = useCallback(
+    <K extends keyof AppSettings>(key: K, value: AppSettings[K]) => {
+      setSettings((prev) => ({ ...prev, [key]: value }));
+      setSaved(false);
+    },
+    []
+  );
+
+  const save = async () => {
+    setError(null);
+    try {
+      const { invoke } = await import("@tauri-apps/api/core");
+      await invoke("save_settings", { settings });
+      setSaved(true);
+      setTimeout(() => setSaved(false), 2500);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  };
+
+  const reset = () => {
+    setSettings(DEFAULT_SETTINGS);
+    setSaved(false);
+  };
+
+  return (
+    <div style={{ padding: "var(--space-5)", maxWidth: 600 }}>
+      <h1 className="heading-lg" style={{ margin: "0 0 var(--space-1)" }}>Settings</h1>
+      <p style={{ fontSize: 13, color: "var(--text-secondary)", marginBottom: "var(--space-5)" }}>
+        Configure server, network, and application preferences
+      </p>
+
+      {error && (
+        <div
+          style={{
+            background: "rgba(248, 81, 73, 0.1)",
+            border: "1px solid rgba(248, 81, 73, 0.3)",
+            borderRadius: 6,
+            padding: "var(--space-3) var(--space-4)",
+            marginBottom: "var(--space-4)",
+            fontSize: 13,
+            color: "var(--status-error)",
+          }}
+        >
+          {error}
+        </div>
+      )}
+
+      {saved && (
+        <div
+          style={{
+            background: "rgba(63, 185, 80, 0.1)",
+            border: "1px solid rgba(63, 185, 80, 0.3)",
+            borderRadius: 6,
+            padding: "var(--space-3) var(--space-4)",
+            marginBottom: "var(--space-4)",
+            fontSize: 13,
+            color: "var(--status-online)",
+          }}
+        >
+          Settings saved.
+        </div>
+      )}
+
+      {/* Sensing Server */}
+      <Section title="Sensing Server">
+        <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: "var(--space-4)" }}>
+          <Field label="HTTP Port">
+            <NumberInput value={settings.server_http_port} onChange={(v) => update("server_http_port", v)} min={1} max={65535} />
+          </Field>
+          <Field label="WebSocket Port">
+            <NumberInput value={settings.server_ws_port} onChange={(v) => update("server_ws_port", v)} min={1} max={65535} />
+          </Field>
+          <Field label="UDP Port">
+            <NumberInput value={settings.server_udp_port} onChange={(v) => update("server_udp_port", v)} min={1} max={65535} />
+          </Field>
+          <Field label="Bind Address">
+            <input
+              type="text"
+              value={settings.bind_address}
+              onChange={(e) => update("bind_address", e.target.value)}
+              placeholder="127.0.0.1"
+              style={{ fontFamily: "var(--font-mono)" }}
+            />
+          </Field>
+        </div>
+        <div style={{ marginTop: "var(--space-4)" }}>
+          <Field label="UI Static Files Path">
+            <input
+              type="text"
+              value={settings.ui_path}
+              onChange={(e) => update("ui_path", e.target.value)}
+              placeholder="Leave empty for default"
+            />
+          </Field>
+        </div>
+      </Section>
+
+      {/* Security */}
+      <Section title="Security">
+        <Field label="OTA Pre-Shared Key (PSK)">
+          <div style={{ display: "flex", gap: "var(--space-2)" }}>
+            <input
+              type={showPsk ? "text" : "password"}
+              value={settings.ota_psk}
+              onChange={(e) => update("ota_psk", e.target.value)}
+              placeholder="Enter PSK for OTA authentication"
+              style={{ flex: 1, fontFamily: "var(--font-mono)" }}
+            />
+            <button onClick={() => setShowPsk((prev) => !prev)} style={secondaryBtn}>
+              {showPsk ? "Hide" : "Show"}
+            </button>
+          </div>
+          <p style={{ fontSize: 11, color: "var(--text-muted)", marginTop: "var(--space-1)" }}>
+            Used for authenticating OTA firmware updates to nodes.
+          </p>
+        </Field>
+      </Section>
+
+      {/* Discovery */}
+      <Section title="Network Discovery">
+        <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: "var(--space-4)" }}>
+          <Field label="Auto-Discover">
+            <label style={{ display: "flex", alignItems: "center", gap: "var(--space-2)", cursor: "pointer" }}>
+              <input
+                type="checkbox"
+                checked={settings.auto_discover}
+                onChange={(e) => update("auto_discover", e.target.checked)}
+                style={{ accentColor: "var(--accent)" }}
+              />
+              <span style={{ fontSize: 13, color: "var(--text-secondary)" }}>Enable periodic scanning</span>
+            </label>
+          </Field>
+          <Field label="Scan Interval (ms)">
+            <NumberInput
+              value={settings.discover_interval_ms}
+              onChange={(v) => update("discover_interval_ms", v)}
+              min={1000}
+              max={120_000}
+              step={1000}
+              disabled={!settings.auto_discover}
+            />
+          </Field>
+        </div>
+      </Section>
+
+      {/* Actions */}
+      <div style={{ display: "flex", justifyContent: "space-between", marginTop: "var(--space-5)" }}>
+        <button onClick={reset} style={secondaryBtn}>Reset to Defaults</button>
+        <button onClick={save} style={primaryBtn}>Save Settings</button>
+      </div>
+    </div>
+  );
+}
+
+// --- Sub-components ---
+
+function Section({ title, children }: { title: string; children: React.ReactNode }) {
+  return (
+    <div
+      style={{
+        background: "var(--bg-surface)",
+        border: "1px solid var(--border)",
+        borderRadius: 8,
+        padding: "var(--space-5)",
+        marginBottom: "var(--space-4)",
+      }}
+    >
+      <h2
+        style={{
+          fontSize: 14,
+          fontWeight: 600,
+          color: "var(--text-primary)",
+          margin: "0 0 var(--space-4)",
+          fontFamily: "var(--font-sans)",
+        }}
+      >
+        {title}
+      </h2>
+      {children}
+    </div>
+  );
+}
+
+function Field({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div>
+      <label
+        style={{
+          display: "block",
+          fontSize: 12,
+          fontWeight: 600,
+          color: "var(--text-secondary)",
+          marginBottom: 6,
+          fontFamily: "var(--font-sans)",
+        }}
+      >
+        {label}
+      </label>
+      {children}
+    </div>
+  );
+}
+
+function NumberInput({
+  value, onChange, min, max, step = 1, disabled = false,
+}: {
+  value: number; onChange: (v: number) => void; min?: number; max?: number; step?: number; disabled?: boolean;
+}) {
+  return (
+    <input
+      type="number"
+      value={value}
+      onChange={(e) => { const n = parseInt(e.target.value, 10); if (!isNaN(n)) onChange(n); }}
+      min={min}
+      max={max}
+      step={step}
+      disabled={disabled}
+    />
+  );
+}
+
+// --- Shared styles ---
+
+const primaryBtn: React.CSSProperties = {
+  padding: "var(--space-2) 20px",
+  border: "none",
+  borderRadius: 6,
+  background: "var(--accent)",
+  color: "#fff",
+  fontSize: 13,
+  fontWeight: 600,
+};
+
+const secondaryBtn: React.CSSProperties = {
+  padding: "var(--space-2) var(--space-4)",
+  border: "1px solid var(--border)",
+  borderRadius: 6,
+  background: "transparent",
+  color: "var(--text-secondary)",
+  fontSize: 13,
+  fontWeight: 500,
+};
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`{"default":{"identifier":"default","description":"RuView default capability set","local":true,"windows":["main"],"permissions":["core:default","shell:allow-execute","shell:allow-open","dialog:allow-open","dialog:allow-save"]}}`