⚠️ ADR-028: Independent Capability Audit — 1,031 Tests, SHA-256 Proof, Witness Bundle #72
Description
What is this project, in plain English?
WiFi signals bounce off your body. When you move, the bounces change. This project reads those changes and figures out where you are, how you're standing, and whether you're breathing — using only a $8 WiFi chip and math.
No cameras. No wearables. No Bluetooth beacons. Just WiFi signals you're already swimming in.
It sounds like magic. It's not. It's physics that's been published in peer-reviewed papers for over a decade. We just built the open-source version — in Rust, with real firmware, real tests, and real proofs.
"Prove it."
Fair. We did.
We ran a full independent audit of every file, every claim, and every test in this repository. Three AI research agents examined the entire codebase simultaneously — one for hardware, one for signal processing and AI, one for deployment and security. They found:
The numbers
| What | Result |
|---|---|
| Rust tests | 1,031 passed, 0 failed |
| Python proof | VERDICT: PASS (deterministic SHA-256 hash match) |
| Witness bundle | 7/7 self-verification checks PASS |
| Published crates | 15 on crates.io @ v0.2.0 |
| Docker images | 2 on Docker Hub (132 MB Rust, 569 MB Python) |
| ESP32 firmware | 606 lines of C, pre-built binaries included |
| Signal algorithms | 10 peer-reviewed methods, 5,937 lines, 105+ tests |
| Training pipeline | 10-phase, 9,051 lines, 174+ tests |
| Architecture decisions | 28 ADRs documenting every design choice |
What got audited (31 of 33 capabilities confirmed)
The witness log has a 33-row table. Each row is one capability claim, with a verdict and evidence. Here's the summary:
- 31 capabilities: Verified YES with passing tests or inspected code
- 2 capabilities: NOT MEASURED at audit time (benchmark throughput needs target hardware, Kubernetes deploy needs a cluster)
- 0 capabilities: Failed
Not "we think it works." Not "it should work." It compiles, it runs, the tests pass, the hashes match, and the bundle self-verifies.
How to verify it yourself
You don't need ESP32 hardware for steps 1-3. A laptop with Rust installed is enough.
Step 1: Run all 1,031 tests (~2 min)
git clone https://github.com/ruvnet/wifi-densepose.git
cd wifi-densepose/rust-port/wifi-densepose-rs
cargo test --workspace --no-default-featuresStep 2: Run the pipeline proof (~1 sec)
cd ../../
python v1/data/proof/verify.py
# → VERDICT: PASSThis feeds a known reference signal through the actual production code (not a mock, not a test double — the same CSIProcessor that handles real WiFi frames), then hashes the output. If the hash matches, the pipeline is real and deterministic.
Step 3: Generate + verify the witness bundle
bash scripts/generate-witness-bundle.sh
cd dist/witness-bundle-ADR028-*/
bash VERIFY.sh
# → 7 passed, 0 failed — ALL CHECKS PASSEDStep 4: Flash an ESP32 and see it work (optional, requires ~$10 hardware)
pip install esptool
python -m esptool --chip esp32s3 --port COM7 --baud 460800 \
write_flash 0x0 firmware/esp32-csi-node/build/bootloader/bootloader.bin \
0x8000 firmware/esp32-csi-node/build/partition_table/partition-table.bin \
0x10000 firmware/esp32-csi-node/build/esp32-csi-node.binWalk near the antenna. Watch the CSI amplitude change in real-time. That's your body affecting WiFi signals.
What's actually inside
The hardware layer — An ESP32-S3 chip ($8) runs custom firmware that captures raw WiFi Channel State Information (CSI) — amplitude and phase across 64 subcarriers — and streams it over UDP at 20-100 frames/sec. The binary protocol (ADR-018) is fully specified: magic number, node ID, antenna count, I/Q pairs. A Rust aggregator receives and validates the frames.
The signal processing layer — 10 algorithms based on published research (SpotFi, Hampel, Fresnel, BVP, etc.) clean and transform the raw CSI into meaningful features: Doppler shifts for motion, Fresnel zones for breathing, spectrograms for activity classification. 5,937 lines of Rust, 105+ tests.
The AI layer — A neural network (DensePose head + modality translator) maps CSI features to 17 body keypoints and 24 body surface regions. The training pipeline has 10 phases. Domain generalization (MERIDIAN/ADR-027) ensures models work across rooms without retraining. Self-supervised learning (AETHER/ADR-024) bootstraps from raw WiFi data alone.
The deployment layer — Docker images, WASM browser build, 15 published Rust crates, 4 CI/CD workflows, 15+ security scanners, and a deterministic proof system with SHA-256 verification.
Links
| Document | What's in it |
|---|---|
| ADR-028 (full audit) | Complete findings: ESP32 specs, binary frame format, signal algorithms, NN architecture, training phases, deployment infra, security posture |
| Witness Log | 11 reproducible verification steps + 33-row attestation matrix |
| Bundle generator | Creates offline-verifiable proof package |
| PR #71 | The merged PR with all audit artifacts |
| ESP32 tutorial | Step-by-step hardware setup guide |
| "Is it fake?" FAQ | The original skeptics thread (with 20+ comments) |
| crates.io | All 15 published Rust crates |
| Docker Hub | Pre-built container images |
The code is open. The tests pass. The proofs hash. The firmware flashes. The physics is peer-reviewed. The bundle self-verifies.
We built the receipts. Your move.
— rUv