Merge pull request #1026 from ruvnet/feat/v2-beyond-sota-sweep-m8

Beyond-SOTA sweep M8 (ADR-162): enforce plugin Ed25519 signatures + capability isolation + bounded RunModes

.github/workflows/ci.yml

@@ -121,12 +121,23 @@ jobs:
       with:
         workspaces: v2
 
+    # The 38-crate workspace debug build exhausts the runner's disk when built
+    # with full debuginfo (observed: "final link failed: No space left on
+    # device" once the engine/benchmark crates landed; the same tree's local
+    # debug target measured 151 GB). Debuginfo is useless in CI — tests either
+    # pass or print their failure — so build without it; target shrinks ~5-10x.
     - name: Run Rust tests
       working-directory: v2
+      env:
+        CARGO_PROFILE_DEV_DEBUG: "0"
+        CARGO_PROFILE_TEST_DEBUG: "0"
       run: cargo test --workspace --no-default-features
 
     - name: Run ADR-147 worldmodel tests
       working-directory: v2
+      env:
+        CARGO_PROFILE_DEV_DEBUG: "0"
+        CARGO_PROFILE_TEST_DEBUG: "0"
       run: cargo test -p wifi-densepose-worldmodel --no-default-features
 
     # ADR-134 CIR tests are behind the `cir` feature so the bench dependency

.gitmodules

@@ -14,3 +14,7 @@
 	path = vendor/rvcsi
 	url = https://github.com/ruvnet/rvcsi
 	branch = main
+[submodule "v2/crates/ruv-neural"]
+	path = v2/crates/ruv-neural
+	url = https://github.com/ruvnet/ruv-neural.git
+	branch = main

CHANGELOG.md

@@ -11,28 +11,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Mesh partition risk now demotes the privacy class and is witnessed (ADR-032).** The dynamic min-cut guard's `at_risk` signal was advisory-only (it fed the recalibration advisor). It now also contributes to the ADR-141 privacy demotion alongside fusion- and array-level contradictions: a mesh close to partitioning makes the fused belief less trustworthy, so the cycle emits at a more restricted class (monotonic — information only removed). Because `effective_class` feeds the BLAKE3 witness, a fragmenting array now shifts the witness — partition risk is auditable, not just logged. The mesh computation moved ahead of the demotion step in `process_cycle`; new `mesh_guard_mut()` exposes risk-threshold tuning. Test proves a forced-risk 3-node cycle demotes PrivateHome Anonymous→Restricted and shifts the witness vs a clean *same-topology* baseline (the only delta between the two cycles is the forced risk).
 
 ### Added
+- **Beyond-SOTA `v2/crates/` sweep (ADR-154–158) + full stub-implementation push — every claim MEASURED or graded.** A 5-milestone review/optimize/secure/benchmark/validate sweep, then a verified-audit-driven push to replace every production stub with real, tested logic (no labels, no placeholders). Each fix is pinned by a test that fails on the old code; every number ships with a reproduce command. Workspace: **3,122 tests / 0 failed** (`cargo test --workspace --no-default-features`), Python proof **VERDICT: PASS** (bit-exact).
+  - **ADR-154 Signal/DSP** — revived a dead ADR-134 CIR coherence gate (canonical-56 vs ht20 mismatch meant it never ran in production: 8/8 Err → 8/8 Ok); NaN-bypass + window div0 guards; PSD FFT-planner cache (**2.0–3.1×**) + honored DTW band (**2.4–4.1×**).
+  - **ADR-155 NN/Training** — unified 7 divergent PCK/OKS metric definitions into one canonical torso-normalized source (fixed two claim-inflating bugs: zero-visible PCK 1.0→0.0, OKS fake-Gold); leak-free subject-disjoint MM-Fi split + injected-leak detector; rapid_adapt replaced fake gradients with real finite-difference; proof.rs gained a min-decrease margin + committed-hash requirement; zero-copy ORT input (**1.48×**).
+  - **ADR-156 RuVector/Fusion** — closed crafted-input DoS panics (triangulation/heartbeat); honest dimensionless GDOP = √(trace(G⁻¹)) replacing an RMSE mislabel; canonical wrapped angular distance; fuse() double-clone removed (**~2.17×** marshalling). SOTA graded: SymphonyQG (CLAIMED), multi-bit RaBitQ (near-term), GraphPose-Fi (data-gated).
+  - **ADR-157 Hardware/Sensing** — `Vec::remove(0)` O(n²) sliding windows → `VecDeque`; breathing partial-weight renormalization; IIR low-sample-rate divergence clamp. Centerpiece: a MEASURED **negative-results** audit showing the layer (802.11bf model, parsers, calibration) was already hardened — cited file:line, NO-ACTION.
+  - **ADR-158 MAT/world-model** — **unified two divergent triage engines** (the confidence-gated result was computed then discarded; gate==record now); **killed survivor count-inflation** (real RSSI localization + vitals-signature dedup, MEASURED 3→1); real ESP32/UDP/PCAP CSI ingest with honest typed `HardwareUnavailable`/`UnsupportedAdapter` errors for hardware-gated adapters (Intel5300/Atheros/PicoScenes — never fabricated CSI); real parabolic peak interpolation; real GDOP.
+  - **Soul Signature §3.6 matcher made real (`wifi-densepose-bfld`, issue #1021).** An external audit correctly found person-identification was spec-only behind a no-op `NullOracle`. Now a real per-channel weighted-cosine matcher + `EnrolledMatcher: SoulMatchOracle` (364 tests). MEASURED: same-person 1.0000 vs cross-person 0.8088; and the audit's own claim proven — on WiFi-only cardiac+respiratory channels alone two people are **not separable** (gap 0.0005). Named identity is honestly **data-gated** on the AETHER/body-resonance channel being fed by a real enrollment; no working-named-identity claim is made.
+  - **OccWorld real forward pass** — replaced `Tensor::randn` encoder/decoder stubs (which emitted trajectory priors from pure noise) with a real deterministic conv VQ-VAE forward pass (input-dependent, proven by tests that fail on the old randn) + a `weights_trained` honesty flag (false until a real checkpoint loads); pointcloud `to_gaussian_splats` 9→2 passes (**1.24×** MEASURED).
+  - **Native multi-BSSID `wlanapi.dll` FFI** (`wifi-densepose-wifiscan`) — real `WlanOpenHandle`/`WlanEnumInterfaces`/`WlanGetNetworkBssList`, **MEASURED 9.74 Hz** on Windows (vs netsh ~2 Hz; no fabricated "10×"), typed `Unsupported` off-Windows. Real Matter 1.3 manual-pairing-code field-packing (canonical 34970112332, lossless decode) replacing a lossy-modulo placeholder.
+  - **HOMECORE assistant** — real `LocalRunner` response path, real semantic intent recognizer (exact in-memory cosine k-NN; MEASURED 0.855 match / 0.106 no-match), real SQL state text-search — three always-empty stubs removed.
+- **ADR-152 WiFi-Pose SOTA 2026 intake — verified external benchmark + four Rust integrations.** A 22-source adversarially-verified survey of the 2025–2026 WiFi-sensing SOTA, with every adopted number reproduced or graded before integration:
+  - **WiFlow-STD (DY2434) reproduction (`benchmarks/wiflow-std/`)** — the external "97.25% PCK@20, 2.23M params" claim audited end-to-end: the **shipped checkpoint is REFUTED** (0.08% PCK@20 — wrong keypoint normalization, predates the published code), the released code does not run as published (6 documented defects, incl. an import that fails and an unreachable test phase), and the released dataset's final 13 files are corrupted (9,072 windows of NaN + float32-max garbage that NaN-poisons fp16 BatchNorm training). After repairing both, retraining with upstream defaults on an RTX 5080 reproduced **96.09% PCK@20 (full test) / 96.61% (corruption-free)** — claims graded MEASURED-EQUIVALENT; params (2,225,042) and FLOPs (~0.055 G) verified exactly. Full forensics in `benchmarks/wiflow-std/RESULTS.md`.
+  - **`GeometryEmbedding` (ADR-152 §2.1.2, `wifi-densepose-calibration`)** — 32-slot permutation-invariant, NaN-proof featurization of the §2.1.1 `NodeGeometry` records (centroid/spread, measured-first pairwise distances, circular azimuth stats, covariance-eigenvalue geometric diversity, per-node flags), schema-versioned for the ADR-151 P6 LoRA heads; derived `SpecialistBank::geometry_embedding()` accessor. The PerceptAlign "coordinate overfitting" defense, transplanted to per-room banks.
+  - **MAE pretraining recipe (ADR-152 §2.3, `wifi-densepose-train/src/mae.rs`)** — `MaePretrainConfig` pinning the UNSW-measured recipe (80% masking, (30,3) patches) with pure-Rust patchify/random-mask (exact counts, seed-deterministic, error-not-truncate divisibility, NaN rejection), property-tested; the consumption seam for the future ADR-150 ViT-Small encoder.
+  - **`WiFlowStdModel` Rust port (`wifi-densepose-train/src/wiflow_std/`)** — tch-gated idiomatic port of the verified spatio-temporal-decoupled architecture (grouped causal TCN → asymmetric conv stack → dual axial attention); ungated param formula asserted equal to the reference 2,225,042; 15/17-keypoint variants share weights (enables the ADR-152 §2.2(b) ESP32 fine-tune).
+  - **RuVector vendor sync + §2.6 opportunity survey** — vendor at `a083bd77f`; graded ADOPT/EVALUATE/WATCH table; crates.io bumps applied (mincut/solver 2.0.6, attention 2.1.0, gnn 2.2.0; RUSTSEC #504 audit: no pinned crate affected); top WATCH: unpublished `ruvector-graph-condense` differentiable min-cut for trainable subcarrier grouping.
+- **ADR-153 IEEE 802.11bf-2025 forward-compatibility protocol model (`wifi-densepose-hardware/src/ieee80211bf/`)** — typed WLAN-sensing procedures (measurement setup/instance/report, SBP, termination) with `SpecProfile` version gates, `SensingCapabilities` negotiation, and **required** `ConsentMode` governance metadata on every setup; deterministic session FSM with rejection/timeout paths; `SensingTransport` seam with `SimTransport` and an `OpportunisticCsiBridge` mapping live ESP32 CSI batches into standardized report shape (a future chipset adapter replaces the bridge without touching RuvSense consumers). Not a certified implementation — simulation-tested protocol surface; OTA binding lands when silicon does. 19 acceptance tests.
 - **Dynamic min-cut mesh partition guard in the streaming engine (`mesh_guard`).** Maintains a `ruvector-mincut` exact min-cut over the live mesh coupling graph (nodes = sensing nodes, coupling = product of fusion attention weights), surfacing per cycle: the global **cut value** (how close the array is to splitting — a structural measure per-node heuristics miss), the **weak side** (which specific nodes would partition: failure/jamming triage feeding ADR-032 posture), and an **at-risk flag** that counts as a structural event for the drift→recalibration advisor. Surfaced as `TrustedOutput::mesh`. **Measured cost policy** (criterion, 12-node mesh): weights are quantized (1/64; a *nonzero* coupling below one quantum saturates to quantum 1 so quantization never erases a live coupling — without the floor, balanced meshes of ≥ 65 nodes had every ~1/n coupling erased and sat permanently "at risk") and updates change-gated, so the steady-state cycle does zero graph work (~7.3 µs, ~23× cheaper than building); on any real change a full exact rebuild (~171 µs) is used because one `DynamicMinCut` delete+insert measured ~240 µs — the incremental machinery's overhead targets much larger graphs, so rebuild-on-change is the measured optimum at mesh scale (one-edge case −28% after the policy switch). Degenerate cases fail toward risk: a node with zero coupling is reported as already partitioned (cut 0). 9 mesh-guard tests + an engine-level wiring test; full `process_cycle` with the guard: ~33 µs for 4 nodes (50 ms budget).
-- **`ruview-gamma-clinic` crate (ADR-251) — clinical dashboard + persistent hash-chained RuVector store.** Read-only research/clinical instrumentation over the ADR-250 platform, closing two operational gaps (no durable cohort memory; no clinician surface). **Store** (`store.rs`): append-only JSONL holding profiles, witnessed session summaries, and acceptance verdicts, each line hash-chained `entry_hash = SHA-256(prev ‖ raw record bytes)` so any retroactive edit/deletion/reorder breaks the chain — the store *fails closed* (refuses to open tampered data) and rebuilds the RuVector kNN/clustering layer on open so warm-start survives restarts. (Hashes the exact on-disk bytes via `RawValue`, since serde_json's default float parse is lossy and re-serialization isn't byte-stable.) **Dashboard** (`server.rs` + embedded dependency-free `dashboard.html`): Axum surface with `GET` routes for participants, per-participant frequency-response map + session trend (safety-stop markers), cohort clusters, per-program acceptance verdicts, and a live chain-integrity badge — **strictly read-only** (a test asserts no route accepts POST). Claim discipline inherited: acceptance payloads carry `AcceptanceReport::released_claim` (the gate's output, `NO_CLAIM` on failure), never a raw program claim. `gamma-clinic` binary; `ingest_governor` bridges the live ADR-250 loop into the store (pseudonymous, dedup by witness hash). 20 tests (13 store/lib + 7 server) + 1 doctest; pseudonymity asserted (the `person_id` never reaches disk).
 - **Opt-in FFT operator for the CIR ISTA solver (8–14× measured).** Φ is a sub-DFT, so each ISTA mat-vec can run as one length-G FFT (O(G log G)) instead of a dense O(K·G) product. New `CirConfig::fft_operator` (default **false** — the dense path stays the bit-exact witness default; the FFT evaluates the same sums in a different order, so enabling it shifts float results and requires regenerating any pinned witness). `FftOperator` (rustfft, planned once at construction, scratch reused across the ISTA loop) dispatches inside `ista_solve`; warm-start/Lipschitz stay dense at construction. Measured (criterion, same run): ht20 2.22 ms → 265 µs (**8.4×**), ht40 10.26 ms → 717 µs (**14.3×**); the real HE40 grid (K=484, G=1452) scales further. 3 new tests: FFT↔dense matvec equivalence to float tolerance (ht20 + he40 grids), end-to-end dominant-tap agreement on a single-path frame, and all default configs keep FFT off. New `cir_estimate_fft` bench group.
 - **Per-room adapter provenance + drift→recalibration advisor in the streaming engine.** Closes the trust-chain gap where an ~11 KB per-room LoRA adapter (ADR-150 §3.4) could silently change inference without the witness noticing. `StreamingEngine::set_room_adapter(AdapterInfo)` pins the adapter's content-derived id into provenance `model_version` (`rfenc-v1+adapter:<id>`) — and therefore into the BLAKE3 witness — so swapping or clearing adapter weights always shifts the witness (engine test proves base → adapter → other-adapter → cleared all witness differently, and cleared == base). New `RecalibrationAdvisor` recommends re-running the ADR-135 baseline / refitting the adapter on sustained low fusion coherence (streak threshold, default 60 cycles ≈ 3 s at 20 Hz) or an ADR-142 change-point; surfaced as `TrustedOutput::recalibration_recommended` and recorded on the sensing-server's `EngineBridge` alongside the witness. Bridge plumbing: `EngineBridge::{set_room_adapter, clear_room_adapter}` + live-path test that the adapter id flows into the live witness. *Scope note: this is the deployable provenance/trigger half of the "retrained model" roadmap item — fitting the adapter itself runs in the existing external calibration service (`aether-arena/calibration/`), and a trained RF-encoder checkpoint still does not exist in-tree.*
-- **`esp32-gamma-stim` firmware — ESP32 gamma stimulation actuator (ADR-250 §21 M2 device harness).** The hardware side of `ruview-gamma`: an ESP32 driving an LED + audio flicker at a commanded 36–44 Hz envelope with a hardware emergency stop. Split into a **pure, host-tested safety core** (`main/stim_core.{h,c}` — envelope validation mirroring `SafetyEnvelope::conservative()`, a latched START/STOP/e-stop state machine, exact integer timing math in millihertz so the ±0.1 Hz HIL target is exact, and a line-protocol parser; **15 host tests pass under gcc, no ESP-IDF needed**) and a thin **ESP-IDF binding** (`main/main.c` — GPTimer ISR, LEDC PWM for LED+audio, sync-out GPIO for logic-analyzer capture, e-stop GPIO ISR that kills outputs in microseconds, USB-CDC console). Defense in depth: the device re-enforces the safety envelope independently of the Rust host, so a buggy/compromised host still cannot command an out-of-envelope output. Emits a canonical integer `SESSION {...}` record per run for witness-hash reproduction. Maps 1:1 to the five `hil::verify_hil` targets. Kconfig pin config, 4 MB single-app, radio-off deterministic actuator profile.
-- **`ruview-gamma` claim-gate invariant + hardware-in-the-loop contract.** Centralized the claim release rule into a single `acceptance::claim_allowed(entrainment, safety, adherence, repeatability)` (strict AND of all four) used by every path, with a test proving every 3-of-4 subset is denied — no path can weaken the gate. New `hil` module: `verify_hil` grades a captured actuator bench measurement against fixed targets (LED frequency ±0.1 Hz, audio-visual sync < 5 ms, stop-signal→actuator-off < 100 ms, session-hash reproducibility 100%, EEG entrainment lift ≥ 20% over fixed 40 Hz) — the next acceptance milestone for a real LED+speaker (e.g. ESP32) actuator; all failure modes fail closed (missing stop measurement, no replay, any hash mismatch). README gains the benchmark table and the "governed personalization engine that refuses to overpromise" positioning. 9 new tests; crate now 97 + 1 doctest; pinned witness preserved.
-- **`ruview-gamma` generalized to an adaptive sensory neuromodulation platform (ADR-250 §23).** 40 Hz is now one prior in one program, not the product. New `program` module: `NeuroProgram` catalog of 7 use cases (Alzheimer's research, post-stroke cognition, sleep optimization, attention/working-memory, mood/arousal, home wellness, drug+device trial infrastructure), each with its own `SafetyEnvelope`, starting prior, `ObjectiveWeights`, physiological-state gating (sleep permits `Asleep` + near-dark brightness cap; attention requires wakefulness), `EvidenceLevel`, and a single non-disease claim. New `acceptance` module makes the acceptance sentence executable: `AcceptanceHarness` grades a program over ≥3 repeats on entrainment gain, safety-stop rate, adherence, and optimal-frequency repeatability, exposing a `ClaimGate` that returns the program's claim **only if all four criteria pass** — the marketing claim is otherwise unreadable (`NO_CLAIM`). Governor wiring: `enroll_program` (per-program envelope/objective; `enroll` stays the bare Alzheimer's-defaults path so the pinned witness `13cb164c…` is preserved), `program()`, `prior()`, `state_eligible()`. 13 new module tests + 2 platform integration tests (per-program envelope enforced end-to-end — a stimulus valid for Alzheimer's is refused by the sleep program; acceptance gates every catalog program's claim); crate now 88 tests + 1 doctest. Bench: full 3-repeat program grading ~425 µs.
-- **`ruview-gamma` RuVector self-learning layer (ADR-250 §10 items 3–6).** New `ruvector` module: anonymized `ProfileStore` (one-way SHA-256 hashed tags, never `person_id`; safe-session scores only), deterministic exact kNN (fixed-range normalization, index tie-break), **cohort warm-start** — a new person's optimizer is seeded from the k nearest responders as down-weighted GP pseudo-observations (`BayesianOptimizer::observe_prior`, ≥25× real-observation noise, excluded from the EI incumbent / audit / clinician report), **physiological drift detection** (Welford centroid with stimulus-input fields masked out of the distance; `Drifted` recommends re-calibration), and deterministic k-means response clustering (farthest-point seeding, no RNG). Wired into `RufloGovernor` (`seed_from_cohort`, `export_anonymized_profile`, per-session `drift_status`). The GP gains per-observation noise (real path unchanged — pinned witness `13cb164c…` preserved). 11 new module tests + 2 integration tests (cohort warm-start beats the cold 40 Hz prior for a detuned subject; collapsed physiology flags drift); crate now 75 tests + 1 doctest. Benches: kNN over 500 profiles ~15 µs, full warm-start ~16 µs; no regression on existing paths.
-- **`ruview-gamma` crate (ADR-250) — Adaptive Gamma Entrainment.** Governed, deterministic, safety-constrained personalization of 40 Hz-prior light+sound stimulation, treating 40 Hz as the evidence-based *starting prior* and learning each person's safe entrainment response curve. Eleven modules: `stimulus` (params + `SafetyEnvelope` validate/clamp), `safety` (exclusion screen + latched `SafetyMonitor` with hard-stop reasons), `response` (`RuViewState`, optional `EegMeasurement`, 20-field `PersonResponseVector` with sticky adverse flag), `objective` (safe-entrainment score; safety is a hard gate, not a weight), `simulator` (deterministic ChaCha20 `frequency_response_curve`), `optimizer` (Phase-1 calibration sweep + Phase-2 GP/Expected-Improvement + Phase-4 closed-loop control), `bandit` (Phase-3 LinUCB over envelope-safe arms), `session` (reproducible SHA-256 `session_hash`), `ruflo` (consent→exclusion→envelope→run→monitor→score→update→witnessed audit, trial/sham mode, clinician export, claim discipline), `proof` (deterministic bundle witness), `math` (dependency-light numerics). **Safety invariant** (asserted in tests): no recommendation, calibration step, bandit arm, or closed-loop nudge can ever emit a stimulus outside the `SafetyEnvelope`; non-finite inputs clamp to the conservative floor. **Claim discipline**: the only product claim is `PRODUCT_CLAIM` = "personalized entrainment optimization" — never Alzheimer's treatment (ADR-250 §19). Standalone leaf crate (no internal RuView deps), `publish = false` pending safety sign-off. 64 unit/integration tests + 1 doctest pass; deterministic witness pinned (`13cb164c…`); criterion benches (safety-stop tick ~9.3 ns vs the ADR §17 500 ms bound, Bayesian recommend ~105 µs, full 9-session governed sweep ~486 µs). See [ADR-250](docs/adr/ADR-250-adaptive-gamma-entrainment.md).
 - **RuView beyond-SOTA research series** (`docs/research/ruview-beyond-sota/`, 6 docs) — research-swarm output defining the beyond-SOTA bar and the path to it: system capability audit (role→crate maturity matrix, gap analysis, risk register), web-verified 2026 SOTA landscape per capability axis (incl. ratified IEEE 802.11bf-2025), 8-pillar target architecture on the ADR-136 contract spine (no rewrite), 6-layer benchmark/validation methodology (all 15 criterion bench targets inventoried; ADR-149 statistical protocol), and a determinism-safe optimization roadmap. Includes session validation evidence: 2,797 workspace tests / 0 failed, Python proof PASS (bit-exact), paired pre/post criterion runs.
 
 ### Performance
-- **`ruview-gamma` Bayesian optimizer factorized once per recommendation.** `BayesianOptimizer::recommend` evaluated Expected Improvement at every 0.1 Hz grid candidate, and each `predict` rebuilt the full kernel matrix and re-ran Cholesky — ~82 factorizations per recommendation, though `K` and `alpha = K⁻¹y` depend only on the observations, not the query point. Now the GP is fit once (`GpFit`: cached `L` + `alpha`, lower-triangle-only `K` build) and reused across the grid. Bit-identical arithmetic (the pinned deterministic witness `13cb164c…` and all 64 tests are unchanged), pure work elimination. Measured (criterion, paired): `gamma_bayesian_recommend` 105 µs → 19 µs (**−81%**), `gamma_calibration_sweep` (9 recommends) 466 µs → 135 µs (**−71%**).
 - **CIR estimator warm-start precompute** — the diagonal Tikhonov preconditioner `diag(Φ^H Φ)+λI` and its CSR matrix were rebuilt every frame although they depend only on Φ and λ (fixed at `CirEstimator::new`); now precomputed at construction (`ruvsense/cir.rs`). Bit-identical floats (summation order unchanged, witness chain unaffected). Measured: `cir_estimate/he40` −3.9% (p<0.01), multiband groups −1.2/−1.4%; smaller configs within container noise.
 - **RF tomography solver hoisting** — ISTA gradient buffer no longer allocated inside the 100-iteration loop, and the Frobenius Lipschitz bound moved from per-`reconstruct` to construction (`ruvsense/tomography.rs`). Bit-identical results.
 
 ### Added
-- **Falsifiable occupancy benchmark (`wifi-densepose-train::occupancy_bench`).** Makes the presence/person-count "beyond SOTA" claim falsifiable in code instead of aspirational (the unfalsifiability gap from the beyond-SOTA system review). Grades predictions vs ground truth and gates a SOTA claim behind one `claim_allowed` invariant requiring all of: `DataProvenance::Measured` (synthetic/mock is scorable but **never claimable** — anti-mock-contamination per the CLAUDE.md Kconfig-bug lesson), a leak-free `EvalSplit` (refuses any split where a subject *or* environment id appears in both train and test — subject leakage / per-environment overfitting), `n_test ≥ min`, a **non-degenerate test set** (both truth classes represented: present-rate ≥ `min_positive_rate` and ≥ 1 absent sample — an all-absent set plus an always-absent predictor cannot release a claim; vacuous F1 scores 0.0, never 1.0), presence-F1 **bootstrap-CI lower bound** (deterministic seeded splitmix64) clearing the threshold, and count MAE within threshold. The claim string is unreadable except through the gate (`NO_CLAIM` otherwise) — same discipline as the `ruview-gamma` acceptance gate. What remains is data, not method: a frozen, SHA-pinned, subject/environment-disjoint measured replay set turns the claim into a passing/failing test. 12 tests cover each refusal path, including the point-above/CI-below case (claim withheld on the CI lower bound even when the point estimate clears the threshold).
+- **Falsifiable occupancy benchmark (`wifi-densepose-train::occupancy_bench`).** Makes the presence/person-count "beyond SOTA" claim falsifiable in code instead of aspirational (the unfalsifiability gap from the beyond-SOTA system review). Grades predictions vs ground truth and gates a SOTA claim behind one `claim_allowed` invariant requiring all of: `DataProvenance::Measured` (synthetic/mock is scorable but **never claimable** — anti-mock-contamination per the CLAUDE.md Kconfig-bug lesson), a leak-free `EvalSplit` (refuses any split where a subject *or* environment id appears in both train and test — subject leakage / per-environment overfitting), `n_test ≥ min`, a **non-degenerate test set** (both truth classes represented: present-rate ≥ `min_positive_rate` and ≥ 1 absent sample — an all-absent set plus an always-absent predictor cannot release a claim; vacuous F1 scores 0.0, never 1.0), presence-F1 **bootstrap-CI lower bound** (deterministic seeded splitmix64) clearing the threshold, and count MAE within threshold. The claim string is unreadable except through the gate (`NO_CLAIM` otherwise). What remains is data, not method: a frozen, SHA-pinned, subject/environment-disjoint measured replay set turns the claim into a passing/failing test. 12 tests cover each refusal path, including the point-above/CI-below case (claim withheld on the CI lower bound even when the point estimate clears the threshold).
 - **Live trust path: sensing-server routes real frames through the governed `StreamingEngine` (parallel governed path with partial output gating).** Previously the live server ran only the *bare* `MultistaticFuser` (fused amplitudes, no trust control plane), while the privacy/provenance/witness engine (ADR-135..146) ran only on synthetic in-test frames — the gap called out in ADR-136 §8 and the beyond-SOTA system review. New `engine_bridge` module drives `StreamingEngine::process_cycle` from the server's live `NodeState` map (reusing the existing `NodeState → MultiBandCsiFrame` conversion), lazily wiring each node as a WorldGraph sensor and bounding belief growth via the retention cap; every *governed belief* carries evidence + model + calibration + privacy decision and a deterministic witness. **Honest scope:** the engine runs alongside (not instead of) the bare fusion path that feeds the live `SensingUpdate`. What its decision gates on the wire today: a cycle emitted at class `Restricted` (base mode or contradiction/mesh-risk demotion) suppresses the per-node raw amplitude vectors from the live publish — the same field mapping `wifi-densepose-bfld`'s privacy gate applies at `Restricted`; gating the remaining derived outputs (person count, classification, signal field) is tracked as a follow-up. Trust state is no longer write-only: the latest witness, effective privacy class, demotion flag, recalibration recommendation, and an engine-error counter are readable on `GET /api/v1/status`, and engine errors are counted + rate-limit logged instead of silently swallowed (`EngineBridge::observe_cycle`). Adds `wifi-densepose-engine/-worldgraph/-bfld/-geo` deps. Bridge tests cover witnessed belief with provenance, determinism, idempotent node registration, retention bound, privacy-mode propagation, trust-state recording, the error-counter path, and Restricted-class raw-output suppression.
 
 ### Fixed
-- **`wifi-densepose-mat` standalone `--no-default-features` build (101 errors → 0).** `pub mod api` was unconditional while its only dependency, serde, is optional behind the `api` feature — so any build without default features failed with unresolved serde imports (masked in `--workspace` runs by feature unification). The `api` module and its `create_router`/`AppState` re-export are now `#[cfg(feature = "api")]`-gated (with docsrs annotations). All feature combos compile: bare `--no-default-features`, `--no-default-features --features api`, and full default (177 tests pass). `StreamingEngine::process_cycle` appended one `SemanticState` belief per cycle with no eviction — ~1.7M nodes/day at 20 Hz (identified in `docs/research/ruview-beyond-sota/04-optimization-roadmap.md`). Added `WorldGraph::prune_semantic_states(max)` — deterministic eviction of the oldest beliefs by `(valid_from_unix_ms, id)`, structural nodes (rooms/zones/sensors/anchors/tracks/events) never eligible — and wired it into the engine after each belief append (`StreamingEngine::DEFAULT_SEMANTIC_RETENTION` = 7,200 ≈ 6 min at 20 Hz; tunable via `set_semantic_retention`). The WorldGraph holds *current* beliefs; durable history is the recorder's job, so no audit data is lost. 3 new tests (bounded growth end-to-end, oldest-only eviction, deterministic tie-break).
+- **`wifi-densepose-mat` standalone `--no-default-features` build (101 errors → 0).** `pub mod api` was unconditional while its only dependency, serde, is optional behind the `api` feature — so any build without default features failed with unresolved serde imports (masked in `--workspace` runs by feature unification). The `api` module and its `create_router`/`AppState` re-export are now `#[cfg(feature = "api")]`-gated (with docsrs annotations). All feature combos compile: bare `--no-default-features`, `--no-default-features --features api`, and full default (177 tests pass).
+- **WorldGraph no longer grows unboundedly under the live loop.** `StreamingEngine::process_cycle` appended one `SemanticState` belief per cycle with no eviction — ~1.7M nodes/day at 20 Hz (identified in `docs/research/ruview-beyond-sota/04-optimization-roadmap.md`). Added `WorldGraph::prune_semantic_states(max)` — deterministic eviction of the oldest beliefs by `(valid_from_unix_ms, id)`, structural nodes (rooms/zones/sensors/anchors/tracks/events) never eligible — and wired it into the engine after each belief append (`StreamingEngine::DEFAULT_SEMANTIC_RETENTION` = 7,200 ≈ 6 min at 20 Hz; tunable via `set_semantic_retention`). The WorldGraph holds *current* beliefs; durable history is the recorder's job, so no audit data is lost. 3 new tests (bounded growth end-to-end, oldest-only eviction, deterministic tie-break).
 - **ESP32 edge heart rate no longer stuck at ~45 BPM / dropping wildly — #987.** The on-device HR estimator (`edge_processing.c`, `0xC5110002`) reported ~45 BPM regardless of true heart rate (Apple-Watch ground truth 87 BPM read as ~45) and swung frame-to-frame. Two root causes: (1) a hardcoded `sample_rate = 10.0f` that became wrong after #985's self-ping raised the CSI callback rate to a variable ~13–19 Hz — BPM scales as `assumed/actual × true`, so 87 read ~45 and the reading swung as CSI yield fluctuated; (2) the zero-crossing estimator locked onto a breathing harmonic (a 0.25 Hz breathing fundamental puts its 3rd harmonic at ~0.74 Hz ≈ 44 BPM inside the HR band). Fix: measure the real sample rate from inter-frame timestamps (used for BPM conversion + biquad re-tuning on >15% drift); replace the HR zero-crossing with an autocorrelation estimator that rejects breathing harmonics (driven by a robust autocorr breathing period); median-13 smooth the output. Hardware A/B (fixed vs unmodified control board, both `edge_tier=2`): control pegged 40–49 BPM; fixed reaches the true 88–91 BPM (vs 87 GT) and holds a stable physiological value (spread 59→0 for a steady subject). Known limitation: heavy subject motion still degrades the estimate (motion gating is a follow-up).
 - **Person count no longer leaks up to 10 in heuristic mode — addresses #894.** `field_bridge::occupancy_or_fallback` returned the eigenvalue-based `FieldModel::estimate_occupancy` count **unbounded** (its internal ceiling is 10), while the sibling estimators on the same single-link data — the perturbation-energy fallback right below it and `score_to_person_count` — both cap at 3 ("1-3 for single ESP32"). On noisy / under-calibrated CSI the eigenvalue count inflated, producing the "10 persons reported when 1 present" symptom (seen when `--model` fails to load and the server runs on heuristics). Bounded the eigenvalue path to the shared `MAX_SINGLE_LINK_OCCUPANCY` (3) so every estimator on one link agrees; genuine higher counts come from the multistatic fusion path, not a single-link covariance estimate.
 - **MQTT multi-node deployments now create one Home-Assistant device per node — closes #898.** After the #872 MQTT wiring landed, the JSON→`VitalsSnapshot` bridge hard-coded a single `node_id` (the MQTT client id) and the publisher used a single `OwnedDiscoveryBuilder`, so every physical node collapsed into one device (`identifiers:["wifi_densepose_wifi-densepose-1"]`), contradicting the "one device per node" docs. The bridge now emits one snapshot per node in the sensing update's `nodes[]` (each with its own `node_id` + RSSI, falling back to a single aggregate snapshot for wifi/simulate sources), and the publisher derives a per-node builder (`OwnedDiscoveryBuilder::for_node`) that publishes discovery + availability lazily on first sight of each `node_id` and routes state to per-node topics — yielding N distinct HA devices with per-node availability/LWT. Unit-tested (distinct nodes → distinct `wifi_densepose_<node>` identifiers); 71 MQTT tests pass.
@@ -44,6 +55,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`--export-rvf` no longer silently produces a placeholder model — PR #920.** The `--export-rvf` handler ran *before* `--train`/`--pretrain` and unconditionally wrote placeholder sine-wave weights, so the documented `--train … --export-rvf <path>` workflow short-circuited to a fake model and never trained (while printing "exported successfully"). It now emits the placeholder **container-format demo** only standalone (with a clear warning), and falls through to real training when `--train`/`--pretrain` is set; docs point to `--save-rvf` for the real model. 3 guard tests.
 
 ### Added
+- **ADR-151 per-room calibration & specialist training — full `baseline → enroll → extract → train` pipeline (new `wifi-densepose-calibration` crate).** "Teach the room before you teach the model": a local-first pipeline that turns a few minutes of clean human anchors — layered on the ADR-135 empty-room baseline — into a versioned bank of small, room-calibrated specialists for **presence, posture, breathing, heartbeat, restlessness, and anomaly**. Stages: guided enrollment with an adaptive quality gate (event-sourced `EnrollmentSession`, re-prompts bad anchors); feature extraction (autocorrelation periodicity in breathing/HR bands + variance/motion); six small specialists (learned threshold / nearest-prototype / band-limited periodicity / novelty); a `SpecialistBank` with baseline-drift **STALE** invalidation; and a `MixtureOfSpecialists` runtime with presence short-circuit + anomaly veto + confidence gating. Specialists are statistical heads today (runnable + hardware-validated); the frozen ADR-150 HF RF Foundation Encoder backbone is the documented upgrade path.
+  - **CLI:** `enroll` / `train-room` / `room-status` / `room-watch`, plus the Stage-1 `calibrate-serve` HTTP API (CORS-enabled: `POST /start`, `GET /status`, `POST /stop`, `GET /result`, `GET /baselines`, `GET /health`) and a firewall-free `scripts/csi-udp-relay.py` for local Windows ESP32 testing without admin.
+  - **Multistatic fusion (ADR-029):** `MultiNodeMixture` fuses several co-located nodes (each with its own room-calibrated bank) into one room state — presence OR'd across nodes, posture/breathing/heartbeat from the highest-confidence node, a single implausible node vetoes the room's vitals. Driven via `room-watch --node-bank N:path` (repeatable), which groups live frames by `node_id` and fuses. Same-room only; cross-room is federation (ADR-105).
+  - **Validated on live ESP32-S3 (COM8, `edge_tier=0` raw CSI):** baseline capture (120 frames → 52-subcarrier baseline); the real parser → feature-extraction → mixture runtime detecting breathing (~16–31 BPM); and the multistatic ingest grouping/fusing by node-id end-to-end. Full multi-anchor enrollment accuracy requires the operator to perform the poses; true 2-node fusion + phase-based breathing + RVF/HNSW storage are noted follow-ups. 54 tests pass (35 calibration + 19 CLI).
 - **WiFi-CSI pose: efficiency frontier + per-room calibration service** (ADR-150 §3.2–3.6). Two beyond-SOTA results on the MM-Fi benchmark, plus the deployment mechanism that resolves real-world generalization:
   - **Efficiency frontier** — a **75 K-param model beats published SOTA** (74.3% vs MultiFormer 72.25% torso-PCK@20); every config from `micro` up is Pareto-dominant (smaller *and* more accurate than prior work). Shipped a deployable **int4 edge model (~20 KB, verified 74.08%, 0.135 ms single-thread CPU)** — published at [`ruvnet/wifi-densepose-mmfi-pose/edge`](https://huggingface.co/ruvnet/wifi-densepose-mmfi-pose). See [`docs/benchmarks/wifi-pose-efficiency-frontier.md`](docs/benchmarks/wifi-pose-efficiency-frontier.md).
   - **Generalization solved by few-shot calibration** — zero-shot cross-subject (~64%) and cross-environment (~10%) are *not* closeable by algorithms (CORAL, DANN, instance-norm, contrastive foundation-pretraining all tested, all failed) or by more training subjects (saturates ~64%). But **~100–200 labeled in-room samples recover SOTA-level pose**: cross-subject 64→76%, **cross-environment 10→73% (60% from just 5 samples)** — deployable as a **~11 KB per-room LoRA adapter** on a frozen shared base. Full empirical chain in ADR-150 §3.2–3.6.

CLAUDE.md

@@ -10,20 +10,19 @@ Dual codebase: Python v1 (`v1/`) and Rust port (`v2/`).
 | `wifi-densepose-core` | Core types, traits, error types, CSI frame primitives |
 | `wifi-densepose-signal` | SOTA signal processing + RuvSense multistatic sensing (16 modules) |
 | `wifi-densepose-nn` | Neural network inference (ONNX, PyTorch, Candle backends) |
-| `wifi-densepose-train` | Training pipeline with ruvector integration + ruview_metrics |
+| `wifi-densepose-train` | Training pipeline with ruvector integration + ruview_metrics; MAE pretraining recipe (`mae.rs`, ADR-152 §2.3) + WiFlow-STD port (`wiflow_std/`, tch-gated) |
 | `wifi-densepose-mat` | Mass Casualty Assessment Tool — disaster survivor detection |
-| `wifi-densepose-hardware` | ESP32 aggregator, TDM protocol, channel hopping firmware |
+| `wifi-densepose-hardware` | ESP32 aggregator, TDM protocol, channel hopping firmware; `ieee80211bf/` 802.11bf forward-compat protocol model (ADR-153) |
 | `wifi-densepose-ruvector` | RuVector v2.0.4 integration + cross-viewpoint fusion (5 modules) |
 | `wifi-densepose-wasm` | WebAssembly bindings for browser deployment |
-| `wifi-densepose-cli` | CLI tool (`wifi-densepose` binary) |
+| `wifi-densepose-cli` | CLI tool (`wifi-densepose` binary) — `calibrate`/`calibrate-serve`/`enroll`/`train-room`/`room-watch` + MAT (MAT gated behind the `mat` feature; build `--no-default-features` for the aarch64/appliance calibration binary) |
+| `wifi-densepose-calibration` | ADR-151 per-room calibration & specialist training — `baseline → enroll → extract → train` → bank of small specialists (presence/posture/breathing/heartbeat/restlessness/anomaly) + multistatic fusion; pure Rust, edge-deployable |
 | `wifi-densepose-sensing-server` | Lightweight Axum server for WiFi sensing UI |
 | `wifi-densepose-wifiscan` | Multi-BSSID WiFi scanning (ADR-022) |
 | `wifi-densepose-vitals` | ESP32 CSI-grade vital sign extraction (ADR-021) |
 | `nvsim` | Deterministic NV-diamond magnetometer pipeline simulator (ADR-089) — standalone leaf, WASM-ready |
 | `vendor/rvcsi` (submodule) | **rvCSI** — edge RF sensing runtime (ADR-095/096): 9 crates (`rvcsi-core`/`-dsp`/`-events`/`-adapter-file`/`-adapter-nexmon`/`-ruvector`/`-runtime`/`-node`/`-cli`). Lives in its own repo ([github.com/ruvnet/rvcsi](https://github.com/ruvnet/rvcsi)), vendored here under `vendor/rvcsi`, published to crates.io as `rvcsi-* 0.3.x` and to npm as `@ruv/rvcsi`. Not a `v2/` workspace member — depend on the published crates (or the submodule's `crates/rvcsi-*` paths). Normalized `CsiFrame`/`CsiWindow`/`CsiEvent` schema, validate-before-FFI, reusable DSP, typed confidence-scored events, the napi-c Nexmon shim (real nexmon_csi `.pcap` from a Raspberry Pi 5 / 4 / 3B+ — BCM43455c0), the napi-rs SDK, the `rvcsi` CLI, a Claude Code plugin. |
 | `ruview-swarm` | Drone swarm control system (ADR-148) — hierarchical-mesh topology, Raft consensus, MARL, CSI sensing payload, MAVLink/PX4 compat, Ruflo AI-agent integration |
-| `ruview-gamma` | Adaptive Sensory Neuromodulation platform (ADR-250) — governed, deterministic, safety-constrained personal neural-rhythm optimization. 7-program `NeuroProgram` catalog (Alzheimer's research, post-stroke cognition, sleep, attention/WM, mood/arousal, home wellness, trial infrastructure), each with its own safety envelope/prior/objective/state-gating/evidence-level/gated-claim. RuView sensing + RuVector cross-person self-learning (cohort warm-start, drift, clustering) + RuFlo audit. Executable acceptance gate (entrainment/safety/adherence/repeatability) releases a claim only
-| `ruview-gamma-clinic` | Clinical dashboard + persistent hash-chained RuVector store (ADR-251) — read-only Axum instrumentation over `ruview-gamma`: participant frequency-response maps, session trends with safety-stop markers, cohort clusters, per-program acceptance verdicts carrying only gate-released claims, live chain-integrity badge. Append-only JSONL, tamper-evident `entry_hash = SHA-256(prev ‖ raw record bytes)` (fails closed). `gamma-clinic` binary. Research tooling, not a medical device. |
 
 ### RuvSense Modules (`signal/src/ruvsense/`)
 | Module | Purpose |
@@ -74,6 +73,8 @@ All 5 ruvector crates integrated in workspace:
 - ADR-031: RuView sensing-first RF mode (Proposed)
 - ADR-032: Multistatic mesh security hardening (Proposed)
 - ADR-148: Drone swarm control system / `ruview-swarm` (In Progress)
+- ADR-152: WiFi-Pose SOTA 2026 intake — geometry conditioning, WiFlow-STD benchmark (measurement (a) complete: claims MEASURED-EQUIVALENT at ~96% PCK@20), MAE recipe (Proposed; §2.1–2.3, 2.6 implemented)
+- ADR-153: IEEE 802.11bf-2025 forward-compatibility protocol model (Accepted — amends ADR-152 §2.4)
 
 ### Supported Hardware
 

PROOF.md

@@ -0,0 +1,75 @@
+# PROOF — reproduce every claim, or find the one we can't yet
+
+This project (RuView / wifi-densepose) has been publicly called "AI slop" and
+"fake." This document is the answer: **a skeptic can clone the repo, run one
+script, and have every headline claim either verified on their own machine or
+shown — explicitly — as "CLAIMED, not yet reproduced (here's exactly what it
+needs)."** Nothing below is asserted without a command you can run.
+
+```bash
+git clone https://github.com/ruvnet/RuView && cd RuView
+bash scripts/prove.sh          # core gate + the anti-slop assertion tests
+bash scripts/prove.sh --full   # also attempt the feature-gated subset
+```
+
+`prove.sh` exits 0 only if every **non-gated** claim passes. Gated claims never
+fail the run; they print the prerequisite (a GPU, a dataset, real hardware, a
+trained checkpoint) so you can reproduce them yourself.
+
+## Grading
+
+- **MEASURED** — reproduced on our hardware, with the exact command recorded, and
+  pinned by a test that *fails on the pre-fix code*. `prove.sh` re-runs these.
+- **CLAIMED** — cited from a source, or measured by the source, but not
+  reproduced in this repo's automated harness.
+- **DATA-GATED / HARDWARE-GATED** — the *code path* is real and tested, but the
+  *accuracy/throughput claim* needs data or hardware we don't ship. We never
+  fabricate the number; the code carries a typed error or a `weights_trained`/
+  provenance flag instead.
+
+## The hard gate (run on any machine with Rust + Python)
+
+| Claim | Grade | Reproduce |
+|---|---|---|
+| Rust workspace: 3,128 tests, 0 failed | **MEASURED** | `cd v2 && cargo test --workspace --no-default-features` |
+| Deterministic CSI pipeline proof (bit-exact SHA-256) | **MEASURED** | `python archive/v1/data/proof/verify.py` → `VERDICT: PASS` |
+
+## Anti-slop assertion tests (each fails on the pre-fix code)
+
+| Claim | Grade | Test (run via `cargo test -p <crate> <name>`) |
+|---|---|---|
+| Fusion crafted-input DoS panics are closed (ADR-156 §2.2) | **MEASURED** | `wifi-densepose-ruvector :: triangulation_out_of_range_index_returns_none_no_panic` |
+| **The "Soul Signature" identity claim, honestly bounded:** on WiFi-only cardiac+respiratory channels two people are **not separable** (gap ≈ 0.0005) | **MEASURED** | `wifi-densepose-bfld :: cardiac_alone_cannot_separate_identity_matches_audit` |
+| OccWorld `predict()` is real (input-dependent), not random noise | **MEASURED** | `wifi-densepose-occworld-candle :: predict_is_deterministic_for_same_input` |
+| Pose runtime emits frames under its own default config (ADR-159 A1) | **MEASURED** | `cog-pose-estimation :: default_config_emits_frames_with_real_model` |
+| Person-count flags untrained classes — no count inflation (ADR-159 A2) | **MEASURED** | `cog-person-count :: untrained_class_argmax_is_flagged_low_confidence` |
+| Medical edge skills carry a "not a medical device" disclaimer (ADR-160 A1) | **MEASURED** | `wifi-densepose-wasm-edge :: a1_med_modules_have_clinical_disclaimer` (`--features std`) |
+| Survivor dedup 3→1, count-inflation killed (ADR-158 §2) | **MEASURED** | `wifi-densepose-mat :: test_identical_vitals_no_location_dedup_to_one` (`--features mat`) |
+
+## Measured performance (criterion; reproduce on your machine)
+
+| Claim | Grade | Reproduce |
+|---|---|---|
+| PSD FFT-planner cache 2.0–3.1×, DTW band 2.4–4.1× (ADR-154) | **MEASURED** | `cd v2 && cargo bench -p wifi-densepose-signal` |
+| fuse() double-clone removed ~2.17× marshalling (ADR-156) | **MEASURED** | `cd v2 && cargo bench -p wifi-densepose-ruvector --bench fusion_bench` |
+| zero-copy ORT input ~1.48× (ADR-155) | **MEASURED** | `cd v2 && cargo bench -p wifi-densepose-nn --features onnx --bench onnx_bench` |
+| pointcloud splats 9→2 passes ~1.24× (ADR-160 research) | **MEASURED** | `cd v2 && cargo bench -p wifi-densepose-pointcloud --bench splats_bench` |
+| native wlanapi multi-BSSID scan 9.74 Hz (vs netsh ~2 Hz) | **MEASURED (Windows)** | `cd v2 && cargo test -p wifi-densepose-wifiscan -- --ignored measure_native_scan_rate` |
+
+## What we do NOT claim (the honest negatives — the strongest anti-slop signal)
+
+| Capability | Status |
+|---|---|
+| **Named person-identity from WiFi** | **NOT achieved, and measured why.** The §3.6 matcher is real, but identity does not lock on WiFi-only channels (gap 0.0005). DATA-GATED on a real enrollment feeding the AETHER/body-resonance channel — never done. No named-identity claim is made. |
+| WiFlow-STD ~96% PCK@20 | **CLAIMED-reproduced** on our RTX 5080 (`benchmarks/wiflow-std/RESULTS.md`); HARDWARE-GATED for you (needs an NVIDIA GPU + the MM-Fi dataset). The upstream *shipped checkpoint* was **REFUTED** (0.08% PCK) — we publish that. |
+| OccWorld trajectory accuracy | DATA-GATED on a trained checkpoint; `predict()` carries `weights_trained=false` until one is loaded — never silently faked. |
+| Edge-skill detection accuracy (seizure, weapon, affect, …) | UNVALIDATED — every such module is now disclaimer-gated as experimental/research; the DSP is real, the accuracy is not claimed. |
+| 802.11bf-2025 OTA conformance | No commodity silicon ships a conformant interface as of 2026; ours is a simulation-tested forward-compat protocol model, not a certified implementation. |
+
+## Provenance
+
+Every claim above traces to a committed ADR (`docs/adr/ADR-154`…`ADR-160`), a
+test, a criterion bench, or `benchmarks/wiflow-std/RESULTS.md`. The history
+includes published **retractions** (the 92.9% PCK retraction; the WiFlow-STD
+shipped-checkpoint refutation; the NV-diamond BOM reality check) — a faker hides
+failures; we commit them.

README.md

@@ -501,7 +501,7 @@ Every WiFi signal that passes through a room creates a unique fingerprint of tha
 **What it does in plain terms:**
 - Turns any WiFi signal into a 128-number "fingerprint" that uniquely describes what's happening in a room
 - Learns entirely on its own from raw WiFi data — no cameras, no labeling, no human supervision needed
-- Recognizes rooms, detects intruders, identifies people, and classifies activities using only WiFi
+- Recognizes rooms, detects intruders, and classifies activities using only WiFi (named person-identity is an experimental, data-gated research capability — see below, not a shipped feature)
 - Runs on an $8 ESP32 chip (the entire model fits in 55 KB of memory)
 - Produces both body pose tracking AND environment fingerprints in a single computation
 
@@ -512,7 +512,7 @@ Every WiFi signal that passes through a room creates a unique fingerprint of tha
 | **Self-supervised learning** | The model watches WiFi signals and teaches itself what "similar" and "different" look like, without any human-labeled data | Deploy anywhere — just plug in a WiFi sensor and wait 10 minutes |
 | **Room identification** | Each room produces a distinct WiFi fingerprint pattern | Know which room someone is in without GPS or beacons |
 | **Anomaly detection** | An unexpected person or event creates a fingerprint that doesn't match anything seen before | Automatic intrusion and fall detection as a free byproduct |
-| **Person re-identification** | Each person disturbs WiFi in a slightly different way, creating a personal signature | Track individuals across sessions without cameras |
+| **Person re-identification** *(experimental, research)* | A real per-channel similarity matcher (Soul Signature §3.6, `wifi-densepose-bfld`); **measured** result: on WiFi-only cardiac+respiratory channels alone two people are *not* separable (gap ~0.0005) | Honest research capability — **named identity is not claimed** and is data-gated on enrollment with the decisive AETHER/body-resonance channel. See [#1021](https://github.com/ruvnet/RuView/issues/1021) |
 | **Environment adaptation** | MicroLoRA adapters (1,792 parameters per room) fine-tune the model for each new space | Adapts to a new room with minimal data — 93% less than retraining from scratch |
 | **Memory preservation** | EWC++ regularization remembers what was learned during pretraining | Switching to a new task doesn't erase prior knowledge |
 | **Hard-negative mining** | Training focuses on the most confusing examples to learn faster | Better accuracy with the same amount of training data |
@@ -610,7 +610,7 @@ Verify the plugin structure: `bash plugins/ruview/scripts/smoke.sh`. Full detail
 | [User Guide](docs/user-guide.md) | Step-by-step guide: installation, first run, API usage, hardware setup, training |
 | [Build Guide](docs/build-guide.md) | Building from source (Rust and Python) |
 | [**Home Assistant + Matter Integration**](docs/integrations/home-assistant.md) | **Works with Home Assistant** via MQTT auto-discovery + **Works with Matter** (Apple Home / Google Home / Alexa / SmartThings) — full entity catalog, 3 starter blueprints, Lovelace dashboards, privacy mode, threshold tuning ([ADR-115](docs/adr/ADR-115-home-assistant-integration.md)). |
-| [**BFLD — Beamforming Feedback Layer for Detection**](v2/crates/wifi-densepose-bfld/README.md) | New privacy-gated WiFi sensing layer that measures + structurally prevents identity leakage from 802.11ac/ax Beamforming Feedback Information. Three type-enforced invariants (raw BFI never exits node, identity embedding is in-RAM-only, cross-site correlation cryptographically impossible via per-site BLAKE3 keyed hash + daily rotation). Ships full operator surface (`BfldPipeline`, `BfldPipelineHandle`, Soul Signature `SoulMatchOracle` integration), MQTT topic router + HA-DISCO + availability + LWT, 3 operator HA blueprints, two runnable examples, eclipse-mosquitto:2 CI service container. 327+ tests. [ADR-118](docs/adr/ADR-118-bfld-beamforming-feedback-layer-for-detection.md) umbrella + sub-ADRs [119](docs/adr/ADR-119-bfld-frame-format-and-wire-protocol.md)/[120](docs/adr/ADR-120-bfld-privacy-class-and-hash-rotation.md)/[121](docs/adr/ADR-121-bfld-identity-risk-scoring.md)/[122](docs/adr/ADR-122-bfld-ruview-ha-matter-exposure.md)/[123](docs/adr/ADR-123-bfld-capture-path-nexmon-and-esp32.md). Research dossier: [`docs/research/BFLD/`](docs/research/BFLD/) (11 files, 13,544 words). |
+| [**BFLD — Beamforming Feedback Layer for Detection**](v2/crates/wifi-densepose-bfld/README.md) | New privacy-gated WiFi sensing layer that measures + structurally prevents identity leakage from 802.11ac/ax Beamforming Feedback Information. Three type-enforced invariants (raw BFI never exits node, identity embedding is in-RAM-only, cross-site correlation cryptographically impossible via per-site BLAKE3 keyed hash + daily rotation). Ships full operator surface (`BfldPipeline`, `BfldPipelineHandle`, the Soul Signature §3.6 per-channel matcher `EnrolledMatcher`/`SoulMatchOracle` — experimental; named identity is data-gated, **measured** as not-separable on WiFi-only channels alone), MQTT topic router + HA-DISCO + availability + LWT, 3 operator HA blueprints, two runnable examples, eclipse-mosquitto:2 CI service container. 327+ tests. [ADR-118](docs/adr/ADR-118-bfld-beamforming-feedback-layer-for-detection.md) umbrella + sub-ADRs [119](docs/adr/ADR-119-bfld-frame-format-and-wire-protocol.md)/[120](docs/adr/ADR-120-bfld-privacy-class-and-hash-rotation.md)/[121](docs/adr/ADR-121-bfld-identity-risk-scoring.md)/[122](docs/adr/ADR-122-bfld-ruview-ha-matter-exposure.md)/[123](docs/adr/ADR-123-bfld-capture-path-nexmon-and-esp32.md). Research dossier: [`docs/research/BFLD/`](docs/research/BFLD/) (11 files, 13,544 words). |
 | [**SENSE-BRIDGE — rvagent MCP server**](tools/ruview-mcp/README.md) | Dual-transport MCP server (`@ruvnet/rvagent`) bridging the RuView sensing stack to AI agents (Claude Code, Cursor, ruflo swarms). 6 tools wired: `ruview.presence.now`, `ruview.vitals.get_{breathing,heart_rate,all}`, `ruview.bfld.last_scan`, `ruview.bfld.subscribe`. stdio + Streamable HTTP (`POST /mcp`, Origin-validated, bearer-token auth, `127.0.0.1` bind). Full 20-tool Zod schema barrel + 5 RUVIEW-POLICY governance tools. 93 tests. [ADR-124](docs/adr/ADR-124-rvagent-mcp-ruvector-npm-integration.md). Try: `npx @ruvnet/rvagent stdio`. |
 | [Semantic Primitives — Precision/Recall](docs/integrations/semantic-primitives-metrics.md) | Per-primitive F1 on the held-out paired-capture set: someone-sleeping, possible-distress, room-active, elderly-inactivity-anomaly, meeting, bathroom, fall-risk, bed-exit, no-movement, multi-room. |
 | [Claude Code / Codex Plugin](plugins/ruview/README.md) | The `ruview` plugin + marketplace — skills, `/ruview-*` commands, agents, and the Codex prompt mirror |

archive/v1/src/hardware/csi_extractor.py

@@ -221,11 +221,15 @@ class ESP32BinaryParser:
 
         snr = float(rssi - noise_floor)
         frequency = float(freq_mhz) * 1e6
-        bandwidth = 20e6  # default; could infer from n_subcarriers
 
-        if n_subcarriers <= 56:
+        # Bandwidth inference (issue #1005): HE-LTF uses a 4x denser tone
+        # grid than HT-LTF on the same channel width — an HE-SU frame with
+        # 256 bins (242 active HE20 tones) is a *20 MHz* capture, not 160.
+        if ppdu_byte in (1, 2, 3):  # HE-SU / HE-MU / HE-TB
+            bandwidth = 40e6 if (flags_byte & 0x01) or n_subcarriers > 256 else 20e6
+        elif n_subcarriers <= 64:  # ESP32 HT20 delivers the full 64-bin FFT
             bandwidth = 20e6
-        elif n_subcarriers <= 114:
+        elif n_subcarriers <= 128:
             bandwidth = 40e6
         elif n_subcarriers <= 242:
             bandwidth = 80e6

benchmarks/wiflow-std/.gitignore

@@ -0,0 +1,26 @@
+# Upstream clone (WiFlow-STD, DY2434) -- never commit third-party code/weights
+upstream/
+
+# Local python env
+.venv/
+
+# Downloaded data / artifacts
+data/
+downloads/
+*.pth
+*.pt
+*.npy
+*.npz
+*.zip
+*.mat
+*.safetensors
+results/parity_fixture.json
+__pycache__/
+*.onnx
+
+# Committed ground truth: corruption masks for the pristine Kaggle download.
+# remote/clean_v2.py zeroes the corrupted source windows IN PLACE, so these
+# masks CANNOT be regenerated from a cleaned copy (generate_corruption_masks.py
+# documents the criteria and reproduces them only from a fresh download).
+!results/nan_windows_mask.npy
+!results/big_windows_mask.npy

benchmarks/wiflow-std/RESULTS.md

@@ -0,0 +1,486 @@
+# WiFlow-STD (DY2434) Benchmark Results — ADR-152 §2.2
+
+Upstream: <https://github.com/DY2434/WiFlow-WiFi-Pose-Estimation-with-Spatio-Temporal-Decoupling>
+pinned at `06899d29` (2026-04-05), Apache-2.0. Dataset: Kaggle `kaka2434/wiflow-dataset`
+(12.8 GB archive → 15.5 GB extracted; 360,000 windows of 540×20 CSI + 15-keypoint 2D labels).
+
+Published claims (README "Setting 1"): PCK@20 97.25%, PCK@30 98.63%, PCK@40 99.16%,
+PCK@50 99.48%, MPJPE 0.007 m, 2.23M params, 0.07 GFLOPs.
+
+## Measurement (a): their model on their data
+
+### Artifact verification (MEASURED, 2026-06-10, this repo `eval_repro.py`)
+
+| Check | Result |
+|---|---|
+| Parameter count | **2,225,042 (2.23M) — matches claim** |
+| FLOPs (torch profiler, batch 1) | ~0.055 GFLOPs — consistent with 0.07B claim |
+| CPU latency (Windows box, torch 2.12 CPU) | 13.2 ms/window @ batch 1 (76/s); 2.48 ms/sample @ batch 64 (403/s) |
+| Checkpoint load | `weights_only=True` (no pickle code execution) |
+
+### Released checkpoint does NOT reproduce the claims — REFUTED as shipped
+
+Running the released `best_pose_model.pth` through the released code on the released
+dataset with the released split procedure (seed-42 file-level 70/15/15; 54,000 test
+samples) yields:
+
+| Metric | Published | Measured (shipped checkpoint) |
+|---|---|---|
+| PCK@20 | 97.25% | **0.08%** |
+| PCK@30 | 98.63% | 0.78% |
+| PCK@40 | 99.16% | 5.53% |
+| PCK@50 | 99.48% | 15.42% |
+| MPJPE | 0.007 | **NaN** (dataset contains NaN CSI windows) |
+
+Raw output: `results/repro_a.json`.
+
+Diagnostics (on 2,000 NaN-free windows from the first files of the dataset, i.e.
+mostly would-be *training* data — so this is not a split mismatch):
+
+- Predictions correlate with targets (Pearson r ≈ 0.76) — the checkpoint is a trained
+  model, but in a **different keypoint normalization/order** than the released data.
+- Best-case post-hoc global per-axis affine correction: PCK@20 ≈ 20%.
+- Best-case per-keypoint affine correction (15×2 fitted transforms — generous
+  cheating): PCK@20 ≈ 72%, still far below 97.25%.
+- Pred↔target keypoint correspondence matrix is degenerate (multiple predicted
+  keypoints best-match the same target joint) — keypoint convention mismatch.
+
+### Reproducibility defects in the released artifacts
+
+1. `models/__init__.py` imports `TemporalConvNet`, which `models/tcn.py` does not
+   define — **the published code does not import/run as-is**.
+2. The released root checkpoint uses pre-rename module names (`att.*`, `final_conv.*`)
+   vs the published code (`attention.*`, `decoder.*`) — same shapes/param count, but
+   confirms the checkpoint predates the published code.
+3. The second shipped checkpoint (`cross_dataset_test/WiFlow/best_pose_model.pth`) is
+   a **different architecture** (342-channel input = MM-Fi layout, 3 TCN layers,
+   3-channel/3D decoder) — not usable on their own dataset.
+4. `run.py` ignores `--data_dir` and hardcodes `../preprocessed_csi_data`.
+5. The released dataset's final 13 files (indices 487–499; 9,072 windows, 2.52%)
+   are corrupted: NaN values plus garbage amplitudes up to 3.4e38 (float32 max) in
+   data that is otherwise [0,1]-normalized. Upstream code has no NaN/inf handling;
+   training as published on this download diverges — the first corrupted batch
+   overflows fp16 autocast and permanently poisons BatchNorm running statistics
+   (GradScaler step-skipping does not protect BN). The authors' training curves
+   show normal convergence, so their local data evidently differed from the
+   Kaggle upload. Window masks: `results/nan_windows_mask.npy`,
+   `results/big_windows_mask.npy`.
+
+### Reproducing the corruption masks
+
+The two mask files (9,070 NaN/Inf windows, 9,072 with |amplitude| > 1.5;
+union 9,072, all in dataset files 487–499) are **committed ground truth**
+(gitignore-negated, ~352 KB each). They can only be regenerated from a
+**pristine** Kaggle download: `remote/clean_v2.py` repairs the dataset by
+zeroing the corrupted windows in place, after which the corruption evidence
+is gone and a rescan returns all-False. `generate_corruption_masks.py`
+re-derives them (chunked scan, criteria: any non-finite value OR
+max |finite| > 1.5 per 540×20 window) and refuses to write all-False masks,
+which indicate a cleaned copy. Verified 2026-06-11: a regeneration from the
+local pristine download is bit-identical to the committed masks.
+
+### Retraining result (MEASURED, 2026-06-10): claims APPROXIMATELY REPRODUCED
+
+Since the shipped checkpoint is unusable, measurement (a) fell back to retraining
+with upstream code + defaults (seed 42, batch 64, early-stopped at epoch 41 of 50,
+best epoch 36, ~75 s/epoch) on ruvultra (RTX 5080). Deviations, all forced and
+documented: one-line fix for defect (1); torch 2.x+cu128 instead of pinned 2.3.1
+(Blackwell sm_120 unsupported); the 9,072 corrupted windows (defect 5) zeroed
+entirely — without this the published pipeline produces NaN from epoch 1 (observed).
+Scripts mirrored in `remote/`; raw metrics in `results/eval_retrained.json`.
+
+| Metric | Published | Retrained (full test, 54,000) | Retrained (corruption-free, 52,560) |
+|---|---|---|---|
+| PCK@20 | 97.25% | **96.09%** | **96.61%** |
+| PCK@30 | 98.63% | 97.89% | 98.23% |
+| PCK@40 | 99.16% | 98.58% | 98.79% |
+| PCK@50 | 99.48% | 98.99% | 99.11% |
+| MPJPE | 0.007 | 0.0098 | 0.0094 |
+
+Within ~0.6–1.2 PCK points of every published figure (single run, corrupted train
+windows zeroed, different torch/GPU). **Verdict: the accuracy claims are credible
+and approximately reproducible — but only after repairing the released dataset and
+code.** Val best: PCK@20 96.99%, MPJPE 0.0086 (epoch 36).
+
+One more defect found during the run:
+
+6. `train.py` calls `plot_training_history`, which is not defined anywhere — the
+   built-in post-training test evaluation is unreachable as published (crashes
+   with NameError after training completes).
+
+## ADR-152 §2.2 citation rule
+
+Evidence grade for the WiFlow-STD accuracy claims after measurement (a):
+**MEASURED-EQUIVALENT (96.1–96.6% PCK@20 reproduced by retraining; shipped
+checkpoint REFUTED; dataset/code require repairs)**. RuView docs may cite
+"~96% PCK@20 (our reproduction)" — still **not comparable** to our 17-keypoint
+ESP32 numbers (different hardware, 5 subjects, in-domain random split,
+15 keypoints).
+
+## Edge optimization (measured)
+
+ADR-152 "optimize beyond SOTA" track, 2026-06-10, this Windows box (Windows 11,
+16 torch threads, torch 2.12.0+cpu, onnxruntime 1.26.0). Subject: the retrained
+checkpoint `results/retrained_best_pose_model.pth` (2,225,042 fp32 params).
+Scripts: `quantize_bench.py`, `onnx_bench.py`, `eval_ort_accuracy.py`.
+Raw numbers: `results/edge_optimization.json`.
+
+Accuracy is on a **10,000-window seed-42 random subset** of the corruption-free
+test split (same seed-42 file-level 70/15/15 split as `eval_repro.py`; 54,000
+test windows, 1,440 corrupted excluded via `results/nan_windows_mask.npy` |
+`results/big_windows_mask.npy`, leaving 52,560; subset drawn with
+`np.random.default_rng(42)`). The fp32 subset PCK@20 (96.68%) matches the full
+clean-test figure (96.61%), so the subset is representative.
+
+Latency is CPU ms/window, median of repeated runs, 3 interleaved repetitions
+per variant (medians below; run-to-run spread on this box is large, roughly
+±20-40% at batch 1 — reps are in the JSON).
+
+| Variant | Disk size | Batch 1 (ms/win) | Batch 64 (ms/win) | PCK@20 | PCK@50 | MPJPE |
+|---|---|---|---|---|---|---|
+| torch fp32 (baseline) | 9.07 MB | 11.0 | 2.27 | 96.68% | 99.15% | 0.00936 |
+| torch fp16 (`.half()`) | **4.58 MB** | 24.3 | 2.42 | 96.68% | 99.15% | 0.00946 |
+| torch int8 dynamic | 9.07 MB (unchanged) | 15.6 | 2.06 | 96.68% (identical) | 99.15% | 0.00936 |
+| ONNX fp32 (onnxruntime) | 8.97 MB | **3.2** | **2.0** | 96.68% | 99.15% | 0.00936 |
+| ONNX int8 (ORT dynamic, supplementary) | **2.44 MB** | 6.5 | 5.8 | 96.52% | 99.15% | 0.01108 |
+
+Findings:
+
+- **torch dynamic INT8 quantizes nothing on this model.** The architecture has
+  **zero `nn.Linear` layers** — it is entirely Conv1d (21) + Conv2d (22) +
+  BatchNorm. `torch.ao.quantization.quantize_dynamic` (requested over
+  `{Linear, Conv1d, Conv2d}`) converted **0 modules / 0.0% of params**: dynamic
+  quantization only has kernels for Linear/RNN-family modules and silently
+  skips convolutions. The "int8" model is bit-identical to fp32 (same outputs,
+  same 9.07 MB). Conv quantization would require static (PTQ) quantization
+  with calibration — out of scope here; the ORT dynamic path below is the
+  honest int8 datapoint.
+- **fp16 halves size for free accuracy-wise** (PCK@20 −0.005 pt, MPJPE
+  +0.0001) but is *slower* on CPU at batch 1 (~2.2×) — torch CPU fp16 conv
+  kernels are emulated. fp16 is a storage/transport format here, not a CPU
+  runtime win.
+- **ONNX Runtime is the real batch-1 latency win: ~3.4× faster than torch**
+  (3.2 vs 11.0 ms/window) at identical accuracy (parity 2.4e-7).
+
+### Verdict on the paper's "~2.2 MB int8" claim
+
+**Plausible but not free, and unreachable by the obvious PyTorch route.**
+2,225,042 params × 1 byte ≈ 2.2 MB assumes *every* parameter quantizes.
+PyTorch dynamic quantization — the one-liner most readers would reach for —
+yields **9.07 MB (0% quantized)** because the model has no Linear layers.
+ONNX Runtime dynamic quantization, which does have int8 conv weight support,
+gets **2.44 MB** (close to the claim; the overhead is BatchNorm params/buffers
+and quantization scales kept in fp32) at a measurable accuracy cost:
+PCK@20 96.68 → 96.52% (−0.16 pt) and MPJPE 0.00936 → 0.01108 (+18%), and
+~2× slower inference than ONNX fp32 (ConvInteger kernels). The paper does not
+state a method or an int8 accuracy; treat "2.2 MB" as a weight-arithmetic
+estimate, achievable in practice only via conv-capable quantization toolchains
+and with a small accuracy penalty.
+
+### ONNX export status
+
+**Works.** Exported via the TorchScript exporter (`dynamo=False`), opset 17,
+with a dynamic batch axis — `results/retrained_fp32_dynamic.onnx` (8.97 MB),
+verified to run at batch 1/2/64. The axial attention's
+`view(N*W, C, H)` reshape traced correctly (sizes recorded as graph ops, not
+baked constants). The dynamo exporter also captures the graph but crashed on
+this box writing a ✅ to a cp1252 console (cosmetic Windows encoding issue, not
+a model blocker). Parity vs torch on the stored fixture
+(`results/parity_fixture.npz`, batch 2, seed 42): **max abs diff 2.4e-7 —
+PASS** (< 1e-4). ORT-quantized int8 model: `results/retrained_int8_ort_dynamic.onnx`.
+
+### Static PTQ (calibrated) — follow-up
+
+Follow-up to the dynamic-int8 row above (2026-06-10, same box, onnxruntime
+1.26.0): ONNX Runtime **static** post-training quantization
+(`quantize_static`, QDQ format, per-channel int8 weights + int8 activations)
+of the same fp32 export, calibrated on **corruption-free TRAINING-split
+windows only** (seed-42 file-level split, same masks; 1,000 windows for
+MinMax, 512 for the histogram calibrators; never test windows). Scopes:
+"conv-only" (`op_types_to_quantize=["Conv"]` — the attention path exports as
+Einsum/Softmax, which ORT never quantizes anyway, so "all-ops" additionally
+quantizes the elementwise Mul/Sigmoid/Add/AveragePool glue). Accuracy on the
+identical 10k-window seed-42 corruption-free test subset; latency median of
+3 interleaved reps (fp32/dynamic re-benched in-session as references).
+Script: `static_ptq_bench.py`; raw: `results/edge_optimization.json`
+(`onnx_static_ptq`).
+
+| Variant | Disk size | Batch 1 (ms/win) | Batch 64 (ms/win) | PCK@20 | PCK@50 | MPJPE |
+|---|---|---|---|---|---|---|
+| ONNX fp32 (reference) | 8.97 MB | 2.5 | 1.9 | 96.68% | 99.15% | 0.00936 |
+| ORT dynamic int8 (baseline) | **2.44 MB** | 5.7 | 4.6 | 96.52% | 99.15% | 0.01108 |
+| static QDQ **Percentile(99.99) conv-only** | 2.53 MB | 5.3 | 4.7 | 96.61% | 99.16% | **0.01031** |
+| static QDQ MinMax conv-only | 2.53 MB | 5.2 | 3.3 | **96.63%** | 99.19% | 0.01084 |
+| static QDQ Entropy conv-only | 2.53 MB | 5.2 | 3.1 | 96.60% | 99.19% | 0.01078 |
+| static QDQ MinMax all-ops | 2.60 MB | 6.5 | 3.9 | 95.45% | 99.14% | 0.01486 |
+| static QDQ Entropy all-ops | 2.60 MB | 5.7 | 4.1 | 95.30% | 99.13% | 0.01510 |
+| static QDQ Percentile all-ops | 2.60 MB | 5.3 | 4.3 | 96.39% | 99.17% | 0.01218 |
+
+**Verdict: static PTQ (conv-only) is the new best int8 point on accuracy —
+but only modestly, and it does not fix int8's latency penalty.**
+
+- **Accuracy: beats dynamic.** All three conv-only calibrations land at
+  PCK@20 96.60–96.63% (vs dynamic 96.52%, fp32 96.68% — recovers ~⅔ of the
+  dynamic gap) and MPJPE 0.0103–0.0108 (vs dynamic 0.01108). Best MPJPE:
+  Percentile conv-only, +10% over fp32 instead of dynamic's +18%.
+- **Size: slightly worse.** 2.53 MB vs 2.44 MB (+3.6%) — QDQ nodes and
+  per-channel scales cost a little; BatchNorm stays fp32 in both (the 12 BNs
+  follow Slice/Einsum/Reshape, never Conv, so they cannot be folded).
+- **Latency: a wash vs dynamic, still ~2× slower than ONNX fp32 at batch 1.**
+  Batch-1 medians 5.2–5.3 vs dynamic 5.7 ms/win in-session — within this
+  box's ±20–40% noise. Batch 64 leans static (3.1–3.3 for MinMax/Entropy
+  conv-only vs 4.6), same caveat.
+- **All-ops QDQ is strictly worse**: up to −1.4 pt PCK@20 and +60% MPJPE for
+  zero size/latency benefit — int8 activations through the elementwise glue
+  around the attention blocks is where the damage is. Conv-only is the right
+  scope.
+- Negative result worth recording: **Entropy calibration is a no-op here** —
+  on an identical calibration set it selects full-range thresholds
+  bit-identical to MinMax (all 247 scales equal; verified on a 64-window
+  smoke set). Also, ORT 1.26's `CalibMaxIntermediateOutputs` raises a
+  spurious "No data is collected" when the batch count divides the chunk
+  size (worked around in the script).
+
+Deployment guidance: need speed → ONNX fp32 (3.2 ms b1). Need int8 weights
+for size → static QDQ conv-only (Percentile or MinMax,
+`results/retrained_int8_static_percentile_conv.onnx`), which strictly
+dominates dynamic int8 on accuracy at ~equal latency and +0.09 MB.
+
+## Efficiency sweep (MEASURED, overnight 2026-06-10/11)
+
+ADR-152 beyond-SOTA track: compact purpose-built variants of the WiFlow-STD
+architecture, trained from scratch on the same cleaned dataset, identical
+seed-42 file-level split, loss and protocol as the measurement-(a) reference
+(fp32, batch 64, ≤50 epochs, patience 5; RTX 5080, ~22–29 min/variant).
+Variant transforms are pure channel/group/stride scalings of an
+architecture-exact parameterized model (validated: reproduces 2,225,042 params
+at the reference config). Scripts: `remote/sweep/`; raw:
+`results/efficiency_sweep.jsonl`; checkpoints `results/{half,quarter,tiny}_best.pth`
+(gitignored).
+
+| Variant | Params | vs 2.23M | Clean-test PCK@20 | PCK@50 | MPJPE | Best epoch |
+|---|---|---|---|---|---|---|
+| full (reference, meas. a) | 2,225,042 | 1× | 96.61% | 99.11% | 0.0094 | 36 |
+| **half** | **843,834** | **0.38×** | **96.62%** | **99.47%** | **0.00898** | 23 |
+| quarter | 338,600 | 0.15× | 96.05% | 99.43% | 0.00928 | 50 |
+| tiny | 56,290 | 0.025× | 94.11% | 99.36% | 0.0125 | 47 |
+
+Findings:
+
+- **The half model (843k params) strictly dominates the full reference** on
+  this dataset — equal PCK@20, better PCK@50 and MPJPE, converges in fewer
+  epochs. The published 2.23M architecture is over-parameterized for its own
+  benchmark.
+- **tiny (56k params, 1/39.5) holds 94.11% PCK@20** — a ~220 KB fp32 /
+  ~60 KB int8-class model in reach of severely constrained edge targets,
+  at −2.5 pt from the full reference.
+- Caveats: in-domain (5-subject random-file split) like every number on this
+  dataset; single run per variant; corruption-free test subset (52,560).
+  Cross-domain behavior of compact variants is untested — ADR-150's evidence
+  says capacity *hurts* cross-subject, so the compact end may generalize no
+  worse, but that is a hypothesis, not a measurement.
+
+### Compact-variant edge artifacts (MEASURED, 2026-06-11)
+
+Edge pipeline for the **tiny** checkpoint (56,290 params), same machinery and
+protocol as the full-model edge rows above (this Windows box, torch
+2.12.0+cpu, onnxruntime 1.26.0; dynamic-batch opset-17 TorchScript export;
+static QDQ **Percentile(99.99) conv-only** int8 calibrated on **512**
+corruption-free TRAIN-split windows; accuracy on the identical 10k-window
+seed-42 clean test subset; latency = median ms/window over 3 interleaved
+reps, with the full-model fp32/int8 sessions interleaved as same-session
+references). Script: `tiny_edge_bench.py`; raw:
+`results/edge_optimization.json` (`tiny_variant`). Torch-vs-ORT parity on the
+stored fixture input: **max abs diff 1.5e-7 — PASS** (< 1e-4). The tiny fp32
+subset PCK@20 (94.11%) matches the full clean-test sweep figure (94.11%)
+exactly, so the subset remains representative.
+
+Two forced deviations, both recorded in the JSON:
+
+1. **Adaptive-pool export rewrite.** tiny's derived stride schedule
+   `[2,1,1,1]` leaves feature width 16, and the TorchScript exporter rejects
+   `AdaptiveAvgPool2d((15,1))` when 15 is not a factor of the input height
+   (the full model never hit this — its width was exactly 15). Since the
+   pool over a fixed-size map is a fixed linear operator, the export wrapper
+   replaces it with `mean(-1)` (W axis, a factor) + a constant averaging
+   matmul using PyTorch's exact bin rule; the parity check (vs the original
+   torch model with the real pool) proves exactness.
+2. **Calibration count 512, not "~500"**: ORT 1.26's histogram collector
+   `np.asarray()`'s the per-batch maxima, so the calibration count must be a
+   multiple of the 64-window calibration batch or the ragged last batch
+   crashes it (the earlier static-PTQ run dodged this by using exactly 512).
+
+| Variant | Disk size | Batch 1 (ms/win) | Batch 64 (ms/win) | PCK@20 | PCK@50 | MPJPE |
+|---|---|---|---|---|---|---|
+| full ONNX fp32 (same-session ref) | 8.97 MB | 2.27 | 1.42 | 96.68% | 99.15% | 0.00936 |
+| full static QDQ Percentile conv-only (same-session ref) | 2.53 MB | 5.53 | 3.82 | 96.61% | 99.16% | 0.01031 |
+| **tiny ONNX fp32** | **0.295 MB** | **0.66** | **0.24** | **94.11%** | 99.37% | 0.01253 |
+| tiny static QDQ Percentile conv-only | 0.248 MB | 0.85 | 1.03 | 92.68% | 99.33% | 0.01491 |
+
+(tiny torch `.pth` checkpoint for reference: 0.34 MB on disk; 56,290 fp32
+params ≈ 225 KB of weights.)
+
+Findings:
+
+- **The smallest deployable WiFlow-class model is the tiny ONNX fp32
+  artifact: ~295 KB on disk, 0.66 ms/window batch-1 CPU (~1,500 windows/s),
+  94.1% PCK@20** — 30× smaller and ~3.4× faster (in-session) than the full
+  ONNX fp32 model for −2.6 pt PCK@20.
+- **int8 is a bad trade at this scale.** Static QDQ conv-only — the recipe
+  that cost the full model only 0.07 pt — costs tiny **−1.43 pt** PCK@20
+  (94.11 → 92.68%) and +19% MPJPE, saves only 47 KB (−16%; QDQ scales and
+  the fp32 BN/attention glue are proportionally larger in a small graph),
+  and is *slower* than tiny fp32 (0.85 vs 0.66 ms b1; 1.03 vs 0.24 ms b64 —
+  QDQ kernel overhead dominates when the convs are this small). A 56k-param
+  model has little redundancy left to absorb weight+activation rounding.
+- Deployment guidance, compact edition: ship tiny as **ONNX fp32** — at
+  295 KB the int8 size saving solves no real constraint and costs accuracy
+  and speed. If ~250 KB vs ~295 KB ever matters, weight-only quantization
+  would be the thing to try next, not QDQ.
+
+## Measurement (b): BLOCKED-ON-DATA (attempted 2026-06-10)
+
+The fine-tune-on-ESP32 measurement stopped at dataset characterization, per the
+pre-registered stop rule (<2,000 paired windows). Findings (MEASURED):
+
+- **Only one trainable paired dataset exists**: `ruvultra:~/work/cog-pose-train/paired.jsonl`
+  — 1,077 windows (one subject, one room, one 29.9-min session, single node;
+  CSI [56, 20]; 17 COCO keypoints, MediaPipe confidence mean 0.44 — only 264
+  windows pass ADR-079's own conf>0.5 training filter). Prior measured attempts
+  on this exact set: 0–3% torso-PCK@20 (temporal splits, three independent
+  pipelines). Fine-tuning a 2.23M-param model on ~860 train windows would
+  measure memorization, not transfer.
+- **The April session behind the old "92.9% PCK@20" claim is lost** (345
+  samples, 35 subcarriers; raw CSI gone from ruvzen/ruvultra/cognitum-v0; only
+  a 69-sample predictions+GT holdout survives at `models/wiflow-real/eval-holdout.jsonl`).
+- **Forensic recheck of that holdout RETRACTS the 92.9% figure**: the trainer's
+  `pck()` used an absolute 0.2 image-unit threshold (not torso-normalized) and
+  the model output a **constant pose** (pred std 0.0000 across 69 near-static
+  frames; a mean predictor scores 100% under the same protocol). The
+  torso-normalized PCK@20 on the same holdout is 19.1%. This corroborates the
+  2026-05-11 audit retraction (CHANGELOG, PR #535); stale doc citations were
+  removed 2026-06-10 (user-guide, readme-details, ADR-152 §2.1.3). The §2.2
+  no-citation rule now applies to ADR-079 accuracy claims.
+
+Unblock criteria: a paired collection session of ≥2k windows (≈35+ min at the
+observed stride; multi-pose, conf>0.5, ideally with the §2.1.3 two-checkerboard
+calibration), plus a re-baselined our-pipeline number under torso-PCK@20 on the
+same split. WiFlow-STD assets stand ready on ruvultra (`~/wiflow-std-bench/`).
+Also worth investigating: ADR-079's protocol predicts ~9k windows per 30 min;
+the May session under-delivered ~8× (aligner drop rate?).
+
+## Measurement (b) (MEASURED 2026-06-10/11)
+
+The data baseline unblocked: the 2026-06-10 22:10–22:40 collection session produced
+**2,046 paired windows** (`ruvultra:~/wiflow-std-bench/paired-20260610.jsonl`; ONE
+subject, ONE room, ONE ESP32 node, varied poses: walk/raise/squat/kick/wave/turn/
+jump/sit; aligner `scripts/align-ground-truth.js`, non-overlapping 20-frame windows
+~0.42 s; 17 COCO keypoints in normalized [0,1] camera coords; MediaPipe confidence
+mean 0.802, min 0.692 — all windows pass the conf>0.5 filter). The −4 h timestamp
+bug and the empty-frame confidence-dilution aligner findings are recorded
+separately; results only here. Trained on ruvultra (RTX 5080, torch 2.11+cu128,
+fp32, batch 32, GPU shared with the efficiency sweep). Scripts mirrored in
+`remote/measb/`; raw metrics + full training curves in `results/measurement_b.json`.
+
+### Two new aligner/dataset findings (forced deviations, MEASURED)
+
+1. **`csi_shape` is heterogeneous, not [70, 20]**: 1,347× [70,20], 284× [134,20],
+   243× [26,20], 130× [12,20], 42× [20,20]. The ESP32 stream emits mixed frame
+   types and `extractCsiMatrix` stamps each window's subcarrier count from
+   `window[0].subcarriers`, zero-padding/truncating the other frames — even
+   native-70 windows contain ~20.4% internally zero-padded short frames
+   (subcarriers 40–69 all-zero). Handling: the primary suite ("all 2,046")
+   linearly resamples every frame's subcarrier axis to 70 bins (identity for
+   native-70 frames) so the pre-registered n and split sizes hold; a secondary
+   suite restricts to the 1,347 native [70,20] windows as a homogeneity check.
+2. **Aligner layout bug**: `extractCsiMatrix` fills `matrix[f * nSc + s]`
+   (frame-major) but declares `shape: [nSc, nFrames]` — the stored shape label is
+   transposed relative to the data. Confirmed by coherent per-frame zero-tails;
+   corrected on load (`reshape(nFrames, nSc).T`).
+
+### Protocol (pre-registered, followed)
+
+Temporal split, no shuffling across time: first 70% train (1,432), next 15% val
+(307), last 15% test (307); seed 42 elsewhere. Model: learned 1×1 Conv1d 70→540
+adapter prepended to the upstream WiFlow-STD trunk; K=17 via the parameter-free
+adaptive pool (`AdaptiveAvgPool2d((17,1))` — pretrained weights load strict for
+any K). CSI normalized by the TRAIN-split p99 amplitude (129.7 all / 130.9
+native-70), clipped to [0,1]. Three runs, ≤60 epochs, early-stop patience 8 on
+val MPJPE, AdamW (adapter lr 1e-4; pretrained trunk lr 1e-5, 10× lower; scratch
+all 1e-4), fp32. Pretrained init = the measurement-(a) **retrained** checkpoint
+(`upstream/test/best_pose_model.pth`, ~96% PCK@20 on WiFlow data; the
+`att.`/`final_conv.` key remap from `eval_repro.py` applied defensively — a no-op,
+that checkpoint already uses post-rename keys). Frozen-trunk run: trunk
+`requires_grad=False` **and** held in `.eval()` so BatchNorm running stats cannot
+drift — a pure transfer probe; only the 70→540 adapter (38,340 params) trains.
+
+PCK is torso-normalized with **torso = ‖l_shoulder(5) − l_hip(11)‖** (upstream
+`calculate_pck` math — per-frame norm clamped at 0.01, mean over keypoints ×
+frames — but upstream's `NECK_IDX/PELVIS_IDX = 2, 12` is a 15-keypoint
+convention; on 17-kp COCO those indices are right_eye/right_hip, so the indices
+were replaced, not the math). MPJPE is in normalized image units (not meters).
+
+### Results — primary suite, all 2,046 windows (test = last 307)
+
+| Run | PCK@10 | PCK@20 | PCK@30 | PCK@40 | PCK@50 | MPJPE | pred std | best ep |
+|---|---|---|---|---|---|---|---|---|
+| **mean-pose baseline** (honesty bar) | **73.1%** | **95.9%** | **98.7%** | 99.3% | 99.3% | **0.0148** | 0 (by constr.) | — |
+| (i) pretrained-init, full fine-tune | 26.0% | 65.0% | 88.0% | 96.4% | 98.9% | 0.0313 | 0.0113 | 58/60 |
+| (ii) scratch | 0.0% | 0.0% | 0.0% | 0.0% | 0.0% | 0.2554 | 0.0002 | 4 (stop @13) |
+| (iii) frozen-trunk (adapter only) | 0.0% | 0.0% | 0.2% | 3.2% | 14.4% | 0.1260 | 0.0073 | 59/60 |
+
+Secondary suite (native [70,20] windows only, n=1,347, test=202) reproduces the
+same ordering: mean-baseline 96.0% / pretrained 67.1% / scratch 0.0% /
+frozen-trunk 0.0% PCK@20 (MPJPE 0.0153 / 0.0318 / 0.2236 / 0.1343) — the
+subcarrier-resampling choice does not change any conclusion.
+
+### Interpretation
+
+- **Did pretraining-transfer happen? Partially — as optimization transfer, not
+  feature transfer, and not past the honesty bar.**
+  - *Pretrained vs scratch*: dramatic (65.0% vs 0.0% PCK@20). The pretrained init
+    is the only configuration that trains at all under the pre-registered budget.
+  - *Frozen-trunk*: near-zero (0.0% PCK@20, 14.4% @50). WiFlow-STD's frozen
+    features do **not** transfer to our ESP32 domain through a linear subcarrier
+    adapter — the pretrained benefit is a well-conditioned initialization (incl.
+    calibrated BN/output scales), not reusable CSI→pose features.
+  - *Everything vs mean-pose baseline*: **no run beats it.** A constant
+    train-mean pose scores 95.9% torso-PCK@20 / 0.0148 MPJPE on this test split,
+    because a single subject in one camera frame barely moves in normalized
+    coordinates. The fine-tuned model is a real, non-constant model
+    (pred std 0.0113 > 0 — passes the constant-pose detector that retracted the
+    old 92.9% figure) but its deviations from the mean hurt: it fits train-period
+    temporal dynamics that do not generalize across the temporal split.
+- **Verdict for ADR-152 §2.2(b): fine-tuning WiFlow-STD on this dataset does not
+  demonstrate CSI→pose signal beyond the mean pose.** Until a model beats the
+  mean-pose baseline on a temporal split, no PCK number from this line may be
+  cited as pose-estimation capability.
+
+### Caveats (honest, pre-registered)
+
+- Single subject, single room, single session (30 min), single ESP32 node —
+  in-domain temporal split only; nothing here speaks to cross-room or
+  cross-subject generalization.
+- 2k windows vs the 360k-window WiFlow-STD corpus — **NOT comparable** to the
+  ~96% in-domain measurement-(a) number, and the published 97.25% even less so.
+- The scratch run's total collapse (it cannot even reach the mean pose; its
+  output BatchNorm/SiLU head must learn output scale from random init at lr 1e-4)
+  is an optimization outcome under the fixed budget, not proof the architecture
+  cannot learn from scratch — the pretrained-vs-scratch gap partially reflects
+  this conditioning advantage.
+- Mixed-subcarrier frames (finding 1) mean even the "clean" windows carry ~20%
+  zero-padded frames; collection-side frame-type filtering should precede the
+  next session.
+- Mean-baseline PCK is inflated by low pose variance relative to torso size
+  (~0.2–0.3 image units); PCK@10 (73.1%) shows the same ceiling effect at a
+  stricter threshold — the bar is the bar, but a livelier dataset would lower it.
+
+## Pending
+
+- (b) fine-tune on our ESP32 17-keypoint eval set — **MEASURED 2026-06-10/11**,
+  see above: no run beats the mean-pose baseline; pretraining transfers as
+  optimization aid only.
+- (c) our internal WiFlow on their dataset (15-keypoint subset mapping) — also
+  affected: there is currently no validated internal pose model to compare
+  (the 92.9% artifact is retracted; the MM-Fi SOTA models in ADR-150 §3 are a
+  different input domain).

benchmarks/wiflow-std/_bench_common.py

@@ -0,0 +1,200 @@
+"""Shared infrastructure for the LOCAL wiflow-std benchmark scripts (ADR-152).
+
+This module is the single canonical implementation of the helpers that were
+previously copy-pasted across eval_repro.py / quantize_bench.py /
+onnx_bench.py / eval_ort_accuracy.py / export_to_safetensors.py:
+
+  - ``import_upstream()``  -- sys.path setup + the models-package stub that
+    works around the upstream import bug, plus the >1GB np.load mmap patch
+  - ``install_np_load_mmap_patch()`` -- the mmap patch on its own
+  - ``remap_legacy_keys()`` / ``load_remapped_state()`` -- checkpoint
+    key remap for the pre-rename released checkpoint
+  - ``load_wiflow_model()`` -- WiFlowPoseModel from a checkpoint, eval mode
+  - ``set_seed()`` -- mirrors upstream run.py seeding exactly
+  - ``evaluate()`` -- THE canonical batch-weighted PCK/MPJPE evaluation loop
+    (thresholds 0.1-0.5, upstream utils/metrics.py math); accepts either a
+    torch nn.Module or an onnxruntime InferenceSession
+
+The scripts under remote/ deploy to ruvultra as standalone single files and
+therefore intentionally inline private copies of these helpers; when editing
+them, treat this module as the reference implementation and keep the copies
+in sync.
+"""
+
+import os
+import random
+import sys
+import time
+import types
+
+import numpy as np
+import torch
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+UPSTREAM = os.path.join(HERE, "upstream")
+RESULTS = os.path.join(HERE, "results")
+
+DEFAULT_THRESHOLDS = (0.1, 0.2, 0.3, 0.4, 0.5)
+
+# ---------------------------------------------------------------------------
+# >1GB np.load mmap patch
+# ---------------------------------------------------------------------------
+
+# csi_windows.npy is ~13 GB; mmap large arrays instead of loading into RAM
+# (loading it eagerly needs ~15 GB).
+_np_load = np.load
+
+
+def _np_load_mmap(path, *a, **kw):
+    if (isinstance(path, str) and path.endswith(".npy")
+            and os.path.getsize(path) > 1 << 30 and "mmap_mode" not in kw):
+        kw["mmap_mode"] = "r"
+    return _np_load(path, *a, **kw)
+
+
+def install_np_load_mmap_patch():
+    """Globally patch np.load so .npy files >1GB are mmap'd read-only.
+
+    Idempotent. Patching the numpy module attribute is equivalent to the
+    historical ``upstream_dataset.np.load = _np_load_mmap`` (dataset.np IS
+    the numpy module), but works regardless of import order.
+    """
+    np.load = _np_load_mmap
+
+
+# ---------------------------------------------------------------------------
+# upstream import shim
+# ---------------------------------------------------------------------------
+
+def import_upstream(mmap_patch=True):
+    """Make the upstream WiFlow-STD clone importable; returns its path.
+
+    Upstream bug: models/__init__.py imports TemporalConvNet, which
+    models/tcn.py does not define -- the package fails to import as
+    published. Register a stub package so the broken __init__ never
+    executes; submodules (models.pose_model etc.) still resolve via
+    __path__. Idempotent.
+    """
+    if UPSTREAM not in sys.path:
+        sys.path.insert(0, UPSTREAM)
+    if "models" not in sys.modules:
+        _models_pkg = types.ModuleType("models")
+        _models_pkg.__path__ = [os.path.join(UPSTREAM, "models")]
+        sys.modules["models"] = _models_pkg
+    if mmap_patch:
+        install_np_load_mmap_patch()
+    return UPSTREAM
+
+
+# ---------------------------------------------------------------------------
+# checkpoint loading
+# ---------------------------------------------------------------------------
+
+# The released checkpoint predates the published code: modules were renamed
+# att -> attention, final_conv -> decoder (param count identical, 2.23M).
+LEGACY_RENAMES = {"att.": "attention.", "final_conv.": "decoder."}
+
+
+def remap_legacy_keys(state):
+    """Remap pre-rename state_dict keys; no-op for already-new-style keys."""
+    return {next((new + k[len(old):] for old, new in LEGACY_RENAMES.items()
+                  if k.startswith(old)), k): v
+            for k, v in state.items()}
+
+
+def load_remapped_state(path, map_location="cpu"):
+    """torch.load (weights_only) + legacy key remap."""
+    state = torch.load(path, map_location=map_location, weights_only=True)
+    return remap_legacy_keys(state)
+
+
+def load_wiflow_model(checkpoint, map_location="cpu", dropout=0.5):
+    """Full-size WiFlowPoseModel from a checkpoint, strict load, eval mode."""
+    import_upstream()
+    from models.pose_model import WiFlowPoseModel
+    model = WiFlowPoseModel(dropout=dropout)
+    model.load_state_dict(load_remapped_state(checkpoint, map_location),
+                          strict=True)
+    model.eval()
+    return model
+
+
+# ---------------------------------------------------------------------------
+# seeding
+# ---------------------------------------------------------------------------
+
+def set_seed(seed=42):
+    # mirror upstream run.py exactly
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+# ---------------------------------------------------------------------------
+# THE canonical evaluation loop
+# ---------------------------------------------------------------------------
+
+def evaluate(model, loader, device=None, dtype=None, label="",
+             thresholds=DEFAULT_THRESHOLDS, progress_every=50):
+    """Batch-weighted PCK/MPJPE over a DataLoader (upstream metrics math).
+
+    ``model`` may be a torch nn.Module (optionally evaluated on ``device``
+    with inputs cast to ``dtype``) or an onnxruntime InferenceSession.
+    Per-threshold PCK values are independent in upstream calculate_pck, so
+    evaluating a superset of thresholds never changes any individual value.
+
+    Returns {"samples", "mpjpe", "pck@10".."pck@50", "wall_seconds"}.
+    """
+    import_upstream()
+    from utils.metrics import calculate_mpjpe, calculate_pck
+
+    is_ort = hasattr(model, "get_inputs")  # onnxruntime InferenceSession
+    if is_ort:
+        inp = model.get_inputs()[0].name
+
+        def forward(bx):
+            return torch.from_numpy(model.run(None, {inp: bx.numpy()})[0])
+    else:
+        model.eval()
+
+        def forward(bx):
+            if device is not None:
+                bx = bx.to(device)
+            if dtype is not None:
+                bx = bx.to(dtype)
+            return model(bx).float()
+
+    thresholds = list(thresholds)
+    totals = {t: 0.0 for t in thresholds}
+    total_mpe, n = 0.0, 0
+    t0 = time.time()
+    with torch.no_grad():
+        for batch_idx, (bx, by) in enumerate(loader):
+            out = forward(bx)
+            if device is not None and not is_ort:
+                by = by.to(device)
+            mpe = calculate_mpjpe(out, by)
+            pck = calculate_pck(out, by, thresholds=thresholds)
+            bs = by.size(0)
+            total_mpe += mpe * bs
+            for t in totals:
+                totals[t] += pck[t] * bs
+            n += bs
+            if batch_idx % progress_every == 0:
+                tag = f"[{label}] " if label else ""
+                pck20 = totals.get(0.2)
+                pck20_str = f"pck20={pck20 / n:.4f} " if pck20 is not None else ""
+                print(f"  {tag}batch {batch_idx}: n={n} {pck20_str}"
+                      f"mpjpe={total_mpe / n:.4f} ({time.time() - t0:.0f}s)",
+                      flush=True)
+    return {
+        "samples": n,
+        "mpjpe": total_mpe / n,
+        **{f"pck@{int(t * 100)}": totals[t] / n for t in thresholds},
+        "wall_seconds": time.time() - t0,
+    }

benchmarks/wiflow-std/eval_ort_accuracy.py

@@ -0,0 +1,67 @@
+"""ADR-152 edge optimization: accuracy of the ONNX fp32 and ORT-dynamic-int8
+models on the same corruption-free 10k test subset used by quantize_bench.py.
+
+The torch dynamic-int8 path quantizes nothing (no nn.Linear in the model), so
+the only real int8 datapoint for the paper's "~2.2 MB int8" claim is the
+onnxruntime dynamically quantized model -- this script measures what that
+quantization costs in PCK/MPJPE.
+
+Usage:
+  .venv/Scripts/python.exe eval_ort_accuracy.py \
+      --data-dir <preprocessed_csi_data> [--subset 10000]
+
+Writes/merges into results/edge_optimization.json under key "onnx_accuracy".
+"""
+
+import argparse
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+from _bench_common import RESULTS, evaluate  # noqa: E402
+from quantize_bench import build_test_subset  # noqa: E402  (sets up upstream imports)
+
+
+def evaluate_ort(sess, loader, label):
+    """ORT-session evaluation via the canonical _bench_common.evaluate loop."""
+    return evaluate(sess, loader, label=label)
+
+
+def main():
+    import onnxruntime as ort
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-dir", default=os.path.join(
+        os.path.expanduser("~"), ".cache", "kagglehub", "datasets", "kaka2434",
+        "wiflow-dataset", "versions", "1", "preprocessed_csi_data"))
+    parser.add_argument("--subset", type=int, default=10000)
+    parser.add_argument("--out", default=os.path.join(RESULTS, "edge_optimization.json"))
+    args = parser.parse_args()
+
+    loader, _n_clean = build_test_subset(args.data_dir, args.subset)
+    results = {}
+    for label, fname in (("onnx_fp32", "retrained_fp32_dynamic.onnx"),
+                         ("onnx_int8_ort_dynamic", "retrained_int8_ort_dynamic.onnx")):
+        path = os.path.join(RESULTS, fname)
+        if not os.path.exists(path):
+            results[label] = {"error": f"{fname} not found; run onnx_bench.py first"}
+            continue
+        sess = ort.InferenceSession(path, providers=["CPUExecutionProvider"])
+        print(f"=== accuracy: {label} ({fname}) ===")
+        results[label] = evaluate_ort(sess, loader, label)
+        print(json.dumps(results[label], indent=2))
+
+    merged = {}
+    if os.path.exists(args.out):
+        with open(args.out) as f:
+            merged = json.load(f)
+    merged["onnx_accuracy"] = results
+    with open(args.out, "w") as f:
+        json.dump(merged, f, indent=2)
+    print(f"wrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/eval_repro.py

@@ -0,0 +1,102 @@
+"""ADR-152 §2.2 measurement (a): reproduce WiFlow-STD (DY2434) published test metrics.
+
+Runs the released pretrained checkpoint (upstream/best_pose_model.pth) against the
+released Kaggle dataset (kaka2434/wiflow-dataset) using the upstream code path:
+identical dataset class, identical file-level 70/15/15 split at seed 42, identical
+PCK/MPJPE implementations (utils/metrics.py).
+
+Published claims (README, "Setting 1 random split"):
+  PCK@20 97.25% | PCK@30 98.63% | PCK@40 99.16% | PCK@50 99.48% | MPJPE 0.007 m
+
+Usage:
+  .venv/Scripts/python.exe eval_repro.py --data-dir <dir containing csi_windows.npy>
+"""
+
+import argparse
+import json
+import os
+import sys
+
+import torch
+from torch.utils.data import DataLoader
+
+from _bench_common import (UPSTREAM, evaluate, import_upstream,
+                           load_remapped_state, set_seed)
+
+import_upstream()  # sys.path + models stub + >1GB np.load mmap patch
+
+from dataset import PreprocessedCSIKeypointsDataset, create_preprocessed_train_val_test_loaders  # noqa: E402
+from models.pose_model import WiFlowPoseModel  # noqa: E402
+
+
+def find_data_dir(root):
+    for dirpath, _dirnames, filenames in os.walk(root):
+        if "csi_windows.npy" in filenames:
+            return dirpath
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-dir", required=True,
+                        help="Directory containing csi_windows.npy (searched recursively)")
+    parser.add_argument("--checkpoint", default=os.path.join(UPSTREAM, "best_pose_model.pth"))
+    parser.add_argument("--batch-size", type=int, default=64)
+    parser.add_argument("--out", default=os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                                      "results", "repro_a.json"))
+    args = parser.parse_args()
+
+    data_dir = args.data_dir
+    if not os.path.exists(os.path.join(data_dir, "csi_windows.npy")):
+        located = find_data_dir(data_dir)
+        if located is None:
+            sys.exit(f"csi_windows.npy not found under {data_dir}")
+        data_dir = located
+    print(f"data dir: {data_dir}")
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"device: {device}, torch {torch.__version__}")
+
+    set_seed(42)
+
+    dataset = PreprocessedCSIKeypointsDataset(
+        data_dir=data_dir, keypoint_scale=1000.0, enable_temporal_clean=True)
+
+    # split must match upstream: file-level shuffle at random_seed=42, 70/15/15
+    _train_loader, _val_loader, test_loader = create_preprocessed_train_val_test_loaders(
+        dataset=dataset, batch_size=args.batch_size, num_workers=0, random_seed=42)
+
+    model = WiFlowPoseModel(dropout=0.5).to(device)
+    # released checkpoint predates the published code: modules were renamed
+    # att -> attention, final_conv -> decoder (param count identical, 2.23M)
+    state = load_remapped_state(args.checkpoint, map_location=device)
+    model.load_state_dict(state, strict=True)
+    n_params = sum(p.numel() for p in model.parameters())
+    print(f"checkpoint: {args.checkpoint} ({n_params/1e6:.2f}M params)")
+
+    # upstream also evaluates with drop_last=True; we report the full test set
+    # (drop_last=False) and the drop_last variant for exact comparability
+    results = {"published": {"pck@20": 0.9725, "pck@30": 0.9863, "pck@40": 0.9916,
+                             "pck@50": 0.9948, "mpjpe": 0.007},
+               "params_millions": n_params / 1e6,
+               "data_dir": data_dir,
+               "device": str(device)}
+
+    print("=== test set (full, drop_last=False) ===")
+    results["test_full"] = evaluate(model, test_loader, device=device)
+    print(json.dumps(results["test_full"], indent=2))
+
+    test_loader_dl = DataLoader(test_loader.dataset, batch_size=args.batch_size,
+                                shuffle=False, drop_last=True)
+    print("=== test set (drop_last=True, as upstream train.py) ===")
+    results["test_drop_last"] = evaluate(model, test_loader_dl, device=device)
+    print(json.dumps(results["test_drop_last"], indent=2))
+
+    os.makedirs(os.path.dirname(args.out), exist_ok=True)
+    with open(args.out, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"wrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/export_to_safetensors.py

@@ -0,0 +1,174 @@
+"""ADR-152 §2.2: export the retrained WiFlow-STD PyTorch checkpoint to
+safetensors with tch-rs (VarStore) variable names, plus a numerical-parity
+fixture for the Rust port.
+
+Outputs (all under results/, gitignored):
+  retrained_wiflow_std.safetensors  -- 248 f32 tensors named exactly as the
+                                       Rust WiFlowStdModel VarStore expects
+                                       (see wiflow_std/model.rs
+                                       `dump_variable_names` for the
+                                       authoritative name dump)
+  parity_fixture.npz                -- deterministic input (seed 42,
+                                       shape (2, 540, 20), uniform [0,1]) and
+                                       the Python model's eval-mode output
+  parity_fixture.json               -- same data as flattened f32 lists, for
+                                       the dependency-free Rust test
+                                       (tests/test_wiflow_std_parity.rs)
+
+PyTorch -> tch key mapping (derived from the VarStore dump, not guessed):
+
+  tcn.network.{i}.conv1_group.weight        -> tcn{i}.conv1_group.weight
+  tcn.network.{i}.bn*_{group,pw}.<leaf>     -> tcn{i}.bn*_{group,pw}.<leaf>
+  tcn.network.{i}.downsample.0.weight       -> tcn{i}.ds_conv.weight
+  tcn.network.{i}.downsample.1.<leaf>       -> tcn{i}.ds_bn.<leaf>
+  up.block.{0,1,4,5,8,9}.<leaf>             -> conv_in.{conv1,bn1,conv2,bn2,conv3,bn3}.<leaf>
+  up.downsample.{0,1}.<leaf>                -> conv_in.{ds_conv,ds_bn}.<leaf>
+  residual_blocks.{i}.block.{...}.<leaf>    -> conv{i}.{conv1..bn3}.<leaf>
+  residual_blocks.{i}.downsample.{0,1}      -> conv{i}.{ds_conv,ds_bn}
+  attention.{width,height}_axis.qkv_transform.weight
+                                            -> attention.{width,height}.qkv.weight
+  attention.{width,height}_axis.bn_*        -> attention.{width,height}.bn_*
+  decoder.{0,1,3,4}.<leaf>                  -> {dec_conv1,dec_bn1,dec_conv2,dec_bn2}.<leaf>
+  *.num_batches_tracked                     -> dropped (tch BatchNorm has no such buffer)
+
+Legacy upstream names (att. -> attention., final_conv. -> decoder.) are
+remapped first, exactly as eval_repro.py does for the released checkpoint.
+
+Usage:
+  .venv/Scripts/python.exe export_to_safetensors.py
+"""
+
+import json
+import os
+import re
+
+import numpy as np
+import torch
+from safetensors.torch import save_file
+
+from _bench_common import RESULTS, import_upstream, remap_legacy_keys
+
+import_upstream()  # sys.path + models stub
+
+from models.pose_model import WiFlowPoseModel  # noqa: E402
+
+CHECKPOINT = os.path.join(RESULTS, "retrained_best_pose_model.pth")
+
+# Sequential index -> tch sub-name inside one ConvBlock1/AsymmetricConvBlock:
+# [Conv2d(0), BN(1), SiLU(2), Dropout2d(3), Conv2d(4), BN(5), SiLU(6),
+#  Dropout2d(7), Conv2d(8), BN(9)]
+_BLOCK_IDX = {"0": "conv1", "1": "bn1", "4": "conv2", "5": "bn2",
+              "8": "conv3", "9": "bn3"}
+_DS_IDX = {"0": "ds_conv", "1": "ds_bn"}
+_DECODER_IDX = {"0": "dec_conv1", "1": "dec_bn1", "3": "dec_conv2",
+                "4": "dec_bn2"}
+
+
+def _conv_block(new_prefix: str, rest: str) -> str:
+    m = re.fullmatch(r"block\.(\d+)\.(.+)", rest)
+    if m:
+        return f"{new_prefix}.{_BLOCK_IDX[m.group(1)]}.{m.group(2)}"
+    m = re.fullmatch(r"downsample\.(\d+)\.(.+)", rest)
+    if m:
+        return f"{new_prefix}.{_DS_IDX[m.group(1)]}.{m.group(2)}"
+    raise KeyError(f"unmapped conv-block key: {new_prefix} / {rest}")
+
+
+def map_key(key: str) -> str:
+    """Map one PyTorch state_dict key to the tch VarStore name."""
+    m = re.fullmatch(r"tcn\.network\.(\d+)\.(.+)", key)
+    if m:
+        i, rest = m.groups()
+        rest = (rest.replace("downsample.0.", "ds_conv.")
+                    .replace("downsample.1.", "ds_bn."))
+        return f"tcn{i}.{rest}"
+
+    m = re.fullmatch(r"up\.(.+)", key)
+    if m:
+        return _conv_block("conv_in", m.group(1))
+
+    m = re.fullmatch(r"residual_blocks\.(\d+)\.(.+)", key)
+    if m:
+        return _conv_block(f"conv{m.group(1)}", m.group(2))
+
+    m = re.fullmatch(r"attention\.(width|height)_axis\.(.+)", key)
+    if m:
+        axis, rest = m.groups()
+        rest = rest.replace("qkv_transform.", "qkv.")
+        return f"attention.{axis}.{rest}"
+
+    m = re.fullmatch(r"decoder\.(\d+)\.(.+)", key)
+    if m:
+        return f"{_DECODER_IDX[m.group(1)]}.{m.group(2)}"
+
+    raise KeyError(f"unmapped checkpoint key: {key}")
+
+
+def main():
+    state = torch.load(CHECKPOINT, map_location="cpu", weights_only=True)
+    if not isinstance(state, dict) or "tcn.network.0.conv1_group.weight" not in {
+        k for k in state
+    } | {k.replace("att.", "attention.") for k in state}:
+        # tolerate trainer wrappers like {"model_state_dict": ...}
+        for wrapper in ("model_state_dict", "state_dict", "model"):
+            if isinstance(state, dict) and wrapper in state:
+                state = state[wrapper]
+                break
+
+    # Legacy upstream names predate the published code (_bench_common).
+    state = remap_legacy_keys(state)
+
+    mapped = {}
+    dropped = 0
+    for k, v in state.items():
+        if k.endswith("num_batches_tracked"):
+            dropped += 1
+            continue
+        tch_key = map_key(k)
+        if tch_key in mapped:
+            raise KeyError(f"duplicate mapped key: {k} -> {tch_key}")
+        mapped[tch_key] = v.detach().to(torch.float32).contiguous()
+
+    n_params = sum(v.numel() for k, v in mapped.items()
+                   if "running_" not in k)
+    print(f"checkpoint tensors: {len(state)} "
+          f"(dropped {dropped} num_batches_tracked)")
+    print(f"mapped tensors: {len(mapped)}, "
+          f"non-buffer params: {n_params/1e6:.6f}M")
+    assert len(mapped) == 248, f"expected 248 tch variables, got {len(mapped)}"
+    assert n_params == 2_225_042, f"param count mismatch: {n_params}"
+
+    st_path = os.path.join(RESULTS, "retrained_wiflow_std.safetensors")
+    save_file(mapped, st_path)
+    print(f"wrote {st_path}")
+
+    # ---- parity fixture --------------------------------------------------
+    model = WiFlowPoseModel(dropout=0.5)
+    model.load_state_dict(state, strict=True)
+    model.eval()
+
+    gen = torch.Generator().manual_seed(42)
+    x = torch.rand(2, 540, 20, generator=gen, dtype=torch.float32)
+    with torch.no_grad():
+        y = model(x)
+    print(f"fixture input {tuple(x.shape)} -> output {tuple(y.shape)}, "
+          f"output range [{y.min().item():.6f}, {y.max().item():.6f}]")
+
+    np.savez(os.path.join(RESULTS, "parity_fixture.npz"),
+             input=x.numpy(), output=y.numpy())
+    fixture = {
+        "seed": 42,
+        "input_shape": list(x.shape),
+        "input": x.flatten().tolist(),
+        "output_shape": list(y.shape),
+        "output": y.flatten().tolist(),
+    }
+    json_path = os.path.join(RESULTS, "parity_fixture.json")
+    with open(json_path, "w") as f:
+        json.dump(fixture, f)
+    print(f"wrote {os.path.join(RESULTS, 'parity_fixture.npz')}")
+    print(f"wrote {json_path}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/generate_corruption_masks.py

@@ -0,0 +1,148 @@
+"""Regenerate results/nan_windows_mask.npy + results/big_windows_mask.npy by
+scanning a PRISTINE kagglehub download of the WiFlow-STD dataset
+(kaka2434/wiflow-dataset v1, csi_windows.npy, 360,000 windows of 540x20).
+
+============================ READ THIS FIRST ===============================
+This script MUST be run against an UNCLEANED copy of the dataset.
+
+remote/clean_v2.py (and its predecessor clean_nan.py) repair the dataset by
+zeroing the corrupted windows IN PLACE, with no backup. A cleaned copy
+contains no non-finite values and no out-of-range amplitudes, so on a cleaned
+copy this scan produces ALL-FALSE masks -- silently wrong ground truth. The
+script errors out loudly in that case (see the sanity check in main()).
+
+That irreversibility is exactly why the two committed mask files under
+results/ (gitignore-negated) are the canonical ground truth: once a download
+has been cleaned, the masks can NEVER be regenerated from it. Only run this
+on a fresh `kagglehub.dataset_download("kaka2434/wiflow-dataset")`.
+============================================================================
+
+Criteria (per window; mirrors the original 2026-06-10 scan and the
+remote/clean_v2.py repair criteria):
+
+  nan mask: any non-finite value (NaN/Inf) anywhere in the 540x20 window
+  big mask: max |finite value| > 1.5 (the data is otherwise [0,1]-normalized;
+            the corrupted files contain garbage up to 3.4e38, float32 max)
+
+Expected result on the pristine Kaggle download (RESULTS.md defect 5):
+  nan: 9,070 True | big: 9,072 True | union: 9,072 -- all windows in dataset
+  files 487-499 (the final 13 files), window indices 350,922-359,999.
+
+Usage:
+  PYTHONUTF8=1 .venv/Scripts/python.exe generate_corruption_masks.py \
+      [--data-dir <dir containing csi_windows.npy>] [--out-dir results]
+"""
+
+import argparse
+import os
+import sys
+
+import numpy as np
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+RESULTS = os.path.join(HERE, "results")
+
+EXPECTED = {"nan": 9070, "big": 9072, "union": 9072,
+            "files": (487, 499), "windows": (350922, 359999)}
+
+
+def scan(csi_path, chunk=4000):
+    """Chunked scan of the (mmap'd) windows array; returns (nan_mask, big_mask)."""
+    csi = np.load(csi_path, mmap_mode="r")
+    n = len(csi)
+    nan_mask = np.zeros(n, dtype=bool)
+    big_mask = np.zeros(n, dtype=bool)
+    for i in range(0, n, chunk):
+        block = np.asarray(csi[i:i + chunk])
+        finite = np.isfinite(block)
+        nan_mask[i:i + chunk] = (~finite).any(axis=(1, 2))
+        big_mask[i:i + chunk] = (
+            np.abs(np.where(finite, block, 0)).max(axis=(1, 2)) > 1.5)
+        if (i // chunk) % 10 == 0:
+            print(f"  scanned {min(i + chunk, n):,}/{n:,} windows "
+                  f"(nan={int(nan_mask.sum()):,} big={int(big_mask.sum()):,})",
+                  flush=True)
+    return nan_mask, big_mask
+
+
+def describe_files(data_dir, mask):
+    """Map marked windows to dataset file indices via window_info.npz."""
+    info = os.path.join(data_dir, "window_info.npz")
+    if not os.path.exists(info):
+        return None
+    w2f = np.load(info)["window_to_file"]
+    return np.unique(w2f[mask])
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Regenerate the corruption masks from a PRISTINE "
+                    "(uncleaned) kagglehub download. See module docstring.")
+    parser.add_argument("--data-dir", default=os.path.join(
+        os.path.expanduser("~"), ".cache", "kagglehub", "datasets", "kaka2434",
+        "wiflow-dataset", "versions", "1", "preprocessed_csi_data"),
+        help="Directory containing csi_windows.npy (PRISTINE copy)")
+    parser.add_argument("--out-dir", default=RESULTS,
+                        help="Where to write the two .npy masks")
+    parser.add_argument("--chunk", type=int, default=4000,
+                        help="Windows per scan chunk (memory/speed tradeoff)")
+    args = parser.parse_args()
+
+    csi_path = os.path.join(args.data_dir, "csi_windows.npy")
+    if not os.path.exists(csi_path):
+        sys.exit(f"csi_windows.npy not found in {args.data_dir}")
+
+    print(f"scanning {csi_path} (chunk={args.chunk}) ...")
+    nan_mask, big_mask = scan(csi_path, args.chunk)
+    union = nan_mask | big_mask
+    print(f"nan: {int(nan_mask.sum()):,} | big: {int(big_mask.sum()):,} | "
+          f"union: {int(union.sum()):,} of {len(union):,} windows")
+
+    # ---- sanity check: an all-False result means a CLEANED copy ------------
+    if not union.any():
+        sys.exit(
+            "ERROR: scan found ZERO corrupted windows.\n"
+            "\n"
+            "The pristine Kaggle download (kaka2434/wiflow-dataset v1) is "
+            "known to contain\n"
+            "9,072 corrupted windows (NaN/Inf + amplitudes up to 3.4e38) in "
+            "dataset files\n"
+            "487-499 (RESULTS.md, reproducibility defect 5). Finding none "
+            "means this copy\n"
+            "has almost certainly already been repaired by remote/clean_v2.py "
+            "(or clean_nan.py),\n"
+            "which zeroes the corrupted windows IN PLACE -- after that the "
+            "corruption evidence\n"
+            "is gone and the masks CANNOT be regenerated from this copy.\n"
+            "\n"
+            "Refusing to overwrite the committed ground-truth masks with "
+            "all-False ones.\n"
+            "Re-download the dataset (kagglehub.dataset_download("
+            "'kaka2434/wiflow-dataset'))\n"
+            "and point --data-dir at the fresh, uncleaned copy.")
+
+    files = describe_files(args.data_dir, union)
+    if files is not None:
+        print(f"marked windows span dataset files {files.min()}-{files.max()}: "
+              f"{files.tolist()}")
+        lo, hi = EXPECTED["files"]
+        if files.min() != lo or files.max() != hi:
+            print(f"WARNING: expected marked files exactly {lo}-{hi} "
+                  f"(the pristine v1 download); got {files.min()}-{files.max()}. "
+                  f"Different dataset version, or a partially cleaned copy?")
+    for name, mask, exp in (("nan", nan_mask, EXPECTED["nan"]),
+                            ("big", big_mask, EXPECTED["big"])):
+        if int(mask.sum()) != exp:
+            print(f"WARNING: {name} mask has {int(mask.sum()):,} True windows; "
+                  f"the pristine v1 download yields {exp:,}.")
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    for name, mask in (("nan_windows_mask.npy", nan_mask),
+                       ("big_windows_mask.npy", big_mask)):
+        out = os.path.join(args.out_dir, name)
+        np.save(out, mask)
+        print(f"wrote {out} ({int(mask.sum()):,} True)")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/onnx_bench.py

@@ -0,0 +1,220 @@
+"""ADR-152 edge optimization: ONNX export + onnxruntime CPU benchmark for the
+retrained WiFlow-STD checkpoint.
+
+- Exports fp32 to ONNX. The axial attention reshapes with python ints taken
+  from tensor.size() (view(N*W, C, H)), so a traced graph bakes the batch
+  size; we first try a dynamic-batch export and verify it actually works at
+  batch sizes 1/2/64 -- if not, we fall back to fixed-batch exports.
+- Verifies output parity vs torch on the stored fixture
+  (results/parity_fixture.npz, batch 2, seed 42): max abs diff < 1e-4.
+- Measures onnxruntime CPU latency at batch 1 and 64 (median of N runs).
+- Supplementary: onnxruntime dynamic int8 quantization of the exported model
+  (weight size datapoint for the paper's "~2.2 MB int8" claim).
+
+Usage:
+  .venv/Scripts/python.exe onnx_bench.py
+
+Writes/merges into results/edge_optimization.json under key "onnx".
+"""
+
+import json
+import os
+import platform
+import statistics
+import time
+import traceback
+
+import numpy as np
+import torch
+
+from _bench_common import RESULTS, import_upstream, load_wiflow_model
+
+import_upstream()  # sys.path + models stub + >1GB np.load mmap patch
+
+CHECKPOINT = os.path.join(RESULTS, "retrained_best_pose_model.pth")
+OUT_JSON = os.path.join(RESULTS, "edge_optimization.json")
+
+
+def load_fp32_model():
+    return load_wiflow_model(CHECKPOINT)
+
+
+def try_export(model, path, batch, dynamic, opset=17):
+    """Returns (ok, exporter_used, error)."""
+    x = torch.rand(batch, 540, 20)
+    attempts = []
+    if dynamic:
+        attempts.append(("dynamo", dict(dynamo=True,
+                                        dynamic_shapes={"x": {0: "batch"}})))
+        attempts.append(("torchscript", dict(dynamo=False,
+                                             dynamic_axes={"input": {0: "batch"},
+                                                           "output": {0: "batch"}})))
+    else:
+        attempts.append(("torchscript", dict(dynamo=False)))
+        attempts.append(("dynamo", dict(dynamo=True)))
+    last_err = None
+    for name, kw in attempts:
+        try:
+            with torch.no_grad():
+                torch.onnx.export(model, (x,), path, opset_version=opset,
+                                  input_names=["input"], output_names=["output"],
+                                  **kw)
+            return True, name, None
+        except Exception as e:  # noqa: BLE001
+            last_err = f"{name}: {type(e).__name__}: {e}"
+            traceback.print_exc()
+    return False, None, last_err
+
+
+def ort_session(path):
+    import onnxruntime as ort
+    return ort.InferenceSession(path, providers=["CPUExecutionProvider"])
+
+
+def ort_run(sess, x):
+    inp = sess.get_inputs()[0].name
+    return sess.run(None, {inp: x})[0]
+
+
+def bench_ort(sess, batch, n_runs):
+    rng = np.random.default_rng(123)
+    x = rng.random((batch, 540, 20), dtype=np.float32)
+    for _ in range(max(5, n_runs // 10)):
+        ort_run(sess, x)
+    times = []
+    for _ in range(n_runs):
+        t0 = time.perf_counter()
+        ort_run(sess, x)
+        times.append(time.perf_counter() - t0)
+    med = statistics.median(times)
+    return {
+        "batch_size": batch,
+        "runs": n_runs,
+        "median_ms_per_batch": med * 1e3,
+        "median_ms_per_window": med * 1e3 / batch,
+        "windows_per_second": batch / med,
+    }
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(
+        description="ONNX export + onnxruntime CPU benchmark for the "
+                    "retrained WiFlow-STD checkpoint (no options; see "
+                    "module docstring). NB: the published "
+                    "retrained_fp32_dynamic.onnx came from the TorchScript "
+                    "exporter; on newer torch the dynamo attempt may succeed "
+                    "first and produce a different (external-data) artifact.")
+    parser.parse_args()
+
+    import onnxruntime
+    model = load_fp32_model()
+    results = {
+        "env": {
+            "torch": torch.__version__,
+            "onnxruntime": onnxruntime.__version__,
+            "platform": platform.platform(),
+        },
+    }
+
+    fixture = np.load(os.path.join(RESULTS, "parity_fixture.npz"))
+    fx, fy = fixture["input"], fixture["output"]  # (2,540,20) -> (2,15,2)
+
+    # ---- export: dynamic batch first, fall back to fixed --------------------
+    dyn_path = os.path.join(RESULTS, "retrained_fp32_dynamic.onnx")
+    ok, exporter, err = try_export(model, dyn_path, batch=2, dynamic=True)
+    dynamic_works = False
+    if ok:
+        # verify the dynamic graph really runs at other batch sizes
+        try:
+            sess = ort_session(dyn_path)
+            for b in (1, 2, 64):
+                y = ort_run(sess, np.zeros((b, 540, 20), dtype=np.float32))
+                assert y.shape == (b, 15, 2), y.shape
+            dynamic_works = True
+        except Exception as e:  # noqa: BLE001
+            print(f"dynamic-batch model does not generalize: {e}")
+
+    sessions = {}
+    if dynamic_works:
+        results["export"] = {"mode": "dynamic-batch", "exporter": exporter,
+                             "file": os.path.basename(dyn_path),
+                             "size_mb": os.path.getsize(dyn_path) / 1e6}
+        sess = ort_session(dyn_path)
+        sessions = {1: sess, 2: sess, 64: sess}
+        print(f"dynamic-batch export OK via {exporter}")
+    else:
+        results["export"] = {"mode": "fixed-batch", "fallback_reason": err,
+                             "files": {}}
+        for b in (1, 2, 64):
+            p = os.path.join(RESULTS, f"retrained_fp32_b{b}.onnx")
+            ok, exporter, err = try_export(model, p, batch=b, dynamic=False)
+            if not ok:
+                results["export"]["files"][str(b)] = {"error": err}
+                print(f"EXPORT FAILED at batch {b}: {err}")
+                continue
+            results["export"]["files"][str(b)] = {
+                "exporter": exporter, "file": os.path.basename(p),
+                "size_mb": os.path.getsize(p) / 1e6}
+            sessions[b] = ort_session(p)
+            print(f"fixed-batch {b} export OK via {exporter}")
+
+    # ---- parity vs torch on the fixture -------------------------------------
+    if 2 in sessions:
+        y_ort = ort_run(sessions[2], fx)
+        with torch.no_grad():
+            y_torch = model(torch.from_numpy(fx)).numpy()
+        results["parity"] = {
+            "fixture": "results/parity_fixture.npz (batch 2, seed 42)",
+            "max_abs_diff_vs_stored_fixture": float(np.abs(y_ort - fy).max()),
+            "max_abs_diff_vs_torch_now": float(np.abs(y_ort - y_torch).max()),
+            "pass_lt_1e-4": bool(np.abs(y_ort - y_torch).max() < 1e-4),
+        }
+        print("parity:", json.dumps(results["parity"], indent=2))
+
+    # ---- latency -------------------------------------------------------------
+    results["latency"] = {}
+    if 1 in sessions:
+        results["latency"]["batch1"] = bench_ort(sessions[1], 1, 100)
+        print(f"ORT batch 1:  {results['latency']['batch1']['median_ms_per_window']:.2f} ms/window")
+    if 64 in sessions:
+        results["latency"]["batch64"] = bench_ort(sessions[64], 64, 30)
+        print(f"ORT batch 64: {results['latency']['batch64']['median_ms_per_window']:.3f} ms/window")
+
+    # ---- supplementary: ORT dynamic int8 (size datapoint for the 2.2MB claim)
+    src = (dyn_path if dynamic_works
+           else os.path.join(RESULTS, "retrained_fp32_b1.onnx"))
+    if os.path.exists(src):
+        try:
+            from onnxruntime.quantization import QuantType, quantize_dynamic
+            q_path = os.path.join(RESULTS, "retrained_int8_ort_dynamic.onnx")
+            quantize_dynamic(src, q_path, weight_type=QuantType.QInt8)
+            entry = {"file": os.path.basename(q_path),
+                     "size_mb": os.path.getsize(q_path) / 1e6}
+            try:
+                qs = ort_session(q_path)
+                yq = ort_run(qs, fx[:1] if not dynamic_works else fx)
+                ref = fy[:1] if not dynamic_works else fy
+                entry["runs"] = True
+                entry["max_abs_diff_vs_fp32_fixture"] = float(np.abs(yq - ref).max())
+            except Exception as e:  # noqa: BLE001
+                entry["runs"] = False
+                entry["run_error"] = f"{type(e).__name__}: {e}"
+            results["ort_int8_dynamic_supplementary"] = entry
+            print("ORT int8:", json.dumps(entry, indent=2))
+        except Exception as e:  # noqa: BLE001
+            results["ort_int8_dynamic_supplementary"] = {
+                "error": f"{type(e).__name__}: {e}"}
+
+    merged = {}
+    if os.path.exists(OUT_JSON):
+        with open(OUT_JSON) as f:
+            merged = json.load(f)
+    merged["onnx"] = results
+    with open(OUT_JSON, "w") as f:
+        json.dump(merged, f, indent=2)
+    print(f"wrote {OUT_JSON}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/quantize_bench.py

@@ -0,0 +1,228 @@
+"""ADR-152 "optimize beyond SOTA": edge-optimization benchmark for the
+retrained WiFlow-STD checkpoint (results/retrained_best_pose_model.pth,
+~96% PCK@20, fp32 params 2,225,042).
+
+Measures, for fp32 / fp16 / dynamic-int8 torch variants:
+  (a) serialized state_dict size on disk,
+  (b) CPU inference latency per window at batch 1 and batch 64
+      (median of repeated runs, this Windows box),
+  (c) accuracy (PCK@20/50 + MPJPE, upstream metrics) on a corruption-free
+      random subset of the seed-42 file-level 70/15/15 test split
+      (same split as eval_repro.py; corrupted windows 487-499 excluded via
+      results/nan_windows_mask.npy | results/big_windows_mask.npy).
+
+Also verifies the paper's "~2.2 MB int8" size claim: reports which layer
+types torch dynamic quantization actually converts (the model contains NO
+nn.Linear -- it is Conv1d/Conv2d/BatchNorm only) and the real on-disk size.
+
+Usage:
+  .venv/Scripts/python.exe quantize_bench.py \
+      --data-dir C:/Users/ruv/.cache/kagglehub/datasets/kaka2434/wiflow-dataset/versions/1/preprocessed_csi_data \
+      [--subset 10000] [--skip-accuracy]
+
+Writes/merges into results/edge_optimization.json under key "torch".
+"""
+
+import argparse
+import json
+import os
+import platform
+import statistics
+import time
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+from _bench_common import HERE, RESULTS, evaluate, import_upstream, load_wiflow_model
+
+import_upstream()  # sys.path + models stub + >1GB np.load mmap patch
+
+from dataset import (  # noqa: E402
+    PreprocessedCSIKeypointsDataset,
+    create_preprocessed_train_val_test_loaders,
+)
+
+CHECKPOINT = os.path.join(RESULTS, "retrained_best_pose_model.pth")
+
+
+def load_fp32_model():
+    # legacy upstream key remap inside is a harmless no-op on this checkpoint
+    return load_wiflow_model(CHECKPOINT)
+
+
+def state_dict_size_bytes(model, path):
+    torch.save(model.state_dict(), path)
+    return os.path.getsize(path)
+
+
+def bench_latency(model, batch_size, n_runs, dtype=torch.float32):
+    gen = torch.Generator().manual_seed(123)
+    x = torch.rand(batch_size, 540, 20, generator=gen).to(dtype)
+    with torch.no_grad():
+        for _ in range(max(5, n_runs // 10)):  # warmup
+            model(x)
+        times = []
+        for _ in range(n_runs):
+            t0 = time.perf_counter()
+            model(x)
+            times.append(time.perf_counter() - t0)
+    med = statistics.median(times)
+    return {
+        "batch_size": batch_size,
+        "runs": n_runs,
+        "median_ms_per_batch": med * 1e3,
+        "median_ms_per_window": med * 1e3 / batch_size,
+        "windows_per_second": batch_size / med,
+    }
+
+
+def build_test_subset(data_dir, subset_size, batch_size=64):
+    """Seed-42 file-level 70/15/15 test split (exactly as eval_repro.py),
+    minus corrupted windows, then a seed-42 random subset."""
+    dataset = PreprocessedCSIKeypointsDataset(
+        data_dir=data_dir, keypoint_scale=1000.0, enable_temporal_clean=True)
+    _tr, _va, test_loader = create_preprocessed_train_val_test_loaders(
+        dataset=dataset, batch_size=batch_size, num_workers=0, random_seed=42)
+    test_indices = np.asarray(test_loader.dataset.indices)
+
+    corrupted = (np.load(os.path.join(RESULTS, "nan_windows_mask.npy"))
+                 | np.load(os.path.join(RESULTS, "big_windows_mask.npy")))
+    clean = test_indices[~corrupted[test_indices]]
+    print(f"test split: {len(test_indices)} windows, "
+          f"{len(test_indices) - len(clean)} corrupted excluded, "
+          f"{len(clean)} clean")
+
+    if subset_size and subset_size < len(clean):
+        rng = np.random.default_rng(42)
+        clean = np.sort(rng.choice(clean, size=subset_size, replace=False))
+    subset = torch.utils.data.Subset(dataset, clean.tolist())
+    loader = DataLoader(subset, batch_size=batch_size, shuffle=False,
+                        num_workers=0)
+    return loader, len(clean)
+
+
+def quantize_int8_dynamic(fp32_model):
+    """torch.ao.quantization.quantize_dynamic on Linear/Conv where supported.
+    Returns (model, report) where report documents what actually quantized."""
+    qmodel = torch.ao.quantization.quantize_dynamic(
+        fp32_model, {nn.Linear, nn.Conv1d, nn.Conv2d}, dtype=torch.qint8)
+
+    quantized, total_params, quant_params = [], 0, 0
+    for name, mod in qmodel.named_modules():
+        cls = type(mod).__module__ + "." + type(mod).__name__
+        if "quantized" in cls:
+            w = mod.weight() if callable(getattr(mod, "weight", None)) else None
+            numel = w.numel() if w is not None else 0
+            quant_params += numel
+            quantized.append({"module": name, "class": cls, "params": numel})
+    for p in fp32_model.parameters():
+        total_params += p.numel()
+
+    n_linear = sum(isinstance(m, nn.Linear) for m in fp32_model.modules())
+    n_conv1d = sum(isinstance(m, nn.Conv1d) for m in fp32_model.modules())
+    n_conv2d = sum(isinstance(m, nn.Conv2d) for m in fp32_model.modules())
+    report = {
+        "eligible_module_counts": {
+            "nn.Linear": n_linear, "nn.Conv1d": n_conv1d, "nn.Conv2d": n_conv2d},
+        "modules_actually_quantized": quantized,
+        "n_modules_quantized": len(quantized),
+        "params_total": total_params,
+        "params_quantized": quant_params,
+        "params_quantized_fraction": quant_params / total_params,
+    }
+    return qmodel, report
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-dir", default=os.path.join(
+        os.path.expanduser("~"), ".cache", "kagglehub", "datasets", "kaka2434",
+        "wiflow-dataset", "versions", "1", "preprocessed_csi_data"))
+    parser.add_argument("--subset", type=int, default=10000)
+    parser.add_argument("--runs-b1", type=int, default=100)
+    parser.add_argument("--runs-b64", type=int, default=30)
+    parser.add_argument("--skip-accuracy", action="store_true")
+    parser.add_argument("--out", default=os.path.join(RESULTS, "edge_optimization.json"))
+    args = parser.parse_args()
+
+    torch.manual_seed(42)
+    results = {
+        "env": {
+            "torch": torch.__version__,
+            "platform": platform.platform(),
+            "processor": platform.processor(),
+            "num_threads": torch.get_num_threads(),
+            "checkpoint": os.path.relpath(CHECKPOINT, HERE),
+        },
+        "variants": {},
+    }
+
+    # ---- build variants ---------------------------------------------------
+    fp32 = load_fp32_model()
+    n_params = sum(p.numel() for p in fp32.parameters())
+    results["env"]["params"] = n_params
+    print(f"fp32 model: {n_params:,} params")
+
+    fp16 = load_fp32_model().half()
+
+    int8, q_report = quantize_int8_dynamic(load_fp32_model())
+    results["int8_dynamic_quant_report"] = q_report
+    print(f"int8 dynamic: {q_report['n_modules_quantized']} modules quantized, "
+          f"{q_report['params_quantized_fraction']*100:.1f}% of params")
+
+    variants = {
+        "fp32": (fp32, torch.float32, "retrained_fp32_resaved.pth"),
+        "fp16": (fp16, torch.float16, "retrained_fp16.pth"),
+        "int8_dynamic": (int8, torch.float32, "retrained_int8_dynamic.pth"),
+    }
+
+    # ---- (a) size + (b) latency -------------------------------------------
+    for name, (model, dtype, fname) in variants.items():
+        path = os.path.join(RESULTS, fname)
+        size = state_dict_size_bytes(model, path)
+        print(f"\n=== {name}: {size/1e6:.3f} MB on disk ({fname}) ===")
+        lat1 = bench_latency(model, 1, args.runs_b1, dtype)
+        lat64 = bench_latency(model, 64, args.runs_b64, dtype)
+        print(f"  batch 1:  {lat1['median_ms_per_window']:.2f} ms/window "
+              f"({lat1['windows_per_second']:.0f}/s)")
+        print(f"  batch 64: {lat64['median_ms_per_window']:.3f} ms/window "
+              f"({lat64['windows_per_second']:.0f}/s)")
+        results["variants"][name] = {
+            "file": fname,
+            "size_bytes": size,
+            "size_mb": size / 1e6,
+            "latency_batch1": lat1,
+            "latency_batch64": lat64,
+        }
+
+    # ---- (c) accuracy ------------------------------------------------------
+    if not args.skip_accuracy:
+        loader, n_clean = build_test_subset(args.data_dir, args.subset)
+        results["accuracy_subset"] = {
+            "description": "seed-42 file-level 70/15/15 test split, corrupted "
+                           "windows (files 487-499) excluded, seed-42 random "
+                           "subset",
+            "subset_size": min(args.subset, n_clean) if args.subset else n_clean,
+            "clean_test_total": n_clean,
+        }
+        for name, (model, dtype, _f) in variants.items():
+            print(f"\n=== accuracy: {name} ===")
+            results["variants"][name]["accuracy"] = evaluate(
+                model, loader, dtype=dtype, label=name)
+            print(json.dumps(results["variants"][name]["accuracy"], indent=2))
+
+    # ---- merge into edge_optimization.json ---------------------------------
+    merged = {}
+    if os.path.exists(args.out):
+        with open(args.out) as f:
+            merged = json.load(f)
+    merged["torch"] = results
+    with open(args.out, "w") as f:
+        json.dump(merged, f, indent=2)
+    print(f"\nwrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/remote/clean_v2.py

@@ -0,0 +1,14 @@
+import numpy as np, os
+d = os.path.expanduser('~/wiflow-std-bench/preprocessed_csi_data')
+csi = np.load(os.path.join(d, 'csi_windows.npy'), mmap_mode='r+')
+zeroed = 0
+chunk = 4000
+for i in range(0, len(csi), chunk):
+    block = csi[i:i+chunk]
+    finite = np.isfinite(block)
+    bad = (~finite).any(axis=(1, 2)) | (np.abs(np.where(finite, block, 0)).max(axis=(1, 2)) > 1.5)
+    if bad.any():
+        block[bad] = 0.0
+        zeroed += int(bad.sum())
+csi.flush()
+print(f'zeroed {zeroed} corrupted windows entirely')

benchmarks/wiflow-std/remote/eval_retrained.py

@@ -0,0 +1,112 @@
+"""Evaluate the retrained WiFlow-STD checkpoint (ADR-152 §2.2a fallback).
+
+Scores the model produced by run.py (train_output/best_pose_model.pth or similar)
+on the seed-42 test split: full test set AND NaN-free subset (excluding windows
+that were zero-filled by clean_nan.py — file indices 487-499).
+
+NOTE: deployed to ruvultra (~/wiflow-std-bench) as a standalone single file,
+so it deliberately inlines its helpers. The reference implementations (upstream
+import shim, >1GB np.load mmap patch, key-remap loader, canonical evaluate
+loop) live in benchmarks/wiflow-std/_bench_common.py — keep copies in sync.
+"""
+import json, os, random, sys
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Subset
+
+# csi_windows.npy is ~13 GB; mmap large arrays instead of eagerly loading
+# ~15 GB into RAM (same patch as _bench_common._np_load_mmap).
+_np_load = np.load
+
+
+def _np_load_mmap(path, *a, **kw):
+    if (isinstance(path, str) and path.endswith('.npy')
+            and os.path.getsize(path) > 1 << 30 and 'mmap_mode' not in kw):
+        kw['mmap_mode'] = 'r'
+    return _np_load(path, *a, **kw)
+
+
+np.load = _np_load_mmap
+
+sys.path.insert(0, os.path.expanduser('~/wiflow-std-bench/upstream'))
+from dataset import PreprocessedCSIKeypointsDataset, create_preprocessed_train_val_test_loaders
+from models.pose_model import WiFlowPoseModel
+from utils.metrics import calculate_pck, calculate_mpjpe
+
+
+def find_checkpoint():
+    cands = []
+    for root, _, files in os.walk(os.path.expanduser('~/wiflow-std-bench/train_output')):
+        for f in files:
+            if f.endswith('.pth'):
+                cands.append(os.path.join(root, f))
+    # also upstream/test default output dir
+    for root, _, files in os.walk(os.path.expanduser('~/wiflow-std-bench/upstream')):
+        for f in files:
+            if f.endswith('.pth') and 'best' in f and 'cross_dataset' not in root:
+                p = os.path.join(root, f)
+                if os.path.getmtime(p) > os.path.getmtime(os.path.expanduser('~/wiflow-std-bench/train.log')) - 86400 * 2:
+                    cands.append(p)
+    cands = [c for c in cands if not c.endswith('upstream/best_pose_model.pth')]
+    if not cands:
+        sys.exit('no retrained checkpoint found')
+    return max(cands, key=os.path.getmtime)
+
+
+def evaluate(model, loader, device):
+    model.eval()
+    totals = {t: 0.0 for t in (0.1, 0.2, 0.3, 0.4, 0.5)}
+    total_mpe, n = 0.0, 0
+    with torch.no_grad():
+        for bx, by in loader:
+            bx, by = bx.to(device), by.to(device)
+            out = model(bx)
+            bs = by.size(0)
+            total_mpe += calculate_mpjpe(out, by) * bs
+            pck = calculate_pck(out, by, thresholds=list(totals))
+            for t in totals:
+                totals[t] += pck[t] * bs
+            n += bs
+    return {'samples': n, 'mpjpe': total_mpe / n,
+            **{f'pck@{int(t*100)}': totals[t] / n for t in totals}}
+
+
+random.seed(42); np.random.seed(42); torch.manual_seed(42)
+torch.cuda.manual_seed_all(42)
+torch.backends.cudnn.deterministic = True
+
+d = os.path.expanduser('~/wiflow-std-bench/preprocessed_csi_data')
+dataset = PreprocessedCSIKeypointsDataset(data_dir=d, keypoint_scale=1000.0,
+                                          enable_temporal_clean=True)
+_, _, test_loader = create_preprocessed_train_val_test_loaders(
+    dataset=dataset, batch_size=256, num_workers=2, random_seed=42)
+
+device = torch.device('cuda')
+ckpt = find_checkpoint()
+print('checkpoint:', ckpt)
+model = WiFlowPoseModel(dropout=0.5).to(device)
+state = torch.load(ckpt, map_location=device, weights_only=True)
+renames = {'att.': 'attention.', 'final_conv.': 'decoder.'}
+state = {next((new + k[len(old):] for old, new in renames.items()
+               if k.startswith(old)), k): v for k, v in state.items()}
+model.load_state_dict(state, strict=True)
+
+results = {'checkpoint': ckpt}
+print('=== full test set ===')
+results['test_full'] = evaluate(model, test_loader, device)
+print(json.dumps(results['test_full'], indent=2))
+
+# NaN-free subset: exclude windows from corrupted files 487-499
+test_subset = test_loader.dataset            # Subset(dataset, test_indices)
+w2f = dataset.window_to_file
+clean_idx = [i for i in test_subset.indices if w2f[i] < 487]
+print(f'=== NaN-free test subset ({len(clean_idx)} of {len(test_subset.indices)}) ===')
+clean_loader = DataLoader(Subset(dataset, clean_idx), batch_size=256, shuffle=False)
+results['test_clean'] = evaluate(model, clean_loader, device)
+print(json.dumps(results['test_clean'], indent=2))
+
+out = os.path.expanduser('~/wiflow-std-bench/eval_retrained.json')
+with open(out, 'w') as f:
+    json.dump(results, f, indent=2)
+print('wrote', out)

benchmarks/wiflow-std/remote/measb/train_measb.py

@@ -0,0 +1,374 @@
+"""ADR-152 SS2.2 measurement (b): WiFlow-STD fine-tuned on our fresh ESP32 paired dataset.
+
+Dataset: ~/wiflow-std-bench/paired-20260610.jsonl -- 2,046 paired windows collected
+2026-06-10 22:10-22:40 (ONE subject, ONE room, ONE ESP32 node, varied poses).
+Per record: csi = flat float32 list, csi_shape, kp = 17 COCO [x, y] normalized [0,1]
+camera coords, conf (MediaPipe mean confidence, all > 0.5 in this set), ts_start/ts_end.
+Aligner: scripts/align-ground-truth.js, non-overlapping 20-frame windows (~0.42 s each).
+
+Dataset findings (MEASURED on this file, 2026-06-10):
+  - csi_shape is HETEROGENEOUS, not uniformly [70, 20]: 1,347x [70,20], 284x [134,20],
+    243x [26,20], 130x [12,20], 42x [20,20]. The ESP32 stream emits mixed frame types
+    and the aligner stamps each window's subcarrier count from frame[0]
+    (extractCsiMatrix: nSc = window[0].subcarriers), zero-padding/truncating the rest.
+    Even native-70 windows contain ~20.4% internally zero-padded short frames
+    (subcarriers 40..69 all-zero for those frames).
+  - LAYOUT BUG: the aligner fills matrix[f * nSc + s] (frame-major) but declares
+    shape [nSc, nFrames]. The true layout is (frame, subcarrier); we reshape
+    (nFrames, nSc) and transpose. Confirmed by coherent per-frame zero-tails.
+  - Handling here (primary suite, "all2046"): every frame's subcarrier axis is
+    linearly resampled to 70 bins (np.interp over a normalized index domain;
+    identity for native-70 frames) so the pre-registered n=2,046 and split sizes
+    hold. Secondary suite ("native70") restricts to the 1,347 native [70,20]
+    windows (temporal 70/15/15 of those) as a homogeneity robustness check.
+
+Pre-registered protocol (followed exactly):
+  1. TEMPORAL split (records are time-sorted; asserted): first 70% train (1,432),
+     next 15% val (307), last 15% test (307). No shuffling across time. Seed 42
+     for everything else.
+  2. Model: upstream WiFlow-STD trunk (WiFlowPoseModel) with a learned 1x1 Conv1d
+     projection 70->540 prepended, and K=17 via the parameter-free adaptive pool
+     (AdaptiveAvgPool2d((17, 1)) instead of (15, 1)) -- pretrained weights load
+     for any K. CSI normalization: divide by the TRAIN-split 99th-percentile
+     amplitude, clip to [0, 1] (documented in output JSON).
+  3. Three runs, <=60 epochs, early-stop patience 8 on val MPJPE, batch 32,
+     AdamW, fp32 (no autocast):
+       (i)   pretrained-init: trunk init from upstream/test/best_pose_model.pth
+             (the measurement-(a) retrained checkpoint, ~96% PCK@20 on WiFlow data;
+             key remap att.->attention. / final_conv.->decoder. applied defensively
+             as in eval_repro.py -- a no-op for this checkpoint, which already uses
+             the new names). Discriminative lr: adapter 1e-4, trunk 1e-5.
+       (ii)  scratch: same architecture, random init, all params lr 1e-4.
+       (iii) frozen-trunk: pretrained trunk frozen (requires_grad=False AND held in
+             .eval() so BatchNorm running stats cannot drift -- pure transfer probe);
+             only the 70->540 adapter trains, lr 1e-4.
+  4. Metrics on the temporal TEST split: torso-normalized PCK@10/20/30/40/50 and
+     MPJPE. Upstream utils/metrics.py calculate_pck(use_torso_norm=True) hardcodes
+     NECK_IDX/PELVIS_IDX = 2, 12 -- a 15-keypoint convention that is WRONG for our
+     17 COCO keypoints (2 = right_eye, 12 = right_hip). We therefore reimplement the
+     identical math (per-frame norm distance, clamp min 0.01, mean over all
+     keypoints x frames) with torso = ||l_shoulder(5) - l_hip(11)||.
+     Also reported: prediction std across test frames (constant-pose detector;
+     must be > 0) and the mean-pose-predictor baseline (train-split mean pose
+     evaluated on test -- the honesty bar).
+
+Usage (on ruvultra):
+  nice -n 10 nohup ~/wiflow-std-bench/venv/bin/python train_measb.py > train_measb.log 2>&1 &
+
+NOTE: deployed to ruvultra as a standalone single file, so it deliberately
+inlines its helpers. The reference implementations (upstream import shim,
+np.load mmap patch, key-remap loader, canonical evaluate loop) live in
+benchmarks/wiflow-std/_bench_common.py — keep copies in sync.
+"""
+
+import json
+import os
+import random
+import sys
+import time
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+BENCH = os.path.expanduser("~/wiflow-std-bench")
+UPSTREAM = os.path.join(BENCH, "upstream")
+MEASB = os.path.join(BENCH, "measb")
+DATA = os.path.join(BENCH, "paired-20260610.jsonl")
+CHECKPOINT = os.path.join(UPSTREAM, "test", "best_pose_model.pth")
+
+sys.path.insert(0, UPSTREAM)
+
+# Upstream defect (1): models/__init__.py imports a name tcn.py does not define.
+# Register a stub package so the broken __init__ never executes (as eval_repro.py).
+import types  # noqa: E402
+
+_models_pkg = types.ModuleType("models")
+_models_pkg.__path__ = [os.path.join(UPSTREAM, "models")]
+sys.modules["models"] = _models_pkg
+
+from models.pose_model import WiFlowPoseModel  # noqa: E402
+
+SEED = 42
+K = 17
+N_SUBC = 70
+TRUNK_IN = 540
+BATCH = 32          # <= 64 per protocol (GPU shared with the efficiency sweep)
+MAX_EPOCHS = 60
+PATIENCE = 8
+LR_ADAPTER = 1e-4
+LR_TRUNK_FT = 1e-5  # 10x lower for the pretrained trunk vs the fresh adapter
+L_SHOULDER, L_HIP = 5, 11
+THRESHOLDS = (0.1, 0.2, 0.3, 0.4, 0.5)
+
+
+def set_seed(seed=SEED):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def resample_subcarriers(frame_major, n_out=N_SUBC):
+    """(nFrames, nSc) -> (nFrames, n_out) by per-frame linear interpolation.
+
+    Identity for nSc == n_out. Normalized index domain [0, 1] on both sides.
+    """
+    nf, nsc = frame_major.shape
+    if nsc == n_out:
+        return frame_major
+    xi = np.linspace(0.0, 1.0, nsc)
+    xo = np.linspace(0.0, 1.0, n_out)
+    return np.stack([np.interp(xo, xi, frame_major[f]) for f in range(nf)]).astype(np.float32)
+
+
+def load_dataset():
+    csi, kps, confs, ts, native70 = [], [], [], [], []
+    shape_counts = {}
+    with open(DATA) as f:
+        for line in f:
+            r = json.loads(line)
+            nsc, nf = r["csi_shape"]
+            shape_counts[f"{nsc}x{nf}"] = shape_counts.get(f"{nsc}x{nf}", 0) + 1
+            assert nf == 20, r["csi_shape"]
+            # Aligner layout bug: data is frame-major despite the declared
+            # [nSc, nFrames] shape -- reshape (nFrames, nSc), then resample the
+            # subcarrier axis to 70 and transpose to (70 subcarriers, 20 frames).
+            fm = np.asarray(r["csi"], dtype=np.float32).reshape(nf, nsc)
+            csi.append(resample_subcarriers(fm).T)
+            kp = np.asarray(r["kp"], dtype=np.float32)
+            assert kp.shape == (K, 2), kp.shape
+            kps.append(kp)
+            confs.append(r["conf"])
+            ts.append(r["ts_start"])
+            native70.append(nsc == N_SUBC)
+    assert all(ts[i] <= ts[i + 1] for i in range(len(ts) - 1)), "records not time-sorted"
+    return (np.stack(csi), np.stack(kps), np.asarray(confs, dtype=np.float32),
+            np.asarray(native70), shape_counts, ts[0], ts[-1])
+
+
+def temporal_split(n):
+    n_train = int(round(n * 0.70))
+    n_val = int(round(n * 0.15))
+    return slice(0, n_train), slice(n_train, n_train + n_val), slice(n_train + n_val, n)
+
+
+class AdaptedWiFlow(nn.Module):
+    """1x1 Conv1d adapter 70->540 + upstream WiFlow-STD trunk with K=17 pool head."""
+
+    def __init__(self, k=K, dropout=0.5):
+        super().__init__()
+        self.adapter = nn.Conv1d(N_SUBC, TRUNK_IN, kernel_size=1)
+        nn.init.kaiming_normal_(self.adapter.weight, mode="fan_out", nonlinearity="relu")
+        nn.init.constant_(self.adapter.bias, 0)
+        self.trunk = WiFlowPoseModel(dropout=dropout)
+        # K=17 via the parameter-free adaptive pool: decoder emits [B, 2, 15, 20]
+        # spatial maps; pooling H->17 instead of 15 yields [B, 17, 2] with no new
+        # parameters, so the pretrained state_dict loads strict=True for any K.
+        self.trunk.avg_pool = nn.AdaptiveAvgPool2d((k, 1))
+
+    def forward(self, x):
+        return self.trunk(self.adapter(x))
+
+
+def load_pretrained_trunk(trunk, path):
+    state = torch.load(path, map_location="cpu", weights_only=True)
+    # Defensive remap as in eval_repro.py (no-op for the retrained checkpoint).
+    renames = {"att.": "attention.", "final_conv.": "decoder."}
+    state = {next((new + k[len(old):] for old, new in renames.items()
+                   if k.startswith(old)), k): v
+             for k, v in state.items()}
+    trunk.load_state_dict(state, strict=True)
+
+
+def pck_torso(pred, target, thresholds=THRESHOLDS):
+    """Upstream calculate_pck math, torso = l_shoulder(5)<->l_hip(11) for 17-kp COCO."""
+    norm = torch.sqrt(((target[:, L_SHOULDER] - target[:, L_HIP]) ** 2).sum(dim=1))
+    norm = torch.clamp(norm, min=0.01)
+    dist = torch.sqrt(((pred - target) ** 2).sum(dim=2)) / norm.unsqueeze(1)
+    return {f"pck@{int(t * 100)}": (dist <= t).float().mean().item() for t in thresholds}
+
+
+def mpjpe(pred, target):
+    return torch.sqrt(((pred - target) ** 2).sum(dim=2)).mean().item()
+
+
+@torch.no_grad()
+def predict(model, x, batch=256):
+    model.eval()
+    return torch.cat([model(x[i:i + batch]) for i in range(0, len(x), batch)])
+
+
+def eval_preds(pred, target):
+    out = pck_torso(pred, target)
+    out["mpjpe"] = mpjpe(pred, target)
+    # Constant-pose detector: std across test frames per coordinate, mean over
+    # the 17x2 coordinates. 0.0 == degenerate constant predictor.
+    out["pred_std"] = pred.std(dim=0).mean().item()
+    return out
+
+
+def train_run(name, x_tr, y_tr, x_va, y_va, device, pretrained, freeze_trunk,
+              lr_trunk):
+    set_seed(SEED)
+    model = AdaptedWiFlow().to(device)
+    if pretrained:
+        load_pretrained_trunk(model.trunk, CHECKPOINT)
+    if freeze_trunk:
+        for p in model.trunk.parameters():
+            p.requires_grad = False
+        groups = [{"params": model.adapter.parameters(), "lr": LR_ADAPTER}]
+    else:
+        groups = [{"params": model.adapter.parameters(), "lr": LR_ADAPTER},
+                  {"params": model.trunk.parameters(), "lr": lr_trunk}]
+    opt = torch.optim.AdamW(groups)
+    loss_fn = nn.MSELoss()
+
+    n = len(x_tr)
+    best_val, best_state, best_epoch, bad = float("inf"), None, -1, 0
+    history = []
+    t0 = time.time()
+    for epoch in range(MAX_EPOCHS):
+        model.train()
+        if freeze_trunk:
+            model.trunk.eval()  # keep BatchNorm running stats fixed: pure transfer
+        perm = torch.randperm(n, device=device)
+        ep_loss = 0.0
+        for i in range(0, n, BATCH):
+            idx = perm[i:i + BATCH]
+            opt.zero_grad()
+            loss = loss_fn(model(x_tr[idx]), y_tr[idx])
+            loss.backward()
+            opt.step()
+            ep_loss += loss.item() * len(idx)
+        val_mpjpe = mpjpe(predict(model, x_va), y_va)
+        history.append({"epoch": epoch, "train_mse": ep_loss / n, "val_mpjpe": val_mpjpe})
+        marker = ""
+        if val_mpjpe < best_val:
+            best_val, best_epoch, bad = val_mpjpe, epoch, 0
+            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
+            marker = " *"
+        else:
+            bad += 1
+        print(f"[{name}] epoch {epoch:02d} train_mse {ep_loss / n:.6f} "
+              f"val_mpjpe {val_mpjpe:.5f}{marker}", flush=True)
+        if bad >= PATIENCE:
+            print(f"[{name}] early stop at epoch {epoch} (best {best_epoch})", flush=True)
+            break
+    model.load_state_dict(best_state)
+    torch.save(best_state, os.path.join(MEASB, f"{name}_best.pth"))
+    return model, {"best_epoch": best_epoch, "best_val_mpjpe": best_val,
+                   "epochs_run": len(history), "wall_seconds": round(time.time() - t0, 1),
+                   "history": history}
+
+
+def run_suite(tag, csi, kps, device):
+    """Temporal 70/15/15 split, mean-pose baseline, three training runs."""
+    n = len(csi)
+    tr, va, te = temporal_split(n)
+    print(f"=== suite {tag}: n={n} train={tr.stop} val={va.stop - va.start} "
+          f"test={te.stop - te.start} ===", flush=True)
+
+    # CSI normalization constant from TRAIN split only.
+    train_p99 = float(np.percentile(csi[tr], 99))
+    train_max = float(csi[tr].max())
+    print(f"[{tag}] train p99={train_p99:.3f} max={train_max:.3f} -> /p99, clip [0,1]",
+          flush=True)
+    csi_n = np.clip(csi / train_p99, 0.0, 1.0).astype(np.float32)
+
+    x = torch.from_numpy(csi_n).to(device)
+    y = torch.from_numpy(kps).to(device)
+    x_tr, y_tr = x[tr], y[tr]
+    x_va, y_va = x[va], y[va]
+    x_te, y_te = x[te], y[te]
+
+    suite = {
+        "n_windows": n,
+        "split": {"n_train": int(tr.stop), "n_val": int(va.stop - va.start),
+                  "n_test": int(te.stop - te.start)},
+        "csi_norm": {"method": "divide by train-split p99 amplitude, clip [0,1]",
+                     "train_p99": train_p99, "train_max": train_max},
+        "runs": {},
+    }
+
+    # Honesty bar: mean-pose predictor fit on TRAIN, evaluated on TEST.
+    mean_pose = y_tr.mean(dim=0, keepdim=True).expand(len(y_te), -1, -1)
+    suite["mean_pose_baseline"] = eval_preds(mean_pose, y_te)
+    suite["mean_pose_baseline"]["note"] = "train-split mean pose; pred_std 0 by construction"
+    print(f"[{tag}] mean-pose baseline:", json.dumps(suite["mean_pose_baseline"]),
+          flush=True)
+
+    configs = [
+        ("pretrained", dict(pretrained=True, freeze_trunk=False, lr_trunk=LR_TRUNK_FT)),
+        ("scratch", dict(pretrained=False, freeze_trunk=False, lr_trunk=LR_ADAPTER)),
+        ("frozen_trunk", dict(pretrained=True, freeze_trunk=True, lr_trunk=0.0)),
+    ]
+    for name, cfg in configs:
+        print(f"=== run: {tag}/{name} {cfg} ===", flush=True)
+        model, train_info = train_run(f"{tag}_{name}", x_tr, y_tr, x_va, y_va,
+                                      device, **cfg)
+        test_metrics = eval_preds(predict(model, x_te), y_te)
+        n_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+        suite["runs"][name] = {"config": cfg, "trainable_params": n_trainable,
+                               "train": {k: v for k, v in train_info.items()
+                                         if k != "history"},
+                               "history": train_info["history"],
+                               "test": test_metrics}
+        print(f"[{tag}/{name}] TEST:", json.dumps(test_metrics), flush=True)
+    return suite
+
+
+def main():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"device {device}, torch {torch.__version__}", flush=True)
+    set_seed(SEED)
+
+    csi, kps, confs, native70, shape_counts, ts_first, ts_last = load_dataset()
+    print(f"shape distribution: {shape_counts}", flush=True)
+
+    results = {
+        "protocol": {
+            "dataset": DATA, "n_windows": len(csi),
+            "ts_first": ts_first, "ts_last": ts_last,
+            "conf_mean": float(confs.mean()), "conf_min": float(confs.min()),
+            "csi_shape_distribution": shape_counts,
+            "csi_layout_note": "aligner stores frame-major data under a transposed "
+                               "[nSc, nFrames] shape label; corrected on load",
+            "csi_resample": "per-frame linear interp of subcarrier axis to 70 bins "
+                            "(identity for native-70 frames); native-70 windows still "
+                            "contain ~20.4% internally zero-padded short frames",
+            "split": "temporal 70/15/15 (no shuffle across time)",
+            "model": "1x1 Conv1d 70->540 adapter + WiFlowPoseModel trunk, "
+                     "AdaptiveAvgPool2d((17,1)) head (parameter-free K=17)",
+            "checkpoint": CHECKPOINT,
+            "checkpoint_note": "measurement-(a) retrained checkpoint (~96% PCK@20 on "
+                               "WiFlow data); att./final_conv. remap applied "
+                               "defensively (no-op, already new-style keys)",
+            "optimizer": f"AdamW, adapter lr {LR_ADAPTER}, fine-tuned trunk lr "
+                         f"{LR_TRUNK_FT} (10x lower), scratch all {LR_ADAPTER}",
+            "batch": BATCH, "max_epochs": MAX_EPOCHS, "patience": PATIENCE,
+            "precision": "fp32", "seed": SEED,
+            "pck": "torso-normalized, torso = ||l_shoulder(5) - l_hip(11)||, "
+                   "clamp min 0.01, mean over keypoints x frames "
+                   "(upstream math; upstream 2/12 indices are a 15-kp convention)",
+        },
+        # Primary: all 2,046 windows (pre-registered n), subcarrier axis resampled.
+        "all2046": None,
+        # Secondary robustness check: the 1,347 native [70,20] windows only.
+        "native70": None,
+    }
+
+    results["all2046"] = run_suite("all2046", csi, kps, device)
+    results["native70"] = run_suite("native70", csi[native70], kps[native70], device)
+
+    out = os.path.join(MEASB, "measurement_b.json")
+    with open(out, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"wrote {out}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/remote/setup_and_train.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+set -ex
+cd ~/wiflow-std-bench
+
+# 1. clone upstream at the pinned commit
+if [ ! -d upstream ]; then
+  git clone https://github.com/DY2434/WiFlow-WiFi-Pose-Estimation-with-Spatio-Temporal-Decoupling upstream
+fi
+cd upstream && git checkout 06899d294a0f44709d601a53e91dbf24759daefb && cd ..
+
+# 2. documented deviation: fix upstream import bug (TemporalConvNet does not exist)
+sed -i 's/from .tcn import TemporalConvNet/from .tcn import TemporalBlock/; s/'"'"'TemporalConvNet'"'"'/'"'"'TemporalBlock'"'"'/' upstream/models/__init__.py
+
+# 3. venv: torch cu128 (RTX 5080 = sm_120 needs >=2.7; their pin 2.3.1 predates Blackwell)
+if [ ! -d venv ]; then
+  python3 -m venv venv
+  ./venv/bin/pip install -q --upgrade pip
+  ./venv/bin/pip install -q torch --index-url https://download.pytorch.org/whl/cu128
+  ./venv/bin/pip install -q numpy pandas matplotlib seaborn scikit-learn opencv-python-headless scipy tqdm psutil kagglehub
+fi
+./venv/bin/python -c "import torch; print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))"
+
+# 4. dataset via kagglehub (anonymous, public dataset)
+DS=$(./venv/bin/python -c "import kagglehub; print(kagglehub.dataset_download('kaka2434/wiflow-dataset'))")
+echo "dataset at: $DS"
+
+# 5. run.py hardcodes ../preprocessed_csi_data relative to upstream/
+ln -sfn "$DS/preprocessed_csi_data" ~/wiflow-std-bench/preprocessed_csi_data
+
+# 6. train with upstream defaults (seed 42 set inside run.py)
+../venv/bin/python ../clean_nan.py 2>/dev/null || venv/bin/python clean_nan.py
+cd upstream
+../venv/bin/python run.py --gpu 0 --batch_size 64 --epochs 50 --output_dir ../train_output

benchmarks/wiflow-std/remote/sweep/model_compact.py

@@ -0,0 +1,332 @@
+"""Configurable compact variants of the WiFlow-STD pose model (ADR-152 efficiency sweep).
+
+This is a parameterized copy of upstream models/{pose_model,tcn,convnet,attention}.py
+(DY2434/WiFlow @ 06899d29, Apache-2.0). upstream/ is NOT modified. Deviations from
+upstream, all forced by shrinking channels and documented per variant in run_sweep.py:
+
+1. TCN grouped-conv groups: upstream hardcodes groups=20, which does not divide
+   the compact channel counts (e.g. 270, 135, 85). Rule here:
+   - groups_mode='gcd20': per-conv groups = gcd(channels, 20)  (== 20 wherever
+     upstream's choice is valid, incl. the 540-ch input conv; falls back to the
+     largest common divisor with 20 otherwise).
+   - groups_mode='depthwise': groups = channels (tiny variant only).
+2. Conv2d downsampling strides: upstream uses 4 stride-(1,2) blocks because
+   240/2^4 = 15 == n_keypoints. With smaller TCN output widths that would leave
+   <15 rows and AdaptiveAvgPool2d((15,1)) would duplicate rows across keypoints.
+   Rule: halve the width only while the result stays >= 15 (stride-2 blocks
+   first, stride-1 after). Full model: 240 -> 4 halvings = upstream exactly.
+3. input_pw_groups (tiny only): the dense 540->c pointwise + residual downsample
+   in TCN block 1 cost 2*540*c params (a ~117k floor that alone exceeds the
+   tiny <100k budget). tiny groups these two convs (groups=4; 4 | gcd(540, 68)).
+4. Decoder mid-channels: upstream 64->32; here c_last -> max(c_last // 2, 4).
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def tcn_groups(channels: int, mode: str) -> int:
+    if mode == 'depthwise':
+        return channels
+    if mode == 'gcd20':
+        return math.gcd(channels, 20)
+    raise ValueError(mode)
+
+
+# ---------------------------------------------------------------- TCN (copy of tcn.py)
+class Chomp1d(nn.Module):
+    def __init__(self, chomp_size):
+        super().__init__()
+        self.chomp_size = chomp_size
+
+    def forward(self, x):
+        return x[:, :, :-self.chomp_size].contiguous()
+
+
+class CompactGroupedTemporalBlock(nn.Module):
+    """Upstream InnerGroupedTemporalBlock with parameterized groups."""
+
+    def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation, padding,
+                 dropout=0.2, groups_mode='gcd20', pw_groups=1):
+        super().__init__()
+        g_in = tcn_groups(n_inputs, groups_mode)
+        g_out = tcn_groups(n_outputs, groups_mode)
+        self.groups = (g_in, g_out)
+        self.pw_groups = pw_groups
+
+        self.conv1_group = nn.Conv1d(n_inputs, n_inputs, kernel_size, stride=stride,
+                                     padding=padding, dilation=dilation,
+                                     groups=g_in, bias=False)
+        self.chomp1 = Chomp1d(padding) if padding > 0 else nn.Identity()
+        self.bn1_group = nn.BatchNorm1d(n_inputs)
+        self.relu1_group = nn.SiLU(inplace=True)
+
+        self.conv1_pw = nn.Conv1d(n_inputs, n_outputs, 1, groups=pw_groups, bias=False)
+        self.bn1_pw = nn.BatchNorm1d(n_outputs)
+        self.relu1_pw = nn.SiLU(inplace=True)
+        self.dropout1 = nn.Dropout(dropout)
+
+        self.conv2_group = nn.Conv1d(n_outputs, n_outputs, kernel_size, stride=1,
+                                     padding=padding, dilation=dilation,
+                                     groups=g_out, bias=False)
+        self.chomp2 = Chomp1d(padding) if padding > 0 else nn.Identity()
+        self.bn2_group = nn.BatchNorm1d(n_outputs)
+        self.relu2_group = nn.SiLU(inplace=True)
+
+        self.conv2_pw = nn.Conv1d(n_outputs, n_outputs, 1, bias=False)
+        self.bn2_pw = nn.BatchNorm1d(n_outputs)
+        self.relu2_pw = nn.SiLU(inplace=True)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.downsample = nn.Sequential(
+            nn.Conv1d(n_inputs, n_outputs, 1, groups=pw_groups, bias=False),
+            nn.BatchNorm1d(n_outputs)
+        ) if n_inputs != n_outputs else nn.Identity()
+
+    def forward(self, x):
+        res = self.downsample(x)
+        out = self.conv1_group(x)
+        out = self.chomp1(out)
+        out = self.bn1_group(out)
+        out = self.relu1_group(out)
+        out = self.conv1_pw(out)
+        out = self.bn1_pw(out)
+        out = self.relu1_pw(out)
+        out = self.dropout1(out)
+        out = self.conv2_group(out)
+        out = self.chomp2(out)
+        out = self.bn2_group(out)
+        out = self.relu2_group(out)
+        out = self.conv2_pw(out)
+        out = self.bn2_pw(out)
+        out = self.relu2_pw(out)
+        out = self.dropout2(out)
+        return F.silu(out + res)
+
+
+class CompactTemporalBlock(nn.Module):
+    def __init__(self, num_inputs, num_channels, kernel_size=3, dropout=0.2,
+                 groups_mode='gcd20', input_pw_groups=1):
+        super().__init__()
+        layers = []
+        for i, out_channels in enumerate(num_channels):
+            dilation_size = 2 ** i
+            in_channels = num_inputs if i == 0 else num_channels[i - 1]
+            layers.append(CompactGroupedTemporalBlock(
+                in_channels, out_channels, kernel_size, stride=1,
+                dilation=dilation_size, padding=(kernel_size - 1) * dilation_size,
+                dropout=dropout, groups_mode=groups_mode,
+                pw_groups=input_pw_groups if i == 0 else 1))
+        self.network = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.network(x)
+
+
+# ------------------------------------------------------- Conv2d path (copy of convnet.py)
+class AsymmetricConvBlock(nn.Module):
+    """Upstream block with parameterized width stride (upstream: always (1,2))."""
+
+    def __init__(self, in_channels, out_channels, dropout=0.3, stride_w=2):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=(1, 3),
+                      stride=(1, stride_w), padding=(0, 1)),
+            nn.BatchNorm2d(out_channels),
+            nn.SiLU(inplace=True),
+            nn.Dropout2d(dropout),
+            nn.Conv2d(out_channels, out_channels, kernel_size=(1, 3), padding=(0, 1)),
+            nn.BatchNorm2d(out_channels),
+            nn.SiLU(inplace=True),
+            nn.Dropout2d(dropout),
+            nn.Conv2d(out_channels, out_channels, kernel_size=(1, 3), padding=(0, 1)),
+            nn.BatchNorm2d(out_channels)
+        )
+        self.downsample = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=1,
+                      stride=(1, stride_w), bias=False),
+            nn.BatchNorm2d(out_channels)
+        )
+        self.activation = nn.SiLU(inplace=True)
+
+    def forward(self, x):
+        return self.activation(self.block(x) + self.downsample(x))
+
+
+class ConvBlock1(nn.Module):
+    def __init__(self, in_channels, out_channels, dropout=0.3):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=(1, 3), padding=(0, 1)),
+            nn.BatchNorm2d(out_channels),
+            nn.SiLU(inplace=True),
+            nn.Dropout2d(dropout),
+            nn.Conv2d(out_channels, out_channels, kernel_size=(1, 3), padding=(0, 1)),
+            nn.BatchNorm2d(out_channels),
+            nn.SiLU(inplace=True),
+            nn.Dropout2d(dropout),
+            nn.Conv2d(out_channels, out_channels, kernel_size=(1, 3), padding=(0, 1)),
+            nn.BatchNorm2d(out_channels)
+        )
+        self.downsample = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
+            nn.BatchNorm2d(out_channels)
+        )
+        self.activation = nn.SiLU(inplace=True)
+
+    def forward(self, x):
+        return self.activation(self.block(x) + self.downsample(x))
+
+
+# ----------------------------------------------------- attention (verbatim attention.py)
+class AxialAttention(nn.Module):
+    def __init__(self, in_planes, out_planes, groups=8, stride=1, bias=False, width=False):
+        assert (in_planes % groups == 0) and (out_planes % groups == 0)
+        super().__init__()
+        self.in_planes = in_planes
+        self.out_planes = out_planes
+        self.groups = groups
+        self.group_planes = out_planes // groups
+        self.stride = stride
+        self.bias = bias
+        self.width = width
+        self.qkv_transform = nn.Conv1d(in_planes, out_planes * 3, kernel_size=1,
+                                       stride=1, padding=0, bias=False)
+        self.bn_qkv = nn.BatchNorm1d(out_planes * 3)
+        self.bn_similarity = nn.BatchNorm2d(groups)
+        self.bn_output = nn.BatchNorm1d(out_planes)
+        if stride > 1:
+            self.pooling = nn.AvgPool2d(stride, stride=stride)
+        nn.init.normal_(self.qkv_transform.weight.data, 0, math.sqrt(1. / self.in_planes))
+
+    def forward(self, x):
+        if self.width:
+            x = x.permute(0, 2, 1, 3)
+        else:
+            x = x.permute(0, 3, 1, 2)
+        N, W, C, H = x.shape
+        x = x.contiguous().view(N * W, C, H)
+        qkv = self.bn_qkv(self.qkv_transform(x))
+        qkv = qkv.reshape(N * W, 3, self.out_planes, H).permute(1, 0, 2, 3)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        q = q.reshape(N * W, self.groups, self.group_planes, H)
+        k = k.reshape(N * W, self.groups, self.group_planes, H)
+        v = v.reshape(N * W, self.groups, self.group_planes, H)
+        qk = torch.einsum('bgci, bgcj->bgij', q, k)
+        qk = self.bn_similarity(qk)
+        similarity = F.softmax(qk, dim=-1)
+        sv = torch.einsum('bgij,bgcj->bgci', similarity, v)
+        sv = sv.reshape(N * W, self.out_planes, H)
+        out = self.bn_output(sv)
+        out = out.view(N, W, self.out_planes, H)
+        if self.width:
+            out = out.permute(0, 2, 1, 3)
+        else:
+            out = out.permute(0, 2, 3, 1)
+        if self.stride > 1:
+            out = self.pooling(out)
+        return out
+
+
+class DualAxialAttention(nn.Module):
+    def __init__(self, in_planes, out_planes, groups=8, stride=1, bias=False):
+        super().__init__()
+        self.width_axis = AxialAttention(in_planes, out_planes, groups, stride, bias, width=True)
+        self.height_axis = AxialAttention(out_planes, out_planes, groups, stride, bias, width=False)
+
+    def forward(self, x):
+        return self.height_axis(self.width_axis(x))
+
+
+# --------------------------------------------------------------- full model
+def compute_strides(width: int, n_blocks: int, target: int = 15):
+    """Halve width while result stays >= target (upstream: 240 -> 4 halvings -> 15)."""
+    strides = []
+    for _ in range(n_blocks):
+        nxt = (width + 1) // 2  # conv k=3 s=2 p=1: out = ceil(in/2)
+        if nxt >= target:
+            strides.append(2)
+            width = nxt
+        else:
+            strides.append(1)
+    return strides, width
+
+
+class CompactWiFlowPoseModel(nn.Module):
+    """Parameterized upstream WiFlowPoseModel.
+
+    Upstream config == tcn_channels=[540,440,340,240], conv_channels=[8,16,32,64],
+    attn_groups=8, groups_mode='gcd20' (gcd(c,20)==20 for all upstream channels),
+    input_pw_groups=1 -> identical architecture, 2,225,042 params.
+    """
+
+    def __init__(self, tcn_channels, conv_channels, attn_groups,
+                 groups_mode='gcd20', input_pw_groups=1, dropout=0.3,
+                 num_subcarriers=540, num_keypoints=15):
+        super().__init__()
+        self.tcn = CompactTemporalBlock(
+            num_inputs=num_subcarriers, num_channels=tcn_channels, kernel_size=3,
+            dropout=dropout, groups_mode=groups_mode, input_pw_groups=input_pw_groups)
+
+        self.up = ConvBlock1(1, conv_channels[0])
+
+        strides, self.final_width = compute_strides(
+            tcn_channels[-1], len(conv_channels), target=num_keypoints)
+        self.conv_strides = strides
+        self.residual_blocks = nn.ModuleList()
+        in_channels = conv_channels[0]
+        for out_channels, s in zip(conv_channels, strides):
+            self.residual_blocks.append(
+                AsymmetricConvBlock(in_channels, out_channels, stride_w=s))
+            in_channels = out_channels
+
+        c_last = conv_channels[-1]
+        self.attention = DualAxialAttention(c_last, c_last, groups=attn_groups)
+
+        c_mid = max(c_last // 2, 4)
+        self.decoder = nn.Sequential(
+            nn.Conv2d(c_last, c_mid, kernel_size=3, padding=1),
+            nn.BatchNorm2d(c_mid),
+            nn.SiLU(inplace=True),
+            nn.Conv2d(c_mid, 2, kernel_size=1),
+            nn.BatchNorm2d(2),
+            nn.SiLU(inplace=True)
+        )
+        self.avg_pool = nn.AdaptiveAvgPool2d((num_keypoints, 1))
+        self._initialize_weights()
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv1d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, (nn.BatchNorm1d, nn.LayerNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def forward(self, x):
+        # [B, 540, 20]
+        x = self.tcn(x)                          # [B, C_tcn, 20]
+        x = x.transpose(1, 2).unsqueeze(1)       # [B, 1, 20, C_tcn]
+        x = self.up(x)
+        for block in self.residual_blocks:
+            x = block(x)                         # [B, C_conv, 20, W']
+        x = x.permute(0, 1, 3, 2)                # [B, C_conv, W', 20]
+        x = self.attention(x)
+        x = self.decoder(x)                      # [B, 2, W', 20]
+        x = self.avg_pool(x).squeeze(-1)         # [B, 2, 15]
+        return x.transpose(1, 2)                 # [B, 15, 2]
+
+
+def describe(model: 'CompactWiFlowPoseModel'):
+    params = sum(p.numel() for p in model.parameters())
+    tcn_g = [blk.groups for blk in model.tcn.network]
+    return {'params': params, 'tcn_groups_per_block': tcn_g,
+            'conv_strides': model.conv_strides, 'final_width': model.final_width}

benchmarks/wiflow-std/remote/sweep/run_sweep.py

@@ -0,0 +1,278 @@
+"""WiFlow-STD compact-variant efficiency sweep (ADR-152) — sequential overnight runner.
+
+Trains compact variants of the upstream WiFlow-STD architecture on the same
+data/split as the full-size reference retraining (seed 42, file-level 70/15/15,
+upstream dataset.py) and evaluates PCK@10..50 + MPJPE on the full test split and
+the corruption-free test subset (file indices < 487).
+
+Training mirrors upstream run.py/train.py defaults except:
+- fp32 only (no fp16 autocast / GradScaler — avoids the BN-poisoning trap
+  documented in RESULTS.md defect 5; data on disk is already cleaned).
+- batch 64 (kept modest: another GPU job may share the 16 GB card tonight).
+- scheduler + early stopping keyed on val MPJPE (upstream early-stops on val MPE
+  with patience 5; same here).
+
+Usage:
+  venv/bin/python sweep/run_sweep.py --dry-run    # param counts only
+  nohup venv/bin/python sweep/run_sweep.py > sweep/sweep.log 2>&1 &
+
+Idempotent: variants already present in sweep/results.jsonl are skipped.
+
+NOTE: deployed to ruvultra (~/wiflow-std-bench/sweep) as a standalone file, so
+it deliberately inlines its helpers. The reference implementations (upstream
+import shim, >1GB np.load mmap patch, key-remap loader, canonical evaluate
+loop) live in benchmarks/wiflow-std/_bench_common.py — keep copies in sync.
+"""
+import argparse
+import copy
+import json
+import os
+import random
+import sys
+import time
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Subset
+
+# csi_windows.npy is ~13 GB; mmap large arrays instead of eagerly loading
+# ~15 GB into RAM (same patch as _bench_common._np_load_mmap).
+_np_load = np.load
+
+
+def _np_load_mmap(path, *a, **kw):
+    if (isinstance(path, str) and path.endswith('.npy')
+            and os.path.getsize(path) > 1 << 30 and 'mmap_mode' not in kw):
+        kw['mmap_mode'] = 'r'
+    return _np_load(path, *a, **kw)
+
+
+np.load = _np_load_mmap
+
+BENCH = os.path.expanduser('~/wiflow-std-bench')
+SWEEP = os.path.join(BENCH, 'sweep')
+sys.path.insert(0, os.path.join(BENCH, 'upstream'))
+sys.path.insert(0, SWEEP)
+
+from dataset import PreprocessedCSIKeypointsDataset, create_preprocessed_train_val_test_loaders  # noqa: E402
+from losses.pose_loss import PoseLoss          # noqa: E402
+from utils.metrics import calculate_pck, calculate_mpjpe  # noqa: E402
+from model_compact import CompactWiFlowPoseModel, describe  # noqa: E402
+
+VARIANTS = [
+    # name, tcn_channels, conv_channels, attn_groups, groups_mode, input_pw_groups
+    dict(name='half',    tcn=[270, 220, 170, 120], conv=[4, 8, 16, 32], attn_groups=4,
+         groups_mode='gcd20', input_pw_groups=1),
+    dict(name='quarter', tcn=[135, 110, 85, 60],   conv=[2, 4, 8, 16],  attn_groups=2,
+         groups_mode='gcd20', input_pw_groups=1),
+    dict(name='tiny',    tcn=[68, 56, 44, 32],     conv=[2, 4, 8, 16],  attn_groups=2,
+         groups_mode='depthwise', input_pw_groups=4),
+]
+
+BATCH = 64
+EPOCHS = 50
+PATIENCE = 5
+LR = 1e-4
+WEIGHT_DECAY = 5e-5
+SEED = 42
+CORRUPT_FILE_START = 487  # files 487-499 were zero-filled by clean_nan.py
+
+
+def set_seed(seed=SEED):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def build_model(v, dropout=0.5):
+    return CompactWiFlowPoseModel(
+        tcn_channels=v['tcn'], conv_channels=v['conv'], attn_groups=v['attn_groups'],
+        groups_mode=v['groups_mode'], input_pw_groups=v['input_pw_groups'],
+        dropout=dropout)
+
+
+@torch.no_grad()
+def evaluate(model, loader, device):
+    model.eval()
+    totals = {t: 0.0 for t in (0.1, 0.2, 0.3, 0.4, 0.5)}
+    total_mpe, n = 0.0, 0
+    for bx, by in loader:
+        bx, by = bx.to(device), by.to(device)
+        out = model(bx)
+        bs = by.size(0)
+        total_mpe += calculate_mpjpe(out, by) * bs
+        pck = calculate_pck(out, by, thresholds=list(totals))
+        for t in totals:
+            totals[t] += pck[t] * bs
+        n += bs
+    return {'samples': n, 'mpjpe': total_mpe / n,
+            **{f'pck@{int(t * 100)}': totals[t] / n for t in totals}}
+
+
+def train_variant(v, dataset, device):
+    set_seed(SEED)
+    train_loader, val_loader, test_loader = create_preprocessed_train_val_test_loaders(
+        dataset=dataset, batch_size=BATCH, num_workers=2, random_seed=SEED)
+
+    set_seed(SEED)  # re-seed after split so init is split-independent
+    model = build_model(v).to(device)
+    info = describe(model)
+    print(f"[{v['name']}] params={info['params']:,} tcn_groups={info['tcn_groups_per_block']} "
+          f"conv_strides={info['conv_strides']} final_width={info['final_width']}", flush=True)
+
+    criterion = PoseLoss(position_weight=1.0, bone_weight=0.2, loss_type='smooth_l1')
+    optimizer = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=WEIGHT_DECAY,
+                                  betas=(0.9, 0.999))
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+        optimizer, mode='min', factor=0.5, patience=3, min_lr=LR / 1000,
+        cooldown=1, threshold=1e-4)
+
+    best_val_mpe = float('inf')
+    best_val_pck20 = 0.0
+    best_epoch = 0
+    best_state = None
+    patience_counter = 0
+    t0 = time.time()
+    error = None
+    epochs_run = 0
+
+    for epoch in range(1, EPOCHS + 1):
+        model.train()
+        ep_loss, nb = 0.0, 0
+        te = time.time()
+        for i, (bx, by) in enumerate(train_loader):
+            bx = bx.to(device, non_blocking=True)
+            by = by.to(device, non_blocking=True)
+            optimizer.zero_grad(set_to_none=True)
+            out = model(bx)
+            loss, _parts = criterion(out, by)
+            if not torch.isfinite(loss):
+                error = f'non-finite loss at epoch {epoch} step {i}'
+                break
+            loss.backward()
+            optimizer.step()
+            ep_loss += loss.item()
+            nb += 1
+            if epoch == 1 and i % 500 == 0:
+                print(f"[{v['name']}] e1 step {i}/{len(train_loader)} loss={loss.item():.5f}",
+                      flush=True)
+        if error:
+            break
+        epochs_run = epoch
+
+        val = evaluate(model, val_loader, device)
+        scheduler.step(val['mpjpe'])
+        lr_now = optimizer.param_groups[0]['lr']
+        print(f"[{v['name']}] epoch {epoch}/{EPOCHS} train_loss={ep_loss / max(nb, 1):.5f} "
+              f"val_mpjpe={val['mpjpe']:.5f} val_pck20={val['pck@20'] * 100:.2f}% "
+              f"lr={lr_now:.2e} ({time.time() - te:.0f}s)", flush=True)
+
+        if val['mpjpe'] < best_val_mpe:
+            best_val_mpe = val['mpjpe']
+            best_val_pck20 = val['pck@20']
+            best_epoch = epoch
+            best_state = copy.deepcopy(model.state_dict())
+            patience_counter = 0
+        else:
+            patience_counter += 1
+            if patience_counter >= PATIENCE:
+                print(f"[{v['name']}] early stop at epoch {epoch} (best {best_epoch})", flush=True)
+                break
+
+    train_seconds = time.time() - t0
+    result = {
+        'variant': v['name'], 'params': info['params'],
+        'tcn_channels': v['tcn'], 'conv_channels': v['conv'],
+        'attn_groups': v['attn_groups'], 'groups_mode': v['groups_mode'],
+        'input_pw_groups': v['input_pw_groups'],
+        'tcn_groups_per_block': info['tcn_groups_per_block'],
+        'conv_strides': info['conv_strides'], 'final_width': info['final_width'],
+        'batch_size': BATCH, 'max_epochs': EPOCHS, 'patience': PATIENCE,
+        'lr': LR, 'weight_decay': WEIGHT_DECAY, 'seed': SEED, 'precision': 'fp32',
+        'epochs_run': epochs_run, 'best_epoch': best_epoch,
+        'best_val_mpjpe': best_val_mpe if best_state else None,
+        'best_val_pck20': best_val_pck20 if best_state else None,
+        'train_seconds': round(train_seconds, 1),
+        'torch': torch.__version__, 'error': error,
+        'finished_utc': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+    }
+
+    if best_state is not None:
+        ckpt = os.path.join(SWEEP, f"{v['name']}_best.pth")
+        torch.save(best_state, ckpt)
+        result['checkpoint'] = ckpt
+        model.load_state_dict(best_state)
+
+        eval_loader = DataLoader(test_loader.dataset, batch_size=256, shuffle=False,
+                                 num_workers=2)
+        result['test_full'] = evaluate(model, eval_loader, device)
+
+        w2f = dataset.window_to_file
+        clean_idx = [i for i in test_loader.dataset.indices if w2f[i] < CORRUPT_FILE_START]
+        clean_loader = DataLoader(Subset(dataset, clean_idx), batch_size=256,
+                                  shuffle=False, num_workers=2)
+        result['test_clean'] = evaluate(model, clean_loader, device)
+        print(f"[{v['name']}] TEST clean: pck20={result['test_clean']['pck@20'] * 100:.2f}% "
+              f"mpjpe={result['test_clean']['mpjpe']:.5f} | full: "
+              f"pck20={result['test_full']['pck@20'] * 100:.2f}%", flush=True)
+    return result
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--dry-run', action='store_true', help='print param counts and exit')
+    args = ap.parse_args()
+
+    if args.dry_run:
+        for v in VARIANTS:
+            m = build_model(v)
+            info = describe(m)
+            x = torch.randn(2, 540, 20)
+            m.eval()
+            y = m(x)
+            print(f"{v['name']:8s} params={info['params']:>9,} "
+                  f"tcn={v['tcn']} conv={v['conv']} attn_g={v['attn_groups']} "
+                  f"mode={v['groups_mode']} pw_g={v['input_pw_groups']} "
+                  f"tcn_groups={info['tcn_groups_per_block']} strides={info['conv_strides']} "
+                  f"W'={info['final_width']} out={tuple(y.shape)}")
+        return
+
+    results_path = os.path.join(SWEEP, 'results.jsonl')
+    done = set()
+    if os.path.exists(results_path):
+        with open(results_path) as f:
+            for line in f:
+                try:
+                    done.add(json.loads(line)['variant'])
+                except Exception:
+                    pass
+
+    device = torch.device('cuda')
+    print(f"torch {torch.__version__} on {torch.cuda.get_device_name(0)}", flush=True)
+    data_dir = os.path.join(BENCH, 'preprocessed_csi_data')
+    dataset = PreprocessedCSIKeypointsDataset(data_dir=data_dir, keypoint_scale=1000.0,
+                                              enable_temporal_clean=True)
+
+    for v in VARIANTS:
+        if v['name'] in done:
+            print(f"[{v['name']}] already in results.jsonl — skipping", flush=True)
+            continue
+        print(f"\n===== variant: {v['name']} =====", flush=True)
+        try:
+            result = train_variant(v, dataset, device)
+        except Exception as e:  # record and move on to next variant
+            import traceback
+            traceback.print_exc()
+            result = {'variant': v['name'], 'error': repr(e),
+                      'finished_utc': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}
+        with open(results_path, 'a') as f:
+            f.write(json.dumps(result) + '\n')
+            f.flush()
+    print('\nSWEEP COMPLETE', flush=True)
+
+
+if __name__ == '__main__':
+    main()

benchmarks/wiflow-std/results/edge_optimization.json

@@ -0,0 +1,772 @@
+{
+  "torch": {
+    "env": {
+      "torch": "2.12.0+cpu",
+      "platform": "Windows-11-10.0.26200-SP0",
+      "processor": "Intel64 Family 6 Model 197 Stepping 2, GenuineIntel",
+      "num_threads": 16,
+      "checkpoint": "results\\retrained_best_pose_model.pth",
+      "params": 2225042
+    },
+    "variants": {
+      "fp32": {
+        "file": "retrained_fp32_resaved.pth",
+        "size_bytes": 9068948,
+        "size_mb": 9.068948,
+        "latency_batch1": {
+          "batch_size": 1,
+          "runs": 100,
+          "median_ms_per_batch": 24.903650000851485,
+          "median_ms_per_window": 24.903650000851485,
+          "windows_per_second": 40.15475642991324
+        },
+        "latency_batch64": {
+          "batch_size": 64,
+          "runs": 30,
+          "median_ms_per_batch": 184.02919999789447,
+          "median_ms_per_window": 2.875456249967101,
+          "windows_per_second": 347.77089723115813
+        },
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9668200004577636,
+          "pck@50": 0.9915333324432373,
+          "mpjpe": 0.00936222033649683,
+          "wall_seconds": 37.85407733917236
+        }
+      },
+      "fp16": {
+        "file": "retrained_fp16.pth",
+        "size_bytes": 4580332,
+        "size_mb": 4.580332,
+        "latency_batch1": {
+          "batch_size": 1,
+          "runs": 100,
+          "median_ms_per_batch": 23.936699999467237,
+          "median_ms_per_window": 23.936699999467237,
+          "windows_per_second": 41.776853117691964
+        },
+        "latency_batch64": {
+          "batch_size": 64,
+          "runs": 30,
+          "median_ms_per_batch": 102.32584999903338,
+          "median_ms_per_window": 1.5988414062348966,
+          "windows_per_second": 625.4529036465817
+        },
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.966773332977295,
+          "pck@50": 0.9915066654205322,
+          "mpjpe": 0.009460017587244511,
+          "wall_seconds": 21.632277250289917
+        }
+      },
+      "int8_dynamic": {
+        "file": "retrained_int8_dynamic.pth",
+        "size_bytes": 9068948,
+        "size_mb": 9.068948,
+        "latency_batch1": {
+          "batch_size": 1,
+          "runs": 100,
+          "median_ms_per_batch": 18.105350000041653,
+          "median_ms_per_window": 18.105350000041653,
+          "windows_per_second": 55.23229321707117
+        },
+        "latency_batch64": {
+          "batch_size": 64,
+          "runs": 30,
+          "median_ms_per_batch": 168.77549999844632,
+          "median_ms_per_window": 2.6371171874757238,
+          "windows_per_second": 379.20195763359703
+        },
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9668200004577636,
+          "pck@50": 0.9915333324432373,
+          "mpjpe": 0.00936222033649683,
+          "wall_seconds": 45.35376596450806
+        }
+      }
+    },
+    "int8_dynamic_quant_report": {
+      "eligible_module_counts": {
+        "nn.Linear": 0,
+        "nn.Conv1d": 21,
+        "nn.Conv2d": 22
+      },
+      "modules_actually_quantized": [],
+      "n_modules_quantized": 0,
+      "params_total": 2225042,
+      "params_quantized": 0,
+      "params_quantized_fraction": 0.0
+    },
+    "accuracy_subset": {
+      "description": "seed-42 file-level 70/15/15 test split, corrupted windows (files 487-499) excluded, seed-42 random subset",
+      "subset_size": 10000,
+      "clean_test_total": 10000
+    }
+  },
+  "onnx": {
+    "env": {
+      "torch": "2.12.0+cpu",
+      "onnxruntime": "1.26.0",
+      "platform": "Windows-11-10.0.26200-SP0"
+    },
+    "export": {
+      "mode": "dynamic-batch",
+      "exporter": "torchscript",
+      "file": "retrained_fp32_dynamic.onnx",
+      "size_mb": 8.971781
+    },
+    "parity": {
+      "fixture": "results/parity_fixture.npz (batch 2, seed 42)",
+      "max_abs_diff_vs_stored_fixture": 2.384185791015625e-07,
+      "max_abs_diff_vs_torch_now": 2.384185791015625e-07,
+      "pass_lt_1e-4": true
+    },
+    "latency": {
+      "batch1": {
+        "batch_size": 1,
+        "runs": 100,
+        "median_ms_per_batch": 2.5410999987798277,
+        "median_ms_per_window": 2.5410999987798277,
+        "windows_per_second": 393.5303610563043
+      },
+      "batch64": {
+        "batch_size": 64,
+        "runs": 30,
+        "median_ms_per_batch": 181.95204999938142,
+        "median_ms_per_window": 2.8430007812403346,
+        "windows_per_second": 351.7410218803118
+      }
+    },
+    "ort_int8_dynamic_supplementary": {
+      "file": "retrained_int8_ort_dynamic.onnx",
+      "size_mb": 2.438794,
+      "runs": true,
+      "max_abs_diff_vs_fp32_fixture": 0.00827130675315857
+    }
+  },
+  "onnx_accuracy": {
+    "onnx_fp32": {
+      "samples": 10000,
+      "pck@20": 0.9668200004577636,
+      "pck@50": 0.9915333324432373,
+      "mpjpe": 0.00936222568154335,
+      "wall_seconds": 22.34790802001953
+    },
+    "onnx_int8_ort_dynamic": {
+      "samples": 10000,
+      "pck@20": 0.965240001964569,
+      "pck@50": 0.9915466655731201,
+      "mpjpe": 0.01108054072111845,
+      "wall_seconds": 55.742953062057495
+    }
+  },
+  "latency_controlled_rerun": {
+    "note": "3 interleaved repetitions per variant, median ms/window; quiet box",
+    "fp32": {
+      "batch1_ms_per_window_median": 10.969150001983508,
+      "batch1_reps": [
+        10.969150001983508,
+        12.646450000829645,
+        10.49820000116597
+      ],
+      "batch64_ms_per_window_median": 2.2734187500077496,
+      "batch64_reps": [
+        2.377234374989712,
+        2.124126562478068,
+        2.2734187500077496
+      ]
+    },
+    "fp16": {
+      "batch1_ms_per_window_median": 24.313550000442774,
+      "batch1_reps": [
+        25.1078499986761,
+        21.856999999727122,
+        24.313550000442774
+      ],
+      "batch64_ms_per_window_median": 2.414695312495496,
+      "batch64_reps": [
+        2.5705156249955508,
+        1.7137437499741281,
+        2.414695312495496
+      ]
+    },
+    "int8_dynamic": {
+      "batch1_ms_per_window_median": 15.627150000000256,
+      "batch1_reps": [
+        17.67525000104797,
+        14.627999998992891,
+        15.627150000000256
+      ],
+      "batch64_ms_per_window_median": 2.0546906250160646,
+      "batch64_reps": [
+        2.0546906250160646,
+        2.03407343752815,
+        2.9325796875241394
+      ]
+    },
+    "onnx_fp32": {
+      "batch1_ms_per_window_median": 3.186650001225644,
+      "batch1_reps": [
+        2.7332500012562377,
+        3.1995500012271805,
+        3.186650001225644
+      ],
+      "batch64_ms_per_window_median": 1.9893374999924163,
+      "batch64_reps": [
+        1.5590843750032946,
+        1.9893374999924163,
+        2.2144343749914697
+      ]
+    },
+    "onnx_int8_ort_dynamic": {
+      "batch1_ms_per_window_median": 6.50984999811044,
+      "batch1_reps": [
+        6.50984999811044,
+        6.455249998907675,
+        6.789299999581999
+      ],
+      "batch64_ms_per_window_median": 5.770093750015803,
+      "batch64_reps": [
+        5.770093750015803,
+        3.912374999970325,
+        7.8067296875019565
+      ]
+    }
+  },
+  "onnx_static_ptq": {
+    "env": {
+      "onnxruntime": "1.26.0",
+      "torch": "2.12.0+cpu",
+      "platform": "Windows-11-10.0.26200-SP0",
+      "source_model": "retrained_fp32_dynamic.onnx",
+      "preprocessed_model": {
+        "file": "retrained_fp32_preproc.onnx",
+        "size_mb": 8.981529
+      }
+    },
+    "variants": {
+      "minmax_all": {
+        "file": "retrained_int8_static_minmax_all.onnx",
+        "size_bytes": 2604286,
+        "size_mb": 2.604286,
+        "calibration": {
+          "method": "minmax",
+          "windows": 1000,
+          "percentile": null,
+          "seconds": 5.052440166473389
+        },
+        "scope": "all",
+        "per_channel": true,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+        "node_counts": {
+          "Add": 9,
+          "AveragePool": 1,
+          "BatchNormalization": 12,
+          "Concat": 10,
+          "Conv": 43,
+          "DequantizeLinear": 283,
+          "Einsum": 4,
+          "Gather": 16,
+          "Mul": 39,
+          "QuantizeLinear": 181,
+          "Reshape": 14,
+          "Shape": 2,
+          "Sigmoid": 37,
+          "Slice": 8,
+          "Softmax": 2,
+          "Squeeze": 1,
+          "Transpose": 7,
+          "Unsqueeze": 11
+        },
+        "max_abs_diff_vs_fp32_fixture": 0.015945255756378174,
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9545266661643982,
+          "pck@50": 0.9913666645050049,
+          "mpjpe": 0.014860070134699345,
+          "wall_seconds": 43.455235958099365
+        }
+      },
+      "minmax_conv": {
+        "file": "retrained_int8_static_minmax_conv.onnx",
+        "size_bytes": 2527421,
+        "size_mb": 2.527421,
+        "calibration": {
+          "method": "minmax",
+          "windows": 1000,
+          "percentile": null,
+          "seconds": 4.380746126174927
+        },
+        "scope": "conv",
+        "per_channel": true,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+        "node_counts": {
+          "Add": 9,
+          "AveragePool": 1,
+          "BatchNormalization": 12,
+          "Concat": 10,
+          "Conv": 43,
+          "DequantizeLinear": 156,
+          "Einsum": 4,
+          "Gather": 16,
+          "Mul": 39,
+          "QuantizeLinear": 78,
+          "Reshape": 14,
+          "Shape": 2,
+          "Sigmoid": 37,
+          "Slice": 8,
+          "Softmax": 2,
+          "Squeeze": 1,
+          "Transpose": 7,
+          "Unsqueeze": 11
+        },
+        "max_abs_diff_vs_fp32_fixture": 0.010693132877349854,
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9663399996757507,
+          "pck@50": 0.9918666641235352,
+          "mpjpe": 0.01084446222037077,
+          "wall_seconds": 35.937947034835815
+        }
+      },
+      "entropy_all": {
+        "file": "retrained_int8_static_entropy_all.onnx",
+        "size_bytes": 2604268,
+        "size_mb": 2.604268,
+        "calibration": {
+          "method": "entropy",
+          "windows": 512,
+          "percentile": null,
+          "seconds": 23.835066318511963
+        },
+        "scope": "all",
+        "per_channel": true,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+        "node_counts": {
+          "Add": 9,
+          "AveragePool": 1,
+          "BatchNormalization": 12,
+          "Concat": 10,
+          "Conv": 43,
+          "DequantizeLinear": 283,
+          "Einsum": 4,
+          "Gather": 16,
+          "Mul": 39,
+          "QuantizeLinear": 181,
+          "Reshape": 14,
+          "Shape": 2,
+          "Sigmoid": 37,
+          "Slice": 8,
+          "Softmax": 2,
+          "Squeeze": 1,
+          "Transpose": 7,
+          "Unsqueeze": 11
+        },
+        "max_abs_diff_vs_fp32_fixture": 0.015280365943908691,
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9530466662406921,
+          "pck@50": 0.9912600006103516,
+          "mpjpe": 0.015098519864678382,
+          "wall_seconds": 51.514281034469604
+        }
+      },
+      "entropy_conv": {
+        "file": "retrained_int8_static_entropy_conv.onnx",
+        "size_bytes": 2527403,
+        "size_mb": 2.527403,
+        "calibration": {
+          "method": "entropy",
+          "windows": 512,
+          "percentile": null,
+          "seconds": 9.634419918060303
+        },
+        "scope": "conv",
+        "per_channel": true,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+        "node_counts": {
+          "Add": 9,
+          "AveragePool": 1,
+          "BatchNormalization": 12,
+          "Concat": 10,
+          "Conv": 43,
+          "DequantizeLinear": 156,
+          "Einsum": 4,
+          "Gather": 16,
+          "Mul": 39,
+          "QuantizeLinear": 78,
+          "Reshape": 14,
+          "Shape": 2,
+          "Sigmoid": 37,
+          "Slice": 8,
+          "Softmax": 2,
+          "Squeeze": 1,
+          "Transpose": 7,
+          "Unsqueeze": 11
+        },
+        "max_abs_diff_vs_fp32_fixture": 0.012535125017166138,
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9659599989891052,
+          "pck@50": 0.9918666648864746,
+          "mpjpe": 0.010778637571632861,
+          "wall_seconds": 41.01180171966553
+        }
+      },
+      "percentile_all": {
+        "file": "retrained_int8_static_percentile_all.onnx",
+        "size_bytes": 2604052,
+        "size_mb": 2.604052,
+        "calibration": {
+          "method": "percentile",
+          "windows": 512,
+          "percentile": 99.99,
+          "seconds": 20.221954584121704
+        },
+        "scope": "all",
+        "per_channel": true,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+        "node_counts": {
+          "Add": 9,
+          "AveragePool": 1,
+          "BatchNormalization": 12,
+          "Concat": 10,
+          "Conv": 43,
+          "DequantizeLinear": 283,
+          "Einsum": 4,
+          "Gather": 16,
+          "Mul": 39,
+          "QuantizeLinear": 181,
+          "Reshape": 14,
+          "Shape": 2,
+          "Sigmoid": 37,
+          "Slice": 8,
+          "Softmax": 2,
+          "Squeeze": 1,
+          "Transpose": 7,
+          "Unsqueeze": 11
+        },
+        "max_abs_diff_vs_fp32_fixture": 0.017689883708953857,
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9639333323478698,
+          "pck@50": 0.9916799991607667,
+          "mpjpe": 0.012176512064039708,
+          "wall_seconds": 49.365190744400024
+        }
+      },
+      "percentile_conv": {
+        "file": "retrained_int8_static_percentile_conv.onnx",
+        "size_bytes": 2527241,
+        "size_mb": 2.527241,
+        "calibration": {
+          "method": "percentile",
+          "windows": 512,
+          "percentile": 99.99,
+          "seconds": 8.223475694656372
+        },
+        "scope": "conv",
+        "per_channel": true,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+        "node_counts": {
+          "Add": 9,
+          "AveragePool": 1,
+          "BatchNormalization": 12,
+          "Concat": 10,
+          "Conv": 43,
+          "DequantizeLinear": 156,
+          "Einsum": 4,
+          "Gather": 16,
+          "Mul": 39,
+          "QuantizeLinear": 78,
+          "Reshape": 14,
+          "Shape": 2,
+          "Sigmoid": 37,
+          "Slice": 8,
+          "Softmax": 2,
+          "Squeeze": 1,
+          "Transpose": 7,
+          "Unsqueeze": 11
+        },
+        "max_abs_diff_vs_fp32_fixture": 0.014725983142852783,
+        "accuracy": {
+          "samples": 10000,
+          "pck@20": 0.9660599988937378,
+          "pck@50": 0.9916066654205322,
+          "mpjpe": 0.010310938355326652,
+          "wall_seconds": 36.89548587799072
+        }
+      }
+    },
+    "latency": {
+      "note": "3 interleaved repetitions per variant, median ms/window; onnx_fp32 / onnx_int8_ort_dynamic are same-session references",
+      "onnx_fp32": {
+        "batch1_reps": [
+          4.5327999996516155,
+          2.535649999117595,
+          2.167549997466267
+        ],
+        "batch64_reps": [
+          1.9354515624740998,
+          2.4948054687854437,
+          1.9334703125082342
+        ],
+        "batch1_ms_per_window_median": 2.535649999117595,
+        "batch64_ms_per_window_median": 1.9354515624740998
+      },
+      "onnx_int8_ort_dynamic": {
+        "batch1_reps": [
+          5.698599999959697,
+          5.721350000385428,
+          4.805099997611251
+        ],
+        "batch64_reps": [
+          4.096601562508795,
+          4.857628124995017,
+          4.583800000006022
+        ],
+        "batch1_ms_per_window_median": 5.698599999959697,
+        "batch64_ms_per_window_median": 4.583800000006022
+      },
+      "entropy_all": {
+        "batch1_reps": [
+          6.444149999879301,
+          5.038299999796436,
+          5.713200000172947
+        ],
+        "batch64_reps": [
+          4.149468750028973,
+          3.437125000004926,
+          4.410960937491382
+        ],
+        "batch1_ms_per_window_median": 5.713200000172947,
+        "batch64_ms_per_window_median": 4.149468750028973
+      },
+      "entropy_conv": {
+        "batch1_reps": [
+          4.874750000453787,
+          5.169099998965976,
+          5.236699998931726
+        ],
+        "batch64_reps": [
+          3.010160156236452,
+          3.1175546875203963,
+          3.516850781238645
+        ],
+        "batch1_ms_per_window_median": 5.169099998965976,
+        "batch64_ms_per_window_median": 3.1175546875203963
+      },
+      "percentile_all": {
+        "batch1_reps": [
+          5.184749999898486,
+          5.2898499998264015,
+          5.916899999647285
+        ],
+        "batch64_reps": [
+          4.305105468745296,
+          4.460741406262514,
+          4.184502343747454
+        ],
+        "batch1_ms_per_window_median": 5.2898499998264015,
+        "batch64_ms_per_window_median": 4.305105468745296
+      },
+      "percentile_conv": {
+        "batch1_reps": [
+          4.916449999655015,
+          7.150899999032845,
+          5.284949998895172
+        ],
+        "batch64_reps": [
+          3.855813281262499,
+          4.688969531230214,
+          5.220103124997877
+        ],
+        "batch1_ms_per_window_median": 5.284949998895172,
+        "batch64_ms_per_window_median": 4.688969531230214
+      },
+      "minmax_all": {
+        "batch1_reps": [
+          6.463300000177696,
+          7.149449998905766,
+          5.3209000016067876
+        ],
+        "batch64_reps": [
+          3.9251343750095202,
+          4.033442187505898,
+          3.428199218745931
+        ],
+        "batch1_ms_per_window_median": 6.463300000177696,
+        "batch64_ms_per_window_median": 3.9251343750095202
+      },
+      "minmax_conv": {
+        "batch1_reps": [
+          5.9961499991914025,
+          5.236549999608542,
+          4.854399998293957
+        ],
+        "batch64_reps": [
+          4.368359375007458,
+          3.249617187492504,
+          3.0238906249735464
+        ],
+        "batch1_ms_per_window_median": 5.236549999608542,
+        "batch64_ms_per_window_median": 3.249617187492504
+      }
+    },
+    "accuracy_subset": {
+      "description": "seed-42 file-level 70/15/15 test split, corrupted windows excluded, seed-42 random subset (same as quantize_bench/eval_ort_accuracy)",
+      "subset_size": 10000
+    }
+  },
+  "tiny_variant": {
+    "env": {
+      "torch": "2.12.0+cpu",
+      "onnxruntime": "1.26.0",
+      "platform": "Windows-11-10.0.26200-SP0",
+      "num_threads": 16,
+      "checkpoint": "results\\tiny_best.pth",
+      "checkpoint_size_bytes": 340555,
+      "params": 56290,
+      "variant_config": {
+        "tcn": [
+          68,
+          56,
+          44,
+          32
+        ],
+        "conv": [
+          2,
+          4,
+          8,
+          16
+        ],
+        "attn_groups": 2,
+        "groups_mode": "depthwise",
+        "input_pw_groups": 4
+      }
+    },
+    "export": {
+      "mode": "dynamic-batch",
+      "exporter": "torchscript",
+      "opset": 17,
+      "file": "tiny_fp32_dynamic.onnx",
+      "size_bytes": 295279,
+      "size_mb": 0.295279,
+      "verified_batches": [
+        1,
+        2,
+        64
+      ],
+      "note": "AdaptiveAvgPool2d((15,1)) replaced at export by an exact mean(-1) + constant averaging matmul (final_width 16 is not a multiple of 15, which the TorchScript exporter rejects); exactness proven by the parity check vs the original torch model"
+    },
+    "parity": {
+      "fixture": "results/parity_fixture.npz input (batch 2, seed 42); reference output recomputed with the tiny torch model",
+      "max_abs_diff_vs_torch": 1.4901161193847656e-07,
+      "pass_lt_1e-4": true
+    },
+    "int8_static_percentile_conv": {
+      "file": "tiny_int8_static_percentile_conv.onnx",
+      "size_bytes": 248278,
+      "size_mb": 0.248278,
+      "calibration": {
+        "method": "percentile",
+        "percentile": 99.99,
+        "windows": 512,
+        "scope": "conv-only TRAIN-split corruption-free",
+        "seconds": 1.5347836017608643
+      },
+      "per_channel": true,
+      "activation_type": "QInt8",
+      "weight_type": "QInt8",
+      "max_abs_diff_vs_fp32_fixture": 0.018491357564926147
+    },
+    "latency": {
+      "note": "3 interleaved repetitions per variant, median ms/window; full-model sessions are same-session references",
+      "tiny_onnx_fp32": {
+        "batch1_reps": [
+          0.6312500008789357,
+          0.6834500018157996,
+          0.6595999984710943
+        ],
+        "batch64_reps": [
+          0.37747578119251557,
+          0.24196640623586063,
+          0.2314671875183194
+        ],
+        "batch1_ms_per_window_median": 0.6595999984710943,
+        "batch64_ms_per_window_median": 0.24196640623586063
+      },
+      "tiny_onnx_int8_static_percentile_conv": {
+        "batch1_reps": [
+          0.7988500001374632,
+          0.9382499993080273,
+          0.8451000030618161
+        ],
+        "batch64_reps": [
+          0.9211476562995813,
+          1.3045390625165965,
+          1.026230468767153
+        ],
+        "batch1_ms_per_window_median": 0.8451000030618161,
+        "batch64_ms_per_window_median": 1.026230468767153
+      },
+      "full_onnx_fp32_reference": {
+        "batch1_reps": [
+          2.267249998112675,
+          2.80170000041835,
+          2.132149998942623
+        ],
+        "batch64_reps": [
+          1.3050578124875756,
+          1.4244992187855132,
+          1.8014164062947202
+        ],
+        "batch1_ms_per_window_median": 2.267249998112675,
+        "batch64_ms_per_window_median": 1.4244992187855132
+      },
+      "full_onnx_int8_static_percentile_conv_reference": {
+        "batch1_reps": [
+          5.529599999135826,
+          4.768399998283712,
+          6.215800000063609
+        ],
+        "batch64_reps": [
+          3.815724218725336,
+          3.1025562500417436,
+          4.333318749957016
+        ],
+        "batch1_ms_per_window_median": 5.529599999135826,
+        "batch64_ms_per_window_median": 3.815724218725336
+      }
+    },
+    "accuracy_subset": {
+      "description": "seed-42 file-level 70/15/15 test split, corrupted windows excluded, seed-42 random subset (same as quantize_bench/eval_ort_accuracy/static_ptq_bench)",
+      "subset_size": 10000
+    },
+    "accuracy": {
+      "tiny_onnx_fp32": {
+        "samples": 10000,
+        "pck@20": 0.941106667804718,
+        "pck@50": 0.99369333152771,
+        "mpjpe": 0.012527281279861927,
+        "wall_seconds": 10.927234888076782
+      },
+      "tiny_onnx_int8_static_percentile_conv": {
+        "samples": 10000,
+        "pck@20": 0.9268133331298828,
+        "pck@50": 0.9932933319091797,
+        "mpjpe": 0.014906252065300942,
+        "wall_seconds": 12.320892333984375
+      }
+    }
+  }
+}

benchmarks/wiflow-std/results/efficiency_sweep.jsonl

@@ -0,0 +1,3 @@
+{"variant": "half", "params": 843834, "tcn_channels": [270, 220, 170, 120], "conv_channels": [4, 8, 16, 32], "attn_groups": 4, "groups_mode": "gcd20", "input_pw_groups": 1, "tcn_groups_per_block": [[20, 10], [10, 20], [20, 10], [10, 20]], "conv_strides": [2, 2, 2, 1], "final_width": 15, "batch_size": 64, "max_epochs": 50, "patience": 5, "lr": 0.0001, "weight_decay": 5e-05, "seed": 42, "precision": "fp32", "epochs_run": 28, "best_epoch": 23, "best_val_mpjpe": 0.008576328293592842, "best_val_pck20": 0.9690593021534107, "train_seconds": 1346.4, "torch": "2.11.0+cu128", "error": null, "finished_utc": "2026-06-11T03:09:47Z", "checkpoint": "/home/ruvultra/wiflow-std-bench/sweep/half_best.pth", "test_full": {"samples": 54000, "mpjpe": 0.009419974447676428, "pck@10": 0.8740543655289544, "pck@20": 0.9610469643628156, "pck@30": 0.9813556064146537, "pck@40": 0.9896086878246731, "pck@50": 0.9934827546013726}, "test_clean": {"samples": 52560, "mpjpe": 0.008980081718602137, "pck@10": 0.8840944136840205, "pck@20": 0.9662253179869514, "pck@30": 0.9847971080282144, "pck@40": 0.9917795997050618, "pck@50": 0.9946956242600532}}
+{"variant": "quarter", "params": 338600, "tcn_channels": [135, 110, 85, 60], "conv_channels": [2, 4, 8, 16], "attn_groups": 2, "groups_mode": "gcd20", "input_pw_groups": 1, "tcn_groups_per_block": [[20, 5], [5, 10], [10, 5], [5, 20]], "conv_strides": [2, 2, 1, 1], "final_width": 15, "batch_size": 64, "max_epochs": 50, "patience": 5, "lr": 0.0001, "weight_decay": 5e-05, "seed": 42, "precision": "fp32", "epochs_run": 50, "best_epoch": 50, "best_val_mpjpe": 0.008780752391864856, "best_val_pck20": 0.9672531302240159, "train_seconds": 1754.4, "torch": "2.11.0+cu128", "error": null, "finished_utc": "2026-06-11T03:39:06Z", "checkpoint": "/home/ruvultra/wiflow-std-bench/sweep/quarter_best.pth", "test_full": {"samples": 54000, "mpjpe": 0.009705399298005634, "pck@10": 0.8646123917014511, "pck@20": 0.9553815319449813, "pck@30": 0.979827209190086, "pck@40": 0.9887037501511751, "pck@50": 0.9931309027671814}, "test_clean": {"samples": 52560, "mpjpe": 0.009279253277105465, "pck@10": 0.8742288637923323, "pck@20": 0.9605315079427745, "pck@30": 0.9833016723076865, "pck@40": 0.9908206971631566, "pck@50": 0.9942719799017071}}
+{"variant": "tiny", "params": 56290, "tcn_channels": [68, 56, 44, 32], "conv_channels": [2, 4, 8, 16], "attn_groups": 2, "groups_mode": "depthwise", "input_pw_groups": 4, "tcn_groups_per_block": [[540, 68], [68, 56], [56, 44], [44, 32]], "conv_strides": [2, 1, 1, 1], "final_width": 16, "batch_size": 64, "max_epochs": 50, "patience": 5, "lr": 0.0001, "weight_decay": 5e-05, "seed": 42, "precision": "fp32", "epochs_run": 50, "best_epoch": 47, "best_val_mpjpe": 0.012602971208592256, "best_val_pck20": 0.9397210340146666, "train_seconds": 1540.1, "torch": "2.11.0+cu128", "error": null, "finished_utc": "2026-06-11T04:04:50Z", "checkpoint": "/home/ruvultra/wiflow-std-bench/sweep/tiny_best.pth", "test_full": {"samples": 54000, "mpjpe": 0.012859782406853305, "pck@10": 0.7640358444319831, "pck@20": 0.9364815320968628, "pck@30": 0.9731568422317505, "pck@40": 0.9866444962642811, "pck@50": 0.992488939108672}, "test_clean": {"samples": 52560, "mpjpe": 0.012502924276904246, "pck@10": 0.770895526488985, "pck@20": 0.9411073559313967, "pck@30": 0.9764840687790962, "pck@40": 0.9886695077067278, "pck@50": 0.9936238432039409}}

benchmarks/wiflow-std/results/eval_retrained.json

@@ -0,0 +1,21 @@
+{
+  "checkpoint": "/home/ruvultra/wiflow-std-bench/upstream/test/best_pose_model.pth",
+  "test_full": {
+    "samples": 54000,
+    "mpjpe": 0.009834060806367133,
+    "pck@10": 0.8686346120127925,
+    "pck@20": 0.9608815324571398,
+    "pck@30": 0.9789111610695168,
+    "pck@40": 0.9857975759682832,
+    "pck@50": 0.9898827553325229
+  },
+  "test_clean": {
+    "samples": 52560,
+    "mpjpe": 0.009432755044379373,
+    "pck@10": 0.876996495807189,
+    "pck@20": 0.9661454100405608,
+    "pck@30": 0.9823453060205306,
+    "pck@40": 0.987909734176537,
+    "pck@50": 0.9911238361167036
+  }
+}

benchmarks/wiflow-std/results/repro_a.json

@@ -0,0 +1,32 @@
+{
+  "published": {
+    "pck@20": 0.9725,
+    "pck@30": 0.9863,
+    "pck@40": 0.9916,
+    "pck@50": 0.9948,
+    "mpjpe": 0.007
+  },
+  "params_millions": 2.225042,
+  "data_dir": "C:\\Users\\ruv\\.cache\\kagglehub\\datasets\\kaka2434\\wiflow-dataset\\versions\\1\\preprocessed_csi_data",
+  "device": "cpu",
+  "test_full": {
+    "samples": 54000,
+    "mpjpe": NaN,
+    "pck@10": 5.6790124349020145e-05,
+    "pck@20": 0.0007876543271596785,
+    "pck@30": 0.007780246982971827,
+    "pck@40": 0.05529259262923841,
+    "pck@50": 0.1542370371548114,
+    "wall_seconds": 118.03756999969482
+  },
+  "test_drop_last": {
+    "samples": 53952,
+    "mpjpe": NaN,
+    "pck@10": 5.6840649370682976e-05,
+    "pck@20": 0.0007883550872372227,
+    "pck@30": 0.007787168910892621,
+    "pck@40": 0.055318307667895535,
+    "pck@50": 0.15425316342412276,
+    "wall_seconds": 120.87458372116089
+  }
+}

benchmarks/wiflow-std/static_ptq_bench.py

@@ -0,0 +1,333 @@
+"""ADR-152 edge optimization follow-up: ONNX Runtime STATIC post-training
+quantization (calibration-based QDQ) of the retrained WiFlow-STD model, to
+improve on the dynamic-int8 result (2.44 MB, PCK@20 96.52%, 6.5 ms/win b1).
+
+Static PTQ pre-computes activation ranges from calibration data, so inference
+uses QLinearConv/QDQ kernels instead of dynamic ConvInteger -- typically both
+faster and (with good calibration) closer to fp32 accuracy.
+
+Method:
+  - Calibration set: corruption-free windows drawn ONLY from the seed-42
+    file-level TRAINING split (same split as eval_repro.py; corrupted windows
+    excluded via results/nan_windows_mask.npy | big_windows_mask.npy), chosen
+    with np.random.default_rng(42). Never test windows.
+  - quantize_static, QuantFormat.QDQ, per-channel int8 weights, int8
+    activations; calibration methods MinMax / Entropy / Percentile(99.99);
+    scopes "all" (ORT default op set) vs "conv" (op_types_to_quantize=
+    ["Conv"] -- leaves the attention path, which exports as Einsum/Softmax
+    and elementwise ops, in fp32).
+  - Model is pre-processed first (quant_pre_process: symbolic shape
+    inference + ORT graph optimization, folds BatchNormalization into Conv).
+  - Accuracy: identical protocol to eval_ort_accuracy.py -- the 10,000-window
+    seed-42 subset of the corruption-free test split (PCK@20/50, MPJPE).
+  - Latency: median ms/window at batch 1 (100 runs) and batch 64 (30 runs),
+    3 interleaved repetitions across all variants (fp32 and dynamic-int8
+    sessions included as same-session reference points).
+
+Usage:
+  PYTHONUTF8=1 .venv/Scripts/python.exe static_ptq_bench.py \
+      [--data-dir <preprocessed_csi_data>] [--subset 10000]
+      [--calib-minmax 1000] [--calib-hist 512] [--skip-accuracy]
+
+Writes/merges into results/edge_optimization.json under key "onnx_static_ptq".
+"""
+
+import argparse
+import collections
+import json
+import os
+import platform
+import statistics
+import sys
+import time
+
+import numpy as np
+import torch
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+from _bench_common import RESULTS  # noqa: E402
+# quantize_bench sets up upstream imports + the np.load mmap patch
+# (both via _bench_common.import_upstream)
+from quantize_bench import build_test_subset  # noqa: E402
+import quantize_bench as qb  # noqa: E402
+from eval_ort_accuracy import evaluate_ort  # noqa: E402
+
+FP32_ONNX = os.path.join(RESULTS, "retrained_fp32_dynamic.onnx")
+DYN_INT8_ONNX = os.path.join(RESULTS, "retrained_int8_ort_dynamic.onnx")
+PREPROC_ONNX = os.path.join(RESULTS, "retrained_fp32_preproc.onnx")
+
+
+# ---------------------------------------------------------------------------
+# calibration data: corruption-free TRAINING-split windows only
+# ---------------------------------------------------------------------------
+
+def build_calibration_windows(data_dir, n_windows):
+    """Seed-42 file-level 70/15/15 TRAIN split (exactly as eval_repro.py),
+    minus corrupted windows, then a seed-42 random draw of n_windows."""
+    dataset = qb.PreprocessedCSIKeypointsDataset(
+        data_dir=data_dir, keypoint_scale=1000.0, enable_temporal_clean=True)
+    train_loader, _va, _te = qb.create_preprocessed_train_val_test_loaders(
+        dataset=dataset, batch_size=64, num_workers=0, random_seed=42)
+    train_indices = np.asarray(train_loader.dataset.indices)
+
+    corrupted = (np.load(os.path.join(RESULTS, "nan_windows_mask.npy"))
+                 | np.load(os.path.join(RESULTS, "big_windows_mask.npy")))
+    clean = train_indices[~corrupted[train_indices]]
+    print(f"train split: {len(train_indices)} windows, "
+          f"{len(train_indices) - len(clean)} corrupted excluded, "
+          f"{len(clean)} clean")
+
+    rng = np.random.default_rng(42)
+    sel = np.sort(rng.choice(clean, size=n_windows, replace=False))
+    xs = np.stack([dataset[int(i)][0].numpy() for i in sel]).astype(np.float32)
+    print(f"calibration tensor: {xs.shape} from {n_windows} clean TRAIN windows")
+    return xs
+
+
+def make_reader(windows, batch_size=64):
+    from onnxruntime.quantization import CalibrationDataReader
+
+    class WindowReader(CalibrationDataReader):
+        def __init__(self):
+            self._batches = [windows[i:i + batch_size]
+                             for i in range(0, len(windows), batch_size)]
+            self._it = iter(self._batches)
+
+        def get_next(self):
+            b = next(self._it, None)
+            return None if b is None else {"input": b}
+
+        def rewind(self):
+            self._it = iter(self._batches)
+
+        def __len__(self):
+            return len(self._batches)
+
+    return WindowReader()
+
+
+# ---------------------------------------------------------------------------
+# quantization variants
+# ---------------------------------------------------------------------------
+
+def preprocess_model():
+    from onnxruntime.quantization.shape_inference import quant_pre_process
+    quant_pre_process(FP32_ONNX, PREPROC_ONNX)
+    return PREPROC_ONNX
+
+
+def quantize_variant(src, dst, method, scope, calib_windows):
+    from onnxruntime.quantization import (CalibrationMethod, QuantFormat,
+                                          QuantType, quantize_static)
+    methods = {
+        "minmax": CalibrationMethod.MinMax,
+        "entropy": CalibrationMethod.Entropy,
+        "percentile": CalibrationMethod.Percentile,
+    }
+    # NB: do NOT pass CalibMaxIntermediateOutputs -- in ORT 1.26 the MinMax
+    # calibrater clears its buffer every N batches and then raises
+    # "No data is collected" if the batch count is divisible by N.
+    extra = {}
+    if method == "percentile":
+        extra["CalibPercentile"] = 99.99
+    op_types = ["Conv"] if scope == "conv" else None
+
+    t0 = time.time()
+    quantize_static(
+        src, dst, make_reader(calib_windows),
+        quant_format=QuantFormat.QDQ,
+        op_types_to_quantize=op_types,
+        per_channel=True,
+        activation_type=QuantType.QInt8,
+        weight_type=QuantType.QInt8,
+        calibrate_method=methods[method],
+        extra_options=extra,
+    )
+    secs = time.time() - t0
+
+    import onnx
+    ops = collections.Counter(n.op_type for n in onnx.load(dst).graph.node)
+    return {
+        "file": os.path.basename(dst),
+        "size_bytes": os.path.getsize(dst),
+        "size_mb": os.path.getsize(dst) / 1e6,
+        "calibration": {"method": method,
+                        "windows": int(len(calib_windows)),
+                        "percentile": extra.get("CalibPercentile"),
+                        "seconds": secs},
+        "scope": scope,
+        "per_channel": True,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+        "node_counts": {k: v for k, v in sorted(ops.items())},
+    }
+
+
+# ---------------------------------------------------------------------------
+# latency (3 interleaved reps, like the latency_controlled_rerun)
+# ---------------------------------------------------------------------------
+
+def ort_session(path):
+    import onnxruntime as ort
+    return ort.InferenceSession(path, providers=["CPUExecutionProvider"])
+
+
+def bench_ort(sess, batch, n_runs):
+    rng = np.random.default_rng(123)
+    x = rng.random((batch, 540, 20), dtype=np.float32)
+    inp = sess.get_inputs()[0].name
+    for _ in range(max(5, n_runs // 10)):
+        sess.run(None, {inp: x})
+    times = []
+    for _ in range(n_runs):
+        t0 = time.perf_counter()
+        sess.run(None, {inp: x})
+        times.append(time.perf_counter() - t0)
+    return statistics.median(times) * 1e3 / batch  # ms/window
+
+
+def interleaved_latency(sessions, reps=3, runs_b1=100, runs_b64=30):
+    lat = {name: {"batch1_reps": [], "batch64_reps": []} for name in sessions}
+    for rep in range(reps):
+        for name, sess in sessions.items():
+            lat[name]["batch1_reps"].append(bench_ort(sess, 1, runs_b1))
+            lat[name]["batch64_reps"].append(bench_ort(sess, 64, runs_b64))
+            print(f"  rep {rep + 1}/{reps} {name}: "
+                  f"b1={lat[name]['batch1_reps'][-1]:.2f} "
+                  f"b64={lat[name]['batch64_reps'][-1]:.3f} ms/win", flush=True)
+    for name in lat:
+        lat[name]["batch1_ms_per_window_median"] = statistics.median(
+            lat[name]["batch1_reps"])
+        lat[name]["batch64_ms_per_window_median"] = statistics.median(
+            lat[name]["batch64_reps"])
+    return lat
+
+
+# ---------------------------------------------------------------------------
+
+def main():
+    import onnxruntime
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-dir", default=os.path.join(
+        os.path.expanduser("~"), ".cache", "kagglehub", "datasets", "kaka2434",
+        "wiflow-dataset", "versions", "1", "preprocessed_csi_data"))
+    parser.add_argument("--subset", type=int, default=10000)
+    parser.add_argument("--calib-minmax", type=int, default=1000)
+    parser.add_argument("--calib-hist", type=int, default=512,
+                        help="calibration windows for Entropy/Percentile "
+                             "(histogram calibraters hold all intermediate "
+                             "activations in RAM)")
+    parser.add_argument("--skip-accuracy", action="store_true")
+    parser.add_argument("--methods", default="minmax,entropy,percentile",
+                        help="comma list of calibration methods to (re)run; "
+                             "results merge into existing onnx_static_ptq")
+    parser.add_argument("--out", default=os.path.join(RESULTS, "edge_optimization.json"))
+    args = parser.parse_args()
+
+    results = {
+        "env": {
+            "onnxruntime": onnxruntime.__version__,
+            "torch": torch.__version__,
+            "platform": platform.platform(),
+            "source_model": os.path.basename(FP32_ONNX),
+        },
+        "variants": {},
+    }
+
+    # ---- calibration data (TRAIN split only) -------------------------------
+    calib_mm = build_calibration_windows(args.data_dir, args.calib_minmax)
+    calib_hist = calib_mm[:args.calib_hist]
+
+    # ---- preprocess + quantize ---------------------------------------------
+    print("\n=== quant_pre_process (shape inference + graph optimization) ===")
+    src = preprocess_model()
+    results["env"]["preprocessed_model"] = {
+        "file": os.path.basename(src),
+        "size_mb": os.path.getsize(src) / 1e6,
+    }
+
+    matrix = [(m, s) for m in args.methods.split(",")
+              for s in ("all", "conv")]
+    for method, scope in matrix:
+        name = f"{method}_{scope}"
+        dst = os.path.join(RESULTS, f"retrained_int8_static_{name}.onnx")
+        calib = calib_mm if method == "minmax" else calib_hist
+        print(f"\n=== quantize_static: {name} "
+              f"({len(calib)} calib windows) ===", flush=True)
+        try:
+            results["variants"][name] = quantize_variant(
+                src, dst, method, scope, calib)
+            print(f"  {results['variants'][name]['size_mb']:.3f} MB")
+        except Exception as e:  # noqa: BLE001
+            results["variants"][name] = {"error": f"{type(e).__name__}: {e}"}
+            print(f"  FAILED: {e}")
+
+    # ---- fixture parity (sanity, batch 2) ----------------------------------
+    fixture = np.load(os.path.join(RESULTS, "parity_fixture.npz"))
+    fx, fy = fixture["input"], fixture["output"]
+    sessions = {}
+    for name, info in results["variants"].items():
+        if "error" in info:
+            continue
+        path = os.path.join(RESULTS, info["file"])
+        try:
+            sess = ort_session(path)
+            yq = sess.run(None, {sess.get_inputs()[0].name: fx})[0]
+            info["max_abs_diff_vs_fp32_fixture"] = float(np.abs(yq - fy).max())
+            sessions[name] = sess
+        except Exception as e:  # noqa: BLE001
+            info["run_error"] = f"{type(e).__name__}: {e}"
+    print("\nfixture max-abs-diff vs fp32:",
+          {n: round(results["variants"][n].get("max_abs_diff_vs_fp32_fixture",
+                                               float("nan")), 5)
+           for n in results["variants"]})
+
+    # ---- latency: 3 interleaved reps incl. fp32 + dynamic-int8 reference ----
+    print("\n=== latency (3 interleaved reps) ===")
+    lat_sessions = {"onnx_fp32": ort_session(FP32_ONNX),
+                    "onnx_int8_ort_dynamic": ort_session(DYN_INT8_ONNX)}
+    lat_sessions.update(sessions)
+    results["latency"] = {
+        "note": "3 interleaved repetitions per variant, median ms/window; "
+                "onnx_fp32 / onnx_int8_ort_dynamic are same-session references",
+        **interleaved_latency(lat_sessions),
+    }
+
+    # ---- accuracy on the standard 10k corruption-free test subset ----------
+    if not args.skip_accuracy:
+        loader, n_clean = build_test_subset(args.data_dir, args.subset)
+        results["accuracy_subset"] = {
+            "description": "seed-42 file-level 70/15/15 test split, corrupted "
+                           "windows excluded, seed-42 random subset (same as "
+                           "quantize_bench/eval_ort_accuracy)",
+            "subset_size": min(args.subset, n_clean) if args.subset else n_clean,
+        }
+        for name, sess in sessions.items():
+            print(f"\n=== accuracy: {name} ===")
+            results["variants"][name]["accuracy"] = evaluate_ort(
+                sess, loader, name)
+            print(json.dumps(results["variants"][name]["accuracy"], indent=2))
+
+    # ---- merge into edge_optimization.json ----------------------------------
+    merged = {}
+    if os.path.exists(args.out):
+        with open(args.out) as f:
+            merged = json.load(f)
+    prev = merged.get("onnx_static_ptq")
+    if prev:  # nested merge so partial --methods reruns don't clobber
+        prev["env"] = results["env"]
+        prev["variants"].update(results["variants"])
+        prev.setdefault("latency", {}).update(results["latency"])
+        if "accuracy_subset" in results:
+            prev["accuracy_subset"] = results["accuracy_subset"]
+    else:
+        merged["onnx_static_ptq"] = results
+    with open(args.out, "w") as f:
+        json.dump(merged, f, indent=2)
+    print(f"\nwrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/wiflow-std/tiny_edge_bench.py

@@ -0,0 +1,313 @@
+"""ADR-152 efficiency-sweep follow-up: edge pipeline for the TINY compact
+WiFlow-STD variant (56,290 params, results/tiny_best.pth, trained overnight
+2026-06-10/11 -- see RESULTS.md "Efficiency sweep").
+
+Headline question: what does the smallest deployable WiFlow-class model look
+like (KB + ms + PCK)? Reuses the onnx_bench.py / static_ptq_bench.py
+machinery on the tiny checkpoint:
+
+  1. Load tiny_best.pth with remote/sweep/model_compact.py
+     (depthwise TCN groups, input_pw_groups=4, conv [2,4,8,16], attn groups 2).
+  2. Export ONNX: dynamic batch, opset 17, TorchScript exporter (dynamo=False)
+     -- same recipe that worked for the full model; verified at batch 1/2/64.
+     One forced deviation: tiny's stride schedule [2,1,1,1] leaves final_width
+     16, and the TorchScript exporter cannot export AdaptiveAvgPool2d((15,1))
+     when 15 is not a factor of the input height (the full model never hit
+     this -- its width was exactly 15). The adaptive pool over a fixed-size
+     feature map is a fixed linear map, so the export wrapper replaces it with
+     an exact matmul equivalent (PyTorch adaptive-pool bin semantics:
+     bin i averages rows floor(i*H/K)..ceil((i+1)*H/K)); the W axis (20->1,
+     a factor) becomes mean(-1). Exactness is proven by the parity check
+     below, which compares against the ORIGINAL torch model with the real
+     AdaptiveAvgPool2d.
+  3. Torch-vs-ORT parity on the stored fixture input
+     (results/parity_fixture.npz, batch 2, seed 42 -- same 540x20 input layout;
+     reference output recomputed with the tiny torch model). PASS < 1e-4.
+  4. Static QDQ conv-only int8 (quant_pre_process + quantize_static,
+     per-channel QInt8 weights+activations, Percentile(99.99) calibration on
+     512 corruption-free TRAIN-split windows -- the winning recipe and
+     calibration count from static_ptq_bench.py. 512, not "about 500":
+     ORT 1.26's histogram collector np.asarray()'s the per-batch maxima, so
+     the calibration count must be a multiple of the batch size 64 or the
+     ragged last batch crashes it).
+  5. Disk size + CPU latency b1/b64 (3 interleaved reps, median ms/window)
+     for tiny fp32 + tiny int8, with the full-model ONNX fp32 + static-int8
+     sessions interleaved as same-session references.
+  6. Accuracy (PCK@20/50 + MPJPE) on the identical 10k-window seed-42
+     corruption-free test subset for tiny fp32 + tiny int8.
+
+Usage:
+  PYTHONUTF8=1 .venv/Scripts/python.exe tiny_edge_bench.py \
+      [--data-dir <preprocessed_csi_data>] [--subset 10000] [--calib 512]
+  (--calib must be a multiple of 64; see step 4 above)
+
+Writes/merges into results/edge_optimization.json under key "tiny_variant".
+"""
+
+import argparse
+import json
+import os
+import platform
+import sys
+import time
+
+import numpy as np
+import torch
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+RESULTS = os.path.join(HERE, "results")
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(HERE, "remote", "sweep"))
+
+# quantize_bench sets up upstream imports + the np.load mmap patch
+from quantize_bench import build_test_subset  # noqa: E402
+from eval_ort_accuracy import evaluate_ort  # noqa: E402
+from static_ptq_bench import (  # noqa: E402
+    build_calibration_windows,
+    interleaved_latency,
+    make_reader,
+    ort_session,
+)
+from model_compact import CompactWiFlowPoseModel, describe  # noqa: E402
+
+TINY_CKPT = os.path.join(RESULTS, "tiny_best.pth")
+TINY_FP32_ONNX = os.path.join(RESULTS, "tiny_fp32_dynamic.onnx")
+TINY_PREPROC_ONNX = os.path.join(RESULTS, "tiny_fp32_preproc.onnx")
+TINY_INT8_ONNX = os.path.join(RESULTS, "tiny_int8_static_percentile_conv.onnx")
+FULL_FP32_ONNX = os.path.join(RESULTS, "retrained_fp32_dynamic.onnx")
+FULL_INT8_ONNX = os.path.join(RESULTS, "retrained_int8_static_percentile_conv.onnx")
+
+# Exact tiny config from remote/sweep/run_sweep.py VARIANTS (measured 56,290
+# params, clean-test PCK@20 94.11% -- results/efficiency_sweep.jsonl).
+TINY = dict(tcn=[68, 56, 44, 32], conv=[2, 4, 8, 16], attn_groups=2,
+            groups_mode="depthwise", input_pw_groups=4)
+
+
+def load_tiny_model():
+    model = CompactWiFlowPoseModel(
+        tcn_channels=TINY["tcn"], conv_channels=TINY["conv"],
+        attn_groups=TINY["attn_groups"], groups_mode=TINY["groups_mode"],
+        input_pw_groups=TINY["input_pw_groups"], dropout=0.5)
+    state = torch.load(TINY_CKPT, map_location="cpu", weights_only=True)
+    model.load_state_dict(state, strict=True)
+    model.eval()
+    return model
+
+
+def adaptive_pool_matrix(h_in, h_out):
+    """Exact AdaptiveAvgPool1d as a (h_out, h_in) averaging matrix, using
+    PyTorch's bin rule: bin i covers rows floor(i*h_in/h_out) ..
+    ceil((i+1)*h_in/h_out)."""
+    w = torch.zeros(h_out, h_in)
+    for i in range(h_out):
+        s = (i * h_in) // h_out
+        e = -((-(i + 1) * h_in) // h_out)  # ceil division
+        w[i, s:e] = 1.0 / (e - s)
+    return w
+
+
+class ExportWrapper(torch.nn.Module):
+    """CompactWiFlowPoseModel forward with the AdaptiveAvgPool2d((K,1))
+    replaced by an exact fixed linear map (mean over the factor W axis, then
+    a constant averaging matmul over the non-factor H axis) so the
+    TorchScript ONNX exporter accepts it. Bit-equivalent up to float
+    round-off; proven by the parity check against the original model."""
+
+    def __init__(self, m, num_keypoints=15):
+        super().__init__()
+        self.m = m
+        self.register_buffer(
+            "pool_w_t", adaptive_pool_matrix(m.final_width, num_keypoints).t())
+
+    def forward(self, x):
+        m = self.m
+        x = m.tcn(x)
+        x = x.transpose(1, 2).unsqueeze(1)
+        x = m.up(x)
+        for block in m.residual_blocks:
+            x = block(x)
+        x = x.permute(0, 1, 3, 2)
+        x = m.attention(x)
+        x = m.decoder(x)                  # [B, 2, H=final_width, T=20]
+        x = x.mean(-1)                    # W-axis pool (20 -> 1, a factor)
+        x = x.matmul(self.pool_w_t)       # exact adaptive H pool: [B, 2, K]
+        return x.transpose(1, 2)          # [B, K, 2]
+
+
+def export_onnx(model):
+    """Dynamic-batch TorchScript export (the recipe that worked for the full
+    model in onnx_bench.py), verified at batch 1/2/64. Uses ExportWrapper
+    (see docstring) because final_width 16 is not a multiple of 15."""
+    wrapper = ExportWrapper(model).eval()
+    x = torch.rand(2, 540, 20)
+    with torch.no_grad():
+        torch.onnx.export(
+            wrapper, (x,), TINY_FP32_ONNX, opset_version=17,
+            input_names=["input"], output_names=["output"], dynamo=False,
+            dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}})
+    sess = ort_session(TINY_FP32_ONNX)
+    inp = sess.get_inputs()[0].name
+    for b in (1, 2, 64):
+        y = sess.run(None, {inp: np.zeros((b, 540, 20), dtype=np.float32)})[0]
+        assert y.shape == (b, 15, 2), y.shape
+    return {
+        "mode": "dynamic-batch", "exporter": "torchscript", "opset": 17,
+        "file": os.path.basename(TINY_FP32_ONNX),
+        "size_bytes": os.path.getsize(TINY_FP32_ONNX),
+        "size_mb": os.path.getsize(TINY_FP32_ONNX) / 1e6,
+        "verified_batches": [1, 2, 64],
+        "note": "AdaptiveAvgPool2d((15,1)) replaced at export by an exact "
+                "mean(-1) + constant averaging matmul (final_width 16 is not "
+                "a multiple of 15, which the TorchScript exporter rejects); "
+                "exactness proven by the parity check vs the original torch "
+                "model",
+    }
+
+
+def quantize_tiny(calib_windows):
+    """quant_pre_process + static QDQ conv-only Percentile(99.99) int8 --
+    the winning recipe from static_ptq_bench.py."""
+    from onnxruntime.quantization import (CalibrationMethod, QuantFormat,
+                                          QuantType, quantize_static)
+    from onnxruntime.quantization.shape_inference import quant_pre_process
+
+    quant_pre_process(TINY_FP32_ONNX, TINY_PREPROC_ONNX)
+    t0 = time.time()
+    quantize_static(
+        TINY_PREPROC_ONNX, TINY_INT8_ONNX, make_reader(calib_windows),
+        quant_format=QuantFormat.QDQ,
+        op_types_to_quantize=["Conv"],
+        per_channel=True,
+        activation_type=QuantType.QInt8,
+        weight_type=QuantType.QInt8,
+        calibrate_method=CalibrationMethod.Percentile,
+        extra_options={"CalibPercentile": 99.99},
+    )
+    return {
+        "file": os.path.basename(TINY_INT8_ONNX),
+        "size_bytes": os.path.getsize(TINY_INT8_ONNX),
+        "size_mb": os.path.getsize(TINY_INT8_ONNX) / 1e6,
+        "calibration": {"method": "percentile", "percentile": 99.99,
+                        "windows": int(len(calib_windows)),
+                        "scope": "conv-only TRAIN-split corruption-free",
+                        "seconds": time.time() - t0},
+        "per_channel": True,
+        "activation_type": "QInt8",
+        "weight_type": "QInt8",
+    }
+
+
+def main():
+    import onnxruntime
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-dir", default=os.path.join(
+        os.path.expanduser("~"), ".cache", "kagglehub", "datasets", "kaka2434",
+        "wiflow-dataset", "versions", "1", "preprocessed_csi_data"))
+    parser.add_argument("--subset", type=int, default=10000)
+    parser.add_argument("--calib", type=int, default=512,
+                        help="calibration windows; must be a multiple of the "
+                             "64-window calibration batch (ORT histogram "
+                             "collector rejects ragged batches)")
+    parser.add_argument("--skip-accuracy", action="store_true")
+    parser.add_argument("--out", default=os.path.join(RESULTS, "edge_optimization.json"))
+    args = parser.parse_args()
+
+    if args.calib % 64 != 0:
+        parser.error(
+            f"--calib must be a multiple of 64 (got {args.calib}): ORT 1.26's "
+            f"histogram calibration collector np.asarray()'s the per-batch "
+            f"maxima and crashes on a ragged final batch (calibration batch "
+            f"size is 64)")
+
+    model = load_tiny_model()
+    info = describe(model)
+    print(f"tiny model: {info['params']:,} params, tcn_groups={info['tcn_groups_per_block']}, "
+          f"strides={info['conv_strides']}, final_width={info['final_width']}")
+    assert info["params"] == 56290, info["params"]
+
+    results = {
+        "env": {
+            "torch": torch.__version__,
+            "onnxruntime": onnxruntime.__version__,
+            "platform": platform.platform(),
+            "num_threads": torch.get_num_threads(),
+            "checkpoint": os.path.relpath(TINY_CKPT, HERE),
+            "checkpoint_size_bytes": os.path.getsize(TINY_CKPT),
+            "params": info["params"],
+            "variant_config": TINY,
+        },
+    }
+
+    # ---- export + parity ----------------------------------------------------
+    print("\n=== ONNX export (dynamic batch, opset 17, torchscript) ===")
+    results["export"] = export_onnx(model)
+    print(f"  {results['export']['size_mb']:.3f} MB, batches {results['export']['verified_batches']} OK")
+
+    fixture = np.load(os.path.join(RESULTS, "parity_fixture.npz"))
+    fx = fixture["input"]  # (2, 540, 20), seed 42 -- same input layout as full model
+    sess_fp32 = ort_session(TINY_FP32_ONNX)
+    y_ort = sess_fp32.run(None, {sess_fp32.get_inputs()[0].name: fx})[0]
+    with torch.no_grad():
+        y_torch = model(torch.from_numpy(fx)).numpy()
+    results["parity"] = {
+        "fixture": "results/parity_fixture.npz input (batch 2, seed 42); "
+                   "reference output recomputed with the tiny torch model",
+        "max_abs_diff_vs_torch": float(np.abs(y_ort - y_torch).max()),
+        "pass_lt_1e-4": bool(np.abs(y_ort - y_torch).max() < 1e-4),
+    }
+    print("parity:", json.dumps(results["parity"], indent=2))
+    assert results["parity"]["pass_lt_1e-4"], "torch-vs-ORT parity FAILED"
+
+    # ---- static PTQ int8 ------------------------------------------------------
+    print(f"\n=== static QDQ int8 (Percentile conv-only, {args.calib} calib windows) ===")
+    calib = build_calibration_windows(args.data_dir, args.calib)
+    results["int8_static_percentile_conv"] = quantize_tiny(calib)
+    print(f"  {results['int8_static_percentile_conv']['size_mb']:.3f} MB")
+    sess_int8 = ort_session(TINY_INT8_ONNX)
+    yq = sess_int8.run(None, {sess_int8.get_inputs()[0].name: fx})[0]
+    results["int8_static_percentile_conv"]["max_abs_diff_vs_fp32_fixture"] = float(
+        np.abs(yq - y_torch).max())
+
+    # ---- latency (3 interleaved reps, full-model sessions as references) -----
+    print("\n=== latency (3 interleaved reps) ===")
+    lat_sessions = {
+        "tiny_onnx_fp32": sess_fp32,
+        "tiny_onnx_int8_static_percentile_conv": sess_int8,
+        "full_onnx_fp32_reference": ort_session(FULL_FP32_ONNX),
+        "full_onnx_int8_static_percentile_conv_reference": ort_session(FULL_INT8_ONNX),
+    }
+    results["latency"] = {
+        "note": "3 interleaved repetitions per variant, median ms/window; "
+                "full-model sessions are same-session references",
+        **interleaved_latency(lat_sessions),
+    }
+
+    # ---- accuracy on the standard 10k corruption-free test subset ------------
+    if not args.skip_accuracy:
+        loader, n_clean = build_test_subset(args.data_dir, args.subset)
+        results["accuracy_subset"] = {
+            "description": "seed-42 file-level 70/15/15 test split, corrupted "
+                           "windows excluded, seed-42 random subset (same as "
+                           "quantize_bench/eval_ort_accuracy/static_ptq_bench)",
+            "subset_size": min(args.subset, n_clean) if args.subset else n_clean,
+        }
+        results["accuracy"] = {}
+        for name, sess in (("tiny_onnx_fp32", sess_fp32),
+                           ("tiny_onnx_int8_static_percentile_conv", sess_int8)):
+            print(f"\n=== accuracy: {name} ===")
+            results["accuracy"][name] = evaluate_ort(sess, loader, name)
+            print(json.dumps(results["accuracy"][name], indent=2))
+
+    # ---- merge into edge_optimization.json -----------------------------------
+    merged = {}
+    if os.path.exists(args.out):
+        with open(args.out) as f:
+            merged = json.load(f)
+    merged["tiny_variant"] = results
+    with open(args.out, "w") as f:
+        json.dump(merged, f, indent=2)
+    print(f"\nwrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()

docs/WITNESS-LOG-110.md

@@ -57,7 +57,7 @@ This witness separates what was **empirically observed on real silicon today** f
 
 | # | Claim | Why it's not verified |
 |---|---|---|
-| **B1** | "Wi-Fi 6 HE-LTF: 242 subcarriers per HE20 frame" | The only AP in range (`ruv.net`) is 11n-only. Every captured frame is 128 bytes = 64 subcarriers (HT-LTF, `ppdu_type=0`). No HE-SU/HE-MU/HE-TB observed. Even if an 11ax AP were available, **whether ESP-IDF v5.4's CSI callback exposes HE-LTF subcarriers via `wifi_csi_info_t.buf` is an open question** — the public API was designed for HT-LTF, and the driver may quietly downconvert. **Validate by capturing CSI against an 11ax AP and comparing `info->len` between HT and HE frames.** |
+| **B1** | "Wi-Fi 6 HE-LTF: 242 subcarriers per HE20 frame" | The only AP in range (`ruv.net`) is 11n-only. Every captured frame is 128 bytes = 64 subcarriers (HT-LTF, `ppdu_type=0`). No HE-SU/HE-MU/HE-TB observed. Even if an 11ax AP were available, **whether ESP-IDF v5.4's CSI callback exposes HE-LTF subcarriers via `wifi_csi_info_t.buf` is an open question** — the public API was designed for HT-LTF, and the driver may quietly downconvert. **Validate by capturing CSI against an 11ax AP and comparing `info->len` between HT and HE frames.**<br><br>**RESOLVED WITH MEASUREMENT (2026-06-11, external — issue #1005, production deployment by @stuinfla):** the open question is answered in both directions. **IDF v5.4's driver blob downconverts** (148 B / 64-subcarrier HT frames, PPDU byte 0x00, on a confirmed-HE link); **IDF v5.5.2 delivers true HE-LTF** — 532 B frames = 256 bins (242 active HE20 tones), PPDU byte 0x01 (HE-SU), ~90% of frames, same board/AP/link. Setup: XIAO ESP32-C6 → hostapd on Intel AX210, 2.4 GHz ch 6, `ieee80211ax=1`. No firmware change required (`acquire_csi_su=1` was already set); the gate was purely the IDF driver version. Three C6 nodes ran this mode simultaneously with ADR-110 ESP-NOW sync. Requires the issue-#1005 version-guard fix in `c6_sync_espnow.c` to build on v5.5.x. |<br><br>**REPLICATED IN-HOUSE (2026-06-11):** same source + fix, fresh IDF v5.5.2 toolchain, original COM12 board (`20:6e:f1:17:00:84`), AP `ruv.net` (11ax 2.4 GHz): **84% of 1,525 captured frames at 532 B / PPDU 0x01 (HE-SU)**, HT minority 148 B / 0x00. Evidence grade: MEASURED (two independent rigs). |
 | **B2** | "TWT-bounded deterministic CSI cadence (10 ms wake)" | No 11ax AP in range. The TWT setup *call* was exercised live and the graceful fallback path is now correct (A9), but the agreement itself was never accepted. **Validate by associating with an 11ax AP that has TWT Responder=1, then capturing the timestamped CSI cadence vs the wall clock.** |
 | **B3** | "±100 µs cross-node alignment over 802.15.4" | 3 boards initialized their radios with correct EUIs (A4/A5), but **none stepped down from candidate-leader to follower** during repeated 35-second multi-board captures. <br><br>**Coex hypothesis REJECTED**: rebuilt + reflashed all 3 boards with `CONFIG_C6_TIMESYNC_CHANNEL=26` (2480 MHz, non-overlapping with WiFi ch 5 at 2432 MHz). Result identical: 3× candidate, 0× "stepping down". So 2.4 GHz radio coex was NOT the cause. <br><br>**Current leading hypothesis**: OpenThread (CONFIG_OPENTHREAD_ENABLED=y) owns the 802.15.4 radio when its stack is initialized — our weak-symbol overrides of `esp_ieee802154_receive_done` / `_transmit_done` may never be called because OpenThread registers strong handlers. Validation in progress: rebuilding with `CONFIG_OPENTHREAD_ENABLED=n` (raw 802.15.4 only, our beacon protocol is private — no need for the Thread stack). If leader election fires under raw-15.4-only, hypothesis confirmed. <br><br>If raw-only also fails, next move is to dump the actual PHY frame bytes via the IEEE 802.15.4 sniffer mode on a 4th board and diagnose at the frame level. |
 | **B4** | "~5 µA hibernation for battery seed nodes" | No INA / Joulescope current measurement available on this bench. The shipped code uses `esp_deep_sleep_enable_gpio_wakeup` (ext1 path, ESP-IDF default ~10 µA), not a true LP-core polling program. The 5 µA number is the C6 datasheet figure for ULP-level hibernation, not a measured value. **Validate by hooking an INA219/INA226 between the dev board's 3V3 rail and the regulator output, then averaging current over a 60-second cycle with the LP-core armed.** |

docs/adr/ADR-110-esp32-c6-firmware-extension.md

@@ -19,7 +19,7 @@ The production CSI node firmware (`firmware/esp32-csi-node`) was built around th
 
 | C6 capability | What it enables for sensing | Why we can't get it on S3 |
 |---|---|---|
-| **802.11ax (Wi-Fi 6) HE-LTF CSI** | 242 subcarriers per HE20 frame (vs 52 for HT-LTF), HE-MU/HE-TB PPDU types, OFDMA-aware channel sounding | S3 radio is HT-only (n) |
+| **802.11ax (Wi-Fi 6) HE-LTF CSI** | 242 subcarriers per HE20 frame (vs 52 for HT-LTF), HE-MU/HE-TB PPDU types, OFDMA-aware channel sounding. **Hardware-confirmed 2026-06-11** (issue #1005, external production deployment): requires **ESP-IDF ≥ 5.5** — the v5.4 driver blob silently downconverts to 64-subcarrier HT even on a confirmed-HE link; v5.5.2 delivers 532 B frames = 256 bins (242 active tones), PPDU 0x01 (HE-SU). See WITNESS-LOG-110 §B1 (resolved). | S3 radio is HT-only (n) |
 | **802.15.4 (Thread / Zigbee)** | Cross-node time-sync over a separate radio — frees Wi-Fi airtime for CSI, ±100 µs alignment possible without coordination traffic on the sensing channel | S3 has no 802.15.4 |
 | **TWT (Target Wake Time)** | Sensor negotiates a deterministic wake slot with the AP; CSI cadence becomes scheduler-bounded instead of opportunistic | Requires 802.11ax — S3 can't speak it |
 | **LP-core + hibernation (~5 µA)** | Always-on motion gate runs on a separate RISC-V LP core in deep sleep; HP core stays off until a real event | S3 ULP is FSM-only, ~10 µA floor |

docs/adr/ADR-151-room-calibration-specialist-training.md

@@ -0,0 +1,260 @@
+# ADR-151: RuView Per-Room Calibration & Specialized Model Training System
+
+| Field | Value |
+|-------|-------|
+| **Status** | Accepted — Stages 1–5 implemented (statistical specialists); HF-backbone distillation pending |
+| **Date** | 2026-06-09 |
+| **Deciders** | ruv |
+| **Codebase target** | New `wifi-densepose-calibration` crate (orchestration); `wifi-densepose-train` (`rapid_adapt.rs`, `signal_features.rs`, `trainer.rs`); `wifi-densepose-ruvector` (RVF specialist storage); `wifi-densepose-signal/ruvsense/*` (feature extractors); `wifi-densepose-cli` (`enroll`, `train-room`, `room-status` subcommands) |
+| **Relates to** | ADR-135 (Empty-Room Baseline Calibration), ADR-030 (Persistent Field Model), ADR-134 (CIR), ADR-024 (Contrastive CSI Embedding / AETHER), ADR-027 (Cross-Environment Domain Generalization / MERIDIAN), ADR-070 (Self-Supervised Pretraining), ADR-105 (Federated CSI Training), ADR-149 (AetherArena / Hugging Face), ADR-150 (RF Foundation Encoder) |
+
+---
+
+## 1. Context
+
+### 1.1 The thesis — teach the room before you teach the model
+
+RuView's deployment frontier is not a better generic model. ADR-150 documents the wall directly: an MM-Fi pose head scores **81.63% torso-PCK@20 in-domain but ~11.6% leakage-free cross-subject**, and bigger capacity *hurts* cross-subject (transformer 24.8% < conv 27.3%). A single oversized model that "understands the world" overfits the rooms and bodies it has seen. The lever is the opposite of scale: **a small model that understands *one* room and *one* person**, calibrated in minutes, run locally, and specialised per biological signal.
+
+This positions RuView between the two incumbents in ambient sensing:
+
+- **Wearables** — high fidelity, but people forget to wear them, and they only measure the wearer.
+- **Cameras** — powerful, but invasive, store identifiable video, and fail in the dark / under covers.
+
+RuView sits in the middle: it learns the *space*, learns the *person*, and tracks biological rhythm (breathing, heartbeat, restlessness, posture, presence) without seeing skin or storing video. Heartbeat and breathing are not visual problems — they are tiny, repeating disturbances in the RF field. Capturing them well is a *calibration* problem, not a *model-size* problem.
+
+### 1.2 What already exists (and what is missing)
+
+The pieces of a calibration→training pipeline exist as disconnected modules. There is no system that runs them end to end and emits a per-room model bank.
+
+| Capability | Status today | Gap |
+|------------|--------------|-----|
+| Empty-room baseline (environmental fingerprint) | ADR-135 `BaselineCalibration` (Proposed): per-subcarrier amplitude + circular-phase stats, `ruvcal` NVS namespace | Captures the *room*, but there is no step that captures *guided human anchors* on top of it |
+| Field eigenstructure | ADR-030 `field_model.rs` (SVD room eigenmodes) | Consumes calibration; not wired to a training trigger |
+| Shared invariant backbone | ADR-150 RF Foundation Encoder (pose-preserving, subject/room/device-invariant) | Defined as a *foundation* embedding; nothing distills it into per-room specialists |
+| Few-shot adaptation | `train/src/rapid_adapt.rs` — test-time training → LoRA weight deltas (MERIDIAN P5) | Produces a *single* pose-adaptation delta, not a bank of per-modality specialists |
+| Feature extractors | `ruvsense/{bvp,longitudinal,intention,gesture,pose_tracker,adversarial}.rs`, `train/src/signal_features.rs` | Each emits a signal; none is packaged as a labelled training source for enrollment |
+| Small-model storage | `wifi-densepose-ruvector` (RVF cognitive containers, HNSW, sketch) | No schema for "a bank of specialist models scoped to a room_id" |
+| HF publishing | ADR-149 AetherArena (Hugging Face Space + signed scorer), `sensing-server` `from_pretrained` path | Publishes/評価s a *global* model; no notion of a published *base* + private *local* heads |
+
+**The missing system is the connective tissue**: a guided enrollment protocol, a feature-extraction-to-label bridge, a specialist-bank trainer that reuses the frozen HF backbone, and a runtime that fuses the specialists with confidence gating. This ADR defines that system.
+
+### 1.3 The four-step user model (and where each step lands)
+
+The system is deliberately presented to operators as four plain steps. Each maps to existing or new code:
+
+1. **Capture a quiet baseline** — no people, just room/router/reflections/noise/drift → the *environmental fingerprint*. → **Reuse ADR-135** `BaselineCalibration` + **ADR-030** field eigenmodes. No new capture code; the calibration crate calls it.
+2. **Capture guided samples** — stand, sit, lie down, slow vs normal breathing, small movement, sleep posture. Clean anchors, not hours of data. → **NEW** `EnrollmentProtocol` (Section 2.2).
+3. **Extract the useful signal** — CSI phase, amplitude, Doppler shift, micro-motion, periodicity, variance, timing. → **Reuse** `signal_features.rs` + ruvsense extractors, packaged as labelled `AnchorFeature` records (Section 2.3).
+4. **Compress patterns into small ruVector models** — *specialised* per signal: breathing, heartbeat, sleep restlessness, posture, presence, anomaly. → **NEW** `SpecialistBank` trained via `rapid_adapt` LoRA heads over the frozen ADR-150 backbone, stored as RVF (Section 2.4).
+
+---
+
+## 2. Decision
+
+**Build the RuView Per-Room Calibration & Specialized Model Training System: a four-stage, local-first pipeline (`baseline → enroll → extract → train`) that produces a versioned *bank of small specialised ruVector models* scoped to one `room_id`, each a lightweight head distilled/adapted from the frozen, Hugging-Face-published RF Foundation Encoder (ADR-150).** Big model understands the world; small ruVector models understand *your room*.
+
+Two invariants govern every design choice below:
+
+> **(A) Specialisation over scale.** One small model per biological signal, not one large model for all of them. Each specialist is faster, cheaper, more private, and — because it is calibrated to the room's actual fingerprint — often *more accurate* than a general model.
+>
+> **(B) Local-first, base-shared.** The frozen room/subject/device-invariant backbone is the only artifact published to Hugging Face. Per-room baselines and per-specialist heads never leave the device unless the operator opts into federation (ADR-105).
+
+### 2.1 System architecture
+
+```
+                       HUGGING FACE HUB (public, room-agnostic)
+                       ┌───────────────────────────────────────┐
+                       │  RF Foundation Encoder (ADR-150)       │
+                       │  pose-preserving · subject/room/device │
+                       │  -invariant · frozen · safetensors     │
+                       └───────────────┬───────────────────────┘
+                                       │  from_pretrained() once, cached on device
+                                       ▼
+  STAGE 1 baseline        STAGE 2 enroll        STAGE 3 extract         STAGE 4 train (per room_id)
+  ┌──────────────┐        ┌──────────────┐      ┌────────────────┐      ┌─────────────────────────┐
+  │ ADR-135      │        │ Enrollment   │      │ signal_features│      │ SpecialistBank          │
+  │ Baseline-    │──fp──► │ Protocol     │─clip►│ + ruvsense     │─AF──►│  frozen backbone        │
+  │ Calibration  │        │ guided       │      │ extractors     │      │   │  ┌────────────────┐  │
+  │ (env finger- │        │ anchors:     │      │ → AnchorFeature│      │   ├─►│ breathing head │  │
+  │  print)      │        │ stand/sit/   │      │ (phase, amp,   │      │   ├─►│ heartbeat head │  │
+  │ ADR-030      │        │ lie/breathe/ │      │  doppler,      │      │   ├─►│ restless head  │  │
+  │ field eigen  │        │ move/sleep   │      │  micromotion,  │      │   ├─►│ posture head   │  │
+  └──────────────┘        └──────────────┘      │  periodicity,  │      │   ├─►│ presence head  │  │
+        │                                        │  variance,     │      │   └─►│ anomaly head   │  │
+        │  baseline drift > τ → invalidate bank  │  timing)       │      │     (LoRA / ruVector    │
+        └───────────────────────────────────────┴────────────────┴──────┤      small models)      │
+                                                                          └───────────┬─────────────┘
+                                                                                      │ RVF container
+                                                                                      ▼
+                                                              RUNTIME: Mixture-of-Specialists
+                                                              each head emits {value, confidence};
+                                                              coherence_gate (ADR-135) + anomaly
+                                                              head veto → fused RoomState
+```
+
+The shared backbone is loaded **once per device** and frozen. Every specialist is a small head over its embedding — so the marginal cost of a sixth specialist is kilobytes of LoRA weights, not another full model.
+
+### 2.2 Stage 2 — the guided enrollment protocol (NEW)
+
+`EnrollmentProtocol` is a CLI-driven state machine that walks the operator through a fixed sequence of labelled **anchors**. The design rule from the user vision is explicit: *clean anchors, not hours of data.* Each anchor is a short (default 20 s @ 20 Hz = 400 frames) labelled clip captured against the already-recorded baseline.
+
+| Anchor | Label | Duration | Primary signal taught | Feature emphasis |
+|--------|-------|----------|-----------------------|------------------|
+| `empty` | presence=0 | (reuse ADR-135 baseline) | absence reference | amplitude variance floor |
+| `stand_still` | posture=standing, presence=1 | 20 s | static human load | amplitude mean shift, eigenmode delta |
+| `sit` | posture=sitting | 20 s | lower static load | amplitude profile |
+| `lie_down` | posture=lying | 20 s | sleep-position load | amplitude profile, low Doppler |
+| `breathe_slow` | resp≈0.1–0.15 Hz | 30 s | slow respiration | periodicity, micro-Doppler |
+| `breathe_normal` | resp≈0.2–0.3 Hz | 30 s | normal respiration | periodicity, BVP phase |
+| `small_move` | motion=1 | 20 s | limb micro-motion | Doppler spread, variance |
+| `sleep_posture` | posture=lying, restless=0 | 30 s | quiescent sleep baseline | long-window variance, timing |
+
+The protocol is **adaptive**: an anchor is only accepted when its captured features pass a quality gate (coherence ≥ threshold from `coherence_gate.rs`, sufficient SNR vs baseline, no saturation). A failed anchor is re-prompted rather than silently kept — bad anchors poison small models far more than large ones. Total guided enrollment is ~4 minutes of wall-clock, producing 8 clean anchors. This is intentionally far below the "hours of data" that a from-scratch model needs, because the backbone already carries world knowledge; enrollment only teaches *this* room's offsets.
+
+Anchors are persisted as an append-only `EnrollmentSession` (event-sourced, per CLAUDE.md state rules) under `room_id`, so re-enrollment is incremental and auditable.
+
+### 2.3 Stage 3 — feature extraction to labelled records (REUSE + bridge)
+
+Each accepted anchor clip is run through the existing extractor stack, baseline-subtracted per ADR-135, and packaged into an `AnchorFeature` record. No new DSP is invented — this stage is a *bridge*, not a new algorithm.
+
+| Feature group | Source module | Used by specialists |
+|---------------|---------------|---------------------|
+| CSI amplitude mean/variance | ADR-135 baseline subtraction + `signal_features.rs` | presence, posture |
+| CSI phase (sanitised, LO-aligned) | `phase_sanitizer` → `phase_align` | posture, heartbeat |
+| Doppler shift / micro-Doppler | `ruvsense/bvp.rs`, `breathing` path | breathing, small-move |
+| Micro-motion / intention lead | `ruvsense/intention.rs` | restlessness, anomaly |
+| Periodicity / spectral peaks | `bvp.rs` autocorrelation + FFT | breathing, heartbeat |
+| Long-window variance / drift | `ruvsense/longitudinal.rs` (Welford) | restlessness, presence |
+| Timing / inter-frame epoch | `c6_timesync` epoch, frame Δt | all (rhythm alignment) |
+| Field eigenmode coefficients | ADR-030 `field_model.rs` | posture, presence |
+
+`AnchorFeature` = `{ room_id, anchor_label, t_epoch_us, embedding: [f32; D] (backbone output), aux: { resp_hz?, doppler_spread, variance, periodicity_score, eigen_coeffs } }`. The backbone embedding is the *shared* representation; `aux` carries the cheap hand-features that let small heads specialise without re-learning DSP.
+
+### 2.4 Stage 4 — the specialist bank (NEW, the core contribution)
+
+A **`SpecialistBank`** is a versioned collection of small models scoped to one `room_id`, persisted as a single RVF cognitive container (`wifi-densepose-ruvector`). Each specialist is a *head* over the frozen backbone embedding, trained from the labelled `AnchorFeature` records via the existing `rapid_adapt.rs` LoRA machinery (test-time/few-shot training, contrastive + entropy losses), **not** a from-scratch network.
+
+| Specialist | Model type | Params (typ.) | Label source | Output |
+|------------|-----------|---------------|--------------|--------|
+| **breathing** | 1-D temporal head + periodicity regressor | ~8 KB LoRA + aux | `breathe_slow`/`breathe_normal` | resp rate (Hz) + confidence |
+| **heartbeat** | narrowband phase head (harmonic-aware) | ~12 KB | quiescent anchors + periodicity | HR (bpm) + confidence |
+| **sleep restlessness** | variance/drift classifier | ~4 KB | `sleep_posture` vs `small_move` | restlessness score [0,1] |
+| **posture** | k-way prototype classifier (HNSW NN) | prototypes only | `stand/sit/lie` anchors | posture class + margin |
+| **presence** | binary energy/eigenmode gate | ~2 KB | `empty` vs occupied anchors | presence prob |
+| **anomaly** | one-class / physically-impossible detector (`adversarial.rs`) | ~6 KB | baseline + all anchors (novelty) | anomaly score + veto flag |
+
+Design properties that follow from invariant (A):
+
+- **Independently versioned & swappable.** Re-enrolling breathing does not retrain posture. A specialist carries its own `{trained_at, anchor_set_hash, baseline_hash, backbone_rev}`.
+- **HNSW prototype storage for the classifiers.** Posture and presence are nearest-prototype lookups in the RVF index — no inference engine, microsecond latency, and new postures are added by inserting a prototype, not retraining.
+- **SONA online adaptation.** Each specialist may carry a SONA/MicroLoRA online-adaptation slot (`ruvllm_sona_*` / `microlora` primitives) so it tracks slow drift (furniture moved, seasonal RF change) between full re-enrollments, gated by ADR-135 baseline drift.
+- **Teacher–student distillation (optional, offline).** Where a labelled public corpus exists (MM-Fi, Wi-Pose), the ADR-150 backbone acts as teacher to pre-shape a head before per-room fine-tuning, improving cold-start. The *teacher* is global/HF; the *student head* is local.
+
+**Invalidation contract.** The bank stores the `baseline_id` (the baseline UUID) it was trained against. **As implemented**, the runtime marks the bank `STALE` whenever the *current* baseline id differs from the trained one — a conservative trigger that catches re-calibration (room rearranged, AP moved, band changed) because any of those produces a new baseline. A finer **drift-threshold** trigger (mark STALE when ADR-135's per-subcarrier deviation exceeds τ *without* a full re-baseline) is a planned refinement (P6). Either way the runtime prompts re-enrollment rather than emitting silently wrong vitals — the calibration analogue of the #954 `DEGRADED` honesty rule: never report confident numbers from an invalid model.
+
+### 2.5 Runtime — mixture of specialists with confidence gating
+
+At inference, the frozen backbone embeds each CSI window once; every specialist consumes that shared embedding and emits `{value, confidence}`. Fusion rules:
+
+- The **anomaly** specialist holds a **veto**: a high anomaly score (physically-impossible signal per `adversarial.rs`, or a coherence-gate `Reject`) suppresses positive vitals/posture output and raises a flag, rather than propagating a hallucinated reading.
+- **presence=0** short-circuits breathing/heartbeat/posture to `null` (you cannot have a respiration rate in an empty room).
+- Each emitted reading is tagged with the specialist's confidence and the `baseline_hash`/`backbone_rev` provenance, so downstream consumers (sensing-server, MQTT, Home Assistant) can gate on quality — consistent with ADR-135 coherence-gate semantics.
+
+### 2.6 Crate & module layout
+
+New bounded-context crate `wifi-densepose-calibration` (orchestration only; files < 500 lines, typed public APIs, event-sourced sessions — per CLAUDE.md):
+
+```
+wifi-densepose-calibration/
+  src/
+    lib.rs                 # public API: CalibrationSystem facade
+    enrollment.rs          # EnrollmentProtocol state machine (Stage 2)
+    anchor.rs              # Anchor, EnrollmentSession (event-sourced)
+    extract.rs             # AnchorFeature bridge over signal_features + ruvsense (Stage 3)
+    specialist.rs          # Specialist trait, SpecialistKind enum
+    bank.rs                # SpecialistBank (RVF container, versioning, invalidation)
+    runtime.rs             # MixtureOfSpecialists fusion + veto (Stage 5)
+    backbone.rs            # frozen ADR-150 encoder loader (hf_hub from_pretrained, cached)
+    error.rs
+```
+
+Dependencies (no duplication — orchestrates existing crates): `wifi-densepose-signal` (ruvsense extractors, ADR-135 baseline), `wifi-densepose-train` (`rapid_adapt`, `signal_features`, `trainer`), `wifi-densepose-ruvector` (RVF, HNSW), `wifi-densepose-nn` (backbone inference). The `wifi-densepose-cli` gains `enroll`, `train-room`, and `room-status` subcommands, sequenced after the existing ADR-135 `calibrate`.
+
+### 2.7 CLI flow (operator-facing)
+
+```bash
+# Stage 1 — environmental fingerprint (ADR-135, existing)
+wifi-densepose calibrate --room living-room --duration 60s     # empty room
+
+# Stage 2+3 — guided enrollment (NEW); prompts through 8 anchors, ~4 min
+wifi-densepose enroll --room living-room
+#   → "Stand still in view of the sensor…"  [✓ anchor accepted: coherence 0.91]
+#   → "Sit down…"                            [✗ low SNR, retrying]
+#   ...
+
+# Stage 4 — train the specialist bank (NEW); reuses cached HF backbone
+wifi-densepose train-room --room living-room \
+    --specialists breathing,heartbeat,restlessness,posture,presence,anomaly
+
+# Status / invalidation
+wifi-densepose room-status --room living-room
+#   baseline: fresh (drift 0.04 < 0.20) · backbone: rf-foundation@1.2.0
+#   breathing  ✓ trained 2026-06-09  conf p50 0.88
+#   heartbeat  ✓ trained 2026-06-09  conf p50 0.71
+#   posture    ✓ 3 prototypes (stand/sit/lie)
+#   anomaly    ✓  · presence ✓  · restlessness ✓
+```
+
+---
+
+## 3. Consequences
+
+### 3.1 Positive
+
+- **Fidelity through specialisation.** Six small calibrated heads beat one oversized general model on the cross-room/cross-subject frontier that ADR-150 quantified — and each runs in microseconds-to-milliseconds, on-device.
+- **Privacy by construction.** Only the room-agnostic backbone is public (HF). The environmental fingerprint and the person-specific heads stay local; no video, no skin, no cloud round-trip. This is the core differentiator vs cameras and the convenience differentiator vs wearables.
+- **Minutes, not hours.** Because the backbone carries world knowledge, ~4 minutes of clean anchors calibrates a room. Re-enrollment is incremental.
+- **Honest degradation.** The `baseline_hash` invalidation + anomaly veto mean an out-of-calibration room reports `STALE`/flagged rather than confidently wrong — the same honesty principle as the firmware `DEGRADED` flag.
+- **Composable & cheap to extend.** A new biological signal = a new small head over the same embedding, not a new model.
+
+### 3.2 Negative / risks
+
+- **Backbone dependency.** Every specialist rides on ADR-150's encoder; its quality and revision compatibility (`backbone_rev`) are a single point of leverage. Mitigation: pin `backbone_rev` in each specialist; distillation cold-start reduces sensitivity.
+- **Enrollment burden.** 4 minutes is small but non-zero, and anchor quality depends on the operator following prompts. Mitigation: adaptive re-prompting + quality gates; ship sane defaults so a partial bank (presence+posture) works after just the static anchors.
+- **Heartbeat is hard.** Sub-mm chest displacement at HR frequencies is near the ESP32-S3 noise floor; the heartbeat specialist will have lower and more variable confidence than breathing. The confidence-gated runtime surfaces this rather than faking it.
+- **Per-room storage proliferation.** A bank per room per person; needs a clear RVF lifecycle (list/prune/export) — handled by `bank.rs` versioning and the `room-status` CLI.
+
+### 3.3 Alternatives considered
+
+| Alternative | Verdict | Reason |
+|-------------|---------|--------|
+| One large general model for all signals | **Rejected** | The ADR-150 evidence: scale overfits rooms/subjects and collapses cross-domain; also slower, costlier, less private. Directly contradicts invariant (A). |
+| Cloud training of per-room models | **Rejected** | Violates invariant (B): would ship raw CSI of a person's home/sleep to a server. Local-first is the privacy promise. Federation (ADR-105) is the *opt-in* path for shared improvement, exchanging gradients/deltas, never raw CSI. |
+| Skip the backbone; train each specialist from scratch | **Rejected** | Reintroduces the "hours of data" requirement the user vision explicitly rejects, and loses cross-room priors. |
+| Fold this into ADR-135 | **Rejected** | ADR-135 is *room* calibration (no humans). This ADR is *human-anchor* enrollment + model training on top of it. Distinct lifecycles, distinct invalidation; kept as separate bounded contexts. |
+
+---
+
+## 4. Implementation phases
+
+| Phase | Scope | Exit criterion | Status |
+|-------|-------|----------------|--------|
+| **P1** | Scaffold `wifi-densepose-calibration` crate; `AnchorFeature` schema; (backbone via `hf_hub` deferred) | Crate + schema; unit tests | ✅ Done (crate + Stage-1 baseline via `calibrate`/`calibrate-serve`; HF backbone deferred) |
+| **P2** | `EnrollmentProtocol` + `anchor.rs` (event-sourced sessions) + CLI `enroll` with quality gates | 8-anchor enrollment; bad anchors re-prompt | ✅ Done (`anchor.rs`, `enrollment.rs`, CLI `enroll`) |
+| **P3** | `extract.rs` bridge → labelled records; baseline subtraction (ADR-135) | `AnchorFeature` records persisted per `room_id` | ✅ Done (`extract.rs`; autocorr periodicity + variance/motion) |
+| **P4** | `SpecialistBank` + presence/posture (prototype) + breathing (periodicity); persistence + versioning | `train-room` produces a bank; `room-status` reads it back | ✅ Done (`specialist.rs`, `bank.rs`, CLI `train-room`/`room-status`; JSON persistence — RVF/HNSW = future) |
+| **P5** | heartbeat + restlessness + anomaly specialists; `runtime.rs` mixture + veto + confidence gating | End-to-end RoomState on hardware; anomaly veto verified | ✅ Done (`runtime.rs`, CLI `room-watch`; breathing read live on COM8 ESP32) |
+| **P6** | Baseline-drift `STALE` invalidation; SONA online adaptation; optional ADR-105 federation; HF teacher–student distillation | Drift marks bank STALE; AetherArena entry | ◐ Partial (STALE done; SONA/federation/HF-backbone = follow-ups) |
+
+**Current status (2026-06-10):** Stages 1–5 implemented with *statistical* specialists (threshold/prototype/autocorrelation). 55 tests (35 unit incl. multistatic + 1 full-loop integration + 19 CLI), all passing under qemu-aarch64. **Validation scope is precise:** baseline capture + HTTP API + auth are proven on real CSI (Pi-5 nexmon, 6,813 frames; and an ESP32-S3). The complete `baseline → enroll → train-room → infer` loop is now **proven in-process** on deterministic synthetic CSI (`tests/full_loop.rs`: clean baseline with zero motion flags, 8/8 anchors through the quality gate, 6 specialists trained, JSON bank round-trip, trained-bank inference 18±2 BPM positive / absent negative / foreign-baseline STALE; seed-robust). The one live runtime signal (breathing ~16–31 BPM via `room-watch`) used the *stateless* breathing head, **not** a trained bank; the clean empty-room loop has **not** yet run on-target — the remaining gap is strictly the hardware session (empty room + operator anchors). The four behavioral findings from the full-loop test (z-band squeeze, variance-only presence, ungated hz embedding, heart-band lag-floor leakage) are FIXED and regression-guarded — see the integration doc §7. SOTA-intake decisions affecting this system (geometry conditioning, checkerboard alignment) are recorded in ADR-152. Open refinements: `--source-format adr018v6` (drive from the Pi's own nexmon), phase-based breathing carrier, RVF/HNSW storage, and the ADR-150 frozen HF backbone the specialists would distill from.
+
+Validation per CLAUDE.md: `cargo test --workspace --no-default-features` green; hardware verification on the ESP32-S3 (currently COM8) before any release; witness bundle regenerated if the proof surface changes.
+
+---
+
+## 5. Summary
+
+> Big models understand the world. Small ruVector models understand *your room*.
+
+ADR-151 makes that operational: a local-first `baseline → enroll → extract → train` pipeline that turns ~4 minutes of clean human anchors — layered on ADR-135's empty-room fingerprint and ADR-150's Hugging-Face-published invariant backbone — into a versioned bank of tiny, specialised, privacy-preserving models for breathing, heartbeat, restlessness, posture, presence, and anomaly. Specialisation over scale; local heads over a shared base; honest `STALE` degradation over confident error.

docs/adr/ADR-152-wifi-pose-sota-2026-intake.md

@@ -0,0 +1,125 @@
+# ADR-152: WiFi-Pose SOTA 2026 Intake — Geometry-Conditioned Calibration, External Benchmarks, and the Foundation-Encoder Training Recipe
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed |
+| **Date** | 2026-06-10 |
+| **Deciders** | ruv |
+| **Codebase target** | `wifi-densepose-calibration` (geometry conditioning, ADR-151 Stage 2), `wifi-densepose-train` (camera-supervised path, MAE recipe), `wifi-densepose-cli` (benchmark harness), docs |
+| **Relates to** | ADR-151 (Per-Room Calibration), ADR-150 (RF Foundation Encoder), ADR-135 (Empty-Room Baseline), ADR-079 (Camera-Supervised Pose), ADR-027 (MERIDIAN), ADR-024 (AETHER), ADR-149 (AetherArena), ADR-029 (Multistatic) |
+| **Research provenance** | Deep-research run 2026-06-10: 22 sources fetched, 110 claims extracted, 25 adversarially verified (3-vote), 24 confirmed / 1 refuted. Evidence grades per source below. |
+
+---
+
+## 1. Context
+
+A structured survey of the 2025–2026 WiFi human-sensing state of the art was run on 2026-06-10 to answer: *what should RuView integrate next, and does anything published invalidate our current direction?* Every claim below was verified against the primary source by independent adversarial reviewers; **evidence grades distinguish what the papers measured from what they merely claim**. Almost all performance numbers are author-self-reported preprint results — treated here as CLAIMED until reproduced on our hardware.
+
+### 1.1 The five verified findings
+
+**(F1) "Coordinate overfitting" is a named, diagnosed failure mode of camera-supervised WiFi pose — and our ADR-079 pipeline has the exact shape of it.**
+PerceptAlign (arXiv [2601.12252](https://arxiv.org/abs/2601.12252), accepted ACM MobiCom 2026) shows that models regressing CSI directly to camera-frame coordinates memorize the deployment-specific transceiver layout; SOTA baselines degrade to >600 mm MPJPE in unseen scenes. Their fix is cheap: a <5-minute calibration using two checkerboards and a few photos to align WiFi and vision in one shared 3D frame, plus **fusing transceiver-position embeddings with CSI features**. Claimed: −12.3% in-domain error, −60%+ cross-domain error. They release the claimed-largest cross-domain 3D WiFi pose dataset (21 subjects, 5 scenes, 18 actions, **7 device layouts**). *Evidence: improvements CLAIMED (preprint w/ MobiCom acceptance); the failure mode itself is corroborated across the cross-domain literature — and independently by our own ADR-150 data (81.63% in-domain vs ~11.6% leakage-free cross-subject torso-PCK).*
+
+**(F2) An external model named "WiFlow" claims 97.25% PCK@20 with 2.23M params and ships everything.**
+arXiv [2602.08661](https://arxiv.org/abs/2602.08661) (Apr 2026) — spatio-temporal-decoupled CSI pose, 97.25% PCK@20 / 99.48% PCK@50 / 0.007 m MPJPE, 2.23M parameters (~2.2 MB int8). Code, pretrained weights, and a 360k-sample CSI-pose dataset are public under Apache-2.0 ([repo](https://github.com/DY2434/WiFlow-WiFi-Pose-Estimation-with-Spatio-Temporal-Decoupling), Kaggle dataset). *Evidence: artifact availability MEASURED (verified by direct repo inspection); PCK numbers CLAIMED (5-subject, in-domain, self-collected dataset; hardware unspecified; 15 keypoints vs our 17).* ⚠️ **Name collision:** this is unrelated to RuView's internal WiFlow model. In all RuView docs the external model is referred to as **WiFlow-STD (DY2434)**.
+
+**(F3) For CSI foundation encoders, data scale — not model capacity — is the bottleneck, and the tokenization recipe is now known.**
+UNSW's MAE pretraining study (arXiv [2511.18792](https://arxiv.org/abs/2511.18792), Nov 2025) — the largest heterogeneous CSI pretraining run to date (1,320,892 samples, 14 public datasets incl. MM-Fi, Widar 3.0, Person-in-WiFi 3D; 4 devices; 2.4/5/6 GHz; 20–160 MHz) — reports zero-shot cross-domain gains of 2.2–15.7% over supervised baselines, with unseen-domain performance scaling **log-linearly with pretraining data, unsaturated at 1.3M samples**, while ViT-Base adds only 0.4–0.9% over ViT-Small. Optimal recipe: **80% masking ratio, small (30,3) patches** (+4.7% over (40,5) by preserving fine temporal dynamics). *Evidence: MEASURED within-study (ablations verified in body text) but preprint; downstream tasks are classification, NOT pose — pose transfer is a hypothesis. Independently corroborates ADR-150's finding that capacity hurts cross-subject.*
+
+**(F4) Hardware/standards: 802.11bf is finished; Espressif ships official sensing; Wi-Fi 6 AP CSI is reachable.**
+- **IEEE 802.11bf-2025** published **2025-09-26** (verified against the IEEE SA record) — sensing standardization is complete for both sub-7 GHz and >45 GHz, with formal sensing setup/feedback procedures. No ESP32 silicon implements it yet. *Evidence: MEASURED (standards-body record).*
+- **Espressif `esp_wifi_sensing`** (Apache-2.0, v0.1.x, ESP Component Registry): official CSI presence/motion FSM; esp-csi actively maintained (commit 2026-04-22, verified), CSI confirmed across ESP32/S2/C3/S3/C5/C6/C61. *Evidence: MEASURED (vendor pages + commit log).* ⚠️ A stronger "drop-in compatible with RuView nodes" claim was **REFUTED 0-3** — WiFi-6 parts use a different CSI acquisition config struct.
+- **ZTECSITool** (arXiv [2506.16957](https://arxiv.org/abs/2506.16957), [code](https://github.com/WiFiZTE2025/ZTE_WiFi_Sensing)): CSI from commercial Wi-Fi 6 APs at up to 160 MHz / 512 subcarriers (~5–10× ESP32 subcarrier count; the gain is aperture, not per-Hz granularity). Firmware is gated behind a ZTE serial-number approval. *Evidence: capability CLAIMED by the vendor-authored tool paper; code artifact MEASURED.*
+
+**(F5) Nothing in 2025–2026 does full DensePose UV regression from commodity WiFi.** Keypoint pose remains the field's frontier. Three "wireless foundation model" papers were screened out by full-text inspection (HeterCSI = simulated cellular channels only; the NeurIPS-2025 FMCW pilot = mmWave radar, presence-only; arXiv 2509.15258 = survey, no artifacts). *Evidence: MEASURED (absence verified by full-text inspection of the candidates that surfaced; absence of evidence across the whole literature is necessarily weaker).*
+
+### 1.2 What this means for the ADR-151 calibration system
+
+ADR-151's enrollment protocol captures guided human anchors but does **not** record or condition on transceiver geometry. F1 says that omission is precisely the thing that makes camera-supervised (and, plausibly, anchor-supervised) heads layout-brittle. ADR-151's per-room thesis ("teach the room before you teach the model") is *strengthened* by F1 — PerceptAlign is independent evidence that layout must be modeled explicitly — and the fix composes naturally with our Stage-2 enrollment.
+
+ADR-150's masked-CSI-encoder design is *validated* by F3, which also hands us the hyperparameters and the priority call: **collect/aggregate more heterogeneous CSI before scaling the encoder.**
+
+## 2. Decision
+
+Adopt four changes, ordered by effort-vs-gain:
+
+### 2.1 Geometry-condition the calibration system (extends ADR-151 Stage 2) — ACCEPTED
+
+1. **Record transceiver geometry at enrollment.** `EnrollmentProtocol` gains an optional `NodeGeometry` record per node (position estimate, antenna orientation, inter-node distances where known). Stored alongside the room baseline in the bank; schema-versioned so existing banks remain readable.
+2. **Fuse geometry embeddings into specialist training.** Where a specialist head consumes the (future, ADR-150) backbone embedding, concatenate a small learned embedding of `NodeGeometry` — the PerceptAlign mechanism, transplanted to our per-room banks. Statistical specialists (current) ignore it; LoRA heads (ADR-151 P6) consume it.
+3. **Adopt the two-checkerboard alignment for the camera-supervised path (ADR-079).** When MediaPipe supervision is used, calibrate camera↔WiFi into one shared 3D frame before regression (<5 min, two checkerboards, a few photos). This is the direct defense against F1 for our camera-supervised pipeline. ~~92.9%-PCK@20~~ — *that figure was retracted during measurement (b) (2026-06-10): the surviving holdout shows a constant-output model under an absolute (non-torso) threshold on 69 near-static frames; mean predictor scores 100% under the same protocol. The §2.2 no-citation rule now applies to it.*
+4. **Evaluate on the PerceptAlign cross-domain dataset** (21 subjects / 7 layouts) as the MERIDIAN cross-layout benchmark — *gated on confirming its license and downloadability* (open question; repo per paper: github.com/Trymore-lab/PerceptAlign).
+   > **Gate resolved (2026-06-10, MEASURED by repo inspection):** repo exists, **MIT license**, dataset downloadable from HuggingFace (5 per-scene repos, raw CSI + separate vision keypoints; Intel 5300, 1TX×3RX×3 ant, 57 subcarriers — same order as ESP32 subcarrier counts; Scene3 ships 3 distinct layouts). Code present, no pretrained weights. Benchmark adoption unblocked; dataset-side license terms inherit HF dataset terms (not separately stated — check at download time).
+
+### 2.2 Benchmark against WiFlow-STD (DY2434) — ACCEPTED
+
+Pull the Apache-2.0 weights + 360k-sample dataset; run three measurements: (a) their model on their data (reproduce 97.25% claim), (b) their model fine-tuned on our ESP32 17-keypoint eval set, (c) our internal WiFlow on their dataset (15-keypoint subset mapping). Until (a)–(c) are measured, **no RuView doc may cite 97.25% as a comparable number** — different dataset, subjects, keypoints.
+
+> **Status (2026-06-10, measurement (a) complete — `benchmarks/wiflow-std/RESULTS.md`):** shipped checkpoint REFUTED (0.08% PCK@20 — wrong keypoint normalization, predates published code); released code does not run as published (6 defects, incl. broken package import and an unreachable test phase); released dataset's last 13 files are corrupted (9,072 windows: NaN + float32-max garbage, diverges fp16 training via BatchNorm poisoning). After repairing both, retraining with upstream defaults reproduced **96.09% PCK@20 full-test / 96.61% corruption-free / MPJPE 0.0094–0.0098** (published: 97.25% / 0.007) on an RTX 5080. Accuracy claims graded MEASURED-EQUIVALENT; params (2.23M) and FLOPs (~0.055G) verified. (b)/(c) remain open.
+
+### 2.3 Apply the UNSW recipe to the ADR-150 encoder — ACCEPTED (amends ADR-150 §2.3)
+
+- Pretraining corpus: start from the same 14 public datasets (1.3M samples) + our home/MM-Fi frames; data aggregation takes priority over architecture work.
+- Tokenization: 80% masking, (30,3)-class small patches; encoder stays ViT-Small-class (~15M params) — F3 and our own DANN/transformer results agree that capacity does not pay.
+- The published log-linear scaling (unsaturated) sets the expectation: more heterogeneous CSI in, better zero-shot out.
+
+### 2.4 Hardware watch items — ACCEPTED (no code now)
+
+- **802.11bf**: track silicon/certification; OTA binding remains deferred until commodity chipsets expose standardized sensing measurements. **Amended by ADR-153** (2026-06-10): implement a pure Rust forward-compatibility protocol layer now — typed procedure models, a deterministic session FSM, a transport abstraction, simulation tests, and an `OpportunisticCsiBridge` that maps today's ESP32 CSI batches into standardized sensing-report shape.
+- **esp_wifi_sensing**: benchmark our presence pipeline against the vendor FSM (one afternoon; useful external baseline). Do **not** treat as drop-in (refuted claim).
+- **ZTECSITool AP**: optional high-resolution anchor node for the ADR-029 multistatic mesh — procurement-gated; only pursue if a 160 MHz anchor materially helps tomography.
+
+### 2.5 Explicitly NOT adopted
+
+- No pivot toward "wireless foundation model" papers that don't ship WiFi-CSI artifacts (HeterCSI, FMCW pilot, surveys).
+- No DensePose-UV work item: the field has not demonstrated UV regression from commodity WiFi; keypoints remain our supervised target (F5).
+
+### 2.6 RuVector vendor sync + integration opportunities (added 2026-06-10)
+
+**Vendor sync record.** `vendor/ruvector` moved from pin `e38347601` (2026-05-07) to `a083bd77f` (origin/main, 3 commits past tag `ruvector-v0.2.28`; vendored workspace version 2.2.3). 111 commits in the range, roughly half NAPI-binary/lint chores. Substantive: graph condensation + differentiable min-cut (#547), core HNSW correctness fixes v2.2.3 (#502), RUSTSEC/clippy hardening (#504), ONNX embedder API-contract fix (#523/#525 — npm/TypeScript package only), dead parallel-worker import removal (#532). *Evidence: MEASURED (git range + commit-stat inspection).*
+
+**Opportunity table.** Workspace policy is crates.io versions only, so unpublished crates are WATCH by definition regardless of fit.
+
+| Crate | What it offers | wifi-densepose target | crates.io | Verdict |
+|---|---|---|---|---|
+| `ruvector-graph-condense` (new, #547) | Training-free min-cut graph condensation + **differentiable normalized-cut loss** (`DiffCutCondenser`, analytic MinCutPool-style gradients, gradient-checked tests; provenance-retaining super-nodes) | `subcarrier_selection.rs` (condense 114 subcarriers into cut-preserving regions instead of raw min-cut); auxiliary clustering regularizer for `wifi-densepose-train`; `DynamicPersonMatcher` region structure | **Not published** | **WATCH** — strongest technical fit in the sync; adopt when published. README's "no published method uses graph-cut condensation" is CLAIMED; the diffcut implementation + tests are MEASURED |
+| `ruvector-attention` 2.1.0 | #304 SOTA modules: MLA, KV-cache, SSM, sparse/MoE, hybrid search, Graph RAG (publish date 2026-03-27 matches the #304 commit — MEASURED) | Supersedes pinned 2.0.4 used by `model.rs` spatial attention + `bvp.rs`; SSM/MLA are candidate pure-Rust edge-inference primitives for the ADR-150 encoder | 2.1.0 (pinned **2.0.4**) | **ADOPT** (minor bump; API-compat check first) |
+| `ruvector-gnn` 2.2.0 | panic→`Result` constructors, gradient clipping, MSE/CE/BCE losses, seeded-RNG layer init (#495 is post-2.2.0) | `wifi-densepose-train` GNN path (pinned 2.0.5, `default-features = false`) | 2.2.0 (pinned **2.0.5**) | **ADOPT** (bump) |
+| `ruvector-mincut` / `ruvector-solver` 2.0.6 | Patch-level fixes (workspace republish 2026-03-25) | `metrics.rs` DynamicPersonMatcher, subcarrier interpolation, triangulation | 2.0.6 (pinned **2.0.4** each) | **ADOPT** (routine patch bump) |
+| `ruvector-core` 2.2.3 (vendor) | HNSW correctness: k=0 guard, sorted results, flat-index fixes, cross-integration helpers (#502 — MEASURED, `index/hnsw.rs` + new integration tests) | `homecore-recorder` `RuvectorSemanticIndex` (real HNSW consumer); `sketch.rs` quantization unaffected | **2.2.0 = latest published**; 2.2.3 unpublished | **WATCH** — bump the moment 2.2.3 publishes |
+| `ruvector-cnn` 2.0.6 | Pure-Rust SIMD conv kernels (AVX2/NEON/WASM), MobileNetV3, INT8 quantization, contrastive losses (InfoNCE/triplet, #252) | **Not** the WiFlow-STD training port — `wiflow_std/model.rs` is tch/libtorch (MEASURED). Relevant to the *edge inference* path of the trained ~2.2 MB int8 model, and InfoNCE/triplet overlaps AETHER (ADR-024) | 2.0.6 | **EVALUATE** — only if/when we commit to a no-libtorch edge runtime for WiFlow-STD-class models |
+| `ruvector-acorn` (new-ish) | ACORN predicate-agnostic filtered HNSW (SIGMOD'24 algorithm; γ·M denser graphs for low-selectivity filters) | Metadata-filtered pattern search over ADR-151 calibration banks — speculative; bank sizes are far below where filtered-ANN recall collapse matters | **Not published** | **WATCH** |
+| `ruvector-cluster` 2.0.6 | Distributed sharding, gossip discovery, DAG consensus | No current need; ADR-029 mesh coordination is ESP32-side, not vector-DB-side | 2.0.6 | **WATCH** |
+| ONNX embedder fix (#523/#525) | API-contract + packaging fixes in `npm/packages/ruvector` (TypeScript) | None — `wifi-densepose-nn`'s ONNX backend is Rust (ort/tract), untouched by this change (MEASURED: commit touches npm/ only) | n/a | No action |
+| `ruvector-perception` (new, #547) | "Physical perception substrate" (hypothesis/topology/witness modules) — agent-perception oriented, not RF | None identified | Not published | WATCH (name-overlap only) |
+
+**Security note (RUSTSEC #504).** The substantive fixes target `ruvllm`, `ruvector-dag`, `prime-radiant`, `rvagent-*`, and the `ruvector-server` HTTP endpoint (NaN-safe `partial_cmp`, input-validation guards, env-allowlisted exec) — **none of which we pin**. The commit states `cargo audit` returns clean across the workspace. *Evidence: MEASURED (commit message + file list). Conclusion: no pinned version has an outstanding advisory; no urgent bump required.* The NaN-sort hardening is panic-robustness hygiene our pinned 2.0.4-era crates predate, which is one more reason for the routine bumps below.
+
+**Version-bump recommendations (follow-up PR — no Cargo.toml change in this ADR):** `ruvector-mincut` 2.0.4→2.0.6, `ruvector-solver` 2.0.4→2.0.6, `ruvector-attention` 2.0.4→2.1.0, `ruvector-gnn` 2.0.5→2.2.0. Current: `ruvector-core` 2.2.0, `ruvector-attn-mincut` 2.0.4, `ruvector-temporal-tensor` 2.0.6, `ruvector-crv` 0.1.1 — all at latest published. Nothing in the sync changes §2.1.2 geometry conditioning (our `viewpoint/attention.rs` `GeometricBias` already implements the fusion mechanism) or the ADR-150 MAE recipe (training stays in tch).
+
+## 3. Consequences
+
+**Positive:** the calibration system gains the one mechanism (geometry conditioning) the 2026 literature identifies as the difference between layout-brittle and layout-robust supervised WiFi pose; ADR-150 gets a measured training recipe instead of a guessed one; we acquire two external benchmarks (WiFlow-STD, PerceptAlign dataset) to keep our claims honest.
+
+**Negative / risks:** geometry records add schema surface to banks (mitigated: optional + versioned); every adopted number is preprint-grade until our own benchmark runs land (mitigated by §2.2's no-citation rule); PerceptAlign dataset license is unconfirmed (gated); name collision risk in docs (mitigated: "WiFlow-STD (DY2434)" naming rule).
+
+**Re-check by 2026-12:** 802.11bf silicon, esp_wifi_sensing maturity (v0.1.x today), and the preprint field (newest source Apr 2026).
+
+## 4. Open questions (carried from the research run)
+
+1. Does WiFlow-STD retain accuracy when fine-tuned on ESP32-S3/C6 CSI (fewer subcarriers, lower SNR), scored on our 17-keypoint set? (§2.2 answers this.)
+   > **Partial answer (MEASURED 2026-06-11, measurement (b) on 2,046 single-room windows — `benchmarks/wiflow-std/RESULTS.md`):** pretrained init shows strong *optimization* transfer (65% PCK@20 vs scratch's 0% collapse under the same budget) but **no feature transfer** (frozen-trunk + linear adapter ≈ 0%). And no run beat the mean-pose baseline (95.9% PCK@20 — single subject, near-static normalized coords), so no CSI→pose capability is citable from this data. A definitive answer needs multi-subject/multi-position data where the mean pose is weak.
+2. Is the PerceptAlign dataset downloadable under a usable license, and does the two-checkerboard procedure work with ESP32 transceiver geometry? (§2.1.4 gate.)
+3. Will esp_wifi_sensing evolve toward 802.11bf compliance, replacing opportunistic CSI extraction?
+
+## 5. Source register (evidence-graded)
+
+| Source | Type | Used for | Grade |
+|---|---|---|---|
+| arXiv 2601.12252 (PerceptAlign, MobiCom'26) | preprint+acceptance | F1, §2.1 | CLAIMED numbers; failure mode corroborated |
+| arXiv 2602.08661 + DY2434 repo (WiFlow-STD) | preprint + code | F2, §2.2 | numbers CLAIMED; artifacts MEASURED |
+| arXiv 2511.18792 (UNSW MAE) | preprint | F3, §2.3 | ablations MEASURED in-study; pose transfer hypothesis |
+| IEEE SA 802.11bf-2025 record | standards body | F4, §2.4 | MEASURED |
+| Espressif component registry + esp-csi repo | vendor | F4, §2.4 | MEASURED; "drop-in" REFUTED 0-3 |
+| arXiv 2506.16957 + ZTE repo (ZTECSITool) | vendor preprint + code | F4, §2.4 | capability CLAIMED; code MEASURED |
+| arXiv 2601.18200 (HeterCSI), OpenReview LMufK3vzE5 (FMCW pilot), arXiv 2509.15258 (survey) | preprints | F5, §2.5 (screened out) | MEASURED (full-text inspection) |

docs/adr/ADR-153-ieee-802-11bf-sensing-protocol-layer.md

@@ -0,0 +1,168 @@
+# ADR-153: IEEE 802.11bf-2025 Forward-Compatibility Protocol Model for wifi-densepose-hardware
+
+- **Status**: accepted
+- **Date**: 2026-06-10
+- **Deciders**: ruv
+- **Tags**: hardware, protocol, sensing, 802.11bf, forward-compatibility
+
+## Context
+
+IEEE 802.11bf-2025 (WLAN Sensing) is an **Active Standard**: board approval
+2025-05-28, published 2025-09-26 (verified against the IEEE SA record,
+<https://standards.ieee.org/ieee/802.11bf/11574/>). Its scope modifies the
+MAC, HE and EHT PHY service interfaces, plus DMG and EDMG PHYs, for WLAN
+sensing in **1–7.125 GHz** and **above 45 GHz** bands, with formal sensing
+measurement setup, measurement instance, feedback/reporting, and
+sensing-by-proxy (SBP) procedures (ADR-152 F4, evidence grade MEASURED).
+
+No commodity silicon implements the standard yet — ESP32 parts included.
+ADR-152 §2.4 therefore decided "track silicon; no code now", with RuView's
+opportunistic CSI extraction remaining the mechanism. That left a gap: when
+silicon does land, RuView would have no typed model of the standard's
+procedures to bind to, and the integration would start from zero.
+
+ADR-152 §2.4 originally classified 802.11bf as a hardware watch item with no
+implementation work until commodity silicon exposes standardized sensing
+measurements. This ADR amends that clause: OTA binding remains deferred, but
+a pure Rust protocol model, session FSM, transport seam, and opportunistic
+CSI bridge will be implemented now so RuView consumers can target a stable
+standardized sensing interface before silicon arrives.
+
+The user directed (2026-06-10) that this **forward-compatibility protocol
+model** — a protocol surface, not a conformance implementation — be built
+now.
+
+## Decision
+
+Implement an `ieee80211bf` **forward-compatibility protocol model** in
+`wifi-densepose-hardware` (pure Rust, no internal deps, simulation-testable,
+no OTA path):
+
+> This module is not a certified 802.11bf implementation. It models the
+> public procedure shape needed by RuView and RuvSense, while intentionally
+> avoiding OTA frame binding until chipset support and vendor APIs exist.
+
+1. **`types.rs`** — typed structures for the standard's sensing procedures
+   (sub-7 GHz focus; DMG stubbed): Sensing Measurement Setup (setup ID,
+   initiator/responder and transmitter/receiver roles, bandwidth,
+   periodicity, threshold-based reporting parameters), Sensing Measurement
+   Instance, Sensing Measurement Report (CSI-variant payload), SBP
+   request/response, termination. Two future-proofing requirements:
+
+   - **Version gates** — every negotiated surface is tagged with a spec
+     profile, because vendors will expose partial or renamed capabilities
+     first:
+
+     ```rust
+     pub enum SpecProfile {
+         DraftCompatible,
+         Ieee80211Bf2025,
+         VendorExtension(String),
+     }
+     ```
+
+   - **Capability negotiation** — no hardcoded ESP32 assumptions in the
+     future-silicon path:
+
+     ```rust
+     pub struct SensingCapabilities {
+         pub sub_7_ghz: bool,
+         pub dmg: bool,
+         pub edmg: bool,
+         pub csi_report: bool,
+         pub threshold_reporting: bool,
+         pub sensing_by_proxy: bool,
+         pub max_bandwidth_mhz: u16,
+         pub max_period_ms: u32,
+         pub max_active_setups: u16,
+     }
+     ```
+
+   - **Privacy and governance fields** — sensing is presence inference, not
+     just radio telemetry. Every `SensingMeasurementSetup` carries policy
+     metadata (required, not optional), for enterprise, elderly-care,
+     retail, workplace, and municipal deployments:
+
+     ```rust
+     pub enum ConsentMode {
+         LabOnly,
+         ExplicitConsent,
+         ManagedEnterprisePolicy,
+         Disabled,
+     }
+     ```
+
+2. **`session.rs`** — deterministic event-driven session state machine:
+   `Idle → SetupNegotiating → Active → Terminating → Idle`, with explicit
+   rejection paths (unsupported parameters, setup-ID collision) and timeout
+   handling.
+3. **`transport.rs`** — a `SensingTransport` trait abstracting frame
+   exchange; a `SimTransport` test double; and an `OpportunisticCsiBridge`
+   adapter mapping today's ESP32 CSI extraction onto the report path
+   (measurement instances ≈ CSI frame batches), so current hardware sits
+   behind the standardized interface. **Replaceability benchmark
+   (acceptance test):** RuvSense must consume either ESP32 opportunistic CSI
+   or future 802.11bf chipset reports through the same `SensingTransport`
+   and `SensingMeasurementReport` path, with no consumer-side rewrite — a
+   future chipset adapter replaces `OpportunisticCsiBridge` without changing
+   consumers.
+
+Constraints: input validation at boundaries (typed errors, no panics on
+adversarial input), files under 500 lines, all protocol tests runnable
+without hardware.
+
+### Acceptance checklist
+
+| Area            | Acceptance test                                                      |
+| --------------- | -------------------------------------------------------------------- |
+| Types           | Serde round trip for setup, instance, report, SBP, termination       |
+| FSM             | Idle → setup → active → terminating → idle                           |
+| Rejection       | Unsupported bandwidth, invalid period, duplicate setup ID            |
+| Timeout         | Negotiation timeout returns typed error and resets to Idle           |
+| Threshold       | Report emitted only when threshold condition is crossed              |
+| SBP             | Proxy request maps to responder path without direct sensor coupling  |
+| Bridge          | ESP32 CSI batch becomes standardized measurement report              |
+| Safety          | No panics on malformed inputs                                        |
+| CI              | All protocol tests run without hardware                              |
+| Maintainability | Each file under 500 lines                                            |
+
+### Non-Goals
+
+This ADR does not claim IEEE 802.11bf conformance, certification, or OTA
+interoperability. It creates a typed protocol compatibility layer so RuView
+can consume standardized sensing reports when commodity silicon exposes
+them. Vendor-specific frame exchange, firmware hooks, trigger-frame
+sounding, and certification test vectors remain future ADRs.
+
+## Consequences
+
+### Positive
+- RuView can adopt standardized WLAN sensing the day any chipset exposes
+  802.11bf measurements — the data model, session FSM, and transport seam
+  already exist and are tested.
+- The `OpportunisticCsiBridge` gives current ESP32 nodes a standardized-shape
+  interface now, decoupling RuvSense consumers from the extraction mechanism.
+- Simulation transport enables protocol-level tests in CI without hardware.
+- `SpecProfile` + `SensingCapabilities` give a clean escape hatch for the
+  partial/renamed vendor capabilities that will certainly arrive first.
+- Consent/policy metadata is structural from day one, not retrofitted.
+
+### Negative
+- Code written against a standard with zero silicon risks drift: vendor
+  implementations may interpret parameters differently; the layer may need
+  rework at first real binding (drift risk scored 7/10 at acceptance).
+- Adds maintenance surface to wifi-densepose-hardware before any
+  user-visible benefit (maintenance cost scored 3/10 — small without OTA).
+
+### Neutral
+- ADR-152 §2.4's "watch item" remains: revisit when silicon/certification
+  appears (re-check by 2026-12). This ADR changes only the "no code now"
+  clause.
+
+## Links
+
+- ADR-152 — WiFi-Pose SOTA 2026 Intake (F4, §2.4 — amended by this ADR)
+- ADR-028 — ESP32 capability audit (opportunistic CSI extraction baseline)
+- ADR-029 — RuvSense multistatic sensing mode (consumer of sensing reports)
+- IEEE 802.11bf-2025 — Active Standard, board approval 2025-05-28, published
+  2025-09-26: <https://standards.ieee.org/ieee/802.11bf/11574/>

docs/adr/ADR-154-signal-dsp-beyond-sota.md

@@ -0,0 +1,234 @@
+# ADR-154: Signal/DSP Beyond-SOTA Sweep — Milestone 0 (Correctness, Provable Perf, and the SOTA Landscape)
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed |
+| **Date** | 2026-06-11 |
+| **Deciders** | ruv |
+| **Codebase target** | `wifi-densepose-signal` (`ruvsense/`, `features.rs`, `csi_processor.rs`, `spectrogram.rs`, `bvp.rs`), benches, docs |
+| **Relates to** | ADR-134 (CIR sparse recovery), ADR-135 (Empty-Room Baseline), ADR-029/030/032 (Multistatic mesh + security), ADR-152 (WiFi-Pose SOTA 2026 intake), ADR-153 (802.11bf forward-compat) |
+| **Scope** | Milestone 0 of the beyond-SOTA signal/DSP sweep: high-leverage **correctness/security fixes**, two **measured** perf wins, the per-module SOTA landscape with evidence grades, and a prioritized roadmap. **45 review findings are explicitly deferred** (§7 backlog) — nothing is silently dropped. |
+
+---
+
+## 0. PROOF discipline (this ADR's contract)
+
+This project has been publicly accused of "AI slop." This ADR answers that with **evidence, not adjectives**:
+
+- Every claimed code improvement ships with a **committed regression test** (correctness) or a **committed criterion bench** (performance).
+- Every perf number below is **MEASURED before/after** with the exact reproduce command. A perf claim without a measured before/after is **UNPROVEN** and is not made here.
+- Every external SOTA reference is graded **MEASURED** / **CLAIMED** / **THEORETICAL**, distinguishing what a paper *measured* from what it *asserts* and from what is merely *plausible*.
+- The headline finding — a **dead CIR coherence gate that silently fell back in production for every canonical frame** — is disclosed in full (§2), not buried.
+
+Test machine for the perf numbers: Windows 11, `cargo bench --release`, criterion 0.5. Numbers are wall-clock medians on this box; they are about **ratios** (before/after), which are stable across machines, not absolute ns.
+
+---
+
+## 1. Context
+
+The RuvSense signal stack (16 `ruvsense/` modules + the classic `features.rs`/`csi_processor.rs`/`spectrogram.rs`/`bvp.rs` pipeline) grew quickly across ADR-014/029/030/134/135. A beyond-SOTA review surfaced ~50 findings ranging from two **critical correctness/security defects** to micro-optimizations and SOTA-gap research items. Milestone 0 closes the **provable, high-leverage subset**: the two criticals, a divide-by-zero trio, two measured perf wins, and the research landscape. The remaining ~45 are catalogued in §7 so the backlog is explicit and auditable.
+
+---
+
+## 2. The headline finding — the ADR-134 CIR coherence gate was DEAD in production (CRITICAL, FIXED)
+
+### 2.1 What was wrong
+
+`MultistaticFuser` fuses **canonical CSI frames**: `hardware_norm.rs` resamples every chipset onto a uniform **56-tone canonical grid** before fusion (`HardwareNormalizer`, default `canonical_subcarriers = 56`). The ADR-134 CIR coherence gate (`cir_gate_coherence`, multistatic.rs) is supposed to blend a CIR dominant-tap ratio into the cross-node coherence — `coherence = 0.7·freq + 0.3·dominant_tap_ratio`.
+
+But the gate was wired to `CirEstimator::new(CirConfig::ht20())` (`with_cir_ht20`), and `ht20()` expects **64 FFT bins or 52 active tones**. A canonical-56 frame matches *neither*, so every call returned `CirError::SubcarrierMismatch` and `cir_gate_coherence` hit its **silent `Err(_) => freq_coherence` fallback** (multistatic.rs). Net effect: **the CIR gate never ran on a single production frame** — `use_cir_gate = true` was indistinguishable from `false`. This is the exact shape of "AI slop": a feature that compiles, has tests on the *estimator*, and is dead at the *integration seam*.
+
+### 2.2 The fix (the gate now actually runs)
+
+- New `CirConfig::canonical56()` (cir.rs): 64-bin HT20 framing, **56 active tones**, 168 delay taps, Φ built over a contiguous −28..+28 active-tone grid (also the native Atheros-56 layout). `bandwidth_hz`/`tap_spacing` stay physically correct for a 20 MHz HT20 channel; only the active-tone count differs from `ht20()`.
+- New `MultistaticFuser::with_cir_canonical56()` — the **correct default** for the RuvSense pipeline. `with_cir_ht20()` is retained for genuine raw-64/52 feeds and now carries a loud doc-warning.
+- `active_indices()` handles `(64, 56)` explicitly and the fallback now selects the slice whose length matches `num_active` (so Φ's column count is always self-consistent — no silent fall-through to the 52-index slice).
+- The remaining silent fallback is made **LOUD**: a `SubcarrierMismatch` inside `cir_gate_coherence` now fires a `debug_assert!` naming the misconfiguration ("CIR gate DEAD … build it with `CirConfig::canonical56()`"). A *config* error can no longer hide as a graceful runtime degrade.
+- `cir_estimate_first()` exposes the raw `estimate()` verdict so a test can **count Ok vs Err** on a canonical-56 stream.
+
+### 2.3 The PROOF (committed regression tests, `ruvsense::multistatic::tests`)
+
+| Test | Asserts | Result |
+|------|---------|--------|
+| `cir_gate_ht20_is_dead_on_canonical56` | old ht20 estimator on 8 canonical-56 frames → **0 Ok, 8 `SubcarrierMismatch`** | the dead gate, measured |
+| `cir_gate_canonical56_is_alive` | new canonical56 estimator on the same 8 frames → **8 Ok, 0 Err** | the gate runs |
+| `cir_gate_on_changes_coherence_vs_off` | `coherence(gate on)` ≠ `coherence(gate off)` (\|Δ\| > 1e-6) | the CIR term is actually applied |
+| `cir_gate_dead_ht20_equals_gate_off` (release-only) | dead-ht20 coherence == gate-off coherence (\|Δ\| < 1e-9) | confirms the silent degradation the fix removes |
+
+**Reproduce:**
+```bash
+cd v2 && cargo test -p wifi-densepose-signal --no-default-features --lib \
+  ruvsense::multistatic::tests::cir
+# 3 passed (the 4th is #[cfg(not(debug_assertions))], add --release to run it)
+```
+
+**Resolution: FIXED** (not merely loud-fail-documented). The gate now decodes 100% of canonical-56 frames where it previously decoded 0%.
+
+---
+
+## 3. The second critical — NaN/inf adversarial-detector bypass (CRITICAL, FIXED)
+
+### 3.1 What was wrong
+
+`AdversarialDetector::check` (adversarial.rs) takes per-link `link_energies: &[f64]`. A single **NaN/inf** entry bypassed the whole detector: every `e > threshold` test is `false` on NaN, the Gini sort used `partial_cmp().unwrap_or(Equal)`, and the final `anomaly_score.clamp(0,1)` returns NaN on a NaN input. A real RF link can never have NaN/inf energy, so a non-finite input is *itself* the strongest possible spoof — yet it could slip through as "clean."
+
+### 3.2 The fix
+
+Finite-validate at the boundary: the first non-finite `link_energies` entry now **short-circuits to a definite anomaly** (`anomaly_detected = true`, `anomaly_score = 1.0`, `affected_links = [bad_idx]`, `FieldModelViolation`), and the poisoned frame is **not** seeded into the temporal-continuity state.
+
+### 3.3 The PROOF
+
+| Test | Asserts |
+|------|---------|
+| `nan_link_energy_flags_anomaly` | a NaN link energy → `anomaly_detected`, score 1.0, affected link reported, `anomaly_count == 1` |
+| `inf_link_energy_flags_anomaly` | both `+inf` and `−inf` → anomaly, score 1.0 |
+
+```bash
+cd v2 && cargo test -p wifi-densepose-signal --no-default-features --lib \
+  ruvsense::adversarial::tests::nan_link ruvsense::adversarial::tests::inf_link
+```
+
+---
+
+## 4. Divide-by-(n−1) window trio (CORRECTNESS, FIXED)
+
+Three windowing helpers divided by `(n − 1)` with no small-`n` guard:
+
+| Site | Bug | Fix |
+|------|-----|-----|
+| `csi_processor.rs` `CsiPreprocessor::hamming_window(n)` | `n=0` underflowed `0usize − 1`; `n=1` divided by 0 → all-NaN window | `match n { 0 => [], 1 => [1.0], _ => … }` |
+| `bvp.rs` Hann window | `window_size=1` divided by 0 → NaN BVP | length-1 guard → constant `[1.0]` |
+| `spectrogram.rs` `make_window` | `size=1` divided by 0 for Hann/Hamming/Blackman | `size <= 1` short-circuit → `vec![1.0; size]` |
+
+The standard convention for a length-1 window is the constant `1.0`; length-0 is empty.
+
+**PROOF:** `test_hamming_window_degenerate_sizes` (csi_processor), `bvp_window_size_one_is_finite` (bvp), `make_window_size_0_and_1_are_safe` (spectrogram) — each asserts finiteness at sizes 0/1/2.
+
+The Python deterministic proof (`archive/v1/data/proof/verify.py`) still prints **VERDICT: PASS** with the **same** pipeline hash `f8e76f21…46f7a` — the reference path uses `n ≥ 2`, so the guard is bit-transparent there.
+
+---
+
+## 5. Measured performance wins (MEASURED before/after; benches committed)
+
+Both changes are **bit-equivalent** (asserted by a committed test) — they only remove wasted work. New criterion benches in `benches/features_bench.rs` (registered in `Cargo.toml`).
+
+**Reproduce both:**
+```bash
+cd v2 && cargo bench -p wifi-densepose-signal --no-default-features --bench features_bench
+# compile-only: append --no-run
+```
+
+### 5.1 FFT-planner caching for PSD (features.rs)
+
+`PowerSpectralDensity::from_csi_data` constructed a fresh `FftPlanner` and re-planned the FFT **on every frame** — and `FeatureExtractor::extract` calls it per frame on the hot path. New `from_csi_data_with_fft(csi, fft_size, &Arc<dyn Fft>)` reuses a plan cached in `FeatureExtractor` (built once in `new()`). Output is **bit-identical** (`psd_cached_fft_bit_identical_to_fresh` compares `f64::to_bits` of values + all summary stats across 6 FFT sizes).
+
+Bench group `psd_fft_planner` — `fresh_planner` (before) vs `cached_planner` (after), per frame:
+
+| fft_size | before (fresh plan), median | after (cached), median | speedup |
+|----------|------------------------------|-------------------------|---------|
+| 64  | 5.84 µs/frame | 1.89 µs/frame | **3.09×** |
+| 128 | 9.31 µs/frame | 3.61 µs/frame | **2.58×** |
+| 256 | 13.77 µs/frame | 6.73 µs/frame | **2.04×** |
+
+Medians from criterion (warm-up 1 s, 20 samples). Raw three-point estimates (low/median/high), per frame:
+`fresh/64 [5.27, 5.84, 6.34] µs` vs `cached/64 [1.76, 1.89, 2.03] µs`;
+`fresh/256 [13.29, 13.77, 14.32] µs` vs `cached/256 [6.26, 6.73, 7.43] µs`.
+The win is the re-planned `FftPlanner` construction the cache hoists out of the per-frame loop; it grows in *relative* terms at small FFTs (planning is a larger fraction of a cheap transform) and stays a flat ~2× at 256.
+
+### 5.2 DTW Sakoe-Chiba band honored (gesture.rs)
+
+`dtw_distance` computed the band bounds `j_start/j_end` but still iterated the **full** `1..=m` row, `continue`-ing on out-of-band cells — so the band constrained the *path* but not the *work* (still O(n·m)). The fix iterates only `j_start..=j_end` (O(n·band)), resetting just the two boundary-guard cells the recurrence can read, and computes the endpoint reachability (`|n−m| ≤ band`) at the return site. Result is **bit-identical** to the full-row version across 12 shapes × 8 band widths (`dtw_banded_bit_identical_to_fullrow`).
+
+Bench group `dtw_sakoe_chiba` — `full_row` (before) vs `banded` (after):
+
+| case | before (full row), median | after (banded), median | speedup |
+|------|-----------------------------|--------------------------|---------|
+| n=m=100, band=5  | 33.45 µs | 13.77 µs | **2.43×** |
+| n=m=200, band=5  | 122.32 µs | 29.55 µs | **4.14×** |
+| n=m=200, band=10 | 159.98 µs | 60.19 µs | **2.66×** |
+
+Medians from criterion (warm-up 1 s, 20 samples). Raw (low/median/high):
+`full_row n200_band5 [107.6, 122.3, 146.5] µs` vs `banded n200_band5 [26.4, 29.5, 33.1] µs`.
+The speedup tracks the inner-loop cell-count ratio `m / (2·band+1)` — n=m=200, band=5 → 200/11 ≈ 18× fewer cells, but euclidean-distance cost and loop overhead dominate at these sizes so the wall-clock win is ~4× (still the **largest at the longest sequence / narrowest band**, exactly as the algorithm predicts). It shrinks toward 1× as the band widens to cover the whole matrix (band=10 → 2.66×), and grows with sequence length (band=5: 2.43× at n=100 → 4.14× at n=200).
+
+> **Note on the other re-plan sites.** `spectrogram.rs`/`bvp.rs` plan their FFT **once per call** and reuse it across all frames/subcarriers (already amortized), so caching there is marginal — deferred (§7). The PSD site was the only one re-planning *per frame*.
+
+---
+
+## 6. Per-module SOTA landscape (evidence-graded)
+
+Grades: **MEASURED** (the source measured it, ideally with public method/code), **CLAIMED** (asserted, no reproducible artifact), **THEORETICAL** (plausible, no published target).
+
+### 6.1 CSI → CIR (cir.rs — our ISTA/L1 sparse recovery)
+
+- **Deep-unfolded ISTA / LISTA for CSI→CIR — MEASURED.** Learned ISTA unrolling reports ~**3 dB NMSE** improvement over classical OMP/FISTA for channel/CIR estimation (arXiv [2211.15440](https://arxiv.org/abs/2211.15440); survey [2502.05952](https://arxiv.org/abs/2502.05952)). Public methods; numbers measured in-paper. **This is our #1 future item (§7) — our `cir.rs` already builds the sub-DFT Φ that LISTA would make trainable.**
+- **Diffusion CIR prior — MEASURED (artifact).** [github.com/benediktfesl/Diffusion_channel_est](https://github.com/benediktfesl/Diffusion_channel_est) ships **public weights** for a diffusion-model channel-estimation prior. Heavier than our edge budget; tracked, not adopted.
+- **Coherence gating (the §2 gate) — THEORETICAL.** Our 0.7/0.3 freq/CIR blend is an engineering heuristic with no published accuracy target; now that it *runs*, it can finally be A/B-measured.
+
+### 6.2 Adversarial robustness (adversarial.rs)
+
+- **Adversarial-robustness eval for WiFi sensing — MEASURED.** arXiv [2511.20456](https://arxiv.org/abs/2511.20456) + the **Wi-Spoof** benchmark provide a measured evaluation protocol for spoofed/injected CSI. Our detector's physical-plausibility checks (consistency/Gini/temporal/energy) are in the same spirit; adopting Wi-Spoof as an external benchmark is a §7 item. (The §3 NaN fix is a precondition: a detector that NaN-bypasses can't be benchmarked honestly.)
+
+### 6.3 Multi-AP / multistatic fusion (multistatic.rs)
+
+- **Bayesian multi-AP fusion — CLAIMED.** arXiv [2512.02462](https://arxiv.org/abs/2512.02462) proposes a Bayesian fusion across APs; **no code released**, numbers self-reported. Our attention-weighted fusion is a different (cheaper) mechanism; tracked as a comparison target, not adopted.
+
+### 6.4 RF intention-lead / pre-movement (intention.rs) — THEORETICAL
+
+The 200–500 ms pre-movement "lead signal" framing has **no published commodity-WiFi target** we can grade. Honestly THEORETICAL; no work item.
+
+---
+
+## 7. Decision, roadmap, and the deferred-findings backlog
+
+### 7.1 Accepted now (this milestone)
+
+The §2–§5 fixes are **ACCEPTED and committed**: dead CIR gate fixed, NaN bypass fixed, window trio fixed, calibration dead-branch de-misled, two measured perf wins. All `cargo test -p wifi-densepose-signal --no-default-features` (and `--features cir`) green; Python proof PASS.
+
+### 7.2 Top accepted-future item — LISTA-for-CIR (NOT implemented here)
+
+**Unroll the existing ISTA in `cir.rs` into trainable layers (LISTA).** Effort: **M**. The sensing matrix Φ and the ISTA recurrence already exist; LISTA replaces the fixed step size / threshold with per-layer learned parameters over a fixed unroll depth. Measured target to beat: **~3 dB NMSE over OMP/FISTA** (arXiv 2211.15440 — MEASURED). Proposed, not built in Milestone 0.
+
+### 7.3 Other graded-future items
+
+- Adopt **Wi-Spoof** (arXiv 2511.20456, MEASURED) as the external adversarial benchmark for `adversarial.rs`.
+- Evaluate the **diffusion CIR prior** (public weights, MEASURED) as an offline quality ceiling — *not* an edge target.
+- Bayesian multi-AP fusion (2512.02462, CLAIMED) — comparison only, pending released code.
+
+### 7.4 Deferred Milestone-0 review findings (the ~45 not fixed here — explicit backlog)
+
+Catalogued so nothing is silently dropped. Priority: **P1** correctness-adjacent, **P2** perf, **P3** clarity/style.
+
+| # | Module | Finding | Pri | Why deferred |
+|---|--------|---------|-----|--------------|
+| 1 | cir.rs ~937 | `phase_variance` uses **linear** variance on **wrapped** angles (doc says "variance of phase angles") — spuriously inflates near ±π | P1 | Used as the `> TAU` ghost-tap *guard*; a correct circular variance is bounded [0,1] and would need the threshold re-derived. Semantic change — defer with a real recalibration, don't risk a silent gate regression in a perf/correctness pass. |
+| 2 | calibration.rs ~311 | `subtract_in_place` had a vacuous `if active_input {ki} else {ki}` branch implying a full-FFT→bin remap that didn't exist | P3 | **Resolved here** (branch removed, sequential-convention documented to match the sibling `extract_first_stream`). Listed for visibility — behavior unchanged. |
+| 3 | spectrogram.rs / bvp.rs | FFT planner built once-per-call (already amortized across frames) | P2 | Marginal vs the per-frame PSD site; cache if these become hot. |
+| 4 | features.rs ~347 | Doppler FFT planner planned once per call, reused across subcarriers | P2 | Already amortized within the call. |
+| 5 | multistatic.rs | `node_attention_weights` recomputes consensus/softmax each call; no SIMD | P2 | Needs a bench before touching; not obviously hot. |
+| 6 | tomography.rs | ISTA L1 solver re-allocates voxel buffers per solve | P2 | Bench first. |
+| 7 | pose_tracker.rs | Kalman gain matrices reallocated per update | P2 | Bench first. |
+| 8 | field_model.rs | SVD recomputed on every perturbation extract | P2 | Incremental SVD is a real project, not a micro-fix. |
+| 9 | coherence.rs / coherence_gate.rs | Z-score thresholds are magic constants, untested at boundaries | P1 | Needs labelled data to set defensible thresholds. |
+| 10 | longitudinal.rs | Welford update not numerically guarded for n=0 | P1 | Add `n>=1` guard + test (same family as §4). |
+| 11 | cross_room.rs | Fingerprint hash collisions unhandled | P2 | Low collision prob; needs design. |
+| 12 | gesture.rs | `euclidean_distance` no length-mismatch guard | P3 | Caller-enforced; add `debug_assert`. |
+| 13 | adversarial.rs | Gini/consistency thresholds are magic constants | P1 | Same labelled-data dependency as #9. |
+| 14 | cir.rs | `fft_operator` path changes the witness hash (documented) — no test that it's *numerically close* to dense | P2 | Add a tolerance test. |
+| 15 | multistatic.rs | `cir_gate_coherence` only estimates the **first** node/channel; multi-node CIR consensus unused | P2 | Design item (which node's CIR is authoritative?). |
+| 16 | phase_align.rs | Iterative LO offset estimation has no convergence cap test | P2 | Add iteration-cap test. |
+| 17 | hampel.rs | Window edge handling at series boundaries | P3 | Cosmetic. |
+| 18 | motion.rs | Threshold constants undocumented | P3 | Doc-only. |
+| 19 | csi_ratio.rs | Division guard relies on `1e-12` epsilon; no test | P2 | Add boundary test. |
+| 20 | spectrogram.rs | `compute_multi_subcarrier_spectrogram` re-plans per subcarrier via `compute_spectrogram` | P2 | Hoist the planner (relates to #3). |
+| 21–45 | (assorted) | Remaining clarity/doc/magic-constant/missing-boundary-test findings across `ruvsense/*`, `features.rs`, `motion.rs` | P3 | Bulk-addressable in a dedicated "test-the-boundaries + de-magic-constant" follow-up; not high-leverage individually. |
+
+> **Horizon-ledger one-liner.** Milestone-0 DONE: dead CIR gate (FIXED+proved), NaN/inf adversarial bypass (FIXED+proved), divide-by-(n−1) window trio (FIXED+proved), calibration dead-branch (FIXED), PSD FFT-planner cache (MEASURED), DTW band (MEASURED). DEFERRED to follow-up: the ~45 findings in §7.4 (P1: phase_variance circular bug #1, Welford guard #10, threshold magic-constants #9/#13; P2/P3: the rest) — none silently dropped.
+
+---
+
+## 8. Consequences
+
+- **Positive:** the ADR-134 CIR gate is alive for the first time in production; the adversarial detector can no longer be NaN-bypassed; three latent divide-by-zero NaN sources are gone; the per-frame PSD path and gesture DTW are measurably faster with bit-identical output; the SOTA landscape and a concrete LISTA-for-CIR roadmap are graded and recorded.
+- **Negative / honest limits:** `canonical56()` models the canonical grid as a contiguous 56-tone band — a reasonable physical interpretation of a *resampled* grid, but not a literal hardware tone map; the CIR gate still uses only the first node's CIR (#15); the `phase_variance` circular bug (#1) remains until it can be re-thresholded with data.
+- **Neutral:** no public API removed; `with_cir_ht20()` kept (warned); files stay scoped; new bench is additive.

docs/adr/ADR-155-nn-training-beyond-sota.md

@@ -0,0 +1,202 @@
+# ADR-155: NN / Training Beyond-SOTA Sweep — Milestone 1 (Claim Integrity, Honest Validation, the Unified Metric, and the SOTA Landscape)
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed |
+| **Date** | 2026-06-11 |
+| **Deciders** | ruv |
+| **Codebase target** | `wifi-densepose-train` (`metrics.rs`, `dataset.rs`, `proof.rs`, `rapid_adapt.rs`, `ruview_metrics.rs`, `config.rs`, `ablation.rs`, `subcarrier.rs`, `bin/train.rs`, `bin/verify_training.rs`), `wifi-densepose-nn` (`tensor.rs`, `translator.rs`, `onnx.rs`), benches, docs |
+| **Relates to** | ADR-154 (Signal/DSP sweep, Milestone 0), ADR-152 (WiFi-Pose SOTA 2026 intake), ADR-150 (RF Foundation Encoder), ADR-079 (Camera-Supervised Pose), ADR-027 (MERIDIAN), ADR-024 (AETHER) |
+| **Scope** | Milestone 1 of the beyond-SOTA NN/training sweep: the **integrity-critical** fixes that let the training/metrics subsystem substantiate a clean accuracy claim (the unified metric, leak-free validation, honest TTA, rigorous proof), a focused set of **correctness/security** fixes, two **measured** perf wins, the NN SOTA landscape with evidence grades, and a prioritized backlog. **~45 review findings are explicitly deferred (§8)** — nothing is silently dropped. |
+
+---
+
+## 0. PROOF discipline (this ADR's contract)
+
+This project has been publicly accused of "AI slop." Milestone 1 is the **most integrity-critical** of the sweep because a gap review found the training/metrics subsystem **could not substantiate a clean accuracy claim**: there were four divergent PCK implementations and three divergent OKS implementations, a model trained on real data was validated against a *synthetic* set, the dataset had no leak-free split, the test-time-adaptation path descended a *fake* gradient, and the deterministic proof self-certified on any loss decrease (including float noise) with no committed baseline.
+
+We answer that with **evidence, not adjectives**:
+
+- Every integrity fix ships with a **committed regression test that would have caught the bug**.
+- Every perf number is **MEASURED before/after** with the exact reproduce command. A perf claim without a measured before/after is **UNPROVEN** and is not made here.
+- Every external SOTA reference is graded **MEASURED** / **CLAIMED** / **THEORETICAL**.
+- We disclose, in full, what the proof does **not** prove and what remains unmeasured.
+
+### Build/test constraint (disclosed)
+
+The reportable-metric code (`metrics.rs`, `trainer.rs`, `proof.rs`, `model.rs`, `losses.rs`) is gated behind the `tch-backend` Cargo feature (libtorch FFI). libtorch is **not installed on the development host**, so the project's standard gate is `cargo test --workspace --no-default-features` (no tch). The canonical-metric *logic* is therefore validated two ways: (1) the non-tch reachable surface (`compute_pck`/`compute_oks` free functions, `dataset.rs` split, `rapid_adapt.rs`, `ruview_metrics.rs`) runs under the workspace test suite with new regression tests; (2) the `tch`-gated accumulator/trainer/proof changes are routed through those same canonical functions, so the metric definition is identical whether or not tch is present. This limitation is disclosed rather than hidden.
+
+---
+
+## 1. Context — the seven divergent metric definitions
+
+The gap review found **four** PCK and **three** OKS implementations that disagreed on normalization, on the zero-visible-joint case, and on the OKS scale:
+
+| # | Location | Normalizer | Zero-visible PCK | OKS scale |
+|---|----------|-----------|------------------|-----------|
+| PCK-1 | `metrics.rs` `MetricsAccumulator` (the trainer's) | bbox **diagonal** | **1.0** (false-perfect bug) | normalized-coord diag² |
+| PCK-2 | `metrics.rs` `compute_pck` | torso **hip↔shoulder** | 0.0 | — |
+| PCK-3 | `metrics.rs` `compute_pck_v2` | torso **hip↔hip** (pixel) | 0.0 | — |
+| PCK-4 | `training_bench.rs` | **raw threshold** (no torso) | 0.0 | — |
+| OKS-1 | `metrics.rs:443` `compute_oks` | — | — | caller `s` (`1.0` ⇒ fake Gold) |
+| OKS-2 | `metrics.rs:994` `compute_oks_v2` | — | — | `sqrt(area)` (could be 0) |
+| OKS-3 | `ruview_metrics.rs:642` | — | — | caller `s` (`1.0` ⇒ fake Gold) |
+
+Two of these are not merely inconsistent, they are **wrong in a claim-inflating direction**:
+
+- **The `MetricsAccumulator` zero-visible-joint bug** scored a sample with *no visible joints* as PCK = 1.0 ("no errors to measure"). An empty or garbage prediction could thus *inflate* the reported metric.
+- **The OKS `s = 1.0`-on-normalized-coordinates bug** ("fake Gold tier"): with keypoints in `[0,1]` and the scale fixed at `1.0`, every squared distance is ≈0 and the exponential kernel returns ≈1.0 for *any* pose. OKS looked near-perfect regardless of prediction quality.
+
+This is the same metric-bug class ADR-152 flagged. Milestone 1 closes it for real.
+
+---
+
+## 2. Decision — TIER 1: CLAIM INTEGRITY (the "prove everything" core)
+
+### 2.1 Unify the metrics — ONE canonical definition — ACCEPTED & IMPLEMENTED
+
+There is now exactly **one** PCK and one OKS that may be used for any *reported* number, in the `canonical` region of `metrics.rs`:
+
+- **`pck_canonical(pred, gt, vis, k)` — torso-normalized PCK@k.** A keypoint `j` is correct iff `‖pred_j − gt_j‖₂ ≤ k · torso`, where `torso = ‖left_hip(11) − right_hip(12)‖₂` in the keypoint coordinate space, with a **bounding-box-diagonal fallback** when the hips are not both visible. This is the COCO / ADR-152 convention validated in `benchmarks/wiflow-std/RESULTS.md` (the ~96% PCK@20 reproduction — hip↔hip torso, COCO Setting). **Zero visible joints ⇒ `(0, 0, 0.0)`** — a sample with no measurable evidence scores 0, never 1.
+- **`oks_canonical(pred, gt, vis)` — COCO OKS.** `s = sqrt(area)` is derived from the **GT pose extent** (the canonical torso size as a robust, always-positive scale proxy), never a fixed `1.0`. There is no escape hatch that makes OKS ≈ 1.0 for any pose; a degenerate (zero-extent) pose returns 0.0.
+
+**Single source of truth, enforced.** `MetricsAccumulator::update` (the trainer's), `compute_pck`, `compute_per_joint_pck`, `compute_oks`, `aggregate_metrics`, and the deprecated `compute_pck_v2`/`compute_oks_v2`/`MetricsAccumulatorV2` **all route through** `pck_canonical`/`oks_canonical`. So `Trainer::evaluate()` → `MetricsAccumulator` → canonical; the WiFlow-STD bench definition (RESULTS.md) is the reference the canonical *matches*. `eval.rs` reports MPJPE (a distinct, non-divergent error metric, unchanged). The `v2` functions and the `training_bench.rs` raw-threshold kernel are annotated **`#[deprecated]` / "DO NOT USE for reported metrics"**.
+
+**The two claim-inflating bugs are fixed and pinned by regression tests:**
+
+- `canonical_pck_zero_visible_is_zero_not_one` — no-visible ⇒ PCK 0.0 (was 1.0).
+- `canonical_oks_not_one_for_wrong_pose_on_normalized_coords` — a pose off by 3× the torso on `[0,1]` coords yields OKS < 0.2 (the old `s=1.0` path returned ≈1.0).
+- `canonical_pck_uses_hip_to_hip_torso`, `canonical_torso_falls_back_to_bbox_when_hips_hidden` — pin the normalizer.
+- `all_invisible_gives_zero_pck` (renamed from `all_invisible_gives_trivial_pck`, comment cites this ADR) — the trainer accumulator now scores no-visible as 0.
+
+**Legitimately changed test expectations** (each updated with a comment citing this finding): the historical "perfect on an all-coincident pose" fixtures used keypoints at a single point, which is *correctly unscoreable* under canonical (zero extent ⇒ no scale). Test fixtures were given a real ±0.05 hip span so the canonical normalizer is positive; `all_invisible_*` flipped from 1.0 → 0.0.
+
+### 2.2 Honest validation — leak-free split + synthetic-val disclosure — ACCEPTED & IMPLEMENTED
+
+**The leak.** MM-Fi windows are extracted with **stride 1** (`MmFiEntry::num_windows = num_frames − window_frames + 1`), so adjacent windows overlap by `window_frames − 1` frames (~99% at the default 100-frame window). And `bin/train.rs` validated a *real* MM-Fi training run against a **synthetic** val set "for pipeline verification" — any PCK it printed was meaningless on two counts.
+
+**The fix (mirroring the leak-free discipline of `occupancy_bench::EvalSplit`):**
+
+- `MmFiDataset::subject_disjoint_split(test_subject_fraction, seed) → (train_view, test_view)` partitions **whole subjects** to one side. Because every window of a subject travels with that subject, the two views share **no subject and no window** — leak-free by construction, deterministic per seed. Returns `DatasetError::InvalidSplit` on <2 subjects, bad fraction, or an empty side.
+- `assert_split_leak_free(train, test)` independently verifies subject-disjointness **and** window-index-disjointness, and is called inside the split so a leaky split can never be handed out.
+- `bin/train.rs` now **prefers the real split**; the synthetic path is reachable only as a labelled fallback (single-subject data) and is routed through a new `run_smoke_test` that prefixes every metric `[SMOKE-TEST] (DO NOT REPORT)`. `--dry-run` is likewise relabelled. A synthetic-val PCK can no longer be mistaken for a measurement.
+
+**Leak-free proof (tests):** `subject_split_is_subject_and_window_disjoint` (no shared subject, no shared window index, partition covers every window once), `subject_split_is_deterministic_for_seed`, `subject_split_rejects_single_subject`, `subject_split_rejects_bad_fraction`, `assert_leak_free_detects_injected_subject_leak` (the validator catches a deliberately-injected subject overlap — a guard against future partitioner bugs).
+
+### 2.3 rapid_adapt honesty — real gradients, scoped claim — ACCEPTED & IMPLEMENTED
+
+`rapid_adapt.rs`'s `contrastive_step`/`entropy_step` wrote a **fake gradient** (`grad += v * 0.01`) unrelated to the stated triplet / entropy objective — so any "TTA improves the metric" was unsupported by the code.
+
+**Resolution: real gradients (not removal).** The two `*_loss` functions are now **pure evaluators** of the real objective; `RapidAdaptation::adapt` descends them with a **central finite-difference gradient** of that exact loss (`∂L/∂wᵢ ≈ (L(w+εeᵢ) − L(w−εeᵢ))/2ε`). Finite differences genuinely minimize the stated objective (to O(ε²) truncation), so "the adaptation loss decreases" is now a **real, reproducible** measurement rather than an artefact of a hand-tuned step. The returned `final_loss` is the *actual* objective at the produced weights.
+
+**Honest scope caveat (recorded in the module and here):** this minimizes a *self-supervised proxy* (temporal-contrastive + prediction entropy) over a tiny LoRA bottleneck on raw CSI. It is **NOT** wired to the pose model, and **there is no measured end-to-end PCK gain on WiFi pose from this path.** TTA-on-pose is a future, **not-yet-measured** capability — no PCK improvement may be cited from this module.
+
+**Tests:** `contrastive_loss_decreases` and `entropy_loss_decreases` (20/30 real gradient steps do not increase the loss vs 0 steps), `reported_loss_is_the_real_objective_not_a_placeholder` (the returned `final_loss` equals an independent recomputation of the objective at the output weights — i.e. it is the real loss, not a fabricated number).
+
+### 2.4 proof.rs rigor — margin + committed-hash requirement — ACCEPTED & IMPLEMENTED
+
+The deterministic proof self-certified: `generate_expected_hash` blessed whatever the pipeline emitted, PASS counted *any* loss decrease (including 1e-9 float noise), and a *missing* expected hash defaulted to PASS.
+
+**Two hardenings:**
+
+1. **Minimum-decrease margin.** `MIN_LOSS_DECREASE = 1e-4`. A run counts as "learning" only when `initial − final ≥ MIN_LOSS_DECREASE` — well above float noise, far below a real step's decrease. A pipeline that only wanders by noise now **FAILS**.
+2. **No-hash is a SKIP, never a PASS.** `ProofResult::is_pass()` requires `hash_matches == Some(true)` (a *committed* `expected_proof.sha256`). An absent baseline yields SKIP (exit 2). The `verify-training` binary additionally **fails fast** on a sub-margin loss *before* the hash comparison, so a missing baseline can never downgrade a non-learning pipeline to SKIP.
+
+**What this proves — and what it does NOT (disclosed):** the proof certifies **reproducibility and determinism** (same seed ⇒ same weights ⇒ same hash) and that the optimiser *measurably* reduces a loss. It runs on a deterministic *synthetic* dataset by construction, so it does **not** prove the shipped weights came from real MM-Fi data, nor that any accuracy claim is met. Accuracy is substantiated separately (`benchmarks/wiflow-std/RESULTS.md`). There is currently **no committed `expected_proof.sha256` for the Rust proof**, so it is honestly in the SKIP state until a baseline is committed on a libtorch-enabled host — and SKIP is now reported as SKIP, not green.
+
+**Tests:** `no_committed_hash_is_skip_not_pass`, `submargin_loss_change_fails_even_without_hash`, `committed_matching_hash_with_real_decrease_passes`.
+
+---
+
+## 3. Decision — TIER 2: CORRECTNESS / SECURITY
+
+Each fix ships a test that would have caught the bug (all in the non-tch, workspace-tested surface).
+
+| Finding | File | Fix | Test |
+|---------|------|-----|------|
+| `softmax(axis)` ignored the axis (whole-tensor normalize — breaks densepose per-pixel probs) | `nn/tensor.rs` | softmax along the given axis per lane; out-of-range axis ⇒ `NnError` (no panic) | (tier-2 suite) |
+| `apply_attention` identity/uniform stub (any "with attention" ablation == without) | `nn/translator.rs` | **implemented real single-head scaled-dot-product attention** (`softmax(QKᵀ/√d)V` with Q/K/V/output projections); mis-shaped checkpoint projections rejected so a bad checkpoint can't silently become a no-op | `test_attention_is_not_uniform_stub`, `test_attention_rejects_wrong_weight_shape` |
+| `config.validate()` had no UPPER bounds (config-OOM class still open) | `train/config.rs` | upper bounds on `window_frames`/subcarriers/`backbone_channels`/`heatmap_size`/keypoints/parts/`batch_size`; reject negative `gpu_device_id` | rejection tests; defaults+presets still validate |
+| `subcarrier.rs` panic on non-contiguous input | `train/subcarrier.rs` | graceful path / typed error on strided input | non-contiguous-input test |
+| `ablation.rs` `latency_percentiles` `partial_cmp().unwrap()` NaN panic | `train/ablation.rs` | `total_cmp` / NaN-guarded compare | NaN-input no-panic test |
+| `onnx.rs` unchecked `-1` dim cast | `nn/onnx.rs` | reject negative/zero output dims with `NnError` | guarded-dim test |
+| `ruview_metrics` `compute_single_oks` `s=1.0` fake-Gold + unguarded `[j]<17` | `train/ruview_metrics.rs` | derive scale from GT extent when none supplied; reject `s≤0`; bound the loop to array extents | `oks_rejects_nonpositive_scale`, `oks_does_not_panic_on_short_arrays`, `oks_not_perfect_for_wrong_pose_with_derived_scale` |
+
+`rf_encoder.rs` was inspected and found to contain **no checkpoint-deserialization assert**: its `assert_eq!`s in `LinearHead::new` / `ContrastiveBatcher::new` are documented construction-time API contracts on *programmer-supplied* vector lengths, not adversarial-input panics — the described bug does not exist there. Any genuine checkpoint-load assert lives in the tch-gated `proof.rs`/`trainer.rs` path and is deferred (§8) as unverifiable without libtorch. Test pass counts: nn `--no-default-features` **35 passed**, nn `--features onnx onnx::tests` **3 passed**, train `--no-default-features` lib **176 passed**.
+
+---
+
+## 4. Decision — TIER 3: MEASURED perf wins (new criterion benches)
+
+All numbers MEASURED on the Windows dev host with the `onnx` feature (`ort 2.0.0-rc.11`, runtime auto-downloaded), committed in `nn/benches/onnx_bench.rs`.
+
+### 4.1 Zero-copy ORT input — LANDED, MEASURED
+
+`onnx.rs` built the ORT input via `arr.iter().cloned().collect::<Vec<f32>>()` — a full element-wise copy. Replaced with a contiguous fast path (`arr.as_slice() ⇒ single memcpy`, iterator fallback only for strided views).
+
+- **Reproduce:** `cargo bench -p wifi-densepose-nn --no-default-features --features onnx --bench onnx_bench -- onnx_input_copy`
+- **Measured** (input `[1,256,64,64]` = 1.05M f32): **1.972 ms → 1.336 ms (~1.48× faster)**, 532 → 785 Melem/s. Strided fallback unchanged (within noise), correctness preserved. End-to-end real-model inference: ~45.9 µs.
+
+### 4.2 ONNX per-inference write-lock — DIAGNOSED, NOT LANDABLE (honest)
+
+`OnnxBackend::run` takes a `parking_lot::RwLock` **write** lock per inference, serializing concurrency. The intended fix was a read-lock. **It is not landable on `ort 2.0.0-rc.11`:** the safe `Session::run` is `&mut self` (verified against the vendored source) — there is no `&self` run path, so a read-lock fails the borrow checker. The underlying C++ `OrtSession::Run` is thread-safe, but exploiting that would require an `unsafe` interior-mutability bypass; we did **not** introduce that soundness risk. The write lock was kept, with a doc comment recording the upgrade path (a future `ort` with `&self` run ⇒ flip to `read()`).
+
+- **Harness landed anyway**, empirically proving the serialization: `cargo bench -p wifi-densepose-nn --no-default-features --features onnx --bench onnx_bench -- onnx_concurrency` → throughput **drops** with more threads (1 thr 19.4 Kelem/s → 2 thr 16.9K → 4 thr 14.0K → 8 thr 14.3K). When `ort` exposes `&self` run, the one-line lock change will show the speedup on this same bench.
+
+The native-conv naive-loop rewrite was **deferred** (§8) as out of scope for a measured milestone.
+
+---
+
+## 5. The NN / training SOTA landscape (graded)
+
+| Candidate | What | Grade | Verdict |
+|-----------|------|-------|---------|
+| **GraphPose-Fi** (arXiv 2511.19105, code github.com/Cirrick/GraphPose-Fi) | Graph/skeleton pose **decoder** for cross-environment WiFi pose; MM-Fi, 17 joints — matches our setup. ADR-150 §2.2 named a graph decoder but never built it. | **CLAIMED** (preprint; cross-env gains author-reported) | **Top beyond-SOTA candidate. Propose as ACCEPTED-future — NOT built here.** Best fit because the decoder is a drop-in on our 17-joint MM-Fi backbone and directly targets the cross-environment brittleness ADR-150/ADR-027 fight. |
+| **ONNX INT4** | Extend our **measured** INT8 ONNX quantization to INT4 for edge. | **THEORETICAL** for our pipeline (INT8 is MEASURED; INT4 untested here) | #2 priority — natural extension of a measured capability. |
+| **CSI-JEPA vs MAE A/B** | Joint-embedding predictive pretraining vs the ADR-152 §2.3 MAE recipe. | **CLAIMED** (JEPA strong elsewhere) — **honest caveat: no JEPA *or* MAE result exists on WiFi POSE yet** (ADR-152 F3: UNSW MAE downstream tasks are classification, not pose). | #3 — run as a measured A/B, do not pre-announce a winner. |
+| **"Mamba-CSI-pose"** | A state-space-model CSI pose backbone. | — | **Does NOT exist. Do not propose it.** No such artifact in the 2025–2026 literature; naming it would be exactly the kind of unfounded claim this sweep exists to prevent. |
+
+---
+
+## 6. Validation
+
+- `cargo test --workspace --no-default-features` — green (the metric unification legitimately changed a handful of test expectations; each was updated with a comment citing the finding, and the trainer/eval/proof now all route through the one canonical metric).
+- `python archive/v1/data/proof/verify.py` — `VERDICT: PASS` (Python pipeline proof, independent of the Rust changes).
+- New criterion benches compile and run under the `onnx` feature.
+
+---
+
+## 7. What changed, file by file
+
+- `metrics.rs` — `canonical_torso_size`, `pck_canonical`, `oks_canonical` (single source of truth); `MetricsAccumulator`/`compute_pck`/`compute_per_joint_pck`/`compute_oks`/`aggregate_metrics` route through them; `compute_pck_v2`/`compute_oks_v2`/`MetricsAccumulatorV2` deprecated → canonical; zero-visible and `s=1.0` bugs fixed; canonical bug-catching tests.
+- `dataset.rs` — `subject_disjoint_split`, `MmFiSplitView`, `assert_split_leak_free`; leak-free split tests.
+- `error.rs` — `DatasetError::InvalidSplit`.
+- `bin/train.rs` — prefer real subject-disjoint split; synthetic path relabelled `run_smoke_test` ("DO NOT REPORT").
+- `proof.rs` + `bin/verify_training.rs` — `MIN_LOSS_DECREASE` margin; no-hash ⇒ SKIP-not-PASS; sub-margin ⇒ FAIL-not-SKIP; new tests.
+- `rapid_adapt.rs` — fake gradient removed; finite-difference gradient of the real objective; honesty docs + tests.
+- `ruview_metrics.rs` — OKS scale derived from GT extent (no `s=1.0`); `s≤0` rejected; OKS loop bounded; tests.
+- `config.rs` / `ablation.rs` / `subcarrier.rs` / `nn/tensor.rs` / `nn/translator.rs` / `nn/onnx.rs` — Tier-2 fixes (§3) + Tier-3 perf (§4).
+- `training_bench.rs`, `sensing-server/training_api.rs` — divergent local PCK kernels annotated "DO NOT USE for reported metrics"; the sensing-server torso-height PCK unification is a **deferred** backlog item (separate service + tch boundary).
+
+---
+
+## 8. Deferred backlog (NOT silently dropped)
+
+The gap review surfaced ~60 findings; this milestone scoped to the provable integrity-critical subset plus two measured perf wins. The remainder are tracked here for a future ADR-155 milestone:
+
+- **GraphPose-Fi graph decoder** — build the §5 top candidate (ACCEPTED-future, not built).
+- **ONNX INT4** quantization; **CSI-JEPA vs MAE** A/B; the rest of the §5 roadmap.
+- **ONNX read-lock concurrency win** — blocked on an `ort` release exposing `&self` `Session::run` (§4.2); harness already committed.
+- **native-conv naive-loop** perf rewrite (§4).
+- **`rf_encoder.rs` `assert_eq!`-on-checkpoint** and any other **tch-gated** panic-on-input sites — require a libtorch host to compile/verify (`model.rs` `amp_fc1` unbounded alloc is *indirectly* guarded by the new `config.validate()` upper bounds, but a direct guard + test is deferred).
+- **`sensing-server/training_api.rs` PCK** — unify the live-server torso-height PCK with `pck_canonical` (crosses the service + tch boundary).
+- **`test_metrics.rs` reference kernels** — the integration test's local `compute_pck`/`compute_oks` are independent reference impls (not production); fold them onto the canonical definition.
+- The remaining ~40 lower-severity review findings (style, micro-opt, doc) from the NN/training gap review.
+
+---
+
+## 9. Consequences
+
+**Positive.** The training/metrics subsystem can now substantiate a clean accuracy claim: one documented metric used everywhere, a leak-free split, an honest TTA path, a proof that fails on noise and refuses to bless an unbaselined run, and two of the most claim-inflating bugs (false-perfect PCK, fake-Gold OKS) closed and pinned by regression tests. The unmeasured/unprovable parts are **disclosed**, not hidden.
+
+**Negative / honest.** The reportable-metric tch-gated code cannot be compiled on the dev host (libtorch absent), so its validation rests on routing through the workspace-tested canonical functions plus review; the Rust deterministic proof is in SKIP until a baseline is committed on a tch host; the ONNX concurrency win is blocked upstream; and ~45 findings are deferred. None of these is presented as done.

docs/adr/ADR-156-ruvector-fusion-beyond-sota.md

@@ -0,0 +1,153 @@
+# ADR-156: RuVector / Cross-Viewpoint Fusion Beyond-SOTA Sweep — Milestone 2 (Correctness Integrity, an Honest GDOP, Crafted-Input Safety, a Measured Hot-Path Win, and the ANN/Fusion SOTA Landscape)
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed |
+| **Date** | 2026-06-11 |
+| **Deciders** | ruv |
+| **Codebase target** | `wifi-densepose-ruvector` — `viewpoint/` (`attention.rs`, `geometry.rs`, `fusion.rs`, `coherence.rs`), `mat/` (`triangulation.rs`, `heartbeat.rs`), `sketch.rs`, benches, docs |
+| **Relates to** | ADR-031 (RuView sensing-first RF mode), ADR-016/017 (RuVector integration), ADR-024 (AETHER re-ID), ADR-027 (MERIDIAN cross-env), ADR-084 (RaBitQ similarity sensor), ADR-138 (ClockQualityGate), ADR-152 (WiFi-Pose SOTA 2026 intake), ADR-154 (Signal/DSP sweep M0), ADR-155 (NN/Training sweep M1) |
+| **Scope** | Milestone 2 of the beyond-SOTA sweep: four **correctness/integrity/security** fixes on the cross-viewpoint fusion path (each pinned by a regression test that fails on the old code), one **measured** hot-path perf win + a new criterion bench, the ANN/fusion SOTA landscape graded MEASURED/CLAIMED/data-gated, and a prioritized deferred backlog. **Nothing is silently dropped.** |
+
+---
+
+## 0. PROOF discipline (this ADR's contract)
+
+This project has been publicly accused of "AI slop." Milestone 2 answers with **evidence, not adjectives** — the same contract as ADR-154/155:
+
+- Every correctness/integrity fix ships a **committed regression test that fails on the old code and passes on the new**. We verified each by reverting the fix and observing the test fail (recorded in §6).
+- Every perf number is **MEASURED before/after** with the exact reproduce command and a committed criterion bench. A perf claim without a measured before/after is **UNPROVEN** and is not made here.
+- Every external SOTA reference is graded **MEASURED** / **CLAIMED** / **DATA-GATED**, distinguishing what a paper *measured* from what it *asserts* from what our own prior measurement (ADR-152) says is **not currently the bottleneck**.
+- We disclose, in full, the **one staged finding that turned out to be a numeric no-op** (§2.1): the geometric-bias "angular wrap bug" is real as a *contract* violation but, because the bias kernel is `cos()` (even and 2π-periodic), it changes **no output value** under the current kernel. We land the fix anyway (it matches the documented contract and reuses the canonical helper) but we **do not claim a behaviour change** — that would be exactly the kind of inflation this sweep exists to prevent.
+
+Test machine for the perf numbers: Windows 11, `cargo bench --release`, criterion 0.5. Numbers are wall-clock medians on this box; the **ratio** (before/after) is the claim, not the absolute ns.
+
+Build/test gate: `cargo test --workspace --no-default-features` (the project's standard gate — no `crv`/GPU features). All fixes in this milestone are on the **default, non-feature-gated surface**, so they are fully exercised by the standard gate.
+
+---
+
+## 1. Context
+
+The cross-viewpoint fusion stack (`viewpoint/` — ADR-031) combines per-viewpoint AETHER embeddings into one fused embedding via geometric-bias attention, gated by phase coherence, with array-geometry quality scored by a Geometric Diversity Index and a Cramér-Rao bound. The `mat/` survivor-localisation helpers (`triangulation.rs`, `heartbeat.rs`) share the same crate. A beyond-SOTA review surfaced findings spanning a **mislabeled metric**, an **angular-distance contract violation**, **crafted-input panics on a network-reachable path**, and a **redundant clone in the fusion hot path**, plus an ANN/fusion SOTA-research gap. Milestone 2 closes the provable subset and grades the research landscape.
+
+---
+
+## 2. Decision — CORRECTNESS / INTEGRITY FIXES
+
+Each fix ships a regression test (all on the non-feature-gated, workspace-tested surface).
+
+### 2.1 GeometricBias angular separation — use the canonical *wrapped* distance — ACCEPTED & IMPLEMENTED (honest: numeric no-op under the current cos kernel)
+
+**The finding.** `attention::GeometricBias::build_matrix` computed the pairwise angular separation as the **raw** `|azimuth_i − azimuth_j|`. That can exceed π and mis-states the separation across the 0/2π seam (350° and 10° are 20° apart, but raw `|Δ|` = 340°). The module already had a correct wrapped helper, `geometry::angular_distance` (returns `[0, π]`), but it was **private** and `GeometricBias` did not use it.
+
+**The honest correction (disclosed, not hidden).** The bias kernel is `w_angle·cos(theta_ij)`. Because `cos` is **even and 2π-periodic**, `cos(raw) == cos(wrapped)` for every pair (verified numerically: max abs diff `1.1e-16` across seam-crossing test cases). So under the *current* kernel this "bug" produces **identical bias values** — it is a **contract violation, not a behaviour bug**. We say so plainly rather than dressing a no-op as a fix.
+
+**Why land it anyway.** (1) It makes the code satisfy its own documented contract (`theta_ij`: "angular separation in radians", which must be `[0, π]`). (2) It reuses the **single canonical** `angular_distance` helper (now made `pub`), eliminating a divergent angle computation — the same single-source-of-truth discipline ADR-155 applied to metrics. (3) It is **correct by construction** for any future non-even angular kernel (e.g. a linear `w_angle·theta_ij` penalty), which the raw-diff form would silently break.
+
+**Tests:** `geometric_bias_angular_separation_uses_wrapped_distance` (pins that a seam-crossing pair's wrapped distance is 20° while its raw `|Δ|` exceeds π, and that `build_matrix` is symmetric across the seam) and `geometric_bias_linear_angular_kernel_would_catch_raw_diff` (pins the wrapped value ∈ `[0, π]` — the invariant a future linear kernel relies on; the raw-diff form gives 190° where the wrapped form gives 170°).
+
+### 2.2 Crafted-input panics on the fusion/localisation path — typed `None` instead of panic — ACCEPTED & IMPLEMENTED (the security item)
+
+**The finding (DoS).** Two functions on a path that can carry **network-sourced multistatic frames** panicked on crafted input:
+
+- `mat::triangulation::solve_triangulation` indexed `ap_positions[0]` (panics on an empty AP table) and `ap_positions[i]` / `ap_positions[j]` (panics when a TDoA measurement references an **out-of-range AP index**). A remote peer supplying a TDoA tuple `(i=99, …)` with only 3 APs triggers an out-of-bounds panic — a remotely-triggerable denial of service.
+- `mat::heartbeat::CompressedHeartbeatSpectrogram::band_power` computed `self.n_freq_bins - 1`, which **underflows** (usize `0 − 1`) for a zero-bin spectrogram — a debug panic / release `usize::MAX` (then an out-of-range index).
+
+**The fix.** `solve_triangulation` uses `ap_positions.first()?` and `ap_positions.get(i)?` / `.get(j)?` — any empty table or out-of-range index returns `None`, never panics. `band_power` guards `n_freq_bins == 0` up front and **clamps both bounds** into `[0, last]`, returning `0.0` for empty/inverted ranges. No out-of-range index, no subtraction overflow, on any input.
+
+**Tests:** `triangulation_out_of_range_index_returns_none_no_panic`, `triangulation_empty_ap_positions_returns_none_no_panic`, `heartbeat_band_power_zero_bins_no_panic`, `heartbeat_band_power_out_of_range_bounds_no_panic`. Each **panics on the old code** (verified by reverting — §6) and returns a clean `None`/`0.0` on the new.
+
+### 2.3 GDOP mislabel — compute a real, dimensionless GDOP — ACCEPTED & IMPLEMENTED
+
+**The finding.** `geometry::CramerRaoBound` exposed a field named `gdop` ("Geometric Dilution of Precision") that was computed as `(crb_x + crb_y).sqrt()` — **identical to `rmse_lower_bound`**. That is the RMSE (metres, noise-dependent), **not** a GDOP. GDOP is a *dimensionless geometry factor* independent of the noise level; the name was a lie about the quantity.
+
+**The fix (honest rename was the fallback; real GDOP was cheap, so we computed it).** True GDOP `= sqrt(trace(G⁻¹))` where `G` is the **unit-variance** bearing-geometry matrix (the Fisher matrix with every `1/σ²` set to 1). It depends only on the array/target geometry and relates noise to position error as `rmse ≈ GDOP·σ`. We accumulate `G` alongside the FIM in both `estimate` and `estimate_regularised` (cheap 2×2), and report `INFINITY` (not NaN/panic) for a degenerate collinear geometry. The doc comment now states exactly what the field is and what it used to (wrongly) be.
+
+**Test:** `gdop_is_dimensionless_and_noise_independent` — scales every sensor's noise by 10× and asserts GDOP is unchanged while RMSE scales ~10×, and that `rmse ≈ GDOP·σ` at both noise levels. The old `gdop = sqrt(crb_x + crb_y)` **fails** this (it scaled with noise, proving it was RMSE) — verified by reverting (§6).
+
+### 2.4 `fuse()` double-clone in the aggregation hot path — eliminate the redundant clone — ACCEPTED & IMPLEMENTED (MEASURED — §4)
+
+**The finding.** `MultistaticArray::fuse` (and `fuse_ungated`) cloned every viewpoint embedding **twice** per fusion: once into the `extracted` tuple vector (`v.embedding.clone()`), then **again** when building the attention input (`extracted.iter().map(|(_, e, _, _)| e.clone())`). At the AETHER dimension (128 f32 = 512 B) over up to 8 viewpoints, that is a wholly redundant second heap allocation + memcpy per viewpoint, every TDM cycle.
+
+**The fix.** Build `extracted` once (the unavoidable clone out of the borrowed `self.viewpoints`), then **consume** `extracted` by value and **move** each embedding into the attention input (`embeddings.push(emb)`), capturing geometry/ids by `Copy` in the same pass. One clone per viewpoint instead of two. Measured win in §4.
+
+---
+
+## 3. Security review (touched files)
+
+The §2.2 crafted-input panics **are** the security item: a DoS via out-of-range indices / zero-bin underflow on a fusion/localisation path that may be driven by network-sourced multistatic frames. Beyond those, the touched files were swept for further panic-on-untrusted-input / unbounded-alloc sites:
+
+- `attention.rs` — all indexing is over internally-sized `n × n` / `d` loops bounded by validated input lengths (`DimensionMismatch` is returned for ragged embeddings); softmax denominators are floored with `f32::EPSILON`. No unbounded alloc (sizes derive from caller-supplied vector lengths already validated against `d_in`). **No further action.**
+- `geometry.rs` — `det`/`det_g` are floored before division; degenerate geometry yields `None`/`INFINITY`, never NaN-panic. **No further action.**
+- `fusion.rs` — embedding dimension is validated in `submit_viewpoint`; the event log is bounded (`max_events`, oldest-half drain). **No further action.**
+- `coherence.rs` — circular buffer is fixed-capacity; gate thresholds are clamped. **No further action.**
+
+No `unsafe`, no `unwrap()` on external input, and no unbounded allocation remain on the touched paths after §2.2.
+
+---
+
+## 4. MEASURED perf win (new criterion bench)
+
+A new bench, `crates/wifi-densepose-ruvector/benches/fusion_bench.rs`, covers the fusion hot path. It has two groups: `fusion_pipeline` (end-to-end `MultistaticArray::fuse_ungated()` at 2/4/8 viewpoints, dim 128) and an isolated A/B of the §2.4 marshalling step (`embedding_extract/before_double_clone` vs `after_single_clone`).
+
+- **Reproduce:** `cargo bench -p wifi-densepose-ruvector --bench fusion_bench`
+- **Measured (`embedding_extract`, 8 viewpoints × 128-d), medians:** `before_double_clone` **1.0029 µs** → `after_single_clone` **461.6 ns** — **~2.17× faster** on the marshalling step. The result is what theory predicts (two embedding clones collapse to one), confirming the redundant clone was the cost, not noise.
+- **End-to-end `fusion_pipeline` (medians):** 2 vp = 56.3 µs, 4 vp = 99.5 µs, 8 vp = 202.1 µs. The marshalling (~0.5–1 µs) is **well under 1%** of total fusion cost (dominated by the `n×n` attention), so the **end-to-end** effect is modest by construction; the `embedding_extract` A/B isolates and proves the clone-elimination itself. We report this honestly rather than attributing the full 2.17× to the pipeline.
+
+The double-clone elimination is also correctness-neutral: all 100 `viewpoint`/`mat` lib tests pass unchanged.
+
+---
+
+## 5. The ANN / cross-viewpoint-fusion SOTA landscape (graded)
+
+| # | Candidate | What | Grade | Verdict |
+|---|-----------|------|-------|---------|
+| **1** | **SymphonyQG** (SIGMOD 2025, public code) | Unified quantization + graph ANN; source reports **3.5–17× QPS over HNSW at equal recall**, pure-CPU / edge-portable. | **CLAIMED** (author-measured; **not reproduced on our hardware** — reproduction is future work) | **Lead beyond-SOTA candidate for the ruvector ANN path.** Propose as ACCEPTED-future; cite honestly as "claimed by source, reproduction pending." Best fit because the ruvector retrieval path (AETHER re-ID, sketch prefilter) is exactly an ANN problem and SymphonyQG is CPU/edge-portable like our deployment. |
+| **2** | **Multi-bit / Extended RaBitQ** | Extends our existing **1-bit** `sketch.rs` (ADR-084) to multiple bits per dimension — precisely the "Pass 2" our own `sketch.rs` doc deferred (1-bit sign quantization ships first; rotation/more-bits "later if benchmark-measured top-K coverage drops below the ADR-084 90% threshold"). | **CLAIMED** (RaBitQ family well-characterised; our 1-bit baseline is MEASURED in `sketch_bench`) | **Accepted near-term.** Concrete, in-scope, incremental — extends a MEASURED capability rather than importing a new system. #2 priority. |
+| **3** | **GraphPose-Fi-style learned antenna-attention + ChebGConv fusion head** | Would replace the current **untrained identity-projection + mean-pool** "attention" (the `CrossViewpointAttention` default is `ProjectionWeights::identity` — not a *learned* attention) with a learned graph fusion head. | **DATA-GATED** (per ADR-152 measurement (b): architecture is **NOT** the current bottleneck — **data is**) | **ACCEPTED-future, data-gated. Do NOT build now.** ADR-152's measured lesson was that swapping architecture without more/better paired data does not move PCK. Building a learned fusion head before the data exists would repeat the mistake ADR-155 §5 also flagged for GraphPose-Fi. |
+| — | **Cramér-Rao / sensor-placement** (`geometry.rs` CRB) | Investigated for a 2026 advance beating the textbook Fisher-information CRB already implemented. | **Investigated — NO ACTION** | **Cleared honestly.** No 2026 method beats the closed-form Fisher-information CRB for this 2-D bearing problem; our implementation is already correct SOTA. (Recording a negative result is a deliberate anti-slop signal.) The only CRB change this milestone is the §2.3 *GDOP* honesty fix, which is a labelling/quantity correction, not an algorithmic one. |
+
+---
+
+## 6. Validation
+
+- **Bug-catching tests verified to bite.** Each §2.2/§2.3/§2.4-adjacent fix was reverted and the corresponding test observed to **fail on the old code**, then restored:
+  - `triangulation_out_of_range_index_returns_none_no_panic` / `triangulation_empty_ap_positions_returns_none_no_panic` — **panic** (index out of bounds) on old code.
+  - `heartbeat_band_power_zero_bins_no_panic` — **panic** ("attempt to subtract with overflow") on old code.
+  - `gdop_is_dimensionless_and_noise_independent` — **assertion failure** (GDOP scaled with noise) on old code.
+  - §2.1 (angular wrap) is the **disclosed no-op**: its tests pin the *contract* (wrapped value ∈ `[0, π]`), since the cos kernel makes the bias value numerically identical with or without the fix. We do not claim a behaviour change.
+- **`cd v2 && cargo test -p wifi-densepose-ruvector --no-default-features --lib`** — **100 passed / 0 failed** (was 93; +7 new tests).
+- **`cd v2 && cargo test --workspace --no-default-features`** — **3050 passed / 0 failed** (full-workspace aggregate across all crates and test binaries; the +7 new `wifi-densepose-ruvector` tests are included and green).
+- **`python archive/v1/data/proof/verify.py`** — **`VERDICT: PASS`** (the Python pipeline proof is independent of these Rust changes — confirmed unaffected).
+- New `fusion_bench` compiles and runs under the default feature set.
+
+---
+
+## 7. What changed, file by file
+
+- `viewpoint/geometry.rs` — `angular_distance` made `pub` (single canonical wrapped-angle helper); real dimensionless GDOP (`sqrt(trace(G⁻¹))`) in `estimate`/`estimate_regularised` (was RMSE mislabelled); `gdop` doc states the quantity and the prior bug; `gdop_is_dimensionless_and_noise_independent` test.
+- `viewpoint/attention.rs` — `GeometricBias::build_matrix` uses the canonical wrapped `angular_distance` (contract fix; numeric no-op under cos — disclosed); two contract-pinning tests.
+- `viewpoint/fusion.rs` — `fuse`/`fuse_ungated` move embeddings out of `extracted` (single clone, not double); existing tests unchanged and green.
+- `mat/triangulation.rs` — `first()?` / `get(i)?` / `get(j)?` guards (no panic on empty table / crafted indices); two no-panic tests.
+- `mat/heartbeat.rs` — `band_power` zero-bin guard + bounds clamp (no underflow / out-of-range index); two no-panic tests.
+- `benches/fusion_bench.rs` (new) + `Cargo.toml` `[[bench]]` — fusion hot-path bench + the double-clone A/B.
+
+---
+
+## 8. Deferred backlog (NOT silently dropped)
+
+The review surfaced more than this milestone scoped. Tracked here for a future ADR-156 milestone:
+
+- **SymphonyQG reproduction** (§5 #1) — reproduce the 3.5–17× QPS-over-HNSW claim on our hardware before integrating into the ruvector ANN path. Currently CLAIMED-only.
+- **Multi-bit / Extended RaBitQ** (§5 #2) — implement the `sketch.rs` "Pass 2" (more bits per dimension and/or the randomized rotation) and re-measure top-K coverage against the ADR-084 ≥90% acceptance bar in `sketch_bench`.
+- **Learned cross-viewpoint fusion head** (§5 #3, GraphPose-Fi-style) — **data-gated**: blocked on the paired multi-room data ADR-152 measurement (b) identified as the real bottleneck; do not build the architecture first.
+- **`CrossViewpointAttention` learned projections** — the default `ProjectionWeights::identity` + mean-pool is honest but unlearned; wiring real learned Q/K/V projections is part of the data-gated item above (no learned weights ⇒ the "attention" is currently a geometric-bias-weighted average, which the code/docs should keep stating plainly).
+- **`coherence.rs` / `fusion.rs` micro-opts and the remaining lower-severity review findings** (style, doc, further hot-path tuning) from the fusion gap review.
+
+---
+
+## 9. Consequences
+
+**Positive.** The fusion path now: uses one canonical wrapped angular-distance helper; reports a **real** dimensionless GDOP instead of a mislabeled RMSE; cannot be panicked by crafted multistatic indices or a zero-bin spectrogram (DoS closed); and does one embedding clone per viewpoint instead of two (measured). Every fix is pinned by a test that fails on the old code, and the ANN/fusion SOTA landscape is graded so the near-term (multi-bit RaBitQ) and the data-gated (learned fusion) are not confused.
+
+**Negative / honest.** The headline angular-wrap fix is a **numeric no-op** under the current cos kernel — we land it for contract/maintainability, not because it changes an output, and we say so. The two strongest external candidates (SymphonyQG, learned fusion) are **not built here** — one is CLAIMED-pending-reproduction, the other is data-gated by a prior measurement. The perf win is a **local hot-path** improvement, modest in the end-to-end pipeline (attention dominates). None of these is presented as more than it is.

docs/adr/ADR-157-hardware-sensing-beyond-sota.md

@@ -0,0 +1,191 @@
+# ADR-157: Hardware / Sensing-Acquisition Layer Beyond-SOTA Sweep — Milestone 3 (An Already-Hardened Layer, Three Small Real Fixes, an Honestly-Null Perf Win, and a Mostly-NO-ACTION SOTA Landscape)
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed |
+| **Date** | 2026-06-11 |
+| **Deciders** | ruv |
+| **Codebase target** | `wifi-densepose-vitals` (`heartrate.rs`, `breathing.rs`, `anomaly.rs`, `store.rs`), `wifi-densepose-wifiscan` (`pipeline/breathing_extractor.rs`, `pipeline/correlator.rs`, `adapter/netsh_scanner.rs`), `wifi-densepose-hardware` (`esp32_parser.rs`, `sync_packet.rs`, `esp32/secure_tdm.rs`, `ieee80211bf/*`), `wifi-densepose-calibration` (`geometry_embedding.rs`), benches, docs |
+| **Relates to** | ADR-021 (ESP32 CSI vitals), ADR-022 (multi-BSSID WiFi sensing), ADR-028 (ESP32 capability audit + witness), ADR-032 (multistatic mesh security), ADR-110 (HE PPDU bandwidth), ADR-151 (per-room calibration), ADR-152 (WiFi-Pose SOTA 2026 intake), ADR-153 (802.11bf forward-compat), ADR-154 (Signal/DSP sweep M0), ADR-155 (NN/Training sweep M1), ADR-156 (RuVector/Fusion sweep M2) |
+| **Scope** | Milestone 3 of the beyond-SOTA sweep across the four hardware/sensing-acquisition crates. The honest headline: **this layer is already well-hardened** — the real work is small. Three correctness/stability fixes (each pinned by a test that fails on the old code), one algorithmic perf change whose end-to-end win is **null at realistic window sizes** (disclosed, not inflated) with a committed bench, one defense-in-depth hardening on an unreachable path, a **MEASURED negative-results section** (the centerpiece — what was investigated and found already-correct), a graded SOTA landscape that is **mostly NO-ACTION**, and a deferred backlog. **Nothing is silently dropped.** |
+
+---
+
+## 0. PROOF discipline (this ADR's contract)
+
+This project has been publicly accused of "AI slop." Milestone 3 answers with **evidence, not adjectives** — the same contract as ADR-154/155/156:
+
+- Every correctness/stability fix ships a **committed regression test that fails on the old code and passes on the new**. Each was verified by reverting the fix and observing the test fail (recorded in §6).
+- Every perf number is **MEASURED before/after** with the exact reproduce command and a committed criterion bench. Where the win is below noise, we **say so and claim nothing** — see §4, which is a deliberately-disclosed near-null result.
+- Every external SOTA reference is graded **MEASURED** / **CLAIMED** / **DATA-GATED**, and where the right answer is "do nothing," we record the negative result explicitly (§5) — a stronger anti-slop signal than a fix.
+- The headline of this milestone is itself a negative result: **the acquisition layer was already hardened.** We disclose what we *checked and did not change* (§3) in as much detail as what we changed (§2), because "investigated, already correct, no action" is the most honest thing a sweep can report when it is true.
+
+Test machine for the perf numbers: Windows 11, `cargo bench --release`, criterion 0.5. Numbers are wall-clock medians on this box; the **ratio** (before/after) is the claim, not the absolute ns.
+
+Build/test gate: `cargo test --workspace --no-default-features` (the project's standard gate — no GPU/`crv` features). All fixes in this milestone are on the **default, non-feature-gated surface**, so they are fully exercised by the standard gate. The serde-validated `ieee80211bf` types are additionally verifiable with `--features serde`; the live-QUIC path in `secure_tdm` is structurally tested (HMAC/replay/tamper) but not live-socket-tested in CI.
+
+---
+
+## 1. Context
+
+The hardware/sensing-acquisition layer is the bottom of the stack: it turns raw RF (ESP32 CSI frames, multi-BSSID netsh scans, 802.11bf measurement reports) into typed, validated domain objects that the signal/fusion/NN layers above consume. A beyond-SOTA review of the four crates surfaced far **fewer** real defects than the signal (ADR-154) or fusion (ADR-156) sweeps — because this layer was written defensively from the start: length-gated parsers, `Option`-returning helpers, `#[serde(try_from)]` validate-on-deserialize, FSMs that return `Result` instead of panicking, and HMAC-authenticated + replay-protected TDM beacons.
+
+The genuine findings are three: an **O(n²) sliding-window data-structure choice** in the vital-sign extractors (perf, latent), a **partial-weights scale-mixing bug** in breathing fusion (correctness), and an **IIR resonator that can diverge at pathologically low sample rates** (stability). Everything else the review flagged turned out to be already-safe — documented in §3 as MEASURED negative results.
+
+---
+
+## 2. Decision — the fixes that landed
+
+Each correctness/stability fix ships a regression test on the non-feature-gated, workspace-tested surface.
+
+### 2.1 §A1 — `Vec::remove(0)` O(n²) sliding windows → `VecDeque` (PERF, latent; MEASURED via bench — near-null at realistic sizes, disclosed)
+
+**The finding.** Every fixed-length sliding window in the extractors was a `Vec<f64>`/`Vec<f32>` whose oldest-sample eviction used `Vec::remove(0)` — an **O(n) shift of the whole buffer on every sample**, making a full-window `extract()` sweep O(n²). Six sites:
+
+| File | Site | Buffer |
+|------|------|--------|
+| `vitals/heartrate.rs` | `extract` history window | `Vec<f64>` → `VecDeque<f64>` |
+| `vitals/breathing.rs` | `extract` history window | `Vec<f64>` → `VecDeque<f64>` |
+| `vitals/anomaly.rs` | `rr_history` / `hr_history` | `Vec<f64>` → `VecDeque<f64>` (×2) |
+| `vitals/store.rs` | `readings` ring buffer | `Vec<VitalReading>` → `VecDeque<VitalReading>` |
+| `wifiscan/pipeline/breathing_extractor.rs` | filtered history | `Vec<f32>` → `VecDeque<f32>` |
+| `wifiscan/pipeline/correlator.rs` | per-BSSID histories | `Vec<Vec<f32>>` → `Vec<VecDeque<f32>>` |
+
+**The fix.** Swap to `VecDeque` with `push_back` + `pop_front` (O(1) eviction). Where the autocorrelation / zero-crossing / Pearson loop needs a contiguous slice, call `make_contiguous()` (or `as_slices().0` after it) **once per `extract()`**. This matches the idiom already used correctly in `wifiscan/pipeline/orchestrator.rs`. **Output is bit-identical** — no behavior test bites; the change is bench-gated.
+
+**The honest measurement (§4).** In **isolation**, the eviction cost collapses from O(n²) to O(n): a microbenchmark of pure eviction shows **34.6× at window=3000 and 3158× at window=100000**. But in the **full `extract()` path at realistic ESP32 window sizes** (heartrate ~1500, breathing ~3000), the per-frame DSP (autocorrelation is O(window·lags); zero-crossing is O(window)) **dominates the eviction entirely**, so the end-to-end win is **below noise** — measured `heartrate` 42.8 ms (before) vs 44.4 ms (after), `breathing` 7.95 ms vs 7.86 ms: overlapping confidence intervals, **no measurable change**. We land A1 because it is the correct data structure and removes a latent O(n²) that *would* bite at higher sample rates or longer windows — **not** because it speeds up the current hot path, which it does not measurably. Claiming an end-to-end speedup here would be exactly the inflation this sweep exists to prevent (the same discipline ADR-156 §2.1 applied to its cos no-op).
+
+### 2.2 §A2 — `breathing.rs` partial-weights scale-mixing (CORRECTNESS, real)
+
+**The finding.** `BreathingExtractor::extract` fused per-subcarrier residuals as `Σ residuals[i]·w[i]` where `w[i] = weights.get(i).unwrap_or(1/n)`. The result was **never normalized**. When `weights` was supplied **shorter than** `n`, the supplied entries (e.g. attention weights ~10.0) were used **raw** while the missing tail defaulted to `uniform_w = 1/n` (~0.125) — two scales summed with no renormalization, **silently mis-scaling the breathing signal** by a factor that depends on `weights.len()`. A caller passing 2 high attention weights for an 8-subcarrier frame got a fused value ~20× too large.
+
+**The fix.** Extracted the fusion into `fuse_weighted_residuals(residuals, weights, n)` and normalized by `Σ(effective weights)` — `weighted_sum / weight_total` — mirroring the **already-correct** pattern in `heartrate::compute_phase_coherence_signal`. A partial weight slice now produces a true weighted average in the residual range, independent of `weights.len()`.
+
+**Tests (fail on old code, verified by reverting — §6):**
+- `partial_weights_are_renormalized_not_scale_mixed` — `residuals=[1.0;8]`, `weights=[10.0,10.0]` → fused value `1.0` (the renormalized weighted mean), and explicitly **not** the old scale-mixed sum `2·10 + 6·0.125 = 20.75`.
+- `partial_weights_fusion_is_weighted_average` — differing residuals → a proper weighted average within `[0, 2]`, which the old un-normalized sum is not.
+
+### 2.3 §A3 — IIR resonator divergence at pathologically low sample rate (STABILITY, real)
+
+**The finding.** Both extractors' `bandpass_filter` set the resonator pole radius `r = 1 - bw/2` with `bw = 2π(f_high − f_low)/fs`. The **research report's stated trigger ("`fs` below ~4 Hz") is incorrect**, and we say so: the resonator pole *magnitude* is `|r|`, and the filter is stable for any `|r| < 1` — a merely-**negative** `r` is still stable. Divergence requires `|r| ≥ 1`, i.e. `bw ≥ 4`, i.e. `fs` very low **relative to the band width** (e.g. `fs = 0.5` Hz with a 0.1–0.9 Hz band → `bw = 10.05`, `r = −4.03`, `|r| = 4.03 > 1`). When that holds, the filter **diverges exponentially**: a unit-step input reaches `~10^183` within 300 frames and **overflows f64 to ±inf within ~600 frames**. Once one inf enters `filtered_history`, the autocorrelation `acf0`/zero-crossing path produces NaN and the extractor is **permanently dead** (silent stall until `reset()`).
+
+**The fix.** Two layers of defense-in-depth:
+1. **Clamp** `r` to a stable range: `r = (1.0 - bw/2.0).clamp(0.0, 0.9999)` — keeps the pole inside the unit circle for **any** sample-rate / band-edge configuration. (We document honestly that the divergence condition is `|r| ≥ 1`, not "`r` negative.")
+2. **Finite-guard** before the history push: `if !filtered.is_finite() { return None; }` — mirrors the NaN-bypass guard in ADR-154 §3, so even a future divergence cannot poison the buffer.
+
+Applied to **both** `heartrate.rs` and `breathing.rs` (identical resonator block).
+
+**Tests (fail on old code, verified by reverting — §6):** `heartrate::low_sample_rate_filter_stays_finite` and `breathing::low_sample_rate_filter_stays_finite` — construct at `fs=0.5` with a 0.1–0.9 Hz band, feed a unit step for 600 frames, assert **every** `filtered_history` sample is finite. On the old code these **panic** (a `filtered_history[i]` is inf/NaN); on the new code all samples are finite.
+
+### 2.4 §D1 — new `vitals/benches/vitals_bench.rs` (MEASURED)
+
+A new criterion bench (`harness = false`, registered in `Cargo.toml`) drives each extractor from empty to a full window (`heartrate` 1500 samples, `breathing` 3000) so the A1 sliding-window bookkeeping is exercised across the whole buffer. Follows the criterion style of the existing `hardware/benches/transport_bench.rs` and ADR-156's `fusion_bench`. Numbers and the honest interpretation are in §4.
+
+### 2.5 §B1 — `ieee80211bf/transport.rs` drop-instead-of-truncate (HARDENING, unreachable path — disclosed)
+
+`OpportunisticCsiBridge::ingest` built `CsiReportPayload { n_subcarriers: self.amp_accum.len() as u16, … }`. The `as u16` would silently wrap a count above 65 535. **This is unreachable in practice**: `ingest` gates `frame.subcarrier_count() > MAX_REPORT_SUBCARRIERS` (484) at entry and returns `None`, and `report.validate()` independently rejects oversized counts downstream. We replaced the cast with `u16::try_from(self.amp_accum.len()).ok()?` (drop-instead-of-truncate) so the construction is **correct-by-construction** rather than relying on the upstream gate. We disclose this as **defense-in-depth on an unreachable path, not a live bug** — no behavior change, no new test (the gate already prevents the input that would exercise it).
+
+### 2.6 §B4 — constant-time HMAC tag compare: **DEFERRED, not landed** (disclosed)
+
+`secure_tdm.rs:284` compares the 8-byte HMAC tag with `self.hmac_tag == expected` (data-dependent, non-constant-time). The research authorized adding `subtle::ConstantTimeEq` **only if `subtle` were already a direct dependency** — it is not (only transitive, via a crypto crate). Per that guidance, and because this is an **8-byte tag on a LAN multistatic sync beacon** (not a remote attacker-controlled timing-oracle surface), we **do not add a direct dependency** for it. Tracked in §8 as a deferred item, not silently dropped.
+
+---
+
+## 3. The MEASURED negative-results section (the centerpiece — what was investigated and found already-correct)
+
+This is the core of ADR-157. The acquisition layer was hardened before this sweep; the strongest anti-slop evidence is an honest accounting of what we **checked and did not need to change**. Each is verified against the live code with a file:line citation.
+
+| Area | Claim verified | Evidence (file:line) | Verdict |
+|------|----------------|----------------------|---------|
+| **ESP32 parser subcarrier index math** | A crafted CSI frame cannot panic via the subcarrier-index arithmetic. The total-frame-size length gate (`data.len() < HEADER_SIZE + n_antennas·n_subcarriers·2 → Err`) dominates **every** subsequent `data[byte_offset]`/`[+1]` access; `n_subcarriers ≤ 256`, `n_antennas ≤ 4` are header-bounded, and the `index` math is pure i16 arithmetic with no indexing. | `esp32_parser.rs:211` (length gate) guards the loop at `:224–242` | **Already safe — NO ACTION** |
+| **`sync_packet.rs` `try_into().unwrap()`** | The four `try_into().unwrap()` calls are **infallible**: each slices a fixed-width sub-range (`[0..4]`, `[8..16]`, `[16..24]`, `[24..28]`) of a buffer already guaranteed `len() >= SYNC_PACKET_SIZE` (32) by the early `return Err(InsufficientData)`. | `sync_packet.rs:88` (length gate) → `:94,102,103,104` (fixed-width slices) | **Already safe — NO ACTION** |
+| **The entire `ieee80211bf/` 802.11bf model** | Validate-on-deserialize and no-panic-by-construction throughout. `MeasurementSetupId` is `#[serde(try_from = "u8")]` rejecting `> MAX_SETUP_ID` (127); `ThresholdParams` is `#[serde(try_from = "RawThresholdParams")]` routing every deserialize through `ThresholdParams::new`; the session FSM `handle()` returns `Result<Vec<Action>, BfError>` (never panics) and enforces **single-role** (`self.role != Initiator/Responder → Err`) on every transition; the SBP request is validated through the **same** single `evaluate_setup` chain as a direct setup (no SBP-only policy bypass). | `types.rs:160–161` (setup-id try_from), `:225–226` (threshold try_from), `:165` (range check); `session.rs:118` (`handle` → Result), `:130/143/166/182` (single-role), `messages.rs:130–147` (SBP single-evaluate) | **Already SOTA-shaped — NO ACTION** |
+| **`secure_tdm.rs` HMAC + replay** | Beacon authentication (HMAC-SHA256, 8-byte tag), tamper rejection, and replay-window protection are correct and tested. (The non-constant-time compare at `:284` is the only nit — §2.6, deferred as out-of-threat-model for an 8-byte LAN tag.) | `secure_tdm.rs:279` (`verify`), `:284` (compare), tests `:614–673` (replay), `:728` (tamper) | **Correct — NO ACTION (B4 deferred)** |
+| **`netsh_scanner.rs` command + parse** | No shell-injection surface: the scanner uses a **fixed argv** (`Command::new("netsh").args(["wlan","show","networks","mode=bssid"])`) — no shell, no interpolation. Parsing is **`Option`-based** (`try_parse_ssid_line`/`try_parse_bssid_line`/`try_parse_signal_line` → `Option`, with `.unwrap_or(default)`), so hostile/garbled netsh output is silently skipped, never panicked. | `netsh_scanner.rs:50–51` (fixed argv), `:96–102` (`unwrap_or` defaults), `:242/257/270` (`Option` parsers) | **Already safe — NO ACTION** |
+| **`calibration/geometry_embedding.rs` overflow guard** | The geometry embedding clamps every position/std-dev component into `±MAX_COORD_M` (1000 m) via `clamp_m`, explicitly to stop adversarial coordinates from overflowing the covariance accumulation into `inf`; the documented invariant ("every value is finite, never NaN/inf") holds. | `geometry_embedding.rs:55` (`MAX_COORD_M`), `:145/150` (`clamp_m` on centroid + std-dev) | **Already safe — NO ACTION** |
+
+---
+
+## 4. The §D1 perf measurement (MEASURED — honestly near-null end-to-end)
+
+New bench: `crates/wifi-densepose-vitals/benches/vitals_bench.rs`, two functions covering a full-window fill of each extractor.
+
+- **Reproduce:** `cargo bench -p wifi-densepose-vitals --bench vitals_bench`
+  (compile-only: append `--no-run`; the medians below used `-- --warm-up-time 1 --measurement-time 3 --sample-size 20`).
+
+**End-to-end `extract()` full-window fill, medians:**
+
+| Bench | Before (`Vec::remove(0)`) | After (`VecDeque`) | Verdict |
+|-------|---------------------------|--------------------|---------|
+| `heartrate_extract_full_window_1500` | 42.81 ms `[42.19, 42.81, 43.46]` | 44.37 ms `[43.55, 44.37, 45.19]` | **no measurable change** (after marginally slower; intervals overlap) |
+| `breathing_extract_full_window_3000` | 7.95 ms `[7.86, 7.95, 8.05]` | 7.86 ms `[7.66, 7.86, 8.04]` | **no measurable change** (intervals overlap) |
+
+The end-to-end effect is **null within noise** because the per-frame DSP dominates: heartrate runs an O(window·lags) autocorrelation every frame (≈1500·125 multiply-adds), which utterly swamps the O(window) eviction the A1 change improves; breathing's O(window) zero-crossing and the `make_contiguous` rotation are the same order as the old `remove(0)` memmove at these sizes.
+
+**Where the win actually lives (isolated eviction-only microbench, supporting evidence — not in the committed bench):**
+
+| Window | `Vec::remove(0)` (eviction only) | `VecDeque` | Speedup |
+|--------|----------------------------------|------------|---------|
+| 3 000 | 1.00 ms | 0.029 ms | **34.6×** |
+| 20 000 | 94.5 ms | 0.122 ms | **773×** |
+| 100 000 | 3 139 ms | 0.994 ms | **3 158×** |
+
+So A1 is **algorithmically correct and removes a real latent O(n²)** that would bite at higher sample rates or longer analysis windows — but at the **current** ESP32 window sizes the end-to-end win is below noise, and we claim nothing more. This is the §0 contract in action: a perf claim without a measured before/after improvement is **not made**.
+
+---
+
+## 5. The hardware/sensing SOTA landscape (graded — mostly NO-ACTION, honest)
+
+Grades: **MEASURED** (source measured it, ideally public method/code), **CLAIMED** (asserted, no reproducible artifact), **DATA-GATED** (blocked on data we don't have, per a prior ADR-152 measurement).
+
+| # | Area | Candidate / question | Grade | Verdict |
+|---|------|----------------------|-------|---------|
+| 1 | **CSI vital signs (HR/BR)** | Deep-CSI vital-sign models report **MAE ~2–3 BPM** vs our classical IIR-bandpass + autocorrelation/zero-crossing. | **DATA-GATED + CLAIMED** | **NO ACTION on method.** A deep model needs **paired PPG/ECG ground truth** we do not have, and no public ESP32 artifact reproduces the cited MAE on commodity CSI. Our classical method is the honest commodity baseline; the real wins this milestone are the A1/A3 robustness fixes, not a new model. |
+| 2 | **802.11bf-2025 conformance** | Adopt a conformance test-vector suite for the `ieee80211bf/` forward-compat model. | **CLAIMED (not public)** | **NO ACTION.** No commodity silicon ships a conformant 802.11bf interface as of 2026, and the conformance suites are **WBA / Wi-Fi Alliance pre-certification** material, **not public**. Our model's "no OTA encoding until silicon exists" posture (ADR-153) is the correct one. Tracked in §8: *add SBP conformance vectors when the WFA publishes a test plan* — we will **not invent vectors**. |
+| 3 | **Per-room calibration (ADR-151)** | Bank-of-specialists + drift-veto vs a 2026 calibration SOTA. | **CLAIMED on numbers, DATA-GATED on a head-to-head** | **NO ACTION on architecture.** The bank-of-specialists + drift-veto design is SOTA-shaped, but we have **no head-to-head PCK** against a published method (no paired multi-room data). The geometry-conditioned LoRA head is **built-but-unconsumed** and data-gated → **ACCEPTED-FUTURE** (§8), not built now. |
+| 4 | **Multi-BSSID throughput (wifiscan)** | The module docs assert a native `wlanapi.dll` FFI 10–20 Hz path; the current `WlanApiScanner` wraps `netsh` (~2 Hz). | **CLAIMED-unmeasured** | **NO ACTION + corrected expectation.** The native FFI fast path is **asserted but NOT implemented** — the live scanner is the ~2 Hz netsh shim. The "10×" is unmeasured. → **ACCEPTED-FUTURE** (§8). **We explicitly do NOT claim a speedup that does not exist.** |
+
+---
+
+## 6. Validation
+
+- **Bug-catching tests verified to bite.** Each §A2/§A3 fix was reverted and the corresponding test observed to fail on the old code, then restored:
+  - `partial_weights_are_renormalized_not_scale_mixed`, `partial_weights_fusion_is_weighted_average` — **assertion failure** (returned the old un-normalized scale-mixed sum) on old code.
+  - `heartrate::low_sample_rate_filter_stays_finite`, `breathing::low_sample_rate_filter_stays_finite` — **panic** (a `filtered_history[i]` is inf/NaN) on old code.
+  - §A1 is the **disclosed bit-identical change**: no behavior test bites (correctly — output is unchanged); the bench (§4) is the gate, and it shows **no measurable end-to-end change**, which we report honestly.
+  - §B1 is on an **unreachable path** (gated upstream), so it carries no new test — disclosed as defense-in-depth, not a live bug.
+- **`cd v2 && cargo test -p wifi-densepose-vitals -p wifi-densepose-hardware -p wifi-densepose-wifiscan -p wifi-densepose-calibration --no-default-features`** — all green. Lib-test counts: `wifi-densepose-vitals` **55** (was 51; +4 net new bug-catching tests — two §A2, two §A3), `wifi-densepose-hardware` **163**, `wifi-densepose-wifiscan` **87**, `wifi-densepose-calibration` **58**. 0 failures across all four.
+- **`cd v2 && cargo test --workspace --no-default-features`** — **3054 passed / 0 failed** (M2 left the workspace at 3050; the +4 net new bug-catching tests are included and green).
+- **`python archive/v1/data/proof/verify.py`** — **`VERDICT: PASS`**, pipeline hash unchanged `f8e76f21…46f7a` (these are Rust-only changes; the Python pipeline proof is independent and confirmed unaffected).
+- New `vitals_bench` compiles and runs under the default feature set.
+- **Disclosed validation limits:** the live-QUIC transport in `secure_tdm` is **structurally** tested (HMAC compute/verify, tamper, replay-window) but **not live-socket-tested** in CI; the serde-gated `ieee80211bf` types are additionally verifiable with `--features serde`. Clippy is not installed in the local 1.89 toolchain, so the per-crate lint pass was not run locally (the project gate is `cargo test`).
+
+---
+
+## 7. What changed, file by file
+
+- `vitals/heartrate.rs` — `filtered_history: Vec<f64>` → `VecDeque<f64>` (`push_back`/`pop_front`, `make_contiguous` once per `extract`); resonator `r` clamped to `[0, 0.9999]`; finite-guard before history push; corrected divergence-condition doc (`|r| ≥ 1`, not "`r` negative"); `low_sample_rate_filter_stays_finite` test.
+- `vitals/breathing.rs` — same `VecDeque` + clamp + finite-guard changes; weighted fusion extracted to `fuse_weighted_residuals` and **normalized by Σ(effective weights)** (the §A2 fix); three new tests (two A2, one A3).
+- `vitals/anomaly.rs`, `vitals/store.rs` — sliding/ring buffers → `VecDeque` (O(1) eviction); `store::history` takes `&mut self` to hand back a contiguous slice via `make_contiguous` (no external callers; observable contents unchanged).
+- `wifiscan/pipeline/breathing_extractor.rs` — `VecDeque<f32>` + `make_contiguous`.
+- `wifiscan/pipeline/correlator.rs` — per-BSSID histories → `Vec<VecDeque<f32>>`; contiguous-ize each touched buffer once before the Pearson pass.
+- `hardware/ieee80211bf/transport.rs` — `n_subcarriers: … as u16` → `u16::try_from(…).ok()?` (§B1 drop-instead-of-truncate, unreachable-path hardening).
+- `vitals/Cargo.toml` + `vitals/benches/vitals_bench.rs` (new) — criterion dev-dep, `[[bench]]`, the §D1 full-window benches.
+
+---
+
+## 8. Deferred backlog (NOT silently dropped)
+
+- **§B4 constant-time HMAC compare** — `secure_tdm.rs:284` uses `==` on the 8-byte tag. Add `subtle::ConstantTimeEq` **if** `subtle` becomes a direct dependency for another reason; not worth a new dependency for an 8-byte LAN sync-beacon tag (out of the current threat model). Deferred, not dropped.
+- **802.11bf SBP conformance vectors** (§5 #2) — add real conformance test vectors to the `ieee80211bf/` model **when the Wi-Fi Alliance / WBA publishes a public test plan**. Do not invent vectors before then.
+- **Geometry-conditioned LoRA calibration head** (§5 #3) — built-but-unconsumed and **data-gated** on paired multi-room PCK data (ADR-152 measurement (b): data, not architecture, is the bottleneck). ACCEPTED-FUTURE.
+- **Native `wlanapi.dll` FFI multi-BSSID fast path** (§5 #4) — the asserted 10–20 Hz path is **not implemented**; the live scanner is the ~2 Hz netsh shim. Implement and **measure** the real throughput before claiming any multiple. ACCEPTED-FUTURE, CLAIMED-unmeasured until then.
+- **Deep-CSI vital-sign model** (§5 #1) — DATA-GATED on paired PPG/ECG ground truth. No public ESP32 artifact reproduces the cited ~2–3 BPM MAE. Not on the near-term path.
+
+---
+
+## 9. Consequences
+
+**Positive.** The vital-sign extractors now use the correct O(1)-eviction data structure (no latent O(n²)), cannot mis-scale a breathing estimate from a partial attention-weight slice, and cannot be silently killed by a diverging IIR filter at a pathological sample rate. The 802.11bf construction site drops-instead-of-truncates on an (already-gated) oversized count. Most importantly, the layer's existing hardening — length-gated parsers, infallible fixed-width slices, validate-on-deserialize, no-panic FSMs, fixed-argv scanning, HMAC+replay TDM, overflow-clamped geometry embeddings — is now **documented as MEASURED negative results** with file:line evidence, so a reader can verify the "already safe" claims rather than take them on faith.
+
+**Negative / honest limits.** The §A1 perf change is **null end-to-end** at realistic window sizes — we land it for correctness, not speed, and the committed bench proves the null rather than hiding it. The research report's stated §A3 divergence trigger ("`fs` below ~4 Hz") was **physically inaccurate** (divergence needs `|r| ≥ 1` ⇒ `bw ≥ 4`, a far lower `fs`); we corrected it in the code comments and the test parameters and disclose the correction here. The strongest external SOTA candidates (deep-CSI vitals, learned calibration, native FFI scanning) are **all NO-ACTION or ACCEPTED-FUTURE** — data-gated, unmeasured, or blocked on a non-public conformance suite — and **none is presented as more than it is.** §B4 is consciously deferred. Nothing in this milestone is inflated beyond what a reverting reviewer can reproduce.

docs/adr/ADR-158-mat-worldmodel-beyond-sota.md

@@ -0,0 +1,212 @@
+# ADR-158: MAT / World-Model Cluster — Beyond-SOTA Sweep, Anti-"AI-Slop" Hardening
+
+- **Status**: accepted
+- **Date**: 2026-06-11
+- **Deciders**: ruv
+- **Tags**: mat, life-safety, localization, triage, worldmodel, worldgraph, geo, engine, prove-everything
+
+## Context
+
+This ADR records the beyond-SOTA sweep over the MAT / world-model cluster
+(`wifi-densepose-mat`, `-worldmodel`, `-worldgraph`, `-geo`, `-engine`), executed
+under the project's **prove-everything / anti-"AI-slop"** directive: every stub is
+either implemented with real logic or replaced by an honest typed error; no
+fake/always-empty/random outputs; tests pass on real behaviour; results are graded
+**MEASURED** (reproduced here with the command recorded), **CLAIMED**,
+**DATA-GATED** (real code path present, needs hardware/data we lack), or
+**NO-ACTION** (already-SOTA — cited as a positive).
+
+The Mass Casualty Assessment Tool touches life-safety. A triage metric that is
+disconnected from the decision it gates, or a survivor count that inflates, is the
+worst class of slop: it produces confident, wrong rescue prioritisation. An audit
+against live code found six concrete defects, four of which were silent
+correctness bugs (not missing features) in the triage → gate → record path and in
+the localization/dedup path.
+
+Grading vocabulary follows ADR-152 (F-evidence grades) and the sweep convention:
+- **MEASURED** — reproduced in this worktree, command recorded below.
+- **DATA-GATED** — real code path implemented; returns a typed error / honest
+  provenance flag where hardware or labelled data is genuinely absent.
+- **NO-ACTION (already-SOTA)** — audited, found correct, cited as a positive.
+- **ACCEPTED-FUTURE** — deliberately deferred, nothing dropped.
+
+## Graded SOTA Landscape
+
+| Capability | Grade | Note |
+|------------|-------|------|
+| RF-through-rubble survivor detection | **DATA-GATED** | Real detection + triage + localization code paths run end-to-end on real CSI bytes; field detection *accuracy* is unproven without instrumented rubble trials and is **not fabricated** here. |
+| OccWorld occupancy architecture (`-worldmodel`) | **NO-ACTION (current)** | `occupancy.rs` voxel mapping is clamp-proven bounds-safe; converts WorldGraph person positions to a 200×200×16 grid with no out-of-bounds path. |
+| WorldGraph provenance / privacy / pruning (`-worldgraph`) | **NO-ACTION (already-SOTA)** | `graph.rs` implements append-with-provenance (`DerivedFrom`), deterministic LRU pruning, and a privacy rollup (`PrivacyLimitedBy`). Cited as a positive; no changes needed. |
+| Point-cloud parser bounds-safety (`-pointcloud`) | **NO-ACTION (already-SOTA)** | Another agent's crate; cited only — its parser is bounds-checked. Out of scope for this ADR's edits. |
+| Learned multi-person counter | **DATA-GATED** | Deferred; requires labelled multi-occupant CSI. The zone+vitals-signature dedup (below) is the honest non-learned stand-in. |
+| RF point-cloud generation | **ACCEPTED-FUTURE** | Not dropped; tracked as future work. |
+
+## Decision — Fixes Landed (MEASURED)
+
+### §1 Unify the two divergent triage engines (CRITICAL)
+
+**Was:** `EnsembleClassifier::determine_triage` (ensemble gate) and
+`TriageCalculator::calculate` (survivor record) were two different START-protocol
+approximations with different rate bands and movement handling. The pipeline
+gated on the ensemble's confidence (`lib.rs:489`), discarded the ensemble triage
+(`lib.rs:524`, `_ensemble`), and recomputed via `TriageCalculator` in
+`Survivor::new` (`survivor.rs:194`). A survivor could be admitted at one priority
+and recorded at another.
+
+**Now:** `determine_triage` delegates to `TriageCalculator` — the **single source
+of truth** used by both the gate and the survivor record. The only ensemble-
+specific behaviour retained is the confidence gate (low confidence → `Unknown`,
+except `Immediate`, which is never suppressed — a missed survivor in distress is
+costlier than a false positive). Rate bands follow START (<10 / >30 bpm →
+Immediate).
+
+**Failing-on-old test:** `detection::ensemble::tests::test_divergent_boundary_28bpm_tremor_gate_equals_survivor`
+— 28 bpm Normal + Tremor. Old gate → Delayed, old survivor record → Immediate
+(divergent). Unified result: gate == survivor == **Immediate**. Companion tests
+(`test_no_vitals_is_unknown_canonical`, `test_normal_breathing_no_movement_is_immediate_canonical`,
+the updated `integration_adr001::test_ensemble_classifier_triage_logic`) assert
+gate-vs-record equality on every boundary.
+
+### §2 Real RSSI/ToA localization + kill count-inflation (HIGH)
+
+**Was:** `fusion.rs:79 simulate_rssi_measurements` always returned `vec![]`, so
+every survivor got `location: None`, so spatial dedup (`disaster_event.rs:285`,
+which only fired on `Some` location) was disabled. One trapped person re-detected
+across N scan cycles became **N survivors** — a fabricated mass-casualty count.
+
+**Now, two real mechanisms:**
+1. **Real RSSI source:** `SensorPosition` gains an optional `last_rssi`
+   (populated by the hardware layer from actual signal-strength readings).
+   `collect_rssi_measurements` reads only real per-sensor RSSI and feeds the
+   existing triangulator; it **never fabricates** a value. With `< min_sensors`
+   real readings, `estimate_position` returns `None` (honest).
+2. **Zone + vitals-signature dedup:** when no usable location exists,
+   `record_detection` matches an existing *active, un-located* survivor in the
+   same zone whose latest vital signature (breathing presence + START rate band,
+   heartbeat presence, movement class) is compatible — collapsing repeat
+   detections of one person while keeping genuinely distinct survivors separate.
+
+**MEASURED:** `test_identical_vitals_no_location_dedup_to_one` — 3× identical-vitals
+/ `None`-location → **1 survivor** (old code: 3). `test_distinct_vitals_no_location_stay_separate`
+keeps two distinct survivors at 2 (no under-count). `test_estimate_position_uses_real_rssi`
+yields a position from 3 real-RSSI sensors; `test_estimate_position_none_without_real_rssi`
+yields `None` (no fabrication).
+
+### §3 Real ESP32/UDP/PCAP CSI ingest; honest typed errors elsewhere (HIGH)
+
+**Was:** `hardware_adapter.rs read_esp32_csi` / `read_udp_csi` / `read_pcap_csi`
+returned "not yet implemented" — even though `csi_receiver.rs` already contained a
+working `CsiParser` (ESP32 CSV, JSON, Intel5300/Atheros/Nexmon byte decoders) and a
+real `PcapCsiReader`.
+
+**Now:**
+- **UDP** — binds, receives one datagram, parses (auto-detect) → `CsiReadings`.
+  End-to-end test sends a real JSON datagram on the wire.
+- **PCAP** — `load` + `read_next` + parse. End-to-end test writes a real
+  little-endian `.pcap` with one record and reads it back.
+- **ESP32** — parses `CSI_DATA` CSV via the real parser. Live serial byte I/O is
+  behind an optional `serial` cargo feature (native `serialport` kept off the
+  default / aarch64 appliance build); with the feature off, live reads return a
+  typed `UnsupportedAdapter` while the byte parser still works.
+- **Intel 5300 / Atheros / PicoScenes** — return typed
+  `AdapterError::HardwareUnavailable` / `UnsupportedAdapter` (no device, no
+  driver, or no validatable format here). **Never fake CSI.** New error variants
+  added to make the gating typed rather than a `String` "Hardware" soup.
+
+**MEASURED:** `test_esp32_bytes_parse_end_to_end`, `test_udp_read_end_to_end`,
+`test_pcap_read_end_to_end`, `test_intel_and_atheros_are_honestly_unavailable`.
+
+### §4 Real parabolic peak interpolation in `find_dominant_frequency` (MED)
+
+**Was:** `breathing.rs:243` comment claimed interpolation but returned the bin
+center, capping breathing-rate resolution at ±half a bin.
+
+**Now:** 3-point parabolic (quadratic) peak interpolation,
+`δ = 0.5·(yL − yR)/(yL − 2y0 + yR)`, clamped to `[-0.5, 0.5]`, with an edge
+fallback to bin center.
+
+**MEASURED:** `test_find_dominant_frequency_parabolic_interpolation` — for a
+parabola-shaped peak at true bin 10.4 the recovery is exact (δ = 0.4); the test
+asserts the result lands within half a bin of truth and strictly beats the
+old bin-center estimate.
+
+### §5 GDOP honesty (LOW)
+
+**Was:** `triangulation.rs:248 estimate_gdop` returned an ad-hoc average-pair-angle
+factor *labelled* GDOP (the same defect class ADR-156 §2.3 fixed elsewhere).
+
+**Now:** real, dimensionless **GDOP = √(trace((HᵀH)⁻¹))** from the range-measurement
+Jacobian `H` (unit target→sensor bearings), returning `None` for singular
+(collinear) geometry, which the caller treats as factor 1.0 (no fabrication).
+
+**MEASURED:** `test_gdop_is_real_dilution` — a well-spread array gives a lower GDOP
+than a near-collinear one, cross-checked against the closed form;
+`test_gdop_singular_collinear_is_none` confirms singular geometry returns `None`.
+
+### §6 OccWorld trajectory-prior consumer honesty (fail-safe)
+
+**Finding:** `wifi-densepose-mat` does **not** consume OccWorld trajectory priors
+and has no `-worldmodel`/`-worldgraph`/occworld dependency (grep-verified: zero
+hits across `crates/wifi-densepose-mat/`). There is therefore no random-derived
+prior being consumed. **No code change** is warranted; the fail-safe (ignore
+priors until a typed `weights_complete`/`stubbed` flag exists) is already the
+status quo by absence. Recorded here so a future consumer wires the flag rather
+than re-introducing the risk.
+
+## Negative Results (Confirmed — NO-ACTION)
+
+These were audited and found genuinely correct; they are cited as positives, not
+edited:
+
+- **`worldgraph` provenance / privacy / pruning** (`graph.rs`) — append-with-
+  provenance (`add_semantic_state` + `DerivedFrom`), deterministic LRU pruning
+  (`prune_semantic_states`, with `prune_is_deterministic_for_equal_timestamps`),
+  and a privacy rollup (`apply_privacy_mode` → `PrivacyLimitedBy`). Already-SOTA.
+- **`worldmodel` occupancy clamp** (`occupancy.rs:74–125`) — `to_voxel_xy` /
+  `to_voxel_z` `.clamp()` voxel indices into `[0, GRID-1]`; the flat index is
+  always in-bounds. No out-of-bounds / fabrication path.
+- **`pointcloud` parser bounds-safety** — another agent's crate; cited only, its
+  parser is bounds-checked.
+
+## Deferred Backlog (Nothing Dropped)
+
+- **Learned multi-person counter** — DATA-GATED on labelled multi-occupant CSI.
+  The zone+vitals-signature dedup (§2) is the honest non-learned stand-in until
+  then.
+- **RF point-cloud generation** — ACCEPTED-FUTURE.
+- **PicoScenes container decode** — DATA-GATED; needs matching NIC/plugin to
+  validate against. Returns `UnsupportedAdapter` today.
+- **Intel 5300 / Atheros live capture** — DATA-GATED on patched drivers; byte
+  parsers exist and are exercised on supplied bytes.
+
+## Consequences
+
+- Triage is now a single auditable function; gate and survivor record can never
+  diverge.
+- Survivor counts cannot inflate from repeat detection of one un-located person.
+- The CSI ingest layer either produces real data or fails with a typed error that
+  names *why* — no path silently substitutes simulated/fabricated CSI.
+- `SensorPosition` grows an optional `last_rssi` field (serde-`default`, non-
+  breaking for deserialisation; 7 constructors updated).
+- A new optional `serial` feature isolates the native `serialport` dependency from
+  the default / appliance builds.
+
+## Reproduction (MEASURED)
+
+```bash
+cd v2
+# MAT — default features (181 unit + 6 + 3[3 ignored] integration)
+cargo test -p wifi-densepose-mat
+# MAT — all features (same counts; exercises ruvector + api + serde paths)
+cargo test -p wifi-densepose-mat --all-features
+# MAT — serial feature compiles (native serialport path)
+cargo check -p wifi-densepose-mat --features serial
+# Sibling crates (cited NO-ACTION; confirmed green)
+cargo test -p wifi-densepose-worldmodel   # 12 + 1
+cargo test -p wifi-densepose-worldgraph   # 9
+cargo test -p wifi-densepose-geo          # 9 + 8
+cargo test -p wifi-densepose-engine       # 27
+```
+
+Result at time of writing: MAT **181 passed; 0 failed** (default and all-features);
+worldmodel **13**, worldgraph **9**, geo **17**, engine **27** — all 0 failed.

docs/adr/ADR-159-cognitum-appliance-beyond-sota.md

@@ -0,0 +1,242 @@
+# ADR-159: Cognitum Appliance Cluster — Beyond-SOTA Sweep, Anti-"AI-Slop" Hardening
+
+- **Status**: accepted
+- **Date**: 2026-06-11
+- **Deciders**: ruv
+- **Tags**: cognitum, cogs, person-count, pose-estimation, ha-matter, drone-swarm, remote-id, manifest, prove-everything
+
+## Context
+
+This ADR records the beyond-SOTA sweep over the Cognitum appliance cluster
+(`cog-person-count`, `cog-pose-estimation`, `cog-ha-matter`, `ruview-swarm`),
+executed under the project's **prove-everything / anti-"AI-slop"** directive: the
+claim surface every cog presents (manifests, descriptions, runtime events,
+broadcast fields) must match what the code and the shipped weights actually do.
+
+### Headline — the "never identified anyone" accusation is REFUTED
+
+A read-only audit raised the worst-class accusation: that these cogs are slop that
+"never identified anyone." That accusation is **refuted by byte-level evidence**:
+
+- `cog-pose-estimation` and `cog-person-count` ship **real, trained Candle models**
+  (`pose_v1.safetensors`, `count_v1.safetensors`), not placeholders. The forward
+  passes (`PoseNet`, `CountNet`) mirror the training scripts exactly and run on
+  real CSI bytes.
+- The artifacts are **SHA-pinned and Ed25519-signed**: the on-disk
+  `manifests/x86_64/manifest.json` carries a real `binary_sha256`
+  (`051614ce…388b3` for person-count, `a434739a…71fa` for pose), a real
+  `weights_sha256`, and a `binary_signature` over `sig_algo: Ed25519`.
+- The manifests are **brutally honest about accuracy**: person-count's
+  `build_metadata` ships `training_class1_accuracy = 0.343` and a candid
+  `training_caveat`; pose ships `training_pck20 = 3.0` / `training_pck50 = 18.5`.
+  Nothing is inflated. That honesty *is* the anti-slop win — the models are weak
+  in the field, and the manifests say so.
+
+So the cogs **do** run real trained inference and **do** disclose how weak it is.
+What the audit correctly found were not fabrications but **claim-surface
+overclaims** — four places where the surface said more than the weights deliver.
+This ADR tightens those four (A1–A4) and cites the already-correct subsystems as
+NO-ACTION positives.
+
+Grading vocabulary follows ADR-152 / ADR-158:
+- **MEASURED** — reproduced in this worktree, command + failing-on-old test recorded.
+- **DATA-GATED** — real code path present; honestly flagged where data/hardware is absent.
+- **NO-ACTION (already-SOTA)** — audited, found correct, cited as a positive.
+- **ACCEPTED-FUTURE** — deliberately deferred, nothing dropped.
+
+## Graded SOTA Landscape
+
+| Capability | Grade | Note |
+|------------|-------|------|
+| CSI person counting (`cog-person-count`) | **DATA-GATED** | Real Candle count head + Bayesian fusion; weights trained only on classes 0/1 (presence). Multi-occupant accuracy is genuinely unproven and is **not fabricated** — counts above the trained range are now flagged `low_confidence` and clamped. |
+| CSI pose estimation (`cog-pose-estimation`) | **DATA-GATED** | Real Candle encoder + 17-keypoint head; field accuracy honestly weak (PCK@50 = 18.5%, disclosed in the manifest). The default-install gate bug (A1) is fixed so it actually emits frames. |
+| Signed cog manifests (Ed25519 + SHA-256) | **NO-ACTION (already-SOTA)** | On-disk manifests are real, signed, SHA-pinned, and honest about accuracy. The CLI now emits them verbatim (A4). |
+| HA bridge (`cog-ha-matter`) MQTT + witness | **NO-ACTION (already-SOTA)** | Real Ed25519 hash-chain witness, mDNS, embedded broker. Matter commissioning is honestly deferred to v0.8 (TLS off, LAN-only) — description softened to stop claiming Matter (honest-absence). |
+| Drone-swarm MARL (`ruview-swarm`) | **DATA-GATED / honest** | `candle_ppo.rs` is real autodiff PPO; it is **untrained at runtime** (random init) by design — the swarm must be trained before deploy, which the code does not hide. |
+| ASTM F3411 Remote ID | **MEASURED (A3)** | Basic ID message is real; the Location/Vector message is honestly *not* implemented (NED metres are no longer mislabelled as WGS84 lat/lon). |
+
+## Decision — Fixes Landed (MEASURED)
+
+### §A1 Pose runtime emitted ZERO frames under default config (HIGH)
+
+**Overclaim (silent correctness bug):** `inference.rs` hardcoded
+`confidence: 0.185` for every inference, `config.rs default_min_confidence()`
+returned `0.3`, and `runtime.rs` gated emission on `confidence >= min_confidence`.
+A default install therefore **never emitted a single `pose.frame`** while
+`health` reported healthy — the cog *claimed* to be a running pose estimator but
+silently produced nothing.
+
+**Real fix:** `pose_v1` has **no confidence head** (the head emits 34 keypoint
+coordinates only), so a real per-frame confidence is genuinely unavailable. We
+took the disclosed "ok" path rather than silently lowering the threshold:
+- Introduced `inference::MODEL_TYPICAL_CONFIDENCE = 0.185` (the validation PCK@50)
+  as the single published per-frame confidence, used by both `infer()` and the
+  config default.
+- Pinned `default_min_confidence()` to `MODEL_TYPICAL_CONFIDENCE` so a default
+  install clears its own gate and emits.
+- Documented the trade-off in the config field doc, the JSON schema
+  (`default` 0.3 → 0.185, with a description), **and** added a `run.started`
+  warning in `main.rs` that fires when an operator raises `min_confidence` above
+  the model's typical confidence — so a deliberately-high threshold is loud, not
+  silent.
+
+**Failing-on-old test:** `cog_pose_estimation` smoke
+`default_config_emits_frames_with_real_model` — parses a default config and
+asserts `min_confidence <= MODEL_TYPICAL_CONFIDENCE` (and, with the real model
+loaded, that `infer().confidence >= min_confidence`). **Proven to fail** on the
+old `default_min_confidence()=0.3`:
+`default min_confidence 0.3 exceeds model typical confidence 0.185 — a default
+install would emit zero pose.frame events`.
+
+**Grade: MEASURED.**
+
+### §A2 8-class count head on a 2-class-trained model (MEDIUM)
+
+**Overclaim:** `inference.rs COUNT_CLASSES = 8` with argmax over {0..7}, but
+`count_train_results.json` has support only for classes 0 and 1 (`per_class_accuracy`
+keys `"0"`/`"1"`). The model is a **presence detector**, not a calibrated
+multi-occupant counter; an argmax on classes 2..=7 is out-of-distribution, yet the
+cog would emit it as a confident headcount. The Cargo.toml billed it as a
+"learned multi-person counter."
+
+**Real fix (no network change — DATA-GATED, accuracy not fabricated):**
+- Added `inference::MAX_TRAINED_CLASS = 1`, plus `CountPrediction::is_low_confidence()`
+  (argmax beyond the trained ceiling) and `clamped_count()` (report clamped to the
+  trained range, raw argmax kept for audit).
+- `person.count` events now carry `low_confidence` + `raw_count`, and downgrade to
+  `level: "warn"` when out-of-distribution; the reported `count` is clamped so we
+  never emit a fabricated headcount the weights can't back.
+- `run.started` discloses `count_max_trained_class` and `count_classes`.
+- Cargo.toml description changed from "learned multi-person counter" to
+  "presence detector + (data-gated) person count".
+
+**Failing-on-old test:** `cog_person_count` smoke
+`untrained_class_argmax_is_flagged_low_confidence` — a prediction whose argmax is
+class 5 is asserted `is_low_confidence() == true` and `clamped_count() ==
+MAX_TRAINED_CLASS`; a class-1 prediction is asserted *not* flagged. Fails on old
+code (no such methods/flag existed).
+
+**Grade: MEASURED (mechanism); multi-occupant accuracy DATA-GATED.**
+
+### §A3 Remote ID broadcast NED metres as WGS84 lat/lon (MEDIUM — safety/compliance)
+
+**Overclaim (compliance hazard):** `security/remote_id.rs update()` stored
+`state.position.x/.y` (NED **metres**) into `drone_lat`/`drone_lon`, so the Remote
+ID broadcast would carry physically-impossible coordinates (e.g. "latitude =
+37.5 m"). The module doc claimed a "Basic ID + Location/Vector message," but only
+`encode_basic_id()` exists.
+
+**Real fix (honest naming — never broadcast impossible coordinates):**
+- Renamed `drone_lat`/`drone_lon` → `drone_north_m`/`drone_east_m` (NED metres
+  relative to the operator/takeoff datum), with field docs stating they are *not*
+  geodetic. `operator_lat`/`operator_lon` remain true WGS84 (from the operator's
+  GNSS).
+- Corrected the module doc to claim **Basic ID only**; the Location/Vector encoder
+  is explicitly deferred until a datum-anchored NED→WGS84 transform lands
+  (ACCEPTED-FUTURE), rather than removing a real feature.
+
+**Failing-on-old test:** `security::remote_id::tests::test_ned_offset_stored_as_metres_not_latlon`
+— a 37.5 m north / −12.0 m east NED offset is asserted to land in
+`drone_north_m`/`drone_east_m`; the operator's real WGS84 fix stays in range. Fails
+on old code, where these values were stored into `drone_lat`/`drone_lon`.
+
+**Grade: MEASURED.**
+
+### §A4 Hollow CLI manifest (LOW)
+
+**Overclaim:** `cog-person-count main.rs cmd_manifest` emitted a null skeleton
+(`binary_sha256: null`, no training metadata), making the CLI look unsigned even
+though the **real signed manifest** existed at
+`cog/artifacts/manifests/x86_64/manifest.json`.
+
+**Real fix:** new `cog_person_count::manifest` module `include_str!`-embeds the
+real signed manifests (x86_64 + arm), selected by build target arch.
+`cmd_manifest` now parses-then-emits the embedded signed manifest — exactly the
+pattern `cog-pose-estimation`'s `manifest_roundtrips` test demonstrates. The CLI
+now reports the real `binary_sha256`, `weights_sha256`, Ed25519 signature, and
+honest `build_metadata` (`training_class1_accuracy = 0.343`).
+
+**Failing-on-old test:** `manifest::tests::embedded_manifest_has_non_null_binary_sha256`
+asserts a 64-hex-char `binary_sha256`; companions assert the embedded manifest is
+signed (`sig_algo == Ed25519`) and `id == COG_ID`. End-to-end verified:
+`cog-person-count manifest` prints `binary_sha256:
+051614ce6ba63df704fae848a67ad095df4bb88862fdff05ef3c0419cc8388b3`.
+
+**Grade: MEASURED.**
+
+### §A5 cog-ha-matter description claimed Matter before it exists (LOW — honest-labeling)
+
+**Overclaim:** the Cargo.toml description said "Home Assistant + Matter
+integration," but Matter commissioning is deferred to v0.8 (`TlsConfig::Off`,
+LAN-only, asserted by `runtime.rs tls_defaults_to_off_for_v1_lan_only`).
+
+**Real fix (no code change):** softened the description to "Home Assistant (MQTT)
+integration … LAN-only (no TLS); Matter Bridge commissioning is deferred to v0.8
+and not yet implemented." Mirrors ADR-158 §6 honest-absence: state what isn't
+there rather than implying it is.
+
+**Grade: MEASURED (label).**
+
+## Negative Results (Confirmed — NO-ACTION positives)
+
+Audited and found genuinely correct; cited as positives, not edited:
+
+- **`cog-ha-matter` witness chain** (`witness.rs` / `witness_signing.rs`) — real
+  Ed25519 hash-chained witness log. Already-SOTA.
+- **`cog-person-count` fusion** (`fusion.rs`) — real Bayesian product-of-experts
+  multi-node fusion (Stoer-Wagner-bounded clip), not a heuristic. Already-SOTA.
+- **`ruview-swarm` PPO** (`marl/candle_ppo.rs`) — real Candle autodiff PPO with a
+  genuine policy-gradient update; its `randn` uses (init, action sampling,
+  exploration) are all legitimate, not fake-output substitutes. Untrained at
+  runtime by design (the swarm must be trained before deploy), which the code
+  does not hide. Already-SOTA / honest.
+
+## Deferred Backlog (Nothing Dropped)
+
+- **Multi-occupant count accuracy** — DATA-GATED on labelled multi-occupant CSI.
+  The `low_confidence` flag + clamp (§A2) is the honest stand-in until then.
+- **Remote ID Location/Vector message** — ACCEPTED-FUTURE; requires a
+  datum-anchored local-tangent-plane NED→WGS84 transform with an operator datum.
+  Basic ID ships today.
+- **Matter Bridge commissioning** — ACCEPTED-FUTURE (v0.8); LAN-only MQTT ships today.
+- **Criterion benches** for cog inference latency and `mesh_guard` — ACCEPTED-FUTURE
+  (cold-start timings are recorded in the manifests' `build_metadata`, not yet a
+  regression bench).
+- **`wasm-edge` skill accuracy** — unvalidated; **now honestly labelled, not
+  claimed** (done in ADR-160: medical/affect/security/exotic claim surfaces
+  disclaimed, renamed, and feature-gated; per-skill accuracy remains DATA-GATED).
+
+## Consequences
+
+- A default pose-estimation install now actually emits `pose.frame` events;
+  raising the threshold above the model's reach is a loud `run.started` warning,
+  not a silent dropout.
+- A person-count reading on an untrained class is flagged `low_confidence`,
+  clamped, and downgraded to `warn` — no fabricated headcounts.
+- The Remote ID broadcast can never carry physically-impossible coordinates; NED
+  metres live in honestly-named metre fields.
+- `cog-person-count manifest` now reports the real signed manifest instead of a
+  hollow null skeleton.
+- No cog Cargo.toml description claims a capability (multi-person counting, Matter)
+  the code/weights don't yet deliver.
+
+## Reproduction (MEASURED)
+
+```bash
+cd v2
+cargo test -p cog-person-count -p cog-pose-estimation -p cog-ha-matter -p ruview-swarm \
+  --no-default-features
+# ruview-swarm train path compiles (PPO autodiff)
+cargo check -p ruview-swarm --features train
+# A4 end-to-end — real signed manifest, non-null binary_sha256
+cargo run -q -p cog-person-count --no-default-features -- manifest
+```
+
+Result at time of writing (all 0 failed):
+- `cog-person-count` — **19 passed** (lib 10 incl. 3 manifest; smoke 9)
+- `cog-pose-estimation` — **8 passed** (smoke)
+- `cog-ha-matter` — **64 passed** (unchanged; description-only edit)
+- `ruview-swarm` — **117 passed** (default features); `--features train` compiles clean.
+
+Scope was limited to the four named crates. NO-ACTION positives (witness chain,
+fusion, PPO + randn audit) were verified by inspection and left untouched.

docs/adr/ADR-160-edge-skill-library-honest-labeling.md

@@ -0,0 +1,228 @@
+# ADR-160: Edge Skill Library (`wifi-densepose-wasm-edge`) — Honest Labeling & Soundness Cleanup
+
+- **Status**: accepted
+- **Date**: 2026-06-11
+- **Deciders**: ruv
+- **Tags**: wasm-edge, esp32, edge-skills, claim-surface, medical-overclaim, affect, prove-everything, soundness, static-mut
+- **Amends**: ADR-159 (deferred-backlog line for wasm-edge now TRUE)
+
+## Context
+
+Beyond-SOTA sweep Milestone 6, over `v2/crates/wifi-densepose-wasm-edge` only,
+executed under the project's **prove-everything / anti-"AI-slop"** directive.
+
+### Headline — 0 stubs, 0 theater, all real DSP (REFUTES the slop accusation)
+
+A read-only audit found this crate has **zero stubs and zero fake-output theater:
+every one of the ~70 edge skills runs real DSP** (Welford statistics,
+autocorrelation, DTW, sliced-Wasserstein, ISTA-style recovery, Kalman/HNSW, etc.).
+The forward paths are genuine signal processing on real CSI-derived inputs. That
+is the anti-slop win and it is cited here as a positive, not a fabrication.
+
+What the audit correctly found was **not fake code but an over-confident claim
+surface**: skill *names* and doc-comments asserting clinical/affective/security
+capabilities that the **unvalidated** code cannot back, concentrated in the
+medical (`med_*`) and affect (`exo_happiness`/`exo_emotion`) skills. The fix is
+**honest labeling — making the labels TRUE — NOT making the claimed capability
+real.** You cannot validate seizure detection, affect inference, or weapon
+discrimination without clinical/labelled data and reference standards; this ADR
+does not pretend to. It disclaims, renames, softens, and feature-gates so the
+surface matches what the DSP actually delivers.
+
+Grading vocabulary follows ADR-152 / ADR-158 / ADR-159:
+- **MEASURED** — reproduced in this worktree, command + failing-on-old test recorded.
+- **DATA-GATED** — real code path present; honestly flagged where data is absent.
+- **NO-ACTION (already-honest)** — audited, found correct, cited as a positive.
+- **ACCEPTED-FUTURE** — deliberately deferred, nothing dropped.
+
+## Per-prefix classification
+
+| Prefix | Class | Note |
+|--------|-------|------|
+| `sig_*` (signal intelligence) | **REAL-DSP, honest** | Algorithm-named (flash-attention, sparse-recovery, optimal-transport, temporal-compress, mincut). Names describe the math, not an overclaimed outcome. NO-ACTION on labels; A5 soundness applied. |
+| `lrn_*` (adaptive learning) | **REAL-DSP, honest** | DTW/EWC/meta-adapt/attractor — algorithm-named. NO-ACTION on labels; A5 applied. |
+| `spt_*` / `tmp_*` | **REAL-DSP, honest** | PageRank/HNSW/spiking-tracker; LTL-guard/GOAP/pattern-sequence. Algorithm-named. NO-ACTION on labels; A5 applied. |
+| `qnt_*` | **REAL-DSP, honest (disclosed analogy)** | "quantum-**inspired**" / Grover-**inspired** are already disclosed analogies. NO-ACTION (DO-NOT-touch); A5 applied (mechanical, no label/behavior change). |
+| `bld_*` / `ret_*` / `ind_*` / `occupancy`/`intrusion` | **REAL-DSP, honest** | Occupancy/queue/forklift/clean-room etc. describe physical observables. NO-ACTION on labels; A5 applied. |
+| `sec_weapon_detect` | **REAL-DSP, overclaiming NAME** → fixed (A3) | Variance-ratio reflectivity renamed off "weapon". |
+| `med_*` (5) | **REAL-DSP, overclaiming NAME/DOC** → fixed (A1) | Clinical detection asserted as fact; now disclaimed + softened + feature-gated. |
+| `exo_happiness` / `exo_emotion` | **REAL-DSP, overclaiming NAME/DOC** → fixed (A2) | Affect outputs reframed as proxies; uncited stat removed. |
+| `exo_dream_stage` / `exo_gesture_language` | **REAL-DSP, quasi-medical/over-named** → fixed (A4) | Disclaimers added; Research tag promoted to header. |
+| `exo_time_crystal` / `exo_ghost_hunter` | **REAL-DSP, honest novelty** | Disclosed exploratory/novelty skills. NO-ACTION (DO-NOT-touch); A5 applied. |
+| `nvsim` | out of scope | Disclaimer gold standard; copied its tone. |
+
+## Decision — Fixes Landed
+
+### §A1 Medical overclaim (HIGH) — MEASURED
+
+The five `med_*` modules (`med_seizure_detect`, `med_cardiac_arrhythmia`,
+`med_respiratory_distress`, `med_sleep_apnea`, `med_gait_analysis`) stated clinical
+detection as fact with no disclaimer ("Detects tonic-clonic seizures…").
+
+**Real fix (honest labeling — the DSP is kept, untouched):**
+- **(a)** Every module's `//!` header now carries a mandatory disclaimer block,
+  modelled on `sec_weapon_detect.rs` and `nvsim/src/lib.rs`: *"EXPERIMENTAL
+  RESEARCH MODULE — NOT VALIDATED AGAINST CLINICAL DATA. NOT A MEDICAL DEVICE.
+  Flags candidate <X>-like signatures only,"* citing ADR-160.
+- **(b)** Doc verbs softened: *"Detects tonic-clonic seizures"* →
+  *"Flags candidate tonic-clonic-seizure-like motion signatures (experimental)"*;
+  similarly for cardiac/respiratory/apnea/gait.
+- **(c)** All five gated behind a new **non-default** cargo feature
+  `medical-experimental` (`#[cfg(feature = "medical-experimental")]` in `lib.rs`,
+  `medical-experimental = []` in `Cargo.toml`, **not** in `default`) so they cannot
+  be silently built into a shipping artifact.
+
+**Failing-on-old tests** (`tests/honest_labeling.rs`):
+`a1_med_modules_have_clinical_disclaimer`,
+`a1_med_modules_gated_behind_medical_experimental`,
+`a1_seizure_verbs_softened`. All fail on the old, undisclaimed, ungated source.
+**Grade: MEASURED (label); per-skill clinical accuracy DATA-GATED.**
+
+### §A2 Affect overclaim (HIGH) — MEASURED
+
+`exo_happiness_score.rs` carried an **uncited** "Happy people walk ~12% faster"
+statistic and emits `HAPPINESS_SCORE`; `exo_emotion_detect.rs` emits
+`STRESS_INDEX`/`CALM_DETECTED`/`AGITATION_DETECTED`.
+
+**Real fix (honest labeling — math kept):**
+- Deleted the uncited "12% faster" / "~12% above" / "Happy people walk" statements.
+- Added a prominent *"speculative, unvalidated affect heuristic; outputs are NOT
+  measurements of emotion"* disclaimer to both `//!` headers, citing ADR-160.
+- Reframed `HAPPINESS_SCORE` in the docs as a **"gait-energy proxy, not a validated
+  affect measure."**
+
+**Failing-on-old tests:** `a2_affect_modules_have_unvalidated_disclaimer`,
+`a2_uncited_12_percent_stat_removed`, `a2_happiness_reframed_as_proxy`.
+**Grade: MEASURED (label); affect validity DATA-GATED.**
+
+### §A3 Security event-name overclaim (MEDIUM) — MEASURED
+
+`sec_weapon_detect.rs`'s module doc was already honest (research-grade,
+calibration-required), but the event/const names claimed weapon-grade
+discrimination a variance ratio cannot deliver.
+
+**Real fix (honest physical-quantity naming — behavior unchanged):**
+- `EVENT_WEAPON_ALERT` → `EVENT_HIGH_METAL_REFLECTIVITY` (event id 221 unchanged).
+- `WEAPON_RATIO_THRESH` → `HIGH_REFLECTIVITY_THRESH`.
+- Internal fields/consts renamed (`weapon_run`→`high_refl_run`,
+  `cd_weapon`→`cd_high_refl`, `WEAPON_DEBOUNCE`→`HIGH_REFLECTIVITY_DEBOUNCE`).
+- `lib.rs` `event_types` registry: `WEAPON_ALERT` → `HIGH_METAL_REFLECTIVITY`.
+- A reflectivity-vs-weapons honest-naming note added to the header.
+The detector still flags a high amplitude-variance/phase-variance ratio (real RF
+reflectivity); it just no longer *names* that "weapon".
+
+**Failing-on-old tests:** `a3_weapon_names_renamed_to_reflectivity`,
+`a3_registry_no_longer_exports_weapon_alert` (registry no longer exports a
+`WEAPON_ALERT` name). **Grade: MEASURED.**
+
+### §A4 Quasi-medical / sign-language exotic modules (MEDIUM) — MEASURED
+
+`exo_dream_stage.rs` ("sleep stage classification", quasi-medical) and
+`exo_gesture_language.rs` ("sign language letter recognition").
+
+**Real fix (honest labeling — DSP kept):** added an experimental "NOT VALIDATED"
+disclaimer to each `//!` header (citing ADR-160) and promoted the
+**Exotic/Research** registry tag into the header where a reader sees it.
+`exo_gesture_language` additionally states it is a coarse gesture-cluster
+classifier that **does not recognize true sign language** (never evaluated on a
+labelled ASL set).
+
+**Failing-on-old test:** `a4_exotic_modules_have_experimental_disclaimer`.
+**Grade: MEASURED (label); accuracy DATA-GATED.**
+
+### §A5 `static mut` event-buffer soundness (MEDIUM) — the one real code fix — MEASURED
+
+~61 per-call event scratch buffers across the crate used a module-level
+`static mut EVENTS: [(i32,f32); N]` (a handful named `EV`/`TE`/`EMPTY`) and returned
+`&EVENTS[..n]`. On a `cdylib`+`rlib` linkable into multithreaded/reentrant host
+code this is latent aliasing UB, and `static_mut_refs` is deny-by-default on newer
+Rust.
+
+**Real fix (mechanical, behavior-preserving):** moved each scratch buffer off
+`static mut` into an **owned per-instance field** (`events: [(i32,f32); N]` on the
+detector struct, written via `&mut self` and returned as `&self.events[..n]`). The
+public `-> &[(i32, f32)]` signature is **unchanged**, so no caller (in-module
+tests, `ghost_hunter` bin, `budget_compliance`) needed editing. Two helper methods
+that built events under `&self` (`spt_pagerank_influence::build_events`,
+`spt_spiking_tracker::build_events`) and `sig_temporal_compress::on_timer` were
+promoted to `&mut self`. Leftover now-redundant `unsafe { }` wrappers were removed.
+
+**Count: 61 scratch buffers across 60 module files fixed** (the only `static mut`
+left in `src/` are the two **legitimate WASM module singletons** — `lib.rs STATE`
+and `bin/ghost_hunter.rs DETECTOR` — `#[cfg(target_arch="wasm32")]`,
+`#[no_mangle]`, accessed via `core::ptr::addr_of_mut!`, single-threaded by the
+wasm runtime contract; these are *not* the aliasing-UB scratch pattern and are
+left as-is).
+
+**Verification:** the full host build (`--features std` and
+`std,medical-experimental`) compiles with **0 warnings** — there is no longer any
+`static mut <name>` + `&<name>` source for `static_mut_refs` to fire on in the 60
+fixed modules. (The pure-`wasm32-unknown-unknown` build, where the lint is
+deny-by-default, could not be run in this worktree because the `wasm32` target is
+not installed on the build toolchain; the source-level elimination is the
+evidence, asserted per-module by `a5_claim_bearing_modules_have_no_static_mut_event_buffer`.)
+**Grade: MEASURED (source-eliminated; residual = 2 legitimate singletons).**
+
+## Negative Results (NO-ACTION positives — cited, not edited for labels)
+
+Audited and found genuinely honest; cited as positives:
+- **`qnt_quantum_coherence.rs`** — discloses "quantum-**inspired**" analogy.
+- **`exo_time_crystal.rs`**, **`exo_ghost_hunter.rs`** — disclosed exploratory/novelty.
+- **`qnt_interference_search.rs`** — disclosed "Grover-**inspired**".
+- **`sig_*` / `lrn_*`** algorithm-named skills — names describe the DSP, not an outcome.
+- **`nvsim`** — out of scope; the project's disclaimer gold standard (its tone was
+  copied into the A1/A2/A4 disclaimers).
+
+(These were A5-soundness-fixed mechanically where they used `static mut`, with no
+label or behavior change, consistent with leaving their claim surface intact.)
+
+## Deferred Backlog (Nothing Dropped)
+
+- **Per-skill accuracy validation** — **DATA-GATED**. Validating any med_*/affect/
+  sign-language claim requires labelled clinical/affective/ASL data and reference
+  standards that do not exist in this repo. The disclaimers + feature gate are the
+  honest stand-in. Nothing is claimed that is not measured.
+- **Criterion benches for `process_frame` budget claims** — **ACCEPTED-FUTURE**.
+  `tests/budget_compliance.rs` asserts L/S/H tier wall-clock budgets (25 tests,
+  passing), but a regression-grade criterion bench is not yet wired.
+- **`wasm32-unknown-unknown` `static_mut_refs` confirmation** — **ACCEPTED-FUTURE**
+  (toolchain): the source pattern is eliminated; a CI job on the wasm target should
+  assert zero `static_mut_refs` once the target is added to the build image.
+- **The 2 residual `static mut` singletons** (`lib.rs STATE`, `ghost_hunter DETECTOR`)
+  — **ACCEPTED-FUTURE**: these are the canonical wasm module-state pattern; migrating
+  them to a safe cell is a separate, larger change with no current UB (single-threaded
+  wasm runtime, `addr_of_mut!` access).
+
+## Reproduction (MEASURED)
+
+```bash
+cd v2/crates/wifi-densepose-wasm-edge   # excluded from the v2 workspace; build here
+cargo test --features std                          # default
+cargo test --features std,medical-experimental     # med_* skills enabled
+cargo test --no-default-features --features std     # no default-pipeline
+cargo test --features std --test honest_labeling   # A1–A5 label invariants
+```
+
+(`std` is required for host tests — the crate is `no_std` for `wasm32`; pure
+`--no-default-features` builds only on `wasm32-unknown-unknown`, where it
+intentionally has no panic handler on the host.)
+
+Result at time of writing (all 0 failed):
+- **DEFAULT** (`--features std`) — **615 passed** (lib 504; budget 25; honest_labeling 10; bench 1; vendor 75)
+- **MEDICAL** (`--features std,medical-experimental`) — **653 passed** (lib 542; +38 med_* tests; others unchanged)
+- **NO-DEFAULT** (`--no-default-features --features std`) — **615 passed**
+- Full host build emits **0 warnings**; **61** `static mut` scratch buffers eliminated, **2** legitimate wasm singletons remain.
+
+## Consequences
+
+- No edge skill's name or doc-comment claims a clinical, affective, security, or
+  sign-language capability the unvalidated DSP cannot back.
+- The five medical skills cannot be silently compiled into a shipping artifact
+  (non-default `medical-experimental` gate).
+- The security skill can never emit a "weapon alert" — it reports
+  `HIGH_METAL_REFLECTIVITY`, the physical quantity it actually measures.
+- The latent `static mut` aliasing-UB / `static_mut_refs` exposure is removed from
+  60 modules; the public API and all runtime behavior are unchanged (615/653 tests
+  prove behavior preservation).
+- ADR-159's deferred-backlog statement *"wasm-edge … honestly labelled, not
+  claimed"* is now actually TRUE.

docs/adr/ADR-161-homecore-server-layer-security.md

@@ -0,0 +1,267 @@
+# ADR-161: HOMECORE Server Layer — WebSocket Auth Bypass, Reply-Theater & Documented-but-No-Op Automation (Security & Honest Labeling)
+
+- **Status**: accepted
+- **Date**: 2026-06-12
+- **Deciders**: ruv
+- **Tags**: homecore, http-ws-boundary, websocket-auth-bypass, security, automation-engine, documented-no-op, prove-everything, soundness, honest-labeling
+- **Amends**: ADR-130 (HOMECORE-API WS protocol), ADR-129 (HOMECORE-AUTO automation engine), ADR-128 (plugin manifest)
+
+## Context
+
+Beyond-SOTA sweep **Milestone 7**, over the HOMECORE **server/network layer**
+crates only — `homecore-api`, `homecore-server`, `homecore-automation`,
+`homecore-hap`, `homecore-plugins` — executed under the project's
+**prove-everything / anti-"AI-slop"** directive.
+
+### Headline — the library cores are real, but the network boundary was unsound
+
+The same audit pattern as ADR-160 held for the *library logic*: the automation
+trigger/condition/template/action evaluators, the REST handlers, the HAP
+mapping, and the plugin manifest parser are **real, tested code** — not stubs.
+That is the anti-slop positive and it is cited here as such.
+
+What the audit found was **not fake business logic but an unsound trust
+boundary plus documented-but-no-op features**:
+
+1. A **CRITICAL WebSocket authentication bypass** — the WS handshake accepted
+   any non-empty token, ignoring the provisioned token whitelist the REST path
+   enforces.
+2. **Reply-theater** — WS command responses were computed, then logged and
+   **discarded**; no `result`/`pong`/`event` ever reached the client.
+3. **Documented-but-idle automation** — the engine was constructed and dropped
+   (never started); time triggers, `RunMode`, `Choose` branches, and template
+   conditions were each **documented as working but were no-ops in the live
+   path**.
+
+This is a worse class than ADR-160's over-naming: here the **doc claimed a
+capability the code did not deliver** (auth enforcement, reply transport,
+running automations). The fix is **implement where feasible, honestly relabel
+where not — never leave a false doc.** Every fix is pinned by a test that
+**fails on the old code**.
+
+Grading vocabulary (ADR-152 / ADR-158 / ADR-160):
+- **MEASURED** — reproduced in this worktree, command + failing-on-old test recorded.
+- **NO-ACTION (already-honest/already-hardened)** — audited, found correct, cited as a positive.
+- **ACCEPTED-FUTURE** — deliberately deferred, nothing dropped.
+
+## Decision — Fixes Landed
+
+### §A1 — WebSocket auth bypass (CRITICAL, security) — MEASURED
+
+`homecore-api/src/ws.rs` handshake checked only `token.trim().is_empty()` and
+sent `auth_ok` for **any** non-empty token. It never called
+`state.tokens().is_valid()` — the check the REST path uses via
+`auth::BearerAuth`. With a provisioned `HOMECORE_TOKENS` whitelist, **any
+attacker-chosen non-empty token got full WS access** (read all states, call any
+service, subscribe to all events).
+
+**Real fix:** the handshake now calls
+`state.tokens().is_valid(&token).await` (the *same* store + method as REST).
+A wrong token receives `auth_invalid` and the socket closes. DEV (`allow_any`)
+mode still accepts any non-empty bearer with a warn, so smoke tests keep
+working; the empty token is rejected inside `is_valid`.
+
+**Failing-on-old test** (`tests/ws_handshake.rs`):
+`wrong_token_is_rejected` — provisions a real (non-dev) store with one good
+token, sends a DIFFERENT non-empty token over the WS handshake, asserts
+`auth_invalid`. On the old source the client received
+`{"type":"auth_ok",…}` (verified: the test panics on old `ws.rs` with
+`left: "auth_ok", right: "auth_invalid"`). Companion: `correct_token_is_accepted`.
+**Grade: MEASURED. This is the milestone headline.**
+
+### §A2 — WS replies never transmitted (HIGH, functional) — MEASURED
+
+`ws.rs::Connection::run` moved the socket into a recv-only task; the only
+consumer of the response mpsc just did `debug!("ws emit: {msg}")` and dropped
+every message. No command reply ever reached the wire.
+
+**Real fix:** the socket is split with `futures_util::StreamExt::split`. A
+dedicated **writer task** drains the response channel onto `sink.send(...)`
+(text frames; a `__pong:<n>` sentinel maps to a Pong control frame); the reader
+task parses commands concurrently. On reader exit the senders drop and the
+writer task ends cleanly.
+
+**Failing-on-old tests:** `result_reply_is_received` (connect → auth →
+`get_states` → assert a `result` reply is RECEIVED within 5s) and
+`ping_pong_reply_is_received`. Both time out on the old source (verified:
+`Elapsed` panic). **Grade: MEASURED.**
+
+### §A8 — `homecore-api` bin: no env-token path, network-exposed (HIGH, security) — MEASURED
+
+`homecore-api/src/bin/server.rs` bound `0.0.0.0:8123` with
+`SharedState::new()` → `allow_any_non_empty()` and **no** `HOMECORE_TOKENS`
+path (unlike `homecore-server`), so a provisioned operator had no way to lock
+it down.
+
+**Real fix:** the bin now mirrors `homecore-server`'s provisioning — prefer the
+`HOMECORE_TOKENS` whitelist (`LongLivedTokenStore::from_env()`), fall back to an
+**explicitly warn-logged** DEV mode only when unset. It also defaults the bind
+address to **`127.0.0.1`** (loopback) so a bare `cargo run` is not
+network-exposed, with `HOMECORE_BIND` to opt into LAN.
+
+**Failing-on-old test** (`tests/server_bin_auth.rs`):
+`provisioned_bin_rejects_wrong_bearer` reproduces the bin's exact provisioning
+path (a populated, non-dev store) and asserts a wrong bearer → 401;
+`from_env_path_enforces_whitelist` proves `from_env()` is not dev mode and
+enforces the list. The old bin's `allow_any_non_empty()` accepted the wrong
+bearer. **Grade: MEASURED.**
+
+### §A3 — Automation engine never started (HIGH) — MEASURED
+
+`homecore-server/src/main.rs` did `let _automation_engine = AutomationEngine::new(...)`
+then dropped it immediately, while the header doc claimed "Automation engine
+subscribed to the state machine."
+
+**Real fix:** the engine is now built into a long-lived binding and `.start()`
+is called, spawning the event loop + timer task; the header/log lines state it
+is started with N automations and which trigger classes are active. (With A4–A7
+the running engine is genuinely functional, not theater.)
+
+**Evidence:** the engine-behavior tests below run against the same
+`AutomationEngine::start()` path now wired into the bin. **Grade: MEASURED.**
+
+### §A4 — `Trigger::Time` hard-coded `false`, no timer (HIGH) — MEASURED
+
+`trigger.rs::matches_sync` returned `false` for `Time` and there was **no timer
+task** anywhere, so time automations could never fire.
+
+**Real fix:** `AutomationEngine::start_timer` — a 1 Hz tokio interval that
+compares each `time:` automation's `at` (`HH:MM` or `HH:MM:SS`) against the
+local wall-clock second and fires it once per match (conditions still gate it).
+`matches_sync` returning `false` for `Time` is now **correct and documented**
+(it is a wall-clock trigger with no state-change context); a public
+`fire_time_for_test` exposes the same path deterministically.
+
+**Failing-on-old test** (`tests/engine_behaviors.rs`):
+`time_trigger_fires_via_timer_path` (+ unit `time_at_matches_handles_hh_mm_and_hh_mm_ss`).
+The method does not exist on the old engine. **Grade: MEASURED.**
+
+### §A5 — `RunMode` documented as AtomicBool-enforced but unbounded-parallel (HIGH) — MEASURED
+
+`engine.rs` doc claimed "RunMode::Single is enforced via a per-automation
+AtomicBool" — but no such code existed and **every** trigger spawned an
+unbounded parallel task regardless of `mode`.
+
+**Real fix:** each registered automation carries a `running: Arc<AtomicBool>`.
+`Single`/`IgnoreFirst` modes `compare_exchange` the flag before spawning and
+**skip** the trigger if a run is already in flight, clearing it on completion;
+`Parallel` (and, for now, `Restart`/`Queued`) spawn on every trigger.
+
+**Failing-on-old tests** (`tests/engine_behaviors.rs`):
+`single_mode_does_not_double_fire_on_rapid_triggers` (two rapid triggers while
+the first run sleeps → exactly **1** run; old code fired **2**, verified) and
+`parallel_mode_does_fire_concurrently` (→ 2). **Grade: MEASURED (Single/Parallel
+honored; bounded `Queued`/`Restart`/`max` ordering → ACCEPTED-FUTURE, see below).**
+
+### §A6 — `Action::Choose` ignored branches (HIGH) — MEASURED
+
+`action.rs` discarded `choices` and always ran `default`.
+
+**Real fix:** `ChoiceBranch::matches` deserialises each branch's
+`serde_yaml::Value` conditions into `Condition` and evaluates them (AND
+semantics, against an `EvalContext` now carried on `ExecutionContext`). `Choose`
+runs the **first matching branch's** sequence and falls to `default` only if
+none match.
+
+**Failing-on-old tests** (`action.rs` inline):
+`choose_runs_matching_branch_not_default` (matching branch runs, default does
+NOT — old code ran default, verified) and
+`choose_falls_to_default_when_no_branch_matches`. **Grade: MEASURED.**
+
+### §A7 — Template conditions always false in the live engine (MEDIUM) — MEASURED
+
+`condition.rs` returned `false` for `Template` whenever `template_env` was
+`None`, and the engine built every `EvalContext` with `template_env: None`
+(`EvalContext::new`), so `template:` conditions could never be true in
+production — only in unit tests that hand-built a template env.
+
+**Real fix:** the engine constructs one `TemplateEnvironment` over the state
+machine and threads it into every `EvalContext` via
+`EvalContext::with_templates` (event loop, timer task, and
+`ExecutionContext` for `Choose` branches).
+
+**Failing-on-old tests** (`tests/engine_behaviors.rs`):
+`template_condition_evaluates_true_in_engine` (a `{{ is_state(...) }}` condition
+gates an action true) and `template_condition_evaluates_false_blocks_action`.
+On the old engine the action never ran (template always false, verified).
+**Grade: MEASURED.**
+
+### §B5 — Plugin manifest sig/hash "verified before execution" doc was false (LOW, honesty) — relabeled
+
+`homecore-plugins/src/manifest.rs` documented `wasm_module_hash` as "verified
+before execution" and carried `wasm_module_sig` / `publisher_key`, but these
+fields are **never read** for verification (only ever set to `None` in tests).
+
+**Fix (honest labeling — no false capability claimed):** the three fields are
+re-doc'd **"(P4 — not yet enforced, ADR-161/B5)"** — parsed and round-tripped,
+but no integrity/signature check happens before a plugin runs. No verification
+code was added (that is P4); the doc now matches the code.
+**Grade: doc-honesty (no behavior change).** *(Superseded by ADR-162 §P4:
+the hash/signature gate is now implemented and enforced.)*
+
+## Negative Results (NO-ACTION positives — audited, found correct, cited not edited)
+
+These were checked and are genuinely sound/honest; cited as positives, **not**
+touched:
+- **CSPRNG correctness** — all IDs are `uuid::v4`; the rng/`randn` suspicion was
+  **REFUTED**. No weak-randomness issue exists.
+- **CORS allowlist** (`app.rs`) — already hardened (explicit `AllowOrigin::list`,
+  no `permissive()`, `allow_credentials(false)`, env override). NO-ACTION.
+- **No path traversal in `homecore-migrate`** — audited, clean.
+- **No secrets in logs** — audited, clean.
+- **HAP pairing stub** — honestly disclaimed as a surface stub; not over-claimed.
+- **`InProcessRuntime` "no sandbox" disclaimer** — honest; left as-is.
+
+## Deferred Backlog (Nothing Dropped)
+
+- **Plugin authority-isolation (P5)** — ~~`homecore_permissions` claims are parsed
+  but not enforced at the host-call boundary.~~ **DONE — ADR-162 §P5.**
+  `hc_state_set` now consults a `PermissionSet` distilled from the manifest;
+  an undeclared write returns a typed `-3` to the guest.
+- **Plugin signature/hash verification (P4)** — ~~implement the
+  `wasm_module_hash`/`wasm_module_sig`/`publisher_key` gate that B5 now honestly
+  says is absent.~~ **DONE — ADR-162 §P4.** `WasmtimeRuntime::load_plugin` now
+  SHA-256-checks the module, Ed25519-verifies the signature against
+  `publisher_key`, and enforces a `PluginPolicy` trust allowlist
+  (secure-default rejects unsigned/untrusted/tampered modules).
+- **HAP real pairing (P2)** — SRP/HKDF pairing + encrypted sessions; current
+  bridge is an accessory-mapping surface. **ACCEPTED-FUTURE (honestly stubbed).**
+- **`RunMode::Queued`/`Restart`/`max` ordering** — ~~`Single`/`Parallel` are
+  honored; bounded queueing, restart-kill, and `max` concurrency are not yet
+  wired (every non-Single mode is parallel).~~ **DONE — ADR-162 §A5.** Restart
+  aborts the in-flight task, Queued serializes via a per-automation async mutex,
+  and `max: N` caps concurrency via a per-automation semaphore.
+- **Automation YAML load-at-boot** — the engine starts empty; a YAML loader is
+  P-next. The bin log states "0 automations registered" honestly.
+
+## Reproduction (MEASURED)
+
+```bash
+cd v2
+cargo test -p homecore-api -p homecore-server -p homecore-automation -p homecore-hap --no-default-features
+cargo test -p homecore-plugins --features wasmtime
+cargo build --workspace --no-default-features
+```
+
+Result at time of writing (all 0 failed):
+- **homecore-api** — **25 passed** (lib 18; `server_bin_auth` 3; `ws_handshake` 4)
+- **homecore-automation** — **42 passed** (lib 37; `engine_behaviors` 5)
+- **homecore-hap** — **17 passed**
+- **homecore-server** — bin, **0 tests**
+- (**homecore-plugins** — **15 passed**: lib 12; integration 3)
+- Full workspace `cargo build --workspace --no-default-features` succeeds.
+
+## Consequences
+
+- The WebSocket path can no longer be entered with a forged token — it enforces
+  the same `LongLivedTokenStore` whitelist as REST (A1).
+- WS clients now actually receive `result`/`pong`/`event` frames (A2).
+- The `homecore-api` dev bin defaults to loopback and honors `HOMECORE_TOKENS`
+  (A8); it is no longer an open `0.0.0.0` accept-any endpoint by default.
+- The automation engine is started for real and its time triggers, `Single`
+  run-mode, `Choose` branches, and `template:` conditions all function — no doc
+  claims a capability the code lacks (A3–A7).
+- The plugin manifest no longer claims signature verification it does not
+  perform (B5).
+- Files kept under the 500-line guideline (`engine.rs` 462; behavioral tests
+  moved to `tests/engine_behaviors.rs`).

docs/adr/ADR-162-plugin-security-and-bounded-runmodes.md

@@ -0,0 +1,186 @@
+# ADR-162: HOMECORE Plugin Security (Signature + Capability Isolation) & Bounded Automation RunModes — Making ADR-161's Deferred Claims TRUE
+
+- **Status**: accepted
+- **Date**: 2026-06-12
+- **Deciders**: ruv
+- **Tags**: homecore, homecore-plugins, homecore-automation, plugin-security, wasm-signature-verification, ed25519, capability-isolation, runmode, prove-everything, soundness, honest-labeling
+- **Amends**: ADR-161 (relabelled P4/P5 + §A5 deferrals → now enforced), ADR-128 (plugin manifest), ADR-129 (automation engine)
+
+## Context
+
+Beyond-SOTA sweep **Milestone 8**, scoped to `homecore-plugins` and
+`homecore-automation` only, under the project's **prove-everything /
+anti-"AI-slop"** directive.
+
+ADR-161 (Milestone 7) did the honest thing with three plugin/automation
+items it could not finish in that window: rather than fake them, it **relabelled
+them as deferred** —
+
+- **P4** (plugin signature verification): the manifest's `wasm_module_hash` /
+  `wasm_module_sig` / `publisher_key` were re-doc'd "(P4 — not yet enforced,
+  ADR-161/B5)" — parsed and round-tripped, but **never checked** before a
+  plugin runs.
+- **P5** (plugin authority isolation): `homecore_permissions` claims were
+  parsed but **never consulted**; `hc_state_set` let any plugin write any
+  entity, including `lock.*` / `alarm_control_panel.*`.
+- **§A5** (`RunMode`): `Single`/`Parallel` were honored; `Restart`/`Queued`/
+  `max: N` were honestly documented as still **unbounded-parallel**.
+
+### Headline — the deferred security items are now ENFORCED + TESTED
+
+M8 turns those honest deferrals into real, tested behavior. The plugin trust
+boundary is now sound (a tampered module, an untrusted publisher, or an
+unsigned module is rejected by the secure default), an over-privileged plugin
+write is denied with a typed error, and the bounded run-modes actually bound.
+**Every fix is pinned by a test that FAILS on the pre-M8 code** — each of the
+three RunMode tests was additionally run against a simulated unbounded-parallel
+dispatch and confirmed to panic.
+
+The Ed25519 crypto reuses the in-repo `cog-ha-matter::witness_signing` pattern
+(same `ed25519-dalek` 2.x API, same deterministic-test-key convention). SHA-256
+matches the `sha256:` prefix the manifest already declared and the
+`cog-ha-matter` cog manifest's `binary_sha256` hex convention. No new external
+dependency tree was introduced — `ed25519-dalek` / `sha2` / `hex` / `base64`
+were already in the workspace `Cargo.lock` (cog-ha-matter / bfld pull them in);
+only new dependency *edges* were added to `homecore-plugins`.
+
+Grading vocabulary (ADR-152 / ADR-158 / ADR-160 / ADR-161):
+- **MEASURED** — reproduced in this worktree, command + failing-on-old test recorded.
+- **ACCEPTED-FUTURE** — deliberately deferred, nothing dropped.
+
+## Decision — Fixes Landed
+
+### §P4 — Plugin signature & integrity verification (SECURITY) — MEASURED
+
+`homecore-plugins/src/manifest.rs` declared `wasm_module_hash` /
+`wasm_module_sig` / `publisher_key` but they were **never read** for
+verification; the load path (`wasmtime_runtime.rs`) instantiated any `.wasm`
+bytes handed to it.
+
+**Real fix** (`src/verify.rs`, wired into `WasmtimeRuntime::load_plugin`):
+before instantiation the runtime now —
+
+1. computes the **SHA-256** of the actual `.wasm` bytes and rejects if it ≠ the
+   manifest's `wasm_module_hash` (`sha256:<hex>`) — tamper detection;
+2. verifies the **Ed25519** `wasm_module_sig` (`ed25519:<base64>`, 64-byte raw)
+   over the 32-byte digest against `publisher_key` (`ed25519:<base64>`, 32-byte
+   raw) and rejects on failure;
+3. enforces a configurable **trust policy** — `PluginPolicy::trusted(&[keys])`
+   is an allowlist of publisher verifying keys; `PluginPolicy::AllowUnsigned`
+   is an explicit dev escape hatch that LOGS a loud `warn` on every load it
+   waves through. The **secure default rejects unsigned and unknown-publisher
+   modules.** `PluginPolicy::deny_all()` trusts no publisher.
+
+A typed `PluginError::SignatureRejected` is returned (no host panic). The
+legacy permission-free `load_wasm` is retained for first-party/trusted/test
+modules; production loading goes through `load_plugin`.
+
+**Failing-on-old tests** (`tests/integration.rs`, `--features wasmtime`) — all
+drive `load_plugin`, which **did not exist** on the old code (so the gate is
+genuinely new):
+- `p4_tampered_module_is_rejected` — a byte-flipped `.wasm` → hash mismatch → rejected.
+- `p4_valid_sig_from_trusted_key_loads` — a valid sig from an allowlisted key loads.
+- `p4_valid_sig_from_untrusted_key_is_rejected` — a correctly-signed module from a key NOT on the allowlist is rejected.
+- `p4_unsigned_module_rejected_by_default_loads_only_under_allow_unsigned` — unsigned rejected under `deny_all`, loads (with warn) only under `AllowUnsigned`.
+- Unit (`src/verify.rs`): `valid_sig_from_trusted_key_passes`, `tampered_module_is_rejected`, `valid_sig_from_untrusted_key_is_rejected`, `forged_signature_is_rejected`, `unsigned_module_rejected_under_default_policy`.
+
+A real deterministic keypair signs real `.wasm` bytes in the tests.
+The manifest doc now reads **"(P4 — ENFORCED, ADR-162)"**. **Grade: MEASURED. Milestone headline.**
+
+### §P5 — Plugin authority / capability isolation (SECURITY) — MEASURED
+
+`wasmtime_runtime.rs::hc_state_set` applied any write a plugin requested,
+ignoring the manifest's `homecore_permissions`.
+
+**Real fix** (`src/permissions.rs` + `hc_state_set`): the manifest's
+`homecore_permissions` (the `state:write:<glob>` form, or a bare entity glob
+like `light.*`) are distilled into a `PermissionSet` installed in the plugin's
+Wasmtime store. The `hc_state_set` host import consults
+`permissions.may_write(entity_id)` before applying a write and returns a typed
+`-3` (permission denied) to the guest on a violation — **the host is not
+panicked.** Wasmtime already gives memory isolation; this adds **authority**
+isolation. A plugin with **no** write grants can write nothing (secure default).
+
+**Failing-on-old tests** (`tests/integration.rs`, `--features wasmtime`):
+- `p5_declared_light_plugin_may_write_light_but_not_lock` — a `light.*` plugin writes `light.kitchen` (succeeds) but is REJECTED (`-3`, and the entity is not written) when it tries `lock.front_door`.
+- `p5_plugin_with_no_permissions_can_write_nothing` — a plugin with empty `homecore_permissions` cannot write `light.kitchen`.
+- Unit (`src/permissions.rs`): domain-glob, exact-grant, wildcard, read-grants-don't-confer-write, no-permissions, and explicit `state:write:` form.
+
+The manifest doc now reads **"(P5 — ENFORCED, ADR-162)"**. **Grade: MEASURED.**
+
+### §A5 — Bounded automation RunModes (Restart / Queued / max) — MEASURED
+
+`homecore-automation/src/engine.rs` (per ADR-161) honored `Single`/`Parallel`
+but spawned an unbounded parallel task for `Restart`/`Queued`/`max`.
+
+**Real fix** (`src/runmode.rs`, a per-automation `RunState` the engine owns and
+dispatches through at all three trigger sites — event loop, timer, test hook):
+- **Restart** — aborts the in-flight action task via `tokio::task::AbortHandle`, then starts a fresh one.
+- **Queued** — serializes runs in arrival order via a per-automation async `Mutex`: sequential, never concurrent, nothing dropped.
+- **max: N** — caps concurrency at N via a per-automation `Semaphore`; triggers beyond N **queue** (await a permit) rather than running concurrently. (HA bounded `parallel`/`queued` semantics — chosen and documented as *queue beyond N*, not drop.)
+- `Single`/`IgnoreFirst` re-entrancy guard and `Parallel` preserved.
+
+`engine.rs` trimmed to **433 lines**; the run-mode machinery lives in the new
+`runmode.rs` (153 lines) to keep both under the 500-line guideline.
+
+**Failing-on-old tests** (`tests/engine_behaviors.rs`) — each was run against a
+simulated unbounded-parallel dispatch and confirmed to panic:
+- `restart_mode_cancels_prior_run` — prior run is aborted: exactly **1** completion (old: both ran → 2).
+- `queued_mode_runs_sequentially_not_concurrently` — 3 rapid triggers all run, **max observed concurrency = 1** (old: 3).
+- `max_two_caps_concurrency_at_two` — 4 rapid triggers all run, **max observed concurrency ≤ 2** (old: 4).
+
+**Grade: MEASURED. Restart, Queued, and `max: N` all implemented — no remaining RunMode deferral.**
+
+## Threat model closed
+
+| Threat | Before (ADR-161) | After (ADR-162) |
+|--------|------------------|-----------------|
+| **Tampered module** — attacker swaps `.wasm` bytes after signing | loaded unconditionally (hash never checked) | rejected: SHA-256 mismatch |
+| **Untrusted publisher** — valid sig from a key the host doesn't trust | loaded (sig/key never read) | rejected: publisher_key not on allowlist |
+| **Unsigned module** — no integrity material at all | loaded | rejected by secure default; loads only under explicit `AllowUnsigned` (loud warn) |
+| **Over-privileged plugin write** — a `light.*` plugin writes `lock.front_door` / `alarm_control_panel.*` | applied (permissions never consulted) | denied: typed `-3` to guest, write not applied |
+| **Run-mode resource exhaustion** — `max`/`Queued` spawn unbounded tasks | unbounded parallel | bounded: Restart cancels, Queued serializes, `max: N` caps at N |
+
+## Remaining honest deferral (Nothing Dropped)
+
+- **Plugin-key provisioning / rotation** — the host's trust allowlist
+  (`PluginPolicy::trusted`) is supplied by the caller; sourcing it from the
+  Cognitum control-plane key store (as `cog-ha-matter` does for Seed keys) and
+  key rotation are **ACCEPTED-FUTURE** (out of M8 scope — same boundary
+  `witness_signing` draws).
+- **`InProcessRuntime` (native first-party plugins)** — has no `.wasm` bytes to
+  hash, so P4/P5 apply only to the WASM (`wasmtime`) path; native plugins remain
+  trusted-by-compilation. Honestly noted, not over-claimed.
+- **HAP real pairing (P2)** — unchanged from ADR-161; out of M8 scope.
+
+## Reproduction (MEASURED)
+
+```bash
+cd v2
+# P4/P5 (wasmtime feature needs rustc 1.91+; workspace pins 1.89 for the rest):
+cargo +1.91.1 test -p homecore-plugins --features wasmtime
+# Bounded RunModes:
+cargo test -p homecore-automation --no-default-features
+# Full workspace still builds (1.89 toolchain, no wasmtime):
+cargo build --workspace --no-default-features
+```
+
+Result at time of writing (all 0 failed):
+- **homecore-plugins** `--features wasmtime` — **32 passed** (lib 23; integration 9). (ADR-161 baseline was 15.)
+- **homecore-automation** `--no-default-features` — **45 passed** (lib 37; `engine_behaviors` 8). (ADR-161 baseline was 42.)
+- Full workspace `cargo build --workspace --no-default-features` succeeds.
+
+## Consequences
+
+- A HOMECORE WASM plugin can no longer be loaded with a tampered binary, an
+  untrusted publisher, or (by default) no signature at all — the trust boundary
+  ADR-161/B5 honestly said was absent is now real (P4).
+- A plugin can no longer write entities outside its declared
+  `homecore_permissions`; the lock/alarm escalation path is closed (P5).
+- The automation engine's `Restart`, `Queued`, and `max: N` run-modes are now
+  bounded as documented — no run-mode claims a capability the code lacks.
+- No new external dependency tree (reuses the cog-ha-matter Ed25519 stack
+  already in the lock); source files kept under the 500-line guideline
+  (`engine.rs` 433, `runmode.rs` 153, `verify.rs` 397, `permissions.rs` 168;
+  `wasmtime_runtime.rs` non-test source < 500, inline WAT tests as ADR-161 left
+  them).

docs/adr/ADR-250-adaptive-gamma-entrainment.md

@@ -1,297 +0,0 @@
-# ADR-250: Adaptive Gamma Entrainment Using RuVector and RuView
-
-| Field | Value |
-|-------|-------|
-| **Status** | Proposed |
-| **Date** | 2026-06-09 |
-| **Owner** | RuView, RuVector, RuFlo clinical systems |
-| **Decision type** | Architecture, safety, research platform |
-| **Scope** | Personalized noninvasive sensory stimulation and passive state sensing |
-| **Codebase target** | `v2/crates/ruview-gamma` (this ADR's reference implementation) |
-
-> **Not medical advice:** This ADR defines a research and engineering
-> architecture. It does **not** define an approved Alzheimer's treatment. The
-> immediate product claim is **personalized entrainment optimization**, never
-> Alzheimer's treatment.
-
----
-
-## 1. Context
-
-Recent research suggests that noninvasive 40 Hz multisensory stimulation using
-light and sound can influence gamma neural activity and may activate glymphatic
-clearance pathways associated with amyloid removal in Alzheimer's mouse models.
-The strongest mechanistic support comes from a 2024 Nature paper showing that
-multisensory gamma stimulation promoted cerebrospinal fluid influx, interstitial
-fluid efflux, aquaporin-4 polarization, meningeal lymphatic dilation, VIP
-interneuron signaling, and amyloid clearance in 5XFAD mice. Blocking glymphatic
-clearance abolished the amyloid-clearing effect.
-
-Human evidence is promising but still early. A 2022 study in mild probable
-Alzheimer's disease reported that 40 Hz sensory stimulation was feasible and
-well tolerated, with exploratory signals around brain structure, connectivity,
-sleep, and memory. A small 2025 long-term pilot reported daily 40 Hz
-audiovisual stimulation over two years was safe and feasible and may slow
-cognitive and biomarker progression, but the sample size was very small and not
-definitive.
-
-The field mostly treats 40 Hz as a fixed protocol. That is a useful population
-prior, but individual brains may differ by baseline gamma state, arousal, sleep
-quality, sensory acuity, medication, age, disease stage, and comfort tolerance.
-A 2025 PLOS One study re-evaluated gamma stimulation frequency across 36–44 Hz,
-supporting the idea that frequency choice should be empirically measured rather
-than assumed.
-
-## 2. Problem
-
-Fixed 40 Hz stimulation creates four engineering limits:
-
-1. It assumes the same frequency works for everyone.
-2. It does not continuously verify entrainment.
-3. It ignores physiological state (sleep, motion, breathing, restlessness, comfort).
-4. It cannot safely optimize stimulation parameters over time.
-
-For clinical or wellness-grade deployment, the system must answer: *which
-frequency, modality, intensity, timing, and session structure produces the
-strongest safe entrainment for this person in this state?*
-
-## 3. Decision
-
-We build an **Adaptive Gamma Entrainment Architecture** where 40 Hz is the
-initial prior, not the hard-coded answer. The system uses:
-
-1. **RuView** as the passive state-sensing layer.
-2. **RuVector** as the personal response-modeling layer.
-3. A **constrained optimizer** to select stimulation parameters.
-4. **RuFlo** as the governed workflow, audit, safety, and protocol-execution layer.
-5. **Clinical-mode separation** to prevent unsupported therapeutic claims.
-
-The system optimizes stimulation **only within a predefined safety envelope**
-and separates entrainment optimization from disease-outcome claims.
-
-## 4. Architecture Overview
-
-```
-Person baseline → RuView passive sensing → optional EEG → stimulus session
-   → response extraction → RuVector personal response vector
-   → constrained optimizer → next best protocol → RuFlo audit + governance
-```
-
-| Component | Role | Output |
-|-----------|------|--------|
-| RuView | Passive sensing of body and environment | breathing, motion, posture, stillness, sleep state, adherence |
-| EEG (optional) | Direct entrainment measurement | gamma power, phase locking, artifact score |
-| Stimulus controller | Light + sound actuator | frequency, intensity, phase, duty cycle, duration |
-| RuVector | Learns personal response surface | individual entrainment vector |
-| Optimizer | Selects next safe stimulation setting | recommended protocol |
-| RuFlo | Governance and audit | protocol record, safety log, reproducibility trail |
-
-## 5. Stimulus Search Space
-
-| Parameter | Default range | Notes |
-|-----------|---------------|-------|
-| Frequency | 36–44 Hz | published exploratory range |
-| Starting prior | 40 Hz | strongest preclinical literature |
-| Modality | audio, visual, combined | combined preferred (GENUS-style) |
-| Brightness | bounded low–moderate | avoid unsafe flicker intensity |
-| Volume | bounded low–moderate | comfort-constrained |
-| Duty cycle | continuous, ramped, pulsed | start conservative |
-| Phase | synchronized, offset | explore only after baseline |
-| Duration | short calibration first | longer only after tolerance |
-| Time of day | morning, evening, quiet wake | state-dependent |
-
-## 6. Personal Response Vector
-
-RuVector represents each person with a compact 20-field adaptive vector
-(`baseline_gamma, baseline_alpha, alpha_gamma_ratio, gamma_power_gain,
-phase_locking_value, breathing_rate, breathing_stability, motion_artifact,
-posture_state, sleep_state, restlessness_score, stimulus_frequency,
-brightness_level, sound_level, duty_cycle, phase_offset, session_duration,
-comfort_score, adherence_score, adverse_event_flag`), updated after each
-session: `R_{t+1} = update(R_t, stimulus_t, response_t, safety_t)`.
-
-## 7. Optimization Objective
-
-The optimizer maximizes **safe, stable entrainment**, not raw gamma power:
-
-```
-score =  w1·gamma_power_gain + w2·phase_locking_gain + w3·breathing_stability
-       + w4·adherence + w5·comfort
-       − w6·motion_artifact − w7·adverse_event_risk − w8·overstimulation_penalty
-```
-
-Default weights: gamma 0.30, phase-locking 0.25, comfort 0.15, breathing 0.10,
-adherence 0.10, motion penalty 0.05; **safety penalty is a hard constraint, not
-negotiable**.
-
-## 8. Learning Method (staged loop)
-
-- **Phase 1 — Conservative calibration:** short sessions at 36–44 Hz (1 Hz steps).
-- **Phase 2 — Bayesian optimization:** GP surrogate + Expected Improvement,
-  subject to `safety==true ∧ comfort≥threshold ∧ adverse_event_risk≤threshold`.
-- **Phase 3 — Contextual bandit:** once enough sessions exist, LinUCB over state
-  context → stimulus action → safe-entrainment reward.
-- **Phase 4 — Closed-loop control:** mid-session, bounded frequency nudges when
-  entrainment drops, intensity reduction on discomfort, scoring pause on motion
-  spikes, and hard terminate-and-lock on adverse events.
-
-## 9–12. RuView / RuVector / RuFlo roles & Safety
-
-RuView supplies non-camera passive context (breathing, motion, posture,
-stillness, restlessness, sleep proxy, interference, adherence). RuVector
-supplies adaptive memory (personal vector, session-to-session learning,
-anonymized nearest-neighbor, drift detection, clustering, recommendation, edge
-inference) and predicts **safe-entrainment / comfort / artifact / adherence
-likelihood** — not Alzheimer's improvement. RuFlo governs (consent,
-inclusion/exclusion, scheduling, safety-stop rules, parameter audit trail, ADR
-linkage, model-version tracking, clinician export, trial-mode separation).
-Every session is reproducible via
-`session_hash = hash(protocol_version, model_version, device_version,
-stimulus_parameters, sensor_summary, response_summary, safety_events)`.
-
-**Hard-stop conditions:** headache, dizziness, nausea, agitation, visual
-discomfort, abnormal distress, seizure-like symptoms, user-stop request, sensor
-confidence below threshold, protocol outside approved envelope.
-
-**Exclusion / clinical supervision:** epilepsy or seizure history,
-photosensitivity, severe migraine sensitivity, severe psychiatric instability,
-implanted neurological devices, significant sensory impairment affecting
-protocol validity, medication changes affecting neural response. **The system
-must never autonomously expand beyond the allowed safety envelope.**
-
-## 18. Acceptance Criteria
-
-| Criterion | Target |
-|-----------|--------|
-| Frequency control precision | ±0.1 Hz |
-| Session audit completeness | 100% |
-| Motion artifact detection | ≥90% valid/invalid classification |
-| Adaptive protocol improvement | ≥20% entrainment gain vs fixed 40 Hz |
-| Comfort | no worse than fixed 40 Hz |
-| Safety stops | 100% logged |
-| Repeatability | same optimal band within ±1 Hz across 3 sessions |
-| Claim discipline | no disease-treatment claim in product UI |
-
-## 19. Non-Goals
-
-This ADR does **not** claim: RuView treats Alzheimer's; RuVector clears amyloid;
-RF sensing measures amyloid directly; personalized frequency improves clinical
-outcomes; consumer deployment is safe without screening; 40 Hz is always optimal.
-
-## 21. Implementation Roadmap → reference crate `ruview-gamma`
-
-| Milestone | Module(s) in `ruview-gamma` | Status in this ADR's impl |
-|-----------|------------------------------|---------------------------|
-| M1 Simulator | `simulator.rs` (deterministic ChaCha20 response surface) | **Implemented** |
-| M2 Device harness (contract) | `stimulus.rs`, `safety.rs` (envelope + emergency stop) | **Interfaces + safety implemented** |
-| M3 RuView integration (contract) | `response.rs` (`RuViewState`) | **State contract implemented** |
-| M4 EEG validation (contract) | `response.rs` (`EegMeasurement`), `objective.rs` | **Optional input implemented** |
-| M5 Adaptive optimizer | `optimizer.rs` (Phase 1+2), `bandit.rs` (Phase 3), closed-loop | **Implemented** |
-| M6 Trial mode | `ruflo.rs` (consent, inclusion/exclusion, sham, audit, session hash) | **Implemented** |
-| §10 RuVector self-learning | `ruvector.rs` (anonymized `ProfileStore`, deterministic kNN, cohort warm-start priors via down-weighted GP pseudo-observations, physiological drift detection, deterministic clustering) | **Implemented** |
-
-The crate is a **deterministic, dependency-light leaf** (no internal RuView
-deps, ChaCha20 PRNG, SHA-256 witness — same discipline as `nvsim`), so the
-optimizer, safety envelope, and RuVector update logic can be tested and replayed
-bit-exactly before any hardware or human exposure. Hardware actuation, real RF
-sensing, and real EEG land behind feature flags / external adapters; this crate
-implements the governed software core and its proofs.
-
-## 23. Platform Generalization — Adaptive Sensory Neuromodulation
-
-The broader opportunity is **adaptive sensory neuromodulation**, not just
-Alzheimer's. 40 Hz is one prior in one program; the engine is a personal
-neural-rhythm optimization platform. RuView turns the body into the feedback
-signal, RuVector turns repeated sessions into a personal response map, the
-device is the actuator, and RuFlo makes the loop governed and auditable.
-
-Each use case is a `NeuroProgram` (`program.rs`) bundling its own safety
-envelope, starting prior, objective weighting, physiological-state gating,
-evidence level, and the single non-disease claim it may surface:
-
-| Program | Evidence level | RuView / RuVector role | Released claim |
-|---------|----------------|------------------------|----------------|
-| `alzheimers-research` | Medium preclinical, early human | Adaptive entrainment + trial monitoring | personalized entrainment optimization |
-| `post-stroke-cognition` | Early human | Recovery-state tracking (ramped, comfort-weighted) | …with recovery-state monitoring |
-| `sleep-optimization` | Early but plausible | Time stimulation to sleep state (audio, near-dark cap) | sleep-state-timed entrainment optimization |
-| `attention-working-memory` | Mixed / protocol-dependent | Personal frequency discovery (entrainment-weighted) | personalized frequency-response discovery |
-| `mood-arousal` | Early human | Avoid overstimulation, tune calming response | personalized calming-response optimization |
-| `home-wellness` | Speculative | Safe personalization without treatment claims | personal neural-rhythm wellness optimization |
-| `trial-infrastructure` | Strong infrastructure | Governed protocol/safety/consent/sham log | governed, reproducible protocol measurement |
-
-**Claim discipline is structural.** A program's claim is always an
-optimization/monitoring statement, never a disease-treatment claim; the disease
-*context* lives only in `EvidenceLevel`. A claim is releasable **only** through
-the acceptance gate.
-
-### 23.1 Generalized acceptance gate (`acceptance.rs`)
-
-> Every use case must show measurable **entrainment**, **safety**,
-> **adherence**, and **repeatability** before making any disease claim.
-
-`AcceptanceHarness::evaluate(program, person, state)` runs the program over ≥3
-independent repeats and measures: adaptive-vs-fixed-prior entrainment gain,
-safety-stop rate, mean adherence, and the spread of the discovered optimal
-frequency. The resulting `AcceptanceReport` exposes a `ClaimGate` that returns
-the program's claim **iff all four criteria pass**, and the research-only
-`NO_CLAIM` string otherwise — the program's marketing claim cannot be read
-except through this gate. This makes the acceptance sentence executable, not
-aspirational, and applies uniformly to all seven programs.
-
-## 22. Final Decision Statement
-
-We build Adaptive Gamma Entrainment as a governed RuView + RuVector
-architecture. The system treats 40 Hz as the evidence-based starting prior, then
-learns each person's safe entrainment response curve using passive sensing,
-optional EEG, constrained optimization, and auditable RuFlo workflows. The
-immediate product claim is **personalized entrainment optimization** — not
-Alzheimer's treatment. That distinction keeps the system scientifically
-credible, clinically safer, and commercially defensible.
-
-## Safety hardening (2026-06-11 review)
-
-A safety review of the `ruview-gamma` reference crate found five places where
-safety depended on *default values* rather than *construction*. The following
-invariants now hold by construction; the reference crate enforces and tests each.
-
-1. **Safety stops are control-flow events (Finding 1).** `run_session` still
-   returns the witnessed record on a stop, but `run_calibration` (and any
-   multi-session loop) inspects the record's safety outcome and **terminates the
-   sweep** on any stop — a stop in step *N* can no longer let steps *N+1…*
-   proceed. The partial calibration is preserved in the audit log.
-
-2. **Latched, persisted governor lock (Finding 2, ADR-250 §8 terminate-and-lock).**
-   An adverse-event / seizure-like / distress stop engages a **latched lock** on
-   the participant's `ParticipantSafetyState`, which is serialized into the
-   session store. A *new* governor instance for the same participant also
-   refuses (`Err(ParticipantLocked)`) until `unlock_with_acknowledgment(operator_note)`
-   is called, which itself writes an audit record. Lock-class mapping: seizure-like
-   → `SeizureLike`, abnormal distress → `Distress`, other medical adverse events
-   → `AdverseEvent`; user-stop / low-sensor-confidence / out-of-envelope stops do
-   not latch a cross-session lock (retryable / pre-empted, not adverse).
-
-3. **Compiled-in absolute envelope bounds (Finding 3).** `SafetyEnvelope` fields
-   are now private, reachable only through a validated `try_new` / `with_*`
-   constructor and `#[serde(try_from)]`, so no config — however hostile — can be
-   built outside the absolute bounds: frequency floor **≥ 30 Hz** (keeps the whole
-   envelope above the 15–25 Hz photosensitive provocative band with margin),
-   ceiling **≤ 60 Hz**, brightness/volume cap **≤ 0.6**, max session duration
-   **≤ 30 min**. This mirrors the firmware's compiled-in stance: deserialization
-   of an 18–22 Hz / brightness-1.0 / 10⁶-minute envelope fails closed.
-
-4. **Daily-dose cap + inter-session cooldown (Finding 4).** The governor enforces
-   **≤ 4 sittings per rolling 24 h** and a **≥ 60 min** inter-sitting cooldown from
-   the persisted ledger; violations return typed errors and are enforced across
-   governor instances. A calibration sweep delivered at one timestamp is **one
-   sitting / one dose unit** (sub-sessions do not trip the inter-step cooldown),
-   and calibration sittings are counted toward the cap — not a backdoor around it.
-
-5. **Per-tick monitor wired into the session loop (Finding 5).** `run_session`
-   now evaluates the latched `SafetyMonitor` over **every tick** of the simulated
-   session; a mid-session latch truncates the session at that tick (the recorded
-   delivered stimulus duration is reduced to the completed fraction). A clean
-   session is byte-identical to the prior single-summary path, so the pinned
-   deterministic proof witness is unchanged.
-
-   *Minor:* `seed_from_cohort` enforces a privacy k-floor (**≥ 3 distinct cohort
-   profiles**) before consuming cohort priors.

docs/adr/ADR-251-gamma-clinical-dashboard.md

@@ -1,91 +0,0 @@
-# ADR-251: Clinical Dashboard + Persistent RuVector Store for Adaptive Gamma
-
-| Field | Value |
-|-------|-------|
-| **Status** | Proposed |
-| **Date** | 2026-06-11 |
-| **Owner** | RuView, RuVector, RuFlo clinical systems |
-| **Decision type** | Architecture, clinical tooling |
-| **Relates to** | ADR-250 (Adaptive Gamma Entrainment — platform, programs, acceptance gate) |
-| **Codebase target** | `v2/crates/ruview-gamma-clinic` (this ADR's implementation) |
-
-> **Not a medical device.** Read-only research/clinical *instrumentation* over
-> the ADR-250 platform. It surfaces only gated claims and witnessed records; it
-> can neither start stimulation nor widen any safety envelope.
-
-## 1. Context
-
-ADR-250 shipped the governed adaptive-neuromodulation engine: per-program
-safety envelopes, the RuVector self-learning layer (anonymized profiles, kNN
-warm-start, drift detection, clustering), witnessed session records, and the
-executable acceptance gate. Two operational gaps remain for clinical use:
-
-1. **No durable store.** `ProfileStore` and the governor's audit log are
-   in-memory; a clinic restart loses cohort memory, and there is no
-   tamper-evident persistence matching the platform's proof discipline.
-2. **No clinician surface.** RuFlo's clinician export exists as a struct
-   (`ClinicianReport`), but there is no way for a clinician/trial monitor to
-   *see* a participant's frequency-response curve, session trend, safety
-   events, drift status, or a program's acceptance verdict.
-
-## 2. Decision
-
-Build `ruview-gamma-clinic`, a separate crate (keeping `ruview-gamma` a
-dependency-light deterministic leaf) with two components:
-
-### 2.1 Persistent RuVector store (`store.rs`)
-
-Append-only JSON-lines file per clinic, holding three record kinds —
-anonymized profiles, witnessed session summaries, and acceptance reports —
-each line **hash-chained** (`entry_hash = SHA-256(prev_hash ‖ canonical_json)`)
-so any retroactive edit breaks the chain (`verify_chain()`); the RuVector
-in-memory layer (`ProfileStore` kNN, clustering) is rebuilt from the file at
-open. Pseudonymity is preserved: records carry only the one-way profile tags
-from ADR-250 §10.
-
-### 2.2 Read-only clinical dashboard (`server.rs` + embedded `dashboard.html`)
-
-Axum surface, **strictly read-only** (no POST mutates stimulation state):
-
-| Route | Payload |
-|-------|---------|
-| `GET /` | embedded single-file HTML dashboard (no build step; SVG charts) |
-| `GET /api/clinic/participants` | tag, session count, mean entrainment, safety stops, adverse flag, drift status |
-| `GET /api/clinic/participants/{tag}` | response vector, frequency→score curve, session trend |
-| `GET /api/clinic/cohort` | deterministic k-means clusters over the stored profiles |
-| `GET /api/clinic/acceptance` | per-program acceptance reports with the **gated** claim |
-| `GET /api/clinic/integrity` | hash-chain verification result + record count |
-
-**Claim discipline is inherited, not re-implemented:** acceptance payloads
-embed `AcceptanceReport::released_claim` (the gate's output), never the
-program's raw claim. The dashboard renders what the gate released — nothing
-stronger.
-
-### 2.3 Visualization (embedded, dependency-free)
-
-One static HTML file (`include_str!`) with vanilla JS + inline SVG:
-participant list → per-participant frequency-response curve (the personal
-response map), entrainment/comfort session trend, safety-event markers, cohort
-cluster table, and an integrity badge (green only when `verify_chain` passes).
-No JS framework, no CDN, no build step — auditable by reading one file.
-
-## 3. Consequences
-
-- Clinic restarts no longer lose cohort memory; warm-start works across runs.
-- Tampering with stored records is detectable by one endpoint call.
-- A clinician can inspect a trial without shell access; the surface cannot
-  actuate anything.
-- The store is JSONL, not a database server: at research-cohort scale this is
-  deliberate (greppable, diffable, witness-friendly). An HNSW/ruvector-crate
-  backend remains the drop-in path past ~10⁵ profiles (ADR-250 §10).
-
-## 4. Acceptance criteria (tested)
-
-| Criterion | Test |
-|-----------|------|
-| Store round-trips all three record kinds across reopen | `store::tests` |
-| Hash chain detects any line edit/deletion/reorder | `tampered_chain_is_detected` |
-| kNN warm-start works from a reloaded store | `knn_survives_reload` |
-| Every API route serves and is read-only | `server::tests` (oneshot) |
-| Acceptance payload carries only the gated claim | `acceptance_payload_uses_gated_claim` |
-| Dashboard HTML embeds and serves | `dashboard_html_served` |

docs/adr/README.md

@@ -79,6 +79,10 @@ Statuses: **Proposed** (under discussion), **Accepted** (approved and/or impleme
 | [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 |
+| [ADR-149](ADR-149-public-community-leaderboard-huggingface.md) | AetherArena: public spatial-intelligence benchmark on Hugging Face | Proposed |
+| [ADR-150](ADR-150-rf-foundation-encoder.md) | RF Foundation Encoder: pose-preserving, subject/room/device-invariant CSI embedding | Proposed |
+| [ADR-151](ADR-151-room-calibration-specialist-training.md) | Per-Room Calibration & Specialized Model Training (room-first → bank of small ruVector specialists) | Proposed |
+| [ADR-152](ADR-152-wifi-pose-sota-2026-intake.md) | WiFi-Pose SOTA 2026 Intake: geometry-conditioned calibration, external benchmarks, foundation-encoder recipe | Proposed |
 
 ### Platform and UI
 
@@ -93,6 +97,8 @@ Statuses: **Proposed** (under discussion), **Accepted** (approved and/or impleme
 | [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 |
 | [ADR-115](ADR-115-home-assistant-integration.md) | Home Assistant integration via MQTT auto-discovery + Matter bridge (HA-DISCO + HA-FABRIC + HA-MIND) | Accepted (MQTT track) / Proposed (Matter SDK P8b) |
+| [ADR-147](ADR-147-adam-mode-light-theme.md) | adam-mode — light theme toggle for the three.js realtime demo | Proposed |
+| [ADR-148](ADR-148-yoga-mode-pose-system.md) | yoga-mode — yoga pose detection, classification, and scoring for the three.js realtime demo | Proposed |
 
 ### Architecture and infrastructure
 

docs/integration/calibration-appliance-integration.md

@@ -0,0 +1,234 @@
+# Per-Room Calibration — Integration Overview (for `cognitum-one/v0-appliance`)
+
+**Audience:** integrators wiring the RuView per-room calibration system (ADR-151) into the
+Cognitum V0 appliance (`cognitum-v0`, Pi 5 + Hailo). This document is the contract +
+deployment spec: data formats, API surface, crate API, and the appliance integration plan.
+
+**Source of truth:** crate `v2/crates/wifi-densepose-calibration` + CLI `v2/crates/wifi-densepose-cli`
+(`calibrate`, `calibrate-serve`, `enroll`, `train-room`, `room-status`, `room-watch`) on this PR's branch.
+
+---
+
+## 1. What it is
+
+"Teach the room before you teach the model." A local-first pipeline that turns a few minutes of
+clean human anchors — layered on an empty-room baseline — into a versioned **bank of small,
+room-calibrated specialists** for presence, posture, breathing, heartbeat, restlessness, and anomaly.
+
+```
+baseline (ADR-135)  →  enroll (anchors + quality gate)  →  extract (features)  →  train (specialist bank)  →  runtime (mixture + veto)
+   environmental         stand/sit/lie/breathe/move        periodicity/variance     6 small models             RoomState per window
+   fingerprint           (re-prompts bad captures)                                  + STALE invalidation       (+ multistatic fusion)
+```
+
+**Design invariants (carry these into the appliance):**
+- **Specialisation over scale** — six tiny models (threshold / nearest-prototype / autocorrelation), not one big model. They run in microseconds on a Pi CPU; **they do not need the Hailo HAT**.
+- **Local-first** — baselines + per-room banks stay on the device. Cross-room sharing is *model deltas* (federation, ADR-105), **never raw CSI**.
+- **Honest degradation** — baseline drift marks a bank `STALE`; a physically-implausible window is vetoed rather than emitting a hallucinated reading.
+
+---
+
+## 2. Tiering on the Pi 5 + Hailo (what runs where)
+
+| Tier | Runs on | What | Status |
+|------|---------|------|--------|
+| **CSI source** | ESP32-S3/C6 nodes (`edge_tier=0` raw CSI) | `0xC5110001` frames over UDP | shipping (v0.7.1-esp32) |
+| **Calibration service** | **Pi 5 CPU** (aarch64) | this crate: baseline/enroll/train/runtime + HTTP API | **this PR** |
+| **Shared backbone (optional)** | **Hailo HAT (HAILO10H)** | ADR-150 RF Foundation Encoder + neural pose head as HEF | future (ADR-150) |
+
+> The appliance's WiFi (`wlan0`) is `managed` with no nexmon — **the Pi is a CSI *processor*, not a CSI radio.** CSI arrives from the ESP32 nodes (the existing `ruview-vitals-worker:50054` already receives it). Calibration *consumes* that stream; it does not sense directly.
+
+---
+
+## 3. Data contracts (the integration surface)
+
+### 3.1 CSI ingest — ESP32 `0xC5110001` (UDP, little-endian)
+
+```
+Offset  Size  Field
+ 0      4     magic = 0xC511_0001 (LE u32)
+ 4      1     node_id (u8)            ← group multistatic nodes by this
+ 5      1     n_antennas (u8)
+ 6      1     n_subcarriers (u8)      ← 52/64 (HT20), 114 (HT40), 242 (HE20)
+ 7      1     reserved
+ 8      2     freq_mhz (LE u16)
+10      4     sequence (LE u32)
+14      1     rssi (i8)
+15      1     noise_floor (i8)
+16      4     reserved
+20      2·n_antennas·n_subcarriers   IQ pairs: i (i8), q (i8)
+```
+Parser reference: `wifi-densepose-cli/src/calibrate.rs::parse_csi_packet`. The appliance can reuse the
+ESP32 stream the vitals worker already receives, or tee it to the calibration UDP port.
+
+### 3.2 Baseline (ADR-135) — binary, magic `0xCA1B_0001`
+
+```
+Header (16 B LE): magic(4)=0xCA1B0001, version(1)=1, tier(1) {0=HT20,1=HT40,2=HE20,3=HE40},
+                  reserved(2), captured_at_unix_s(8, i64)
+Body:             frame_count(8,u64), num_subcarriers(4,u32),
+                  per subcarrier: amp_mean(f32), amp_variance(f32), phase_mean(f32), phase_dispersion(f32)
+```
+Produced by `calibrate` / `calibrate-serve`; `BaselineCalibration::{to_bytes,from_bytes}`. A baseline's
+UUID (`calibration_uuid()`) is the `baseline_id` referenced by enrollments and banks for STALE checks.
+
+### 3.3 Enrollment output — JSON (`enroll` → `train-room`)
+
+```jsonc
+{
+  "room_id": "living-room",
+  "baseline_id": "<uuid>",
+  "fs_hz": 15.0,
+  "anchors": [
+    { "room_id": "living-room", "label": "stand_still",
+      "features": { "mean": f32, "variance": f32, "motion": f32,
+                    "breathing_score": f32, "breathing_hz": f32,
+                    "heart_score": f32, "heart_hz": f32 } }
+  ],
+  "session": { "room_id": "...", "baseline_id": "...", "events": [ /* event-sourced audit log */ ] }
+}
+```
+Anchor labels (fixed sequence, **JSON wire = snake_case**, test-enforced): `empty, stand_still, sit, lie_down, breathe_slow, breathe_normal, small_move, sleep_posture`.
+
+### 3.4 Specialist bank — JSON (`train-room` → `room-watch` / runtime)
+
+```jsonc
+{
+  "room_id": "living-room",
+  "baseline_id": "<uuid>",            // drift vs current → STALE
+  "trained_at_unix_s": 0,
+  "anchor_count": 6,
+  "presence":     { "threshold": f32, "occupied_var": f32 } | null,
+  "posture":      { "prototypes": [ ["Standing", [f32;5]], ... ] } | null,
+  "breathing":    { "min_score": f32 },
+  "heartbeat":    { "min_score": f32 },
+  "restlessness": { "calm_motion": f32, "active_motion": f32 } | null,
+  "anomaly":      { "prototypes": [ [f32;5], ... ], "scale": f32 } | null
+}
+```
+`SpecialistBank::{to_json,from_json}`. A *partial* bank is valid (missing-anchor specialists are `null`).
+
+### 3.5 Runtime output — `RoomState` JSON (per window)
+
+```jsonc
+{
+  "presence":     { "kind":"Presence", "value":0|1, "confidence":f32, "label":"present|absent" } | null,
+  "posture":      { "kind":"Posture", "value":f32, "confidence":f32, "label":"standing|sitting|lying" } | null,
+  "breathing":    { "kind":"Breathing", "value": <BPM>, "confidence":f32, "label":null } | null,
+  "heartbeat":    { "kind":"Heartbeat", "value": <BPM>, "confidence":f32, "label":null } | null,
+  "restlessness": { "kind":"Restlessness", "value": 0.0..1.0, "confidence":f32 } | null,
+  "anomaly":      { "kind":"Anomaly", "value": 0.0..1.0, "confidence":f32, "label":"normal|anomalous" } | null,
+  "vetoed": bool,   // anomaly veto fired → vitals/posture suppressed
+  "stale":  bool    // bank trained against a different baseline
+}
+```
+
+---
+
+## 4. HTTP API — `calibrate-serve` (CORS-enabled; this is what a UI/appliance drives)
+
+| Method | Path | Body / returns |
+|--------|------|----------------|
+| GET | `/api/v1/calibration/health` | `{ udp_port, frames_seen, last_frame_age_ms, streaming, default_tier, output_dir, session_active }` |
+| POST | `/api/v1/calibration/start` | `{ tier?, duration_s?, room_id?, min_frames? }` → `202` session snapshot |
+| GET | `/api/v1/calibration/status` | live `{ state, frames_recorded, target_frames, progress, z_median, eta_s, ... }` |
+| POST | `/api/v1/calibration/stop` | finalize early → result summary |
+| GET | `/api/v1/calibration/result` | last finalized baseline summary |
+| GET | `/api/v1/calibration/baselines` | list persisted `.bin` baselines |
+| GET | `/api/v1/room/state?bank=<name>` | **live RoomState** (mixture-of-specialists over the CSI window; bank resolved as a sanitized name under `output_dir`) |
+| POST | `/api/v1/room/train` | `{ room_id, baseline_id, anchors[]? }` → train + persist a specialist bank as `<output_dir>/<room_id>.json` (anchors[] optional if enrolled via `/enroll/anchor`; read back via `/room/state?bank=<room_id>`) |
+| POST | `/api/v1/enroll/anchor` | `{ room_id, baseline, label, duration_s? }` → capture one guided anchor against a baseline (blocks for the capture); returns the gate verdict + progress |
+| GET | `/api/v1/enroll/status?room=<id>` | enrollment progress (accepted anchors, next, complete) |
+
+A single background task owns the UDP socket + recorder (handlers talk to it over an mpsc channel +
+shared status snapshot), so the API is non-blocking. **The full pipeline is now drivable over HTTP** — baseline (`start`/`stop`) → `enroll/anchor` (×8) → `room/train` → `room/state` — so the appliance UI needs no CLI. (The CLI `enroll`/`train-room`/`room-watch` remain for scripted/headless use.)
+
+---
+
+## 5. Public crate API (`wifi-densepose-calibration`)
+
+```rust
+// Stage 2 — enrollment
+anchor::{AnchorLabel, Anchor, AnchorQuality, EnrollmentEvent, EnrollmentSession, Posture}
+enrollment::{AnchorQualityGate, AnchorRecorder}
+// Stage 3 — features
+extract::{Features, AnchorFeature, autocorr_dominant}
+// Stage 4 — specialists + bank
+specialist::{Specialist, SpecialistKind, SpecialistReading,
+             PresenceSpecialist, PostureSpecialist, BreathingSpecialist,
+             HeartbeatSpecialist, RestlessnessSpecialist, AnomalySpecialist}
+bank::SpecialistBank
+// Stage 5 — runtime
+runtime::{MixtureOfSpecialists, RoomState}
+multistatic::MultiNodeMixture            // fuse co-located nodes (ADR-029)
+```
+Pure Rust; deps are `wifi-densepose-core` + `wifi-densepose-signal` (default-features off) + serde/uuid.
+**No GPU / no system BLAS** in the calibration path → builds cleanly on aarch64.
+
+---
+
+## 6. Appliance integration plan (`cognitum-one/v0-appliance`)
+
+Verified on `cognitum-v0`: aarch64, `cargo 1.96.0`, Hailo `HAILO10H`, `ruview-vitals-worker:50054`.
+
+**Step 1 — vendor / depend on the crate.** Add `wifi-densepose-calibration` (path or published crate)
+to the appliance workspace. It builds natively on aarch64 — no BLAS/GPU, **and no ONNX/OpenSSL**:
+the CLI's `mat`→`nn`→`ort`(ONNX)→`openssl-sys` chain is now feature-gated out of the calibration build.
+
+```bash
+# Pi/appliance calibration binary — cross-compiles clean (no ort/openssl):
+cargo build -p wifi-densepose-cli --no-default-features --release
+#   (omit `--no-default-features` only if you also need the MAT subcommands)
+```
+Verified: `cargo tree -p wifi-densepose-cli --no-default-features` shows **0** `ort`/`openssl-sys` deps;
+`cross test --target aarch64-unknown-linux-gnu` passes the calibration suite under qemu.
+
+**Step 2 — wire the CSI source.** Two options:
+  - (a) Tee the ESP32 UDP stream the vitals worker already receives into the calibration ingest, or
+  - (b) point ESP32 nodes (`edge_tier=0`) at the appliance's calibration UDP port directly.
+  Reuse `parse_csi_packet` (or the rvCSI `CsiFrame` schema if you normalise upstream).
+
+**Step 3 — run the calibration service.** Either embed the crate (call `CalibrationRecorder` /
+`MixtureOfSpecialists` in-process from a worker like `ruview-vitals-worker`), or run the
+`calibrate-serve` binary as a sidecar (systemd unit, bind `127.0.0.1` + reverse-proxy through the
+appliance gateway on `:9000`). Persist baselines/banks under the appliance data dir, keyed by `room_id`.
+
+**Step 4 — expose to the dashboard.** Surface the `/api/v1/calibration/*` endpoints (and add
+`enroll`/`train`/`room-state` endpoints — small additive work) behind the appliance's bearer-token
+auth + the existing `Seeds`/`Edge` nav. `RoomState` (§3.5) is the live readout payload.
+
+**Step 5 — (optional) Hailo backbone tier.** Compile the ADR-150 RF Foundation Encoder + neural pose
+head to Hailo HEF, serve via `ruvector-hailo-worker:50051`; the small specialists become heads over its
+embedding. This is the ADR-150 follow-on — *not required* for the calibration service to run.
+
+**Privacy / security:** keep baselines + banks local; if federating across appliances (ADR-105),
+exchange bank/model deltas, never raw CSI. Hardening already in place:
+- **`--token <T>`** (or `CALIBRATE_TOKEN` env) requires `Authorization: Bearer <T>` on every route; the
+  server warns loudly if bound to a non-loopback address without a token.
+- **`room_id` is sanitized** to `[A-Za-z0-9_-]` (≤64 chars) before it touches the baseline write path —
+  no `../` / absolute-path traversal.
+- CORS is permissive for dev — in production bind to loopback and reverse-proxy through the appliance
+  gateway (which already enforces bearer auth).
+
+---
+
+## 7. Status & validation
+
+- **Implemented:** all 5 stages + multistatic fusion; CLI + Stage-1 HTTP API (auth + path-traversal hardened). **55 tests** (35 calibration unit + 1 full-loop integration + 19 CLI), all passing under qemu-aarch64.
+
+**Precise validation matrix (don't overstate this — no clean full calibration has run on-target yet):**
+
+| Stage | Pi-5 (real nexmon→`0xC5110001`, 6,813 frames) | ESP32-S3 (COM8, `edge_tier=0`) | qemu / unit / integration |
+|---|---|---|---|
+| baseline capture + HTTP API + **auth gate** | ✅ | ✅ (120-frame) | full-loop ✅ |
+| **clean** empty-room baseline | ❌ `motion_flagged` (artifact) | ❌ (occupied) | full-loop ✅ (synthetic, zero motion flags) |
+| enroll → train-room | ❌ | ❌ (needs operator poses) | full-loop ✅ (8/8 anchors, 6 specialists, JSON round-trip) |
+| runtime infer | ❌ on-target | ◐ single-node breathing ~16–31 BPM via the **stateless** head (not a trained bank) + node-id fusion | full-loop ✅ (trained bank: 18±2 BPM positive, absent negative, foreign-baseline STALE) |
+
+The complete `baseline → enroll → train-room → infer` loop is now **proven in-process** on deterministic synthetic CSI (`wifi-densepose-calibration/tests/full_loop.rs` — drives the CLI's exact stage order through the public API, seed-robust across 5 seeds, runs with and without default features). Capture + API + auth are proven on real CSI (both boxes). What remains is strictly the **on-target** run: real CSI, a physically empty room for baseline, and an operator performing the 8 guided anchors — that hardware session is the last open item.
+
+- **Known follow-ups (appliance backlog):** `--source-format adr018v6` to drive calibration from the Pi's own nexmon (no ESP32/transcoder); the on-target clean-room enroll→train→infer session (above); phase-based (vs mean-amplitude) breathing carrier; RVF/HNSW persistence (currently JSON); enroll/train HTTP endpoints (live `/room/state` already added); ADR-150 Hailo backbone; true 2-node multistatic; ADR-105 federation.
+- **Behavioral findings from the full-loop test — all four FIXED pre-hardware-session:** (1) *z-band squeeze* — anchor motion is now measured from frame-to-frame deltas of the deviation series (`|Δz| > 0.5 ∨ |Δφ| > π/6`), not from the absolute `motion_flagged` (which conflated presence strength with motion); a strongly-reflecting still person (z = 3.0, every frame flagged by the old heuristic) now enrolls — regression-guarded in the full-loop test's `StandStill` anchor and `enrollment::tests`. (2) *Variance-only presence* — `PresenceSpecialist` gained a mean-shift channel (|mean − empty mean| vs a trained threshold); a motionless person is detected via the mean even at empty-level variance — regression-guarded in the full-loop motionless-person case; old persisted banks deserialize with the channel inert (variance-only behavior preserved). (3) *Ungated hz embedding* — `Features::embedding()` zeroes `breathing_hz`/`heart_hz` below `EMBED_MIN_SCORE` (0.25), keeping noise-window random frequencies out of the prototype space. (4) *Heart-band leakage* (found while fixing 3): a strong breathing rhythm's autocorrelation leaks into the HR band as a high-score lag-floor edge value (e.g. score 0.67 at 3.33 Hz from a pure 0.30 Hz breath); `autocorr_dominant` now requires the winning lag to be an interior local maximum, rejecting band-edge leakage while preserving true in-band peaks.
+
+**Reference:** ADR-151 (`docs/adr/ADR-151-room-calibration-specialist-training.md`), ADR-135 (baseline),
+ADR-029 (multistatic), ADR-150 (RF Foundation Encoder), ADR-105 (federation), ADR-147 (OccWorld/Hailo).

docs/readme-details.md

@@ -50,7 +50,7 @@ See [PR #405](https://github.com/ruvnet/RuView/pull/405) for full details.
 ### What's New in v0.7.0
 
 <details>
-<summary><strong>Camera Ground-Truth Training — 92.9% PCK@20</strong></summary>
+<summary><strong>Camera Ground-Truth Training</strong></summary>
 
 **v0.7.0 adds camera-supervised pose training** using MediaPipe + real ESP32 CSI data:
 
@@ -76,15 +76,20 @@ node scripts/train-wiflow-supervised.js --data data/paired/*.jsonl --scale lite
 node scripts/eval-wiflow.js --model models/wiflow-real/wiflow-v1.json --data data/paired/*.jsonl
 ```
 
-**Result: 92.9% PCK@20** from a 5-minute data collection session with one ESP32-S3 and one webcam.
+> **Accuracy retraction (2026-06-10):** the "92.9% PCK@20" figure previously
+> shown here is retracted. A forensic recheck of the surviving eval holdout
+> (69 samples) found a constant-output model scored with an absolute
+> (non-torso-normalized) threshold on nearly-static frames — a protocol under
+> which a trivial mean-pose predictor scores 100%. Torso-normalized PCK@20 on
+> the same holdout is ~19% (from that degenerate predictor). No measured
+> camera-supervised PCK@20 is currently published (CHANGELOG, PR #535).
 
-| Metric | Before (proxy) | After (camera-supervised) |
-|--------|----------------|--------------------------|
-| PCK@20 | 0% | **92.9%** |
-| Eval loss | 0.700 | **0.082** |
-| Bone constraint | N/A | **0.008** |
-| Training time | N/A | **19 minutes** |
-| Model size | N/A | **974 KB** |
+| Metric | Camera-supervised run (protocol retracted) |
+|--------|--------------------------------------------|
+| Eval loss | 0.082 |
+| Bone constraint | 0.008 |
+| Training time | 19 minutes |
+| Model size | 974 KB |
 
 Pre-trained model: [HuggingFace ruv/ruview/wiflow-v1](https://huggingface.co/ruv/ruview)
 
@@ -868,7 +873,7 @@ Download a pre-built binary — no build toolchain needed:
 
 | Release | What's included | Tag |
 |---------|-----------------|-----|
-| [v0.7.0](https://github.com/ruvnet/RuView/releases/tag/v0.7.0) | **Latest** — Camera-supervised WiFlow model (92.9% PCK@20), ground-truth training pipeline, ruvector optimizations | `v0.7.0` |
+| [v0.7.0](https://github.com/ruvnet/RuView/releases/tag/v0.7.0) | **Latest** — Camera-supervised WiFlow model (accuracy figure retracted 2026-06-10, see above), ground-truth training pipeline, ruvector optimizations | `v0.7.0` |
 | [v0.6.0](https://github.com/ruvnet/RuView/releases/tag/v0.6.0-esp32) | [Pre-trained models on HuggingFace](https://huggingface.co/ruv/ruview), 17 sensing apps, 51.6% contrastive improvement, 0.008ms inference | `v0.6.0-esp32` |
 | [v0.5.5](https://github.com/ruvnet/RuView/releases/tag/v0.5.5-esp32) | SNN + MinCut (#348 fix) + CNN spectrogram + WiFlow + multi-freq mesh + graph transformer | `v0.5.5-esp32` |
 | [v0.5.4](https://github.com/ruvnet/RuView/releases/tag/v0.5.4-esp32) | Cognitum Seed integration ([ADR-069](docs/adr/ADR-069-cognitum-seed-csi-pipeline.md)), 8-dim feature vectors, RVF store, witness chain, security hardening | `v0.5.4-esp32` |

docs/research/ruview-beyond-sota/GAMMA-GIST.md

@@ -1,298 +0,0 @@
-<!--
-  Publication-ready GitHub Gist. Publish as a SECRET gist with your own token:
-
-    gh gist create --desc "RuView Gamma — adaptive sensory neuromodulation" \
-      docs/research/ruview-beyond-sota/GAMMA-GIST.md
-    # (omit --public for a secret/unlisted gist; gh uses your stored PAT/token)
-
-  Or with curl + a fine-grained PAT that has the "gists" scope:
-    curl -H "Authorization: Bearer $GH_TOKEN" \
-      -X POST https://api.github.com/gists \
-      -d '{"public":false,"files":{"ruview-gamma.md":{"content":"...">}}}'
-
-  Do NOT paste the token into this file or any committed file.
-  SEO meta description (use as the gist description):
-  "RuView Gamma: an open, governed engine for adaptive 40 Hz light-and-sound
-   neuromodulation — personalized entrainment with proof discipline, built on
-   RuView WiFi sensing and RuVector learning. Research platform, not a medical
-   device."
--->
-
-# RuView Gamma — Adaptive Sensory Neuromodulation, Done Honestly
-
-> **TL;DR** — RuView Gamma is the open-source **control brain** for an adaptive
-> light-and-sound (40 Hz "gamma") neuromodulation device. It personalizes the
-> stimulation to each person, watches the body as feedback, learns what works,
-> and **refuses to advertise any benefit it hasn't measured**. The most valuable
-> thing here is not 40 Hz — it is a governed personalization engine that won't
-> overpromise.
->
-> **Not a medical device. Not medical advice.** It is a research and engineering
-> platform. It makes no Alzheimer's, disease, or treatment claims.
-
-**Keywords:** gamma entrainment, 40 Hz stimulation, GENUS, sensory
-neuromodulation, WiFi sensing, adaptive personalization, Bayesian optimization,
-Rust, ESP32, digital therapeutics infrastructure, RuView, RuVector.
-
-**Projects:** [RuView](https://github.com/ruvnet/ruview) ·
-RuVector (vector learning / response modeling) ·
-Branch: `claude/ruview-beyond-sota-xgv8aq` ·
-Crate: `v2/crates/ruview-gamma` · Firmware: `firmware/esp32-gamma-stim` ·
-Decision record: `docs/adr/ADR-250-adaptive-gamma-entrainment.md`.
-
----
-
-## 1. The easy introduction
-
-Research from MIT and others (the "GENUS" line of work) found that sitting in
-front of a light flickering ~40 times per second, with a matching pulsing
-sound, can drive a brain rhythm called **gamma** — studied for Alzheimer's,
-post-stroke recovery, sleep, focus, and mood.
-
-Today's devices play a **fixed 40 Hz to everyone**. But brains differ: your best
-frequency might be 38.5, 41.2, or somewhere else, and it changes with how calm,
-tired, or restless you are. There's no off-the-shelf software that personalizes
-this **safely and provably**.
-
-RuView Gamma is that software. Four parts work together:
-
-| Part | Role | Plain-English job |
-|------|------|-------------------|
-| **The device** | Actuator | Plays the light + sound |
-| **RuView** | Sensing | Reads the body as feedback (breathing, stillness, restlessness) over WiFi — no camera, no wearable |
-| **RuVector** | Learning | Builds a personal "response map" across sessions |
-| **RuFlo** | Governance | Safety stops, tamper-evident audit log, and the claim boundary |
-
-The thesis in one line: **RuView turns the body into the feedback signal,
-RuVector turns repeated sessions into a personal response map, the device is the
-actuator, and RuFlo makes the whole loop governed, measurable, and auditable.**
-
----
-
-## 2. How it works
-
-```
-enroll (consent + epilepsy/photosensitivity screen)
-  → start from 40 Hz prior
-  → play a short calibration sweep (36–44 Hz)
-  → RuView reads body state each session
-  → score "safe entrainment" (not raw gamma)
-  → RuVector updates the personal response map
-  → Bayesian optimizer recommends the next best safe setting
-  → every session is witness-hashed into a tamper-evident log
-```
-
-Key design choices that make it trustworthy:
-
-- **40 Hz is a starting guess, not the answer.** A Gaussian-process optimizer
-  searches the safe 36–44 Hz band for *your* peak — and proves it can recover a
-  known peak within ±1 Hz in tests.
-- **Safety is a hard gate, not a weighted preference.** A latched safety monitor
-  stops on adverse symptoms, a stop request, or low sensor confidence — in about
-  **9 nanoseconds** per check — and once it fires, the session **cannot silently
-  resume**.
-- **A compiled-in safety envelope** (36–44 Hz, capped brightness/volume/
-  duration) bounds everything. The optimizer can never widen it.
-- **Cross-person warm-start without identity.** A new user can be seeded from
-  anonymized, one-way-hashed profiles of similar responders — but borrowed
-  expectations are **down-weighted** and never counted as your measured data.
-- **Tamper-evident proof.** Every session produces a SHA-256 witness over
-  exactly what was played and sensed. Re-running the same inputs reproduces the
-  identical hash — a regulator, clinician, or trial auditor can verify nothing
-  was fudged. The pinned reference witness is `13cb164c…`.
-
-### The hard claim gate (the important part)
-
-A program may surface a benefit claim **only** if all four pass:
-
-```
-claim_allowed = entrainment_pass AND safety_pass
-             AND adherence_pass  AND repeatability_pass
-```
-
-Anything less returns `research use only — no claim`. The marketing claim is
-literally unreadable in the code except through this gate.
-
-### It's a platform, not one gadget
-
-Seven programs ship, each with its own safety envelope, objective, state-gating,
-evidence level, and a single non-disease claim:
-
-| Program | Evidence | What it tunes for |
-|---------|----------|-------------------|
-| Alzheimer's research | medium preclinical / early human | entrainment + trial monitoring |
-| Post-stroke cognition | early human | gentle, recovery-state tracking |
-| Sleep optimization | early/plausible | audio-only, near-dark, timed to sleep state |
-| Attention / working memory | mixed | personal frequency discovery |
-| Mood / arousal | early human | calming response, avoid overstimulation |
-| Home wellness | speculative | safe personalization, no treatment claim |
-| Drug + device trial infra | strong (as infrastructure) | governed, reproducible measurement |
-
----
-
-## 3. Research supporting it (and its honest limits)
-
-- **Preclinical (strongest):** a 2024 *Nature* paper showed 40 Hz multisensory
-  stimulation promoted cerebrospinal-fluid influx and amyloid clearance via the
-  glymphatic system in Alzheimer's-model mice; blocking that clearance abolished
-  the effect.
-- **Early human:** a 2022 study found 40 Hz sensory stimulation feasible and
-  well-tolerated in mild Alzheimer's, with exploratory signals on structure,
-  connectivity, sleep, and memory. A small 2025 two-year pilot reported safety
-  and feasibility, but the sample was tiny and not definitive.
-- **Frequency is not one-size-fits-all:** a 2025 *PLOS One* study re-evaluated
-  gamma frequency across 36–44 Hz — direct motivation for *measuring* the
-  individual's frequency rather than assuming 40 Hz.
-- **Adjacent areas (early/mixed):** post-stroke cognition, sleep (40 Hz evoked
-  without degrading sleep), attention/working-memory (mixed, protocol-dependent),
-  and mood/arousal.
-
-**Honest limits, encoded as non-goals:** RF sensing does not measure amyloid;
-personalized frequency improving clinical outcomes is unproven; consumer use
-without screening is not safe; 40 Hz is not always optimal. The software makes
-none of these claims.
-
----
-
-## 4. How to use it
-
-### Run the governed engine (Rust)
-
-```bash
-git clone https://github.com/ruvnet/ruview
-cd ruview && git checkout claude/ruview-beyond-sota-xgv8aq
-cd v2
-cargo test -p ruview-gamma --no-default-features      # 97 tests + 1 doctest
-cargo bench -p ruview-gamma --no-default-features      # criterion micro-benchmarks
-```
-
-```rust
-use ruview_gamma::{
-    ruflo::{Consent, RufloGovernor},
-    program::NeuroProgram,
-    response::RuViewState,
-    simulator::{LatentPerson, ResponseSimulator},
-    stimulus::StimulusParameters,
-};
-
-let mut gov = RufloGovernor::enroll_program(
-    "subject-001", NeuroProgram::sleep_optimization(), &[], Consent::Granted,
-).expect("cleared to participate");
-
-let sim = ResponseSimulator::new(42);          // deterministic stand-in for hardware
-let latent = LatentPerson::from_id("subject-001");
-let state = RuViewState::calm_baseline();
-gov.run_calibration(&sim, &latent, &state, 5.0, 0).unwrap();
-
-let rec = gov.recommend(&gov.prior());          // always inside the safety envelope
-```
-
-### Run the device (ESP32)
-
-```bash
-cd firmware/esp32-gamma-stim
-# Host-side safety-core tests — no hardware, no ESP-IDF:
-gcc -Wall -Wextra -Werror -O2 -I main tests/test_stim_core.c main/stim_core.c -o /tmp/t && /tmp/t
-# On hardware (ESP-IDF v5.2+):
-idf.py set-target esp32s3 && idf.py build flash monitor
-```
-
-Serial protocol (frequency in millihertz, so 40.0 Hz = `40000`):
-
-```
-START 40000 30 28 600   # 40 Hz, 30% brightness, 28% volume, 10 min
-STOP | STATUS | UNLOCK | VERSION
-```
-
-### Benchmarks (indicative)
-
-| Path | Time | Role |
-|------|------|------|
-| Safety tick | ~8 ns | real-time stop path |
-| Recommendation | ~15 µs | per-session decision |
-| Cohort kNN (500 profiles) | ~15 µs | warm-start matching |
-| Calibration sweep | ~115 µs | setup/tuning |
-| Full acceptance grading | ~425 µs | enrollment only |
-
----
-
-## 5. Cautions (read these)
-
-- ⚠️ **Flicker can trigger seizures.** Epilepsy and photosensitivity are **hard
-  exclusions** in software; a hardware e-stop is mandatory for any human-facing
-  run. Migraine/psychiatric instability/implanted neuro devices require
-  clinical supervision.
-- ⚠️ **Not a treatment.** No Alzheimer's/disease/efficacy claim. The only
-  product claim is "personalized entrainment optimization," and even that is
-  gated behind measured entrainment + safety + adherence + repeatability.
-- ⚠️ **No hardware actuation in the core crate.** The Rust crate is a validated
-  decision/safety/learning/audit engine tested against a simulator; the ESP32
-  firmware is the actuator. Real EEG validation is a separate, deferred step.
-- ⚠️ **Optical safety is the integrator's job.** The firmware caps PWM duty, but
-  absolute luminance/eye-safety belongs to the LED driver and optical design.
-- ⚠️ **Research/IRB context required** for any study with human subjects,
-  especially clinical populations.
-
----
-
-## 6. Advanced usages
-
-- **Drug + device trials (strongest near-term use):** use RuFlo as the governed
-  measurement layer — consent, inclusion/exclusion, **sham/blinding**, per-session
-  witness hashes, and clinician export — to make *someone else's* therapy trial
-  auditable and reproducible. The value is the instrument, not a therapy claim.
-- **Sham-controlled studies:** `TrialMode::Sham` logs the participant-facing
-  protocol while delivering no entrainment, for blinded arms.
-- **Cohort transfer learning:** export anonymized response profiles and
-  warm-start new participants via RuVector kNN — privacy-preserving, one-way
-  hashed, never identity-bearing.
-- **Drift-triggered recalibration:** a Welford-centroid drift detector flags when
-  a person's physiology has shifted enough to warrant re-running calibration.
-- **Hardware-in-the-loop acceptance:** capture LED frequency, A/V sync, and stop
-  latency on the bench and grade them with `hil::verify_hil` against fixed
-  targets (±0.1 Hz, <5 ms, <100 ms, 100% hash reproducibility, ≥20% EEG lift).
-- **Edge deployment:** the engine is dependency-light and deterministic; an HNSW
-  (RuVector) backend drops in for cohort search past ~10⁵ profiles.
-
----
-
-## 7. Credits
-
-- **RuView** — WiFi/RF human sensing platform that supplies the passive body
-  feedback signal. https://github.com/ruvnet/ruview
-- **RuVector** — vector learning / response-curve modeling (cohort warm-start,
-  drift detection, clustering; HNSW-ready).
-- **RuFlo** — governance, audit, consent, and protocol execution layer.
-- Built by the RuView contributors on branch
-  `claude/ruview-beyond-sota-xgv8aq`. Decision record: ADR-250.
-- Scientific inspiration: the GENUS / 40 Hz gamma-entrainment research community
-  (MIT Tsai/Boyden labs and others). This project implements *engineering and
-  governance*, not their clinical findings.
-
----
-
-## 8. FAQ (SEO)
-
-**What is gamma entrainment?** Driving ~40 Hz brain rhythms with rhythmic light
-and/or sound. RuView Gamma personalizes the exact frequency per person.
-
-**Is RuView Gamma a medical device?** No. It is an open research and engineering
-platform that makes no treatment or disease claims.
-
-**Does it cure or treat Alzheimer's?** No. It optimizes and audits stimulation
-protocols; clinical outcomes are explicitly out of scope.
-
-**Can I run it on an ESP32?** Yes — `firmware/esp32-gamma-stim` drives the LED +
-audio flicker with a hardware emergency stop and a compiled-in safety envelope.
-
-**Why is it "honest"?** A program's benefit claim is unreadable in code until it
-passes measured entrainment, safety, adherence, and repeatability.
-
-**License / source:** see the RuView repository, branch
-`claude/ruview-beyond-sota-xgv8aq`.
-
----
-
-*RuView Gamma — personalized neural-rhythm optimization with tamper-evident
-proof. Not a medical claim. Not a consumer miracle device. A tested, safety-first
-engine ready for hardware, EEG validation, and serious clinical research.*

docs/research/soul/specification.md

@@ -411,6 +411,23 @@ include a conformance layer if regulatory certification is sought.
 
 ### 3.6 Matching Algorithm
 
+> **Implementation status (§3.6 only):** The matching algorithm described below
+> is **implemented and tested** in
+> `v2/crates/wifi-densepose-bfld/src/soul_match.rs` (+ `soul_channels.rs`),
+> with tests in `v2/crates/wifi-densepose-bfld/tests/soul_match.rs`. The
+> implementation is the **first running** version of this formula in the repo:
+> it computes calibrated per-channel scores and exposes a real
+> `SoulMatchOracle` (`EnrolledMatcher`). **Caveats that remain true:** the
+> weights below are unvalidated design intent; named-identity locking is
+> **data-gated** — it requires the decisive high-weight channels (a real AETHER
+> enrollment embedding + body-resonance) to be fed real measured data, which has
+> NOT been done. Measured on synthetic data, the cardiac (0.15) + respiratory
+> (0.10) channels **alone** produce a same-vs-cross-person score gap of ~0.0005
+> (test `cardiac_alone_cannot_separate_identity_matches_audit`) — i.e. identity
+> is NOT separable on those channels, exactly as expected. This status note
+> applies to §3.6 ONLY; the broader Soul Signature system remains
+> Pre-Implementation.
+
 Given a stored profile `P` and a query embedding `Q` derived from a live sensing
 window, the match score is computed as a weighted sum of per-channel cosine
 similarities:

docs/research/wiflow-std-audit-gist.md

@@ -0,0 +1,99 @@
+# We audited a state-of-the-art WiFi pose model. Here's what broke, what reproduced, and the 30× smaller model that nearly matches it.
+
+*RuView team, June 2026. All numbers measured; full scripts and forensics in the
+[RuView repo](https://github.com/ruvnet/RuView/tree/main/benchmarks/wiflow-std).*
+
+## The setup
+
+WiFi sensing is having a moment: a 2026 preprint ("WiFlow", arXiv 2602.08661)
+claims **97.25% pose-estimation accuracy (PCK@20) from WiFi signals alone**,
+with a tiny 2.23M-parameter model — and unlike most papers, it ships
+everything: code, trained weights, and a 360,000-sample dataset.
+
+We build WiFi sensing systems, so before adopting any external number we run
+it through a simple rule: **a claim is "CLAIMED" until we reproduce it, then
+it's "MEASURED."** Here's what happened when we tried.
+
+## Day 1: nothing works
+
+- **The code doesn't run.** The package imports a class that doesn't exist.
+  (One-line fix.)
+- **The released model scores 0.08%, not 97.25%.** The shipped checkpoint was
+  trained under a different data normalization than the shipped dataset —
+  it's a real trained model, just not *this* pipeline's model. Even letting it
+  cheat with a fitted per-keypoint correction only reaches 72%.
+- **The dataset is corrupted.** Its last 13 files contain garbage values up to
+  3.4×10³⁸ (float32's maximum). Subtle consequence: the training loop uses
+  fp16 mixed precision with no guards, so the first corrupted batch overflows
+  and **permanently poisons the model's BatchNorm statistics**. Training from
+  the public download produces NaN from epoch 1, every time.
+- The training script also crashes before its own test phase ever runs
+  (calls an undefined function), and ignores its `--data_dir` flag.
+
+At this point a less patient reader concludes "fraud." That would be wrong.
+
+## Day 1, later: actually, the science is real
+
+We repaired the artifacts — fixed the import, zeroed the 9,072 corrupted
+windows, retrained from scratch with the authors' own code and
+hyperparameters on one GPU (~50 minutes):
+
+| Metric | Published | Our retrain |
+|---|---|---|
+| PCK@20 | 97.25% | **96.1–96.6%** |
+| PCK@50 | 99.48% | 99.0–99.1% |
+| Params | 2.23M | 2,225,042 (exact) |
+
+**The claims reproduce.** What didn't survive contact was the *packaging*:
+wrong checkpoint, corrupted upload, broken glue code. This distinction —
+**artifact rot vs. bad science** — is the single most useful thing a
+reproduction can establish, and you can't establish it without actually
+running the thing.
+
+(We filed all six defects upstream with fixes:
+[issue #3](https://github.com/DY2434/WiFlow-WiFi-Pose-Estimation-with-Spatio-Temporal-Decoupling/issues/3).
+And to be clear: the authors released more than 90% of papers do. That's the
+only reason this audit was possible.)
+
+## Day 2: the model is also 2.6× too big
+
+Once we could train, we asked: does the architecture need 2.23M parameters?
+
+| Variant | Params | Accuracy (PCK@20) | Size on disk |
+|---|---|---|---|
+| Original | 2,225,042 | 96.61% | 8.97 MB |
+| **Half** | **843,834** | **96.62%** ✨ | — |
+| Quarter | 338,600 | 96.05% | — |
+| **Tiny** | **56,290** | **94.11%** | **295 KB** |
+
+The half-width model **matches the original exactly** (and converges faster).
+The tiny one — 1/39th the parameters — gives up 2.5 points and runs at
+**0.66 ms per inference on a laptop CPU** (~1,500 poses/second) as a 295 KB
+ONNX file. For edge devices, that's the interesting end of the curve.
+
+Quantization footnote: the paper's "~2.2 MB int8" estimate is reachable
+(we measured 2.44–2.53 MB) but only via conv-capable toolchains — PyTorch's
+one-line dynamic quantization converts *literally nothing* on this model
+(it has no Linear layers), a trap worth knowing about.
+
+## What we took away
+
+1. **Run the artifact, not the README.** Every number in a paper is one
+   `git clone` away from being either confirmed or understood. Both outcomes
+   are valuable; only one is publishable by the original authors.
+2. **fp16 + unvalidated data = silent model death.** Mixed-precision training
+   with no NaN/inf guards doesn't fail loudly — it corrupts BatchNorm buffers
+   and ships a broken model with a green progress bar. Validate inputs, or
+   train in fp32, or guard the autocast.
+3. **Evidence-grade your own claims too.** Mid-audit, the same forensics
+   tooling caught one of *our own* published accuracy numbers resting on a
+   degenerate evaluation (a constant-output model scored with a flawed
+   metric). We retracted it the same day. The rule has to cut both ways or
+   it's marketing, not measurement.
+4. **Over-parameterization hides in SOTA tables.** Nobody publishes the
+   half-size ablation that matches their headline model. Run it yourself;
+   it's an hour of GPU time and sometimes it *is* the result.
+
+*Reproduction scripts, corruption masks, the efficiency-sweep configs, and a
+numerically parity-proven Rust port (max divergence 1.2e-7) are all in
+[`benchmarks/wiflow-std/`](https://github.com/ruvnet/RuView/tree/main/benchmarks/wiflow-std).*

docs/user-guide.md

@@ -1747,7 +1747,14 @@ See [ADR-071](adr/ADR-071-ruvllm-training-pipeline.md) and the [pretraining tuto
 
 For significantly higher accuracy, use a webcam as a **temporary teacher** during training. The camera captures real 17-keypoint poses via MediaPipe, paired with simultaneous ESP32 CSI data. After training, the camera is no longer needed — the model runs on CSI only.
 
-**Result: 92.9% PCK@20** from a 5-minute collection session.
+> **Accuracy note (2026-06-10):** the previously cited "92.9% PCK@20" figure is
+> retracted — a forensic recheck of the surviving eval holdout showed it came
+> from a constant-output model scored with an absolute (non-torso-normalized)
+> threshold on 69 nearly-static frames, a protocol under which a trivial
+> mean-pose predictor scores 100%. No measured camera-supervised PCK@20 is
+> currently published (see CHANGELOG, PR #535). Treat this workflow as a data
+> collection mechanism; accuracy claims will follow a ≥35-minute multi-pose
+> collection session evaluated with torso-normalized PCK.
 
 ### Requirements
 
@@ -1755,50 +1762,103 @@ For significantly higher accuracy, use a webcam as a **temporary teacher** durin
 - ESP32-S3 node streaming CSI over UDP (port 5005)
 - A webcam (laptop, USB, or Mac camera via Tailscale)
 
-### Step 1: Capture Camera + CSI Simultaneously
+### Step 0: Check your CSI rate and plan the session length
+
+Window yield is `csi_frames / 20` — **your CSI packet rate sets how long you
+must record.** Check it first (10-second probe):
+
+```bash
+python - <<'EOF'
+import socket, time
+s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); s.bind(('0.0.0.0', 5005)); s.settimeout(2)
+n, t0 = 0, time.time()
+while time.time() - t0 < 10:
+    try: s.recvfrom(4096); n += 1
+    except socket.timeout: pass
+print(f"{n/10:.1f} Hz -> {n/10*60/20:.0f} windows/min")
+EOF
+```
+
+| CSI rate | Windows/min | Minutes for 2,000 windows (minimum trainable) |
+|---|---|---|
+| ~13 Hz (idle network) | ~39 | ~52 min |
+| ~53 Hz (active self-ping, #985 firmware) | ~160 | ~13 min — record 35–40 min anyway for pose variety |
+
+A 5-minute session is **not enough to train on** — it produces a few hundred
+windows of one pose context, and models trained on it memorize rather than
+generalize (this is what invalidated the earlier accuracy figure).
+
+### Step 1: (Recommended) calibrate camera ↔ room
+
+The two-checkerboard calibration (ADR-152 §2.1.3) puts labels in a shared 3D
+room frame instead of raw camera coordinates, which is the published defense
+against layout-brittle "coordinate overfitting" (PerceptAlign, MobiCom'26):
+
+```bash
+python scripts/calibrate-camera-room.py   # < 5 min, two checkerboards + a few photos
+```
+
+Without it, collection still works but labels are camera-frame only and the
+trained model will not survive camera/node relocation.
+
+### Step 2: Capture Camera + CSI Simultaneously
 
 Run both scripts at the same time (in separate terminals):
 
 ```bash
-# Terminal 1: Record ESP32 CSI
-python scripts/record-csi-udp.py --duration 300
+# Terminal 1: Record ESP32 CSI (2400 s = 40 min)
+python scripts/record-csi-udp.py --duration 2400
 
 # Terminal 2: Capture camera keypoints
-python scripts/collect-ground-truth.py --duration 300 --preview
+python scripts/collect-ground-truth.py --duration 2400 --preview \
+  --calibration data/calibration/camera-room.json   # omit if you skipped Step 1
 ```
 
-Move around naturally in front of the camera for 5 minutes. The `--preview` flag shows a live skeleton overlay.
+During capture: keep your **full body in frame** with good lighting (MediaPipe
+confidence must stay above 0.5 — low-confidence frames are dropped at
+alignment), and **change activity every 1–2 minutes**: walk, raise hands,
+squat, hands up, kick, wave, turn, jump, sit, stand still. Pose variety is
+what the model learns from; 40 minutes of sitting produces a constant-pose
+predictor.
 
-### Step 2: Align and Train
+### Step 3: Align and Train
 
 ```bash
-# Align camera keypoints with CSI windows
+# Align camera keypoints with CSI windows (prints kept/dropped window counts —
+# expect roughly csi_frames/20 kept; investigate if far below)
 node scripts/align-ground-truth.js \
   --gt data/ground-truth/*.jsonl \
   --csi data/recordings/csi-*.csi.jsonl
 
-# Train (start with lite, scale up as you collect more data)
+# Train (pick the preset matching your window count)
 node scripts/train-wiflow-supervised.js \
   --data data/paired/*.jsonl \
-  --scale lite \
+  --scale small \
   --epochs 50
 
-# Evaluate
+# Evaluate — torso-normalized PCK on a TEMPORAL split
 node scripts/eval-wiflow.js \
   --model models/wiflow-supervised/wiflow-v1.json \
   --data data/paired/*.jsonl
 ```
 
+**Evaluation protocol matters.** Use `eval-wiflow.js` (torso-normalized
+PCK@20, the metric comparable to published WiFi-pose results) on a temporal
+hold-out, and sanity-check that predictions actually vary across frames
+(`pred std > 0`) — a constant-pose model can score deceptively well on
+near-static data under weaker protocols. See
+`benchmarks/wiflow-std/RESULTS.md` for the forensic case study.
+
 ### Scale Presets
 
 | Preset | Params | Training Time | Best For |
 |--------|--------|---------------|----------|
-| `--scale lite` | 189K | ~19 min | < 1,000 samples (5 min capture) |
-| `--scale small` | 474K | ~1 hr | 1K-10K samples |
-| `--scale medium` | 800K | ~2 hrs | 10K-50K samples |
-| `--scale full` | 7.7M | ~8 hrs | 50K+ samples (GPU recommended) |
+| `--scale lite` | 189K | ~19 min | sanity runs only (< 2K windows trains poorly) |
+| `--scale small` | 474K | ~1 hr | 2K-10K windows (one 40-min session) |
+| `--scale medium` | 800K | ~2 hrs | 10K-50K windows (multiple sessions/rooms) |
+| `--scale full` | 7.7M | ~8 hrs | 50K+ windows (GPU recommended) |
 
-See [ADR-079](adr/ADR-079-camera-ground-truth-training.md) for the full design and optimization details.
+See [ADR-079](adr/ADR-079-camera-ground-truth-training.md) for the full design and optimization details, and ADR-152 §2.2 for the external WiFlow-STD benchmark these numbers should be read against.
 
 ---
 

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

@@ -151,9 +151,13 @@ static void on_recv(const uint8_t *src_mac, const uint8_t *data, int len)
  *   void (*)(const esp_now_send_info_t *tx_info, esp_now_send_status_t status)
  * Both signatures ignore the address-side argument here — we only inspect
  * `status` to bump the TX-fail counter — so the body is identical; only the
- * function-pointer type differs. ESP_IDF_VERSION_MAJOR is the canonical guard.
+ * function-pointer type differs.
+ *
+ * Issue #1005: Espressif backported the new signature to v5.5
+ * (`esp_now_send_info_t` = typedef of `wifi_tx_info_t` there), so the guard
+ * must be the full version triple, not ESP_IDF_VERSION_MAJOR.
  */
-#if ESP_IDF_VERSION_MAJOR >= 6
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
 static void on_send(const esp_now_send_info_t *tx_info, esp_now_send_status_t status)
 {
     (void)tx_info;

firmware/esp32-csi-node/test/stubs/esp_netif.h

@@ -0,0 +1,48 @@
+/* Host-fuzzing stub for esp_netif.h (ADR-061).
+ *
+ * csi_collector.c's #954 self-ping needs the STA netif handle + gateway IP.
+ * In the fuzz environment there is no network stack: the handle lookup
+ * returns NULL, so csi_start_self_ping() takes its no-gateway early-out and
+ * the esp_ping path is never exercised (but must compile and link).
+ */
+#pragma once
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "esp_err.h"
+
+typedef struct esp_netif_obj esp_netif_t;
+
+typedef struct {
+    uint32_t addr;
+} esp_ip4_addr_t;
+
+typedef struct {
+    esp_ip4_addr_t ip;
+    esp_ip4_addr_t netmask;
+    esp_ip4_addr_t gw;
+} esp_netif_ip_info_t;
+
+static inline esp_netif_t *esp_netif_get_handle_from_ifkey(const char *if_key)
+{
+    (void)if_key;
+    return NULL; /* no netif in fuzz env -> self-ping early-out */
+}
+
+static inline esp_err_t esp_netif_get_ip_info(esp_netif_t *netif, esp_netif_ip_info_t *ip_info)
+{
+    (void)netif;
+    (void)ip_info;
+    return ESP_FAIL;
+}
+
+static inline char *esp_ip4addr_ntoa(const esp_ip4_addr_t *addr, char *buf, int buflen)
+{
+    if (buf != NULL && buflen > 0) {
+        snprintf(buf, (size_t)buflen, "%u.%u.%u.%u",
+                 (unsigned)(addr->addr & 0xff), (unsigned)((addr->addr >> 8) & 0xff),
+                 (unsigned)((addr->addr >> 16) & 0xff), (unsigned)((addr->addr >> 24) & 0xff));
+    }
+    return buf;
+}

firmware/esp32-csi-node/test/stubs/lwip/ip_addr.h

@@ -0,0 +1,20 @@
+/* Host-fuzzing stub for lwip/ip_addr.h (ADR-061). Minimal surface for the
+ * #954 self-ping block; never functionally exercised in the fuzz env. */
+#pragma once
+
+#include <stdint.h>
+
+typedef struct {
+    uint32_t addr;
+    uint8_t type;
+} ip_addr_t;
+
+static inline int ipaddr_aton(const char *cp, ip_addr_t *addr)
+{
+    (void)cp;
+    if (addr != NULL) {
+        addr->addr = 0;
+        addr->type = 0;
+    }
+    return 1;
+}

firmware/esp32-csi-node/test/stubs/ping/ping_sock.h

@@ -0,0 +1,79 @@
+/* Host-fuzzing stub for ping/ping_sock.h (ADR-061). The #954 self-ping is
+ * unreachable in the fuzz env (esp_netif stub returns no gateway), but the
+ * symbols must compile and link. */
+#pragma once
+
+#include <stdint.h>
+
+#include "esp_err.h"
+#include "lwip/ip_addr.h"
+
+typedef void *esp_ping_handle_t;
+
+typedef void (*esp_ping_cb_t)(esp_ping_handle_t hdl, void *args);
+
+typedef struct {
+    uint32_t count;
+    uint32_t interval_ms;
+    uint32_t timeout_ms;
+    uint32_t data_size;
+    uint8_t tos;
+    int ttl;
+    ip_addr_t target_addr;
+    uint32_t task_stack_size;
+    uint32_t task_prio;
+    uint32_t interface;
+} esp_ping_config_t;
+
+#define ESP_PING_COUNT_INFINITE (0)
+
+#define ESP_PING_DEFAULT_CONFIG()       \
+    {                                   \
+        .count = 5,                     \
+        .interval_ms = 1000,            \
+        .timeout_ms = 1000,             \
+        .data_size = 64,                \
+        .tos = 0,                       \
+        .ttl = 64,                      \
+        .target_addr = {0, 0},          \
+        .task_stack_size = 2048,        \
+        .task_prio = 2,                 \
+        .interface = 0,                 \
+    }
+
+typedef struct {
+    void *cb_args;
+    esp_ping_cb_t on_ping_success;
+    esp_ping_cb_t on_ping_timeout;
+    esp_ping_cb_t on_ping_end;
+} esp_ping_callbacks_t;
+
+static inline esp_err_t esp_ping_new_session(const esp_ping_config_t *config,
+                                             const esp_ping_callbacks_t *cbs,
+                                             esp_ping_handle_t *hdl_out)
+{
+    (void)config;
+    (void)cbs;
+    if (hdl_out != NULL) {
+        *hdl_out = (void *)0;
+    }
+    return ESP_FAIL; /* never starts a ping task in the fuzz env */
+}
+
+static inline esp_err_t esp_ping_start(esp_ping_handle_t hdl)
+{
+    (void)hdl;
+    return ESP_OK;
+}
+
+static inline esp_err_t esp_ping_stop(esp_ping_handle_t hdl)
+{
+    (void)hdl;
+    return ESP_OK;
+}
+
+static inline esp_err_t esp_ping_delete_session(esp_ping_handle_t hdl)
+{
+    (void)hdl;
+    return ESP_OK;
+}

firmware/esp32-gamma-stim/CMakeLists.txt

@@ -1,9 +0,0 @@
-# ESP32 Gamma Stimulation Firmware (ADR-250 §21 M2 device harness)
-# Requires ESP-IDF v5.2+
-cmake_minimum_required(VERSION 3.16)
-
-file(STRINGS "${CMAKE_CURRENT_LIST_DIR}/version.txt" PROJECT_VER LIMIT_COUNT 1)
-string(STRIP "${PROJECT_VER}" PROJECT_VER)
-
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(esp32-gamma-stim VERSION ${PROJECT_VER})

firmware/esp32-gamma-stim/README.md

@@ -1,130 +0,0 @@
-# esp32-gamma-stim — ESP32 gamma stimulation actuator (ADR-250 §21 M2)
-
-The **device harness** for `ruview-gamma`: an ESP32 that drives a light + sound
-flicker at a commanded frequency, gated by a hardware emergency stop, with a
-compiled-in safety envelope that mirrors `SafetyEnvelope::conservative()` in the
-Rust crate. This is the actuator the `hil::verify_hil` contract grades.
-
-> **Not a medical device.** Research/engineering harness. The host
-> (`ruview-gamma`) decides *what* to play and never claims a therapeutic effect;
-> this firmware only plays it safely and reports exactly what it did.
-
-## Design: safety core vs hardware binding
-
-| File | Role | Tested |
-|------|------|--------|
-| `main/stim_core.{h,c}` | Pure C safety core: envelope validation, START/STOP/e-stop **latched** state machine, exact integer timing math, line protocol parser. No ESP-IDF deps. | `tests/test_stim_core.c` on the host (gcc), 15 tests |
-| `main/main.c` | ESP-IDF binding: GPTimer ISR toggling the **gate GPIO** (envelope + hard off path), LEDC PWM carriers (LED + audio, task-context only), sync GPIO, e-stop ISR, dead-man watchdog, USB-CDC console. Only moves registers. | on hardware (HIL) |
-
-Every safety decision lives in the host-tested core — **defense in depth**: the
-Rust host gates the stimulus *and* the device gates it again independently, so a
-buggy or compromised host still cannot command an out-of-envelope output.
-
-## Output gate wiring (hard off path) — REQUIRED
-
-The LEDC driver APIs are **not ISR-safe** (non-IRAM, non-ISR internal locking),
-so the firmware never touches LEDC from an interrupt. Instead the emitted
-output is the **hardware AND** of two signals:
-
-1. **LEDC carrier** (LED 19.5 kHz PWM / audio tone) at a *constant* duty for
-   the whole session, programmed from task context at START.
-2. **Gate GPIO** (`GAMMA_STIM_GATE_GPIO`, default 10) — a plain GPIO toggled
-   by the half-period ISR with a direct register write. It delivers the
-   36–44 Hz envelope *and* is the hard real-time off path: the e-stop ISR and
-   the dead-man watchdog force it low in microseconds.
-
-Wiring requirements:
-
-- Route the gate pin to the **enable input of the LED driver and the audio
-  amplifier** (or a series MOSFET that interrupts both). Output must be
-  physically impossible unless `gate == high` *and* the carrier is running.
-- Add an **external pulldown (~10 kΩ) on the gate pin** so the drivers stay
-  disabled during the boot/reset window while the pin floats, and on firmware
-  crash/brownout.
-- Avoid strapping pins for the gate (e.g. GPIO8/GPIO9 on ESP32-C6).
-
-Without this wiring the LED pin would carry the bare carrier for the whole
-session (no envelope) — the gate is not optional.
-
-## Independent dead-man watchdog
-
-The session-duration cap is enforced by the same GPTimer ISR that toggles the
-gate, so a stalled/killed ISR could otherwise leave the envelope ON. A separate
-250 ms FreeRTOS software timer checks that `elapsed_half_periods` advanced
-since its last tick whenever the state is RUNNING (worst-case half-period is
-13.9 ms @ 36 Hz, so a healthy session advances ~18× per check). On a stall it
-forces the gate low and latches a **FAULT** — same latch semantics as the
-e-stop: the device prints the session record plus `EVT fault_latched`, and
-refuses START until `UNLOCK`.
-
-## Run the safety-core tests (no hardware, no ESP-IDF)
-
-```bash
-cd firmware/esp32-gamma-stim
-gcc -Wall -Wextra -Werror -O2 -I main tests/test_stim_core.c main/stim_core.c -o /tmp/test_stim && /tmp/test_stim
-# -> all 15 stim_core tests passed
-```
-
-## Build & flash (ESP-IDF v5.2+)
-
-```bash
-idf.py set-target esp32s3        # or esp32c6
-idf.py menuconfig                # Gamma Stimulation -> pins, tone freq
-idf.py build flash monitor
-```
-
-Default pins (Kconfig-overridable): LED GPIO 4, audio GPIO 5, sync-out GPIO 6,
-e-stop button GPIO 7 (to GND, active-low), output gate GPIO 10 (to the
-driver/amp enables, with external pulldown — see "Output gate wiring").
-
-## Host protocol (line-based, 115200, USB-CDC/UART0)
-
-```
-START <freq_mhz> <brightness_pct> <volume_pct> <duration_s>
-STOP
-STATUS
-UNLOCK            # clear a latched e-stop/fault
-VERSION
-```
-
-`UNLOCK` is refused with `ERR estop_button_pressed` while the physical e-stop
-button is still held down — release the button first. (A host retry loop can
-therefore never resume a session against a pressed button.) Lines longer than
-95 characters are discarded in full (`ERR parse_error`, then everything up to
-the next newline is swallowed).
-
-Frequency is **millihertz** (40.0 Hz = `40000`) so the ±0.1 Hz HIL target is
-exact integer math (±100 mHz). Example — 40.0 Hz, 30% brightness, 28% volume,
-10 min:
-
-```
-> START 40000 30 28 600
-OK start seq=1 half_period_us=12500
-... (session runs) ...
-SESSION {"seq":1,"freq_mhz":40000,"brightness_pct":30,"volume_pct":28,"duration_s":600,"half_periods":48000,"stop":"completed","fw":"0.1.0"}
-```
-
-The `SESSION {...}` line is canonical (quantized integers, fixed field order) so
-the host pairs it with the RuFlo session builder to reproduce the witness hash
-(HIL: 100% hash reproducibility).
-
-## How it maps to the HIL targets (`v2/crates/ruview-gamma/src/hil.rs`)
-
-| HIL target | How this firmware meets it |
-|------------|----------------------------|
-| LED frequency ±0.1 Hz (incl. worst case over the session) | GPTimer at 1 MHz crystal-derived ticks; half-period from exact integer division; worst-case truncation at 44 Hz is ~3 mHz (35× inside budget) |
-| A/V sync < 5 ms | one **gate GPIO** enables both the LED driver and the audio amp; on/off skew is zero by construction |
-| Stop → actuator off < 100 ms | e-stop GPIO ISR drives the gate GPIO low with a **direct register write** (no driver calls in ISR context) — microseconds; LEDC shutdown follows in task context as defense in depth |
-| Stalled-ISR containment | independent 250 ms dead-man timer latches FAULT and forces the gate low if the half-period ISR stops advancing |
-| Half-period jitter | gate toggled in a GPTimer alarm ISR with auto-reload; jitter is ISR latency (µs-scale), measured at the sync pin |
-| Session-hash reproducibility 100% | canonical integer `SESSION {...}` record, no float formatting, deduped (one record per session seq — STOP-while-idle or e-stop-after-completion never re-print) |
-| EEG lift ≥ 20% vs fixed 40 Hz | provided by the host's adaptive optimizer choosing the frequency this firmware plays |
-
-## Hardware notes
-
-- **Drive the LED through a MOSFET/constant-current driver**, not the GPIO
-  directly. Keep brightness within eye-safe flicker limits — the firmware caps
-  duty at the envelope's 40%, but the optical design owns absolute luminance.
-- **Photosensitivity/epilepsy is a hard exclusion** at the host
-  (`ExclusionScreen`); the device is the last line, not the only line.
-- The e-stop button is mandatory for any human-facing bench run.

firmware/esp32-gamma-stim/main/CMakeLists.txt

@@ -1,5 +0,0 @@
-idf_component_register(
-    SRCS "main.c" "stim_core.c"
-    INCLUDE_DIRS "."
-    REQUIRES driver esp_timer
-)

firmware/esp32-gamma-stim/main/Kconfig.projbuild

@@ -1,55 +0,0 @@
-menu "Gamma Stimulation (ADR-250)"
-
-config GAMMA_STIM_LED_GPIO
-    int "LED PWM output GPIO"
-    default 4
-    help
-        GPIO driving the LED MOSFET/driver. The 36-44 Hz stimulus is the
-        envelope on a 19.5 kHz PWM carrier.
-
-config GAMMA_STIM_AUDIO_GPIO
-    int "Audio tone output GPIO"
-    default 5
-    help
-        GPIO driving the speaker/buzzer amplifier input (square tone,
-        envelope-gated). Use an analog volume stage for real loudness control.
-
-config GAMMA_STIM_SYNC_GPIO
-    int "Sync-out GPIO (HIL measurement)"
-    default 6
-    help
-        Mirrors the stimulation envelope for photodiode/logic-analyzer
-        verification of the +/-0.1 Hz and <5 ms A/V sync HIL targets.
-
-config GAMMA_STIM_ESTOP_GPIO
-    int "Emergency-stop button GPIO (active low)"
-    default 7
-    help
-        Button to GND. Falling edge latches an emergency stop: the output
-        gate GPIO is driven low in the ISR (direct register write), sessions
-        refused until UNLOCK. UNLOCK is refused while the button is still
-        held. Stop latency target <100 ms; the gate write achieves
-        microseconds.
-
-config GAMMA_STIM_GATE_GPIO
-    int "Output-enable gate GPIO (hard off path)"
-    default 10
-    help
-        Plain GPIO that enables BOTH the LED driver and the audio amplifier
-        (hardware AND with the LEDC carriers). The half-period ISR toggles it
-        to deliver the 36-44 Hz envelope, and the e-stop ISR / dead-man
-        watchdog force it low with a direct register write — the <100 ms
-        stop guarantee rests on this pin, NOT on the LEDC driver. Wire it to
-        the driver/amplifier enable inputs with an external pulldown so the
-        outputs stay disabled while the pin floats during boot/reset. Avoid
-        strapping pins (e.g. GPIO8/GPIO9 on ESP32-C6).
-
-config GAMMA_STIM_AUDIO_TONE_HZ
-    int "Audio tone carrier frequency (Hz)"
-    range 200 2000
-    default 440
-    help
-        The audible tone gated at the stimulation frequency. GENUS-style
-        protocols use a click/tone burst per cycle.
-
-endmenu

firmware/esp32-gamma-stim/main/main.c

@@ -1,551 +0,0 @@
-/*
- * esp32-gamma-stim — ESP-IDF hardware binding for the gamma stimulation core.
- *
- * Architecture (ADR-250 §21 M2 device harness, HIL targets in
- * v2/crates/ruview-gamma/src/hil.rs):
- *
- *   GPTimer (1 MHz, crystal-derived) ─ ISR every half-period
- *        ├── GATE:  plain GPIO output-enable, toggled with a direct register
- *        │          write (gpio_ll, IRAM-resident). Carries the 36-44 Hz
- *        │          envelope AND the hard real-time off path.
- *        └── SYNC:  bare GPIO mirroring the envelope (logic-analyzer capture)
- *
- *   LEDC (LED 19.5 kHz carrier, audio tone carrier) runs at a CONSTANT duty
- *   for the whole session, programmed from task context only. The emitted
- *   output is the hardware AND of (LEDC carrier duty) and (GATE asserted):
- *   the gate pin must drive the enable of the LED driver / audio amplifier
- *   (see README "Output gate wiring"). ISRs never call LEDC driver APIs —
- *   they take a non-ISR spinlock and are not IRAM-resident, so calling them
- *   from an ISR is undefined behavior. The stop guarantee rests on a single
- *   GPIO register write instead.
- *
- *   E-STOP button ─ GPIO ISR: gate low FIRST (register write, microseconds),
- *      then latch LOCKED (stim_core) and queue an event; the main task zeroes
- *      the LEDC duty afterwards (defense in depth, not the stop path).
- *
- *   DEAD-MAN ─ independent 250 ms FreeRTOS software timer: while RUNNING the
- *      half-period ISR must advance elapsed_half_periods every <= 13.9 ms
- *      (36 Hz worst case); if a dead-man tick sees no progress the ISR/timer
- *      has died with the envelope possibly ON, so it forces the gate low and
- *      latches a FAULT (same latch semantics as the e-stop).
- *
- *   GPTimer ownership: ONLY the console task starts/stops the GPTimer
- *      (handle_start / STOP). ISRs and the dead-man never call gptimer
- *      functions; after completion/e-stop/fault the timer may idle-tick
- *      harmlessly (state != RUNNING -> gate stays low) until the next host
- *      command reconfigures it. This keeps every driver call in task context.
- *
- *   Host protocol: line-based over USB-CDC/UART0 console at 115200
- *      (START/STOP/STATUS/UNLOCK/VERSION — see stim_core.h). Every session
- *      ends with one "SESSION {...}" JSON line for the host to witness-hash.
- *      UNLOCK is refused while the e-stop button is still held down.
- *
- * All safety decisions (envelope, latch, session math) are in stim_core.c,
- * which is unit-tested on the host. This file only moves registers.
- */
-#include <stdio.h>
-#include <string.h>
-
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/queue.h"
-#include "freertos/timers.h"
-
-#include "driver/gptimer.h"
-#include "driver/ledc.h"
-#include "driver/gpio.h"
-#include "hal/gpio_ll.h"
-#include "soc/gpio_struct.h"
-#include "esp_log.h"
-
-#include "stim_core.h"
-
-static const char *TAG = "gamma-stim";
-
-#define FIRMWARE_VERSION "0.1.1"
-
-/* ---- Pins / peripherals (Kconfig-overridable) ----------------------------- */
-#define PIN_LED      CONFIG_GAMMA_STIM_LED_GPIO
-#define PIN_AUDIO    CONFIG_GAMMA_STIM_AUDIO_GPIO
-#define PIN_SYNC     CONFIG_GAMMA_STIM_SYNC_GPIO
-#define PIN_ESTOP    CONFIG_GAMMA_STIM_ESTOP_GPIO
-#define PIN_GATE     CONFIG_GAMMA_STIM_GATE_GPIO
-
-#define LEDC_LED_CH     LEDC_CHANNEL_0
-#define LEDC_AUDIO_CH   LEDC_CHANNEL_1
-#define LEDC_LED_TIMER  LEDC_TIMER_0
-#define LEDC_AUDIO_TIMER LEDC_TIMER_1
-/* 12-bit duty at ~19.5 kHz LED carrier: flicker-free dimming far above the
- * envelope band; the 36-44 Hz stimulus is the *envelope*, not the carrier. */
-#define LED_CARRIER_HZ   19500
-#define LED_DUTY_RES     LEDC_TIMER_12_BIT
-#define LED_DUTY_MAX     ((1 << 12) - 1)
-/* Audio: square tone carrier gated by the envelope. */
-#define AUDIO_TONE_HZ    CONFIG_GAMMA_STIM_AUDIO_TONE_HZ
-#define AUDIO_DUTY_RES   LEDC_TIMER_12_BIT
-#define AUDIO_DUTY_MAX   ((1 << 12) - 1)
-
-/* Dead-man check period. Worst-case half-period is 13.9 ms (36 Hz), so a
- * healthy session advances elapsed_half_periods ~18+ times per check. */
-#define DEADMAN_PERIOD_MS 250
-
-/* ---- Shared state ---------------------------------------------------------- */
-
-static stim_ctx_t s_ctx;                 /* guarded by s_mux: ISRs + tasks   */
-static portMUX_TYPE s_mux = portMUX_INITIALIZER_UNLOCKED;
-static gptimer_handle_t s_timer = NULL;  /* started/stopped by console task ONLY */
-static QueueHandle_t s_evt_queue = NULL; /* events to the main task          */
-static TimerHandle_t s_deadman = NULL;
-static uint32_t s_printed_seq = 0;       /* guarded by s_mux: record dedupe  */
-
-typedef enum {
-    EVT_SESSION_DONE = 1,  /* duration elapsed (RUNNING -> IDLE edge)   */
-    EVT_ESTOP = 2,         /* e-stop button latched                     */
-    EVT_FAULT = 3,         /* dead-man detected a stalled timer ISR     */
-} stim_evt_kind_t;
-
-typedef struct {
-    stim_evt_kind_t kind;
-    stim_ctx_t snap;       /* context captured at the moment of the event */
-} stim_evt_t;
-
-/* ---- ISR-safe GPIO writes (direct register path, inline => IRAM) ---------- */
-
-static inline void IRAM_ATTR gate_write(bool on)
-{
-    gpio_ll_set_level(&GPIO, PIN_GATE, on ? 1 : 0);
-}
-
-static inline void IRAM_ATTR sync_write(bool on)
-{
-    gpio_ll_set_level(&GPIO, PIN_SYNC, on ? 1 : 0);
-}
-
-/* ---- LEDC carrier control (TASK CONTEXT ONLY — not ISR-safe) --------------- */
-
-static void carrier_set(uint8_t brightness_pct, uint8_t volume_pct)
-{
-    uint32_t led_duty = ((uint32_t)brightness_pct * LED_DUTY_MAX) / 100U;
-    /* Volume cap is 40% -> max audio duty 20% of full scale: keep the square
-     * tone gentle; real loudness control belongs to the analog stage. */
-    uint32_t aud_duty = ((uint32_t)volume_pct * (AUDIO_DUTY_MAX / 2U)) / 100U;
-    ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_LED_CH, led_duty));
-    ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_LED_CH));
-    ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_AUDIO_CH, aud_duty));
-    ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_AUDIO_CH));
-}
-
-static void carrier_off(void)
-{
-    carrier_set(0, 0);
-}
-
-/* ---- ISRs (no driver calls: register writes + queue only) ------------------ */
-
-/* GPTimer alarm ISR: one half-period boundary. The envelope is delivered by
- * toggling the gate GPIO; the LEDC carriers are untouched here. */
-static bool IRAM_ATTR on_half_period(gptimer_handle_t timer,
-                                     const gptimer_alarm_event_data_t *edata,
-                                     void *user)
-{
-    (void)timer; (void)edata; (void)user;
-    BaseType_t hpw = pdFALSE;
-    portENTER_CRITICAL_ISR(&s_mux);
-    bool was_running = (s_ctx.state == STIM_RUNNING);
-    bool running = stim_tick(&s_ctx);
-    bool on = running && s_ctx.envelope_on;
-    gate_write(on);
-    sync_write(on);
-    if (was_running && !running) {
-        /* RUNNING -> done edge: exactly one completion event per session.
-         * The timer is NOT stopped here (gptimer APIs stay in task context);
-         * until the next host command it idle-ticks with the gate low. */
-        stim_evt_t e = { .kind = EVT_SESSION_DONE, .snap = s_ctx };
-        xQueueSendFromISR(s_evt_queue, &e, &hpw);
-    }
-    portEXIT_CRITICAL_ISR(&s_mux);
-    return hpw == pdTRUE;
-}
-
-/* E-stop button ISR. Hard real-time stop path = the first line: one direct
- * GPIO register write forcing the output gate low. Everything after that is
- * bookkeeping. LEDC shutdown happens later in the main task. */
-static void IRAM_ATTR on_estop(void *arg)
-{
-    (void)arg;
-    gate_write(false);                    /* outputs off: microseconds */
-    BaseType_t hpw = pdFALSE;
-    portENTER_CRITICAL_ISR(&s_mux);
-    bool already_latched = (s_ctx.state == STIM_LOCKED);
-    stim_estop(&s_ctx, STIM_STOP_BUTTON);
-    sync_write(false);
-    if (!already_latched) {               /* debounce: one event per latch */
-        stim_evt_t e = { .kind = EVT_ESTOP, .snap = s_ctx };
-        xQueueSendFromISR(s_evt_queue, &e, &hpw);
-    }
-    portEXIT_CRITICAL_ISR(&s_mux);
-    if (hpw == pdTRUE) {
-        portYIELD_FROM_ISR();
-    }
-}
-
-/* ---- Dead-man watchdog (FreeRTOS timer task context) ----------------------- */
-
-/* Independent of the GPTimer ISR: if state == RUNNING but the ISR stopped
- * advancing elapsed_half_periods between two checks, the toggling path is
- * dead — possibly with the gate left ON. Force outputs off and latch FAULT
- * (same latch as the e-stop: START refused until UNLOCK). */
-static void deadman_cb(TimerHandle_t t)
-{
-    (void)t;
-    static uint32_t dm_seq = 0;       /* session_seq starts at 1; 0 = none */
-    static uint32_t dm_elapsed = 0;
-    bool fault = false;
-    stim_evt_t e = { .kind = EVT_FAULT };
-    portENTER_CRITICAL(&s_mux);
-    if (s_ctx.state == STIM_RUNNING) {
-        if (dm_seq == s_ctx.session_seq &&
-            dm_elapsed == s_ctx.elapsed_half_periods) {
-            gate_write(false);
-            sync_write(false);
-            stim_estop(&s_ctx, STIM_STOP_FAULT);
-            e.snap = s_ctx;
-            fault = true;
-        } else {
-            dm_seq = s_ctx.session_seq;
-            dm_elapsed = s_ctx.elapsed_half_periods;
-        }
-    } else {
-        dm_seq = 0;
-        dm_elapsed = 0;
-    }
-    portEXIT_CRITICAL(&s_mux);
-    if (fault) {
-        carrier_off();                /* task context: LEDC allowed */
-        xQueueSend(s_evt_queue, &e, 0);
-    }
-}
-
-/* ---- Peripheral setup -------------------------------------------------------- */
-
-static void setup_ledc(void)
-{
-    ledc_timer_config_t led_t = {
-        .speed_mode = LEDC_LOW_SPEED_MODE,
-        .timer_num = LEDC_LED_TIMER,
-        .duty_resolution = LED_DUTY_RES,
-        .freq_hz = LED_CARRIER_HZ,
-        .clk_cfg = LEDC_AUTO_CLK,
-    };
-    ESP_ERROR_CHECK(ledc_timer_config(&led_t));
-    ledc_channel_config_t led_c = {
-        .gpio_num = PIN_LED,
-        .speed_mode = LEDC_LOW_SPEED_MODE,
-        .channel = LEDC_LED_CH,
-        .timer_sel = LEDC_LED_TIMER,
-        .duty = 0,
-        .hpoint = 0,
-    };
-    ESP_ERROR_CHECK(ledc_channel_config(&led_c));
-
-    ledc_timer_config_t aud_t = {
-        .speed_mode = LEDC_LOW_SPEED_MODE,
-        .timer_num = LEDC_AUDIO_TIMER,
-        .duty_resolution = AUDIO_DUTY_RES,
-        .freq_hz = AUDIO_TONE_HZ,
-        .clk_cfg = LEDC_AUTO_CLK,
-    };
-    ESP_ERROR_CHECK(ledc_timer_config(&aud_t));
-    ledc_channel_config_t aud_c = {
-        .gpio_num = PIN_AUDIO,
-        .speed_mode = LEDC_LOW_SPEED_MODE,
-        .channel = LEDC_AUDIO_CH,
-        .timer_sel = LEDC_AUDIO_TIMER,
-        .duty = 0,
-        .hpoint = 0,
-    };
-    ESP_ERROR_CHECK(ledc_channel_config(&aud_c));
-}
-
-static void setup_gpio(void)
-{
-    /* Output-enable gate FIRST: drive it low before the LEDC carriers exist.
-     * The board-level wiring must add an external pulldown so the LED driver
-     * and audio amp stay disabled while this pin floats during boot/reset
-     * (see README "Output gate wiring"). */
-    gpio_config_t gate = {
-        .pin_bit_mask = 1ULL << PIN_GATE,
-        .mode = GPIO_MODE_OUTPUT,
-        .pull_down_en = GPIO_PULLDOWN_ENABLE,
-    };
-    ESP_ERROR_CHECK(gpio_config(&gate));
-    gpio_set_level(PIN_GATE, 0);
-
-    gpio_config_t sync = {
-        .pin_bit_mask = 1ULL << PIN_SYNC,
-        .mode = GPIO_MODE_OUTPUT,
-    };
-    ESP_ERROR_CHECK(gpio_config(&sync));
-    gpio_set_level(PIN_SYNC, 0);
-
-    gpio_config_t estop = {
-        .pin_bit_mask = 1ULL << PIN_ESTOP,
-        .mode = GPIO_MODE_INPUT,
-        .pull_up_en = GPIO_PULLUP_ENABLE,    /* button to GND, active low */
-        .intr_type = GPIO_INTR_NEGEDGE,
-    };
-    ESP_ERROR_CHECK(gpio_config(&estop));
-    ESP_ERROR_CHECK(gpio_install_isr_service(0));
-    ESP_ERROR_CHECK(gpio_isr_handler_add(PIN_ESTOP, on_estop, NULL));
-}
-
-static void setup_timer(void)
-{
-    gptimer_config_t cfg = {
-        .clk_src = GPTIMER_CLK_SRC_DEFAULT,
-        .direction = GPTIMER_COUNT_UP,
-        .resolution_hz = 1000000, /* 1 us ticks, crystal-derived */
-    };
-    ESP_ERROR_CHECK(gptimer_new_timer(&cfg, &s_timer));
-    gptimer_event_callbacks_t cbs = { .on_alarm = on_half_period };
-    ESP_ERROR_CHECK(gptimer_register_event_callbacks(s_timer, &cbs, NULL));
-    ESP_ERROR_CHECK(gptimer_enable(s_timer));
-}
-
-/* ---- Session lifecycle ---------------------------------------------------------- */
-
-/* Print the canonical witness record for a finished session. The snapshot is
- * captured at the event source (under s_mux), so a new session racing in
- * cannot corrupt the record. Deduped by session_seq: STOP-while-idle or an
- * e-stop pressed after completion must NOT re-print the previous record. */
-static void print_session_record(const stim_ctx_t *snap)
-{
-    if (snap->session_seq == 0 || snap->state == STIM_RUNNING) {
-        return; /* no finished session to report */
-    }
-    portENTER_CRITICAL(&s_mux);
-    bool dup = (snap->session_seq == s_printed_seq);
-    if (!dup) {
-        s_printed_seq = snap->session_seq;
-    }
-    portEXIT_CRITICAL(&s_mux);
-    if (dup) {
-        return;
-    }
-    /* One canonical JSON line per finished session; the host pairs it with the
-     * RuFlo session builder to compute the witness hash (HIL: 100% hash
-     * reproducibility). Quantized integers only — no float formatting drift. */
-    printf("SESSION {\"seq\":%u,\"freq_mhz\":%u,\"brightness_pct\":%u,"
-           "\"volume_pct\":%u,\"duration_s\":%u,\"half_periods\":%u,"
-           "\"stop\":\"%s\",\"fw\":\"%s\"}\n",
-           (unsigned)snap->session_seq, (unsigned)snap->active.freq_mhz,
-           (unsigned)snap->active.brightness_pct, (unsigned)snap->active.volume_pct,
-           (unsigned)snap->active.duration_s, (unsigned)snap->elapsed_half_periods,
-           stim_stop_str(snap->last_stop), FIRMWARE_VERSION);
-}
-
-static void handle_start(const stim_params_t *p)
-{
-    portENTER_CRITICAL(&s_mux);
-    stim_rc_t rc = stim_start(&s_ctx, p);
-    uint32_t seq = s_ctx.session_seq;
-    portEXIT_CRITICAL(&s_mux);
-    if (rc != STIM_OK) {
-        printf("ERR %s\n", stim_rc_str(rc));
-        return;
-    }
-
-    /* Program the carriers at session intensity (task context). Nothing is
-     * emitted yet: the gate GPIO stays low until the first ON half-period. */
-    carrier_set(p->brightness_pct, p->volume_pct);
-
-    uint32_t half_us = stim_half_period_us(p->freq_mhz);
-    gptimer_alarm_config_t alarm = {
-        .alarm_count = half_us,
-        .reload_count = 0,
-        .flags.auto_reload_on_alarm = true,
-    };
-    gptimer_stop(s_timer); /* idempotent: may be idle-ticking or stopped */
-    ESP_ERROR_CHECK(gptimer_set_raw_count(s_timer, 0));
-    ESP_ERROR_CHECK(gptimer_set_alarm_action(s_timer, &alarm));
-
-    /* TOCTOU guard: an e-stop may have latched between the RUNNING commit
-     * above and here. Start the timer under the same mux the e-stop ISR
-     * takes, so "state == LOCKED" and "timer started for this session" can
-     * never coexist. (gptimer_start error, if any, is checked outside the
-     * critical section because it may log.) */
-    esp_err_t start_err = ESP_OK;
-    portENTER_CRITICAL(&s_mux);
-    bool still_running =
-        (s_ctx.state == STIM_RUNNING && s_ctx.session_seq == seq);
-    if (still_running) {
-        start_err = gptimer_start(s_timer);
-    }
-    portEXIT_CRITICAL(&s_mux);
-    if (!still_running) {
-        carrier_off(); /* gate already low (forced by the e-stop ISR) */
-        printf("ERR %s\n", stim_rc_str(STIM_ERR_LOCKED));
-        return;
-    }
-    ESP_ERROR_CHECK(start_err);
-    printf("OK start seq=%u half_period_us=%u\n",
-           (unsigned)seq, (unsigned)half_us);
-}
-
-static void handle_line(const char *line)
-{
-    stim_cmd_t cmd;
-    stim_rc_t rc = stim_parse_line(line, &cmd);
-    if (rc != STIM_OK) {
-        printf("ERR %s\n", stim_rc_str(rc));
-        return;
-    }
-    switch (cmd.kind) {
-    case STIM_CMD_START:
-        handle_start(&cmd.params);
-        break;
-    case STIM_CMD_STOP: {
-        portENTER_CRITICAL(&s_mux);
-        gate_write(false);
-        sync_write(false);
-        stim_stop_host(&s_ctx);
-        stim_ctx_t snap = s_ctx;
-        portEXIT_CRITICAL(&s_mux);
-        gptimer_stop(s_timer); /* console task owns the timer; rc ignored */
-        carrier_off();
-        print_session_record(&snap); /* deduped: no-op if nothing new ran */
-        printf("OK stop\n");
-        break;
-    }
-    case STIM_CMD_STATUS: {
-        portENTER_CRITICAL(&s_mux);
-        stim_ctx_t snap = s_ctx;
-        portEXIT_CRITICAL(&s_mux);
-        const char *st = snap.state == STIM_RUNNING ? "running"
-                       : snap.state == STIM_LOCKED  ? "locked"
-                                                    : "idle";
-        printf("OK status state=%s seq=%u last_stop=%s\n", st,
-               (unsigned)snap.session_seq, stim_stop_str(snap.last_stop));
-        break;
-    }
-    case STIM_CMD_UNLOCK:
-        /* Refuse to clear the latch while the physical e-stop button is still
-         * held (active low): a host retry loop must never be able to resume
-         * against a pressed button. If the button is pressed again right
-         * after this check, the NEGEDGE ISR simply re-latches. */
-        if (gpio_get_level(PIN_ESTOP) == 0) {
-            printf("ERR estop_button_pressed\n");
-            break;
-        }
-        portENTER_CRITICAL(&s_mux);
-        stim_unlock(&s_ctx);
-        portEXIT_CRITICAL(&s_mux);
-        printf("OK unlock\n");
-        break;
-    case STIM_CMD_VERSION:
-        printf("OK version fw=%s envelope=36000-44000mHz b<=%u%% v<=%u%% d<=%us\n",
-               FIRMWARE_VERSION,
-               (unsigned)s_ctx.envelope.max_brightness_pct,
-               (unsigned)s_ctx.envelope.max_volume_pct,
-               (unsigned)s_ctx.envelope.max_duration_s);
-        break;
-    default:
-        printf("ERR %s\n", stim_rc_str(STIM_ERR_UNKNOWN_CMD));
-    }
-}
-
-/* Console reader: line-buffered stdin (USB-CDC / UART0). */
-static void console_task(void *arg)
-{
-    (void)arg;
-    char buf[96];
-    size_t n = 0;
-    bool discard = false; /* swallowing the tail of an overlong line */
-    for (;;) {
-        int ch = fgetc(stdin);
-        if (ch == EOF) {
-            vTaskDelay(pdMS_TO_TICKS(10));
-            continue;
-        }
-        if (ch == '\r') {
-            continue;
-        }
-        if (ch == '\n') {
-            if (discard) {
-                discard = false; /* overlong line fully consumed */
-                n = 0;
-                continue;
-            }
-            buf[n] = '\0';
-            if (n > 0) {
-                handle_line(buf);
-            }
-            n = 0;
-            continue;
-        }
-        if (discard) {
-            continue;
-        }
-        if (n + 1 < sizeof(buf)) {
-            buf[n++] = (char)ch;
-        } else {
-            /* Overlong line: fail closed — drop it AND everything up to the
-             * next newline, so the tail is never reinterpreted as a fresh
-             * command. */
-            discard = true;
-            n = 0;
-            printf("ERR %s\n", stim_rc_str(STIM_ERR_PARSE));
-        }
-    }
-}
-
-void app_main(void)
-{
-    ESP_LOGI(TAG, "gamma-stim v%s (ADR-250 M2 device harness)", FIRMWARE_VERSION);
-    s_evt_queue = xQueueCreate(8, sizeof(stim_evt_t));
-    configASSERT(s_evt_queue != NULL);
-    stim_init(&s_ctx, stim_envelope_conservative());
-    setup_gpio();   /* gate low before the LEDC carriers are configured */
-    setup_ledc();
-    setup_timer();
-    carrier_off();
-
-    s_deadman = xTimerCreate("deadman", pdMS_TO_TICKS(DEADMAN_PERIOD_MS),
-                             pdTRUE, NULL, deadman_cb);
-    configASSERT(s_deadman != NULL);
-    xTimerStart(s_deadman, 0);
-
-    xTaskCreate(console_task, "console", 4096, NULL, 5, NULL);
-    ESP_LOGI(TAG, "ready: envelope 36.0-44.0 Hz, brightness<=%u%%, volume<=%u%%",
-             (unsigned)s_ctx.envelope.max_brightness_pct,
-             (unsigned)s_ctx.envelope.max_volume_pct);
-
-    stim_evt_t evt;
-    for (;;) {
-        if (xQueueReceive(s_evt_queue, &evt, portMAX_DELAY) == pdTRUE) {
-            /* The hard off (gate low) already happened at the event source.
-             * Zero the carriers here in task context — but never behind a
-             * session that has legitimately started since the event fired. */
-            bool cleanup;
-            portENTER_CRITICAL(&s_mux);
-            cleanup = (s_ctx.state != STIM_RUNNING);
-            portEXIT_CRITICAL(&s_mux);
-            if (cleanup) {
-                carrier_off();
-            }
-            switch (evt.kind) {
-            case EVT_SESSION_DONE:
-                print_session_record(&evt.snap);
-                break;
-            case EVT_ESTOP:
-                print_session_record(&evt.snap);
-                printf("EVT estop_latched\n");
-                break;
-            case EVT_FAULT:
-                print_session_record(&evt.snap);
-                printf("EVT fault_latched\n");
-                break;
-            }
-        }
-    }
-}

firmware/esp32-gamma-stim/main/stim_core.c

@@ -1,254 +0,0 @@
-/*
- * stim_core.c — pure, host-testable core of the gamma stimulation firmware.
- * See stim_core.h for the contract. No ESP-IDF includes in this file.
- */
-#include "stim_core.h"
-
-#include <string.h>
-#include <stdlib.h>
-#include <ctype.h>
-
-/* ---- Envelope ------------------------------------------------------------ */
-
-stim_envelope_t stim_envelope_conservative(void)
-{
-    stim_envelope_t e = {
-        .min_freq_mhz       = 36000,  /* 36.0 Hz */
-        .max_freq_mhz       = 44000,  /* 44.0 Hz */
-        .max_brightness_pct = 40,     /* SafetyEnvelope::conservative 0.40 */
-        .max_volume_pct     = 40,
-        .max_duration_s     = 900,    /* 15 min */
-    };
-    return e;
-}
-
-void stim_init(stim_ctx_t *ctx, stim_envelope_t envelope)
-{
-    memset(ctx, 0, sizeof(*ctx));
-    ctx->envelope = envelope;
-    ctx->state = STIM_IDLE;
-    ctx->last_stop = STIM_STOP_NONE;
-}
-
-/* ---- Validation ----------------------------------------------------------- */
-
-stim_rc_t stim_validate(const stim_ctx_t *ctx, const stim_params_t *p)
-{
-    const stim_envelope_t *e = &ctx->envelope;
-    if (p->freq_mhz < e->min_freq_mhz || p->freq_mhz > e->max_freq_mhz) {
-        return STIM_ERR_FREQ_RANGE;
-    }
-    if (p->brightness_pct > e->max_brightness_pct) {
-        return STIM_ERR_BRIGHTNESS_CAP;
-    }
-    if (p->volume_pct > e->max_volume_pct) {
-        return STIM_ERR_VOLUME_CAP;
-    }
-    if (p->duration_s == 0) {
-        return STIM_ERR_ZERO_DURATION;
-    }
-    if (p->duration_s > e->max_duration_s) {
-        return STIM_ERR_DURATION_CAP;
-    }
-    return STIM_OK;
-}
-
-/* ---- Transitions ----------------------------------------------------------- */
-
-stim_rc_t stim_start(stim_ctx_t *ctx, const stim_params_t *p)
-{
-    if (ctx->state == STIM_LOCKED) {
-        return STIM_ERR_LOCKED;
-    }
-    if (ctx->state == STIM_RUNNING) {
-        return STIM_ERR_BUSY;
-    }
-    stim_rc_t rc = stim_validate(ctx, p);
-    if (rc != STIM_OK) {
-        return rc; /* fail closed: state unchanged, outputs stay off */
-    }
-    ctx->active = *p;
-    ctx->elapsed_half_periods = 0;
-    ctx->envelope_on = false;
-    ctx->session_seq += 1;
-    ctx->last_stop = STIM_STOP_NONE;
-    ctx->state = STIM_RUNNING;
-    return STIM_OK;
-}
-
-stim_rc_t stim_stop_host(stim_ctx_t *ctx)
-{
-    if (ctx->state == STIM_RUNNING) {
-        ctx->state = STIM_IDLE;
-        ctx->envelope_on = false;
-        ctx->last_stop = STIM_STOP_HOST;
-    }
-    /* STOP while idle/locked is a harmless no-op (idempotent). */
-    return STIM_OK;
-}
-
-void stim_estop(stim_ctx_t *ctx, stim_stop_reason_t why)
-{
-    ctx->state = STIM_LOCKED;       /* latched, from ANY state */
-    ctx->envelope_on = false;
-    ctx->last_stop = why;
-}
-
-stim_rc_t stim_unlock(stim_ctx_t *ctx)
-{
-    if (ctx->state == STIM_LOCKED) {
-        ctx->state = STIM_IDLE;
-    }
-    return STIM_OK;
-}
-
-bool stim_tick(stim_ctx_t *ctx)
-{
-    if (ctx->state != STIM_RUNNING) {
-        ctx->envelope_on = false;
-        return false;
-    }
-    ctx->envelope_on = !ctx->envelope_on;
-    ctx->elapsed_half_periods += 1;
-    uint32_t total =
-        stim_session_half_periods(ctx->active.freq_mhz, ctx->active.duration_s);
-    if (ctx->elapsed_half_periods >= total) {
-        ctx->state = STIM_IDLE;
-        ctx->envelope_on = false;
-        ctx->last_stop = STIM_STOP_COMPLETED;
-        return false;
-    }
-    return true;
-}
-
-uint32_t stim_half_period_us(uint32_t freq_mhz)
-{
-    if (freq_mhz == 0) {
-        return 0;
-    }
-    /* half period [us] = 1e6 / (2 * f[Hz]) = 5e8 / f[mHz].
-     * 64-bit intermediate; exact division for e.g. 40000 -> 12500 us. */
-    return (uint32_t)(500000000ULL / (uint64_t)freq_mhz);
-}
-
-uint32_t stim_session_half_periods(uint32_t freq_mhz, uint32_t duration_s)
-{
-    /* half periods = duration * 2 * f[Hz] = duration * f[mHz] / 500.
-     * 64-bit intermediate: 900 s * 44000 = 39.6e6, fine. */
-    return (uint32_t)(((uint64_t)duration_s * (uint64_t)freq_mhz) / 500ULL);
-}
-
-/* ---- Protocol parsing ------------------------------------------------------ */
-
-/* Parse an unsigned decimal field; returns false on junk/overflow. */
-static bool parse_u32(const char **cursor, uint32_t *out)
-{
-    const char *s = *cursor;
-    while (*s == ' ') {
-        s++;
-    }
-    if (!isdigit((unsigned char)*s)) {
-        return false;
-    }
-    uint64_t v = 0;
-    while (isdigit((unsigned char)*s)) {
-        v = v * 10ULL + (uint64_t)(*s - '0');
-        if (v > 0xFFFFFFFFULL) {
-            return false;
-        }
-        s++;
-    }
-    *out = (uint32_t)v;
-    *cursor = s;
-    return true;
-}
-
-static bool token_is(const char *line, const char *word, const char **rest)
-{
-    size_t n = strlen(word);
-    if (strncmp(line, word, n) != 0) {
-        return false;
-    }
-    if (line[n] != '\0' && line[n] != ' ') {
-        return false;
-    }
-    *rest = line + n;
-    return true;
-}
-
-stim_rc_t stim_parse_line(const char *line, stim_cmd_t *out)
-{
-    memset(out, 0, sizeof(*out));
-    while (*line == ' ') {
-        line++;
-    }
-    const char *rest = NULL;
-    if (token_is(line, "START", &rest)) {
-        uint32_t f, b, v, d;
-        if (!parse_u32(&rest, &f) || !parse_u32(&rest, &b) ||
-            !parse_u32(&rest, &v) || !parse_u32(&rest, &d)) {
-            return STIM_ERR_PARSE;
-        }
-        while (*rest == ' ') {
-            rest++;
-        }
-        if (*rest != '\0') {
-            return STIM_ERR_PARSE; /* trailing junk */
-        }
-        if (b > 255 || v > 255) {
-            return STIM_ERR_PARSE; /* fields must fit their types */
-        }
-        out->kind = STIM_CMD_START;
-        out->params.freq_mhz = f;
-        out->params.brightness_pct = (uint8_t)b;
-        out->params.volume_pct = (uint8_t)v;
-        out->params.duration_s = d;
-        return STIM_OK;
-    }
-    if (token_is(line, "STOP", &rest)) {
-        out->kind = STIM_CMD_STOP;
-        return STIM_OK;
-    }
-    if (token_is(line, "STATUS", &rest)) {
-        out->kind = STIM_CMD_STATUS;
-        return STIM_OK;
-    }
-    if (token_is(line, "UNLOCK", &rest)) {
-        out->kind = STIM_CMD_UNLOCK;
-        return STIM_OK;
-    }
-    if (token_is(line, "VERSION", &rest)) {
-        out->kind = STIM_CMD_VERSION;
-        return STIM_OK;
-    }
-    return STIM_ERR_UNKNOWN_CMD;
-}
-
-const char *stim_rc_str(stim_rc_t rc)
-{
-    switch (rc) {
-    case STIM_OK:                 return "ok";
-    case STIM_ERR_FREQ_RANGE:     return "freq_out_of_envelope";
-    case STIM_ERR_BRIGHTNESS_CAP: return "brightness_above_cap";
-    case STIM_ERR_VOLUME_CAP:     return "volume_above_cap";
-    case STIM_ERR_DURATION_CAP:   return "duration_above_cap";
-    case STIM_ERR_ZERO_DURATION:  return "zero_duration";
-    case STIM_ERR_BUSY:           return "busy";
-    case STIM_ERR_LOCKED:         return "estop_locked";
-    case STIM_ERR_PARSE:          return "parse_error";
-    case STIM_ERR_UNKNOWN_CMD:    return "unknown_command";
-    default:                      return "unknown_rc";
-    }
-}
-
-const char *stim_stop_str(stim_stop_reason_t r)
-{
-    switch (r) {
-    case STIM_STOP_NONE:      return "none";
-    case STIM_STOP_COMPLETED: return "completed";
-    case STIM_STOP_HOST:      return "host_stop";
-    case STIM_STOP_BUTTON:    return "estop_button";
-    case STIM_STOP_FAULT:     return "fault";
-    default:                  return "unknown";
-    }
-}

firmware/esp32-gamma-stim/main/stim_core.h

@@ -1,164 +0,0 @@
-/*
- * stim_core.h — pure, host-testable core of the gamma stimulation firmware.
- *
- * Everything safety-critical lives here, with NO ESP-IDF dependencies, so the
- * exact code that ships on the device is unit-tested on the host (gcc) and in
- * CI. main.c is a thin hardware binding (timers, LEDC, GPIO, UART).
- *
- * Mirrors the ruview-gamma crate's SafetyEnvelope::conservative() (ADR-250
- * §5/§12): the firmware enforces the same hard caps *independently*, so even a
- * compromised or buggy host cannot command an out-of-envelope stimulus.
- * Defense in depth: host gate (Rust) AND device gate (this file).
- *
- * Units: frequency in millihertz (exact integer math — the ±0.1 Hz HIL target
- * is ±100 mHz), intensity in percent (0–100), duration in seconds.
- */
-#ifndef STIM_CORE_H
-#define STIM_CORE_H
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ---- Hard safety envelope (device-side; never widened at runtime) ------- */
-
-typedef struct {
-    uint32_t min_freq_mhz;      /* 36000 = 36.0 Hz  */
-    uint32_t max_freq_mhz;      /* 44000 = 44.0 Hz  */
-    uint8_t  max_brightness_pct;/* 40 = SafetyEnvelope::conservative cap 0.40 */
-    uint8_t  max_volume_pct;    /* 40 */
-    uint32_t max_duration_s;    /* 900 = 15 min */
-} stim_envelope_t;
-
-/* The compiled-in conservative envelope (ADR-250 §5). The values are
- * hard-coded in stim_core.c — there are deliberately NO Kconfig options for
- * them: widening the envelope requires editing the host-tested core and its
- * unit tests, never a build-time switch. */
-stim_envelope_t stim_envelope_conservative(void);
-
-/* ---- Session state machine ---------------------------------------------- */
-
-typedef enum {
-    STIM_IDLE = 0,     /* outputs off, ready for START            */
-    STIM_RUNNING,      /* stimulation active                      */
-    STIM_LOCKED,       /* emergency-stopped; START refused until UNLOCK */
-} stim_state_t;
-
-typedef enum {
-    STIM_STOP_NONE = 0,
-    STIM_STOP_COMPLETED,    /* duration elapsed (not a safety stop)  */
-    STIM_STOP_HOST,         /* host STOP command                     */
-    STIM_STOP_BUTTON,       /* hardware e-stop button                */
-    STIM_STOP_FAULT,        /* internal fault (watchdog, bad state)  */
-} stim_stop_reason_t;
-
-typedef struct {
-    uint32_t freq_mhz;       /* commanded envelope frequency          */
-    uint8_t  brightness_pct; /* LED intensity during ON half-period   */
-    uint8_t  volume_pct;     /* tone intensity during ON half-period  */
-    uint32_t duration_s;     /* session length                        */
-} stim_params_t;
-
-typedef struct {
-    stim_envelope_t   envelope;
-    stim_state_t      state;
-    stim_params_t     active;          /* valid when state == RUNNING   */
-    stim_stop_reason_t last_stop;
-    uint32_t          session_seq;     /* increments on each START      */
-    uint32_t          elapsed_half_periods; /* advanced by the timer ISR */
-    bool              envelope_on;     /* current half-period phase     */
-} stim_ctx_t;
-
-/* Initialize a context with the given envelope, in IDLE. */
-void stim_init(stim_ctx_t *ctx, stim_envelope_t envelope);
-
-/* ---- Validation (fail closed) ------------------------------------------- */
-
-typedef enum {
-    STIM_OK = 0,
-    STIM_ERR_FREQ_RANGE,     /* outside [min,max] mHz                  */
-    STIM_ERR_BRIGHTNESS_CAP,
-    STIM_ERR_VOLUME_CAP,
-    STIM_ERR_DURATION_CAP,
-    STIM_ERR_ZERO_DURATION,
-    STIM_ERR_BUSY,           /* START while RUNNING                    */
-    STIM_ERR_LOCKED,         /* START while LOCKED (e-stop latched)    */
-    STIM_ERR_PARSE,          /* malformed command line                 */
-    STIM_ERR_UNKNOWN_CMD,
-} stim_rc_t;
-
-/* Validate params against the context envelope. Pure; no state change. */
-stim_rc_t stim_validate(const stim_ctx_t *ctx, const stim_params_t *p);
-
-/* ---- Transitions (the only mutators) ------------------------------------ */
-
-/* START: validate + transition IDLE->RUNNING. Fails closed on any violation,
- * on BUSY, and on LOCKED. */
-stim_rc_t stim_start(stim_ctx_t *ctx, const stim_params_t *p);
-
-/* STOP from the host: RUNNING->IDLE (graceful; not latched). */
-stim_rc_t stim_stop_host(stim_ctx_t *ctx);
-
-/* Emergency stop (button ISR or fault): any state -> LOCKED. Latched —
- * further STARTs are refused until stim_unlock(). Mirrors the Rust
- * SafetyMonitor latch (a session must never silently resume). */
-void stim_estop(stim_ctx_t *ctx, stim_stop_reason_t why);
-
-/* Operator unlock after an e-stop: LOCKED -> IDLE. */
-stim_rc_t stim_unlock(stim_ctx_t *ctx);
-
-/* Timer ISR tick: advance one half-period. Returns true while RUNNING; when
- * the session's duration is reached it transitions to IDLE (COMPLETED) and
- * returns false. Pure integer math, ISR-safe. */
-bool stim_tick(stim_ctx_t *ctx);
-
-/* Half-period length in microseconds for a commanded frequency:
- * 500'000'000'000 / freq_mhz / 1000 — exact for the supported range.
- * (40.0 Hz = 40000 mHz -> 12'500 us.) */
-uint32_t stim_half_period_us(uint32_t freq_mhz);
-
-/* Total half-periods in a session of duration_s at freq_mhz (rounded down). */
-uint32_t stim_session_half_periods(uint32_t freq_mhz, uint32_t duration_s);
-
-/* ---- Host command protocol (line-based, UART) ---------------------------
- *
- *   START <freq_mhz> <brightness_pct> <volume_pct> <duration_s>
- *   STOP
- *   STATUS
- *   UNLOCK
- *   VERSION
- *
- * stim_parse_line() parses one trimmed line into a command. Pure.
- */
-
-typedef enum {
-    STIM_CMD_NONE = 0,
-    STIM_CMD_START,
-    STIM_CMD_STOP,
-    STIM_CMD_STATUS,
-    STIM_CMD_UNLOCK,
-    STIM_CMD_VERSION,
-} stim_cmd_kind_t;
-
-typedef struct {
-    stim_cmd_kind_t kind;
-    stim_params_t   params; /* valid when kind == STIM_CMD_START */
-} stim_cmd_t;
-
-stim_rc_t stim_parse_line(const char *line, stim_cmd_t *out);
-
-/* Human-readable tag for a return code (for "ERR <tag>" replies). */
-const char *stim_rc_str(stim_rc_t rc);
-
-/* Human-readable tag for a stop reason (for the session log). */
-const char *stim_stop_str(stim_stop_reason_t r);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* STIM_CORE_H */

firmware/esp32-gamma-stim/sdkconfig.defaults

@@ -1,9 +0,0 @@
-# esp32-gamma-stim defaults (S3/C6 class; single-purpose actuator node)
-CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
-CONFIG_PARTITION_TABLE_SINGLE_APP=y
-CONFIG_FREERTOS_HZ=1000
-# Console on USB-CDC where available; falls back to UART0.
-CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y
-# Keep radio off: this node is a deterministic actuator, not a network device.
-# (No WiFi/BT init in the firmware; nothing to configure out.)
-CONFIG_COMPILER_OPTIMIZATION_SIZE=y

firmware/esp32-gamma-stim/tests/test_stim_core.c

@@ -1,248 +0,0 @@
-/*
- * Host-side unit tests for stim_core (the safety-critical firmware core).
- * Build & run (no ESP-IDF needed):
- *
- *   cd firmware/esp32-gamma-stim
- *   gcc -Wall -Wextra -Werror -O2 -I main tests/test_stim_core.c main/stim_core.c -o /tmp/test_stim && /tmp/test_stim
- *
- * Exit code 0 = all pass. These tests cover the same invariants the
- * ruview-gamma Rust crate enforces host-side (defense in depth): envelope is
- * never exceeded, e-stop latches, fail-closed parsing, exact timing math for
- * the ±0.1 Hz HIL target.
- */
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "stim_core.h"
-
-static int tests_run = 0;
-#define RUN(t) do { t(); tests_run++; printf("ok - %s\n", #t); } while (0)
-
-static stim_ctx_t fresh(void)
-{
-    stim_ctx_t c;
-    stim_init(&c, stim_envelope_conservative());
-    return c;
-}
-
-static stim_params_t prior(void)
-{
-    stim_params_t p = {
-        .freq_mhz = 40000, .brightness_pct = 30, .volume_pct = 28, .duration_s = 600,
-    };
-    return p;
-}
-
-/* ---- envelope ------------------------------------------------------------ */
-
-static void test_prior_is_inside_envelope(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    assert(stim_validate(&c, &p) == STIM_OK);
-}
-
-static void test_frequency_outside_band_refused(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    p.freq_mhz = 35999; /* 35.999 Hz */
-    assert(stim_validate(&c, &p) == STIM_ERR_FREQ_RANGE);
-    p.freq_mhz = 44001;
-    assert(stim_validate(&c, &p) == STIM_ERR_FREQ_RANGE);
-    p.freq_mhz = 0;
-    assert(stim_validate(&c, &p) == STIM_ERR_FREQ_RANGE);
-    /* band edges are inclusive */
-    p.freq_mhz = 36000;
-    assert(stim_validate(&c, &p) == STIM_OK);
-    p.freq_mhz = 44000;
-    assert(stim_validate(&c, &p) == STIM_OK);
-}
-
-static void test_intensity_caps_refused(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    p.brightness_pct = 41;
-    assert(stim_validate(&c, &p) == STIM_ERR_BRIGHTNESS_CAP);
-    p = prior();
-    p.volume_pct = 41;
-    assert(stim_validate(&c, &p) == STIM_ERR_VOLUME_CAP);
-    p = prior();
-    p.brightness_pct = 40; /* cap value itself is allowed */
-    p.volume_pct = 40;
-    assert(stim_validate(&c, &p) == STIM_OK);
-}
-
-static void test_duration_caps_refused(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    p.duration_s = 0;
-    assert(stim_validate(&c, &p) == STIM_ERR_ZERO_DURATION);
-    p.duration_s = 901;
-    assert(stim_validate(&c, &p) == STIM_ERR_DURATION_CAP);
-    p.duration_s = 900;
-    assert(stim_validate(&c, &p) == STIM_OK);
-}
-
-/* ---- state machine --------------------------------------------------------- */
-
-static void test_start_refused_while_running(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    assert(stim_start(&c, &p) == STIM_OK);
-    assert(c.state == STIM_RUNNING);
-    assert(stim_start(&c, &p) == STIM_ERR_BUSY);
-}
-
-static void test_out_of_envelope_start_keeps_outputs_off(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    p.brightness_pct = 90;
-    assert(stim_start(&c, &p) == STIM_ERR_BRIGHTNESS_CAP);
-    assert(c.state == STIM_IDLE);     /* fail closed */
-    assert(!c.envelope_on);
-    assert(c.session_seq == 0);       /* no session consumed */
-}
-
-static void test_estop_latches_from_any_state(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    assert(stim_start(&c, &p) == STIM_OK);
-    stim_estop(&c, STIM_STOP_BUTTON);
-    assert(c.state == STIM_LOCKED);
-    assert(!c.envelope_on);
-    /* START must be refused while latched — a session can never silently
-     * resume after an e-stop (mirrors the Rust SafetyMonitor latch). */
-    assert(stim_start(&c, &p) == STIM_ERR_LOCKED);
-    /* Host STOP does not clear the latch either. */
-    stim_stop_host(&c);
-    assert(c.state == STIM_LOCKED);
-    /* Only the explicit operator UNLOCK clears it. */
-    assert(stim_unlock(&c) == STIM_OK);
-    assert(c.state == STIM_IDLE);
-    assert(stim_start(&c, &p) == STIM_OK);
-}
-
-static void test_session_completes_after_duration(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    p.freq_mhz = 40000;
-    p.duration_s = 1; /* 1 s @ 40 Hz = 80 half-periods */
-    assert(stim_start(&c, &p) == STIM_OK);
-    uint32_t total = stim_session_half_periods(p.freq_mhz, p.duration_s);
-    assert(total == 80);
-    for (uint32_t i = 0; i < total - 1; i++) {
-        assert(stim_tick(&c));
-    }
-    assert(!stim_tick(&c)); /* final tick ends the session */
-    assert(c.state == STIM_IDLE);
-    assert(c.last_stop == STIM_STOP_COMPLETED);
-    assert(!c.envelope_on);
-}
-
-static void test_tick_alternates_envelope(void)
-{
-    stim_ctx_t c = fresh();
-    stim_params_t p = prior();
-    assert(stim_start(&c, &p) == STIM_OK);
-    assert(!c.envelope_on);
-    stim_tick(&c);
-    assert(c.envelope_on);
-    stim_tick(&c);
-    assert(!c.envelope_on);
-}
-
-/* ---- timing math (the ±0.1 Hz HIL target is integer-exact) ----------------- */
-
-static void test_half_period_math_is_exact(void)
-{
-    assert(stim_half_period_us(40000) == 12500); /* 40.0 Hz */
-    assert(stim_half_period_us(36000) == 13888); /* 36.0 Hz, floor of 13888.9 */
-    assert(stim_half_period_us(44000) == 11363); /* 44.0 Hz, floor of 11363.6 */
-    assert(stim_half_period_us(38500) == 12987); /* 38.5 Hz */
-    /* Worst-case truncation at 44 Hz: commanded period = 2*11363us = 22726us
-     * -> 44.0028 Hz, an error of 2.8 mHz — 35x inside the ±100 mHz target. */
-}
-
-static void test_session_half_periods_math(void)
-{
-    assert(stim_session_half_periods(40000, 600) == 48000); /* 10 min @ 40 Hz */
-    assert(stim_session_half_periods(44000, 900) == 79200);
-    assert(stim_session_half_periods(36000, 1) == 72);
-}
-
-/* ---- protocol parsing -------------------------------------------------------- */
-
-static void test_parse_start(void)
-{
-    stim_cmd_t cmd;
-    assert(stim_parse_line("START 40000 30 28 600", &cmd) == STIM_OK);
-    assert(cmd.kind == STIM_CMD_START);
-    assert(cmd.params.freq_mhz == 40000);
-    assert(cmd.params.brightness_pct == 30);
-    assert(cmd.params.volume_pct == 28);
-    assert(cmd.params.duration_s == 600);
-}
-
-static void test_parse_simple_commands(void)
-{
-    stim_cmd_t cmd;
-    assert(stim_parse_line("STOP", &cmd) == STIM_OK && cmd.kind == STIM_CMD_STOP);
-    assert(stim_parse_line("STATUS", &cmd) == STIM_OK && cmd.kind == STIM_CMD_STATUS);
-    assert(stim_parse_line("UNLOCK", &cmd) == STIM_OK && cmd.kind == STIM_CMD_UNLOCK);
-    assert(stim_parse_line("VERSION", &cmd) == STIM_OK && cmd.kind == STIM_CMD_VERSION);
-    assert(stim_parse_line("  STOP", &cmd) == STIM_OK); /* leading spaces ok */
-}
-
-static void test_parse_rejects_malformed(void)
-{
-    stim_cmd_t cmd;
-    assert(stim_parse_line("START", &cmd) == STIM_ERR_PARSE);
-    assert(stim_parse_line("START 40000 30 28", &cmd) == STIM_ERR_PARSE);
-    assert(stim_parse_line("START 40000 30 28 600 junk", &cmd) == STIM_ERR_PARSE);
-    assert(stim_parse_line("START 40000 999 28 600", &cmd) == STIM_ERR_PARSE);
-    assert(stim_parse_line("START -1 30 28 600", &cmd) == STIM_ERR_PARSE);
-    assert(stim_parse_line("START 99999999999 30 28 600", &cmd) == STIM_ERR_PARSE);
-    assert(stim_parse_line("FLASHBANG", &cmd) == STIM_ERR_UNKNOWN_CMD);
-    assert(stim_parse_line("STOPX", &cmd) == STIM_ERR_UNKNOWN_CMD);
-    assert(stim_parse_line("", &cmd) == STIM_ERR_UNKNOWN_CMD);
-}
-
-static void test_parsed_hostile_start_is_still_refused_by_envelope(void)
-{
-    /* End-to-end fail-closed: a syntactically valid but unsafe command parses
-     * fine and is then refused by validation — never reaches the outputs. */
-    stim_ctx_t c = fresh();
-    stim_cmd_t cmd;
-    assert(stim_parse_line("START 60000 40 40 600", &cmd) == STIM_OK);
-    assert(stim_start(&c, &cmd.params) == STIM_ERR_FREQ_RANGE);
-    assert(c.state == STIM_IDLE);
-}
-
-int main(void)
-{
-    RUN(test_prior_is_inside_envelope);
-    RUN(test_frequency_outside_band_refused);
-    RUN(test_intensity_caps_refused);
-    RUN(test_duration_caps_refused);
-    RUN(test_start_refused_while_running);
-    RUN(test_out_of_envelope_start_keeps_outputs_off);
-    RUN(test_estop_latches_from_any_state);
-    RUN(test_session_completes_after_duration);
-    RUN(test_tick_alternates_envelope);
-    RUN(test_half_period_math_is_exact);
-    RUN(test_session_half_periods_math);
-    RUN(test_parse_start);
-    RUN(test_parse_simple_commands);
-    RUN(test_parse_rejects_malformed);
-    RUN(test_parsed_hostile_start_is_still_refused_by_envelope);
-    printf("\nall %d stim_core tests passed\n", tests_run);
-    return 0;
-}

firmware/esp32-gamma-stim/version.txt

@@ -1 +0,0 @@
-0.1.0

scripts/calibrate-camera-room.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""Two-checkerboard camera-room calibration for WiFi pose training (ADR-152 S2.1.3).
+
+Aligns the ADR-079 ground-truth camera and the ESP32 WiFi transceivers in
+one shared 3D room frame -- the PerceptAlign (arXiv 2601.12252) defense
+against "coordinate overfitting", where CSI-to-camera-coordinate regression
+memorizes the deployment layout and collapses cross-layout.
+
+Procedure (<5 minutes):
+  1. Print a checkerboard (default 9x6 inner corners, 25 mm squares).
+  2. Tape one board flat on the ORIGIN WALL, tape-measure its top-left inner
+     corner position in room coordinates (+x along wall, +y into room, +z up).
+  3. Lay the second board flat on the FLOOR, measure its near-left inner corner.
+  4. With the collection camera in its final position, photograph each board.
+  5. Run this script; tape-measure each ESP32 node position when prompted
+     (or pass --geometry nodes.json).
+
+Output: a calibration bundle JSON consumed by
+    scripts/collect-ground-truth.py --calibration <bundle.json>
+
+Usage:
+    python scripts/calibrate-camera-room.py \\
+        --wall-image photos/wall.jpg --wall-origin 0.50,0.0,1.60 \\
+        --floor-image photos/floor.jpg --floor-origin 1.00,1.00,0.0 \\
+        --calib-images "photos/intrinsics/*.jpg" \\
+        --geometry config/transceivers.json \\
+        --output data/calibration/camera-room.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import calibration_lib as cal  # noqa: E402
+
+INTRINSICS_CACHE = Path("data") / ".cache" / "camera_intrinsics.json"
+
+
+def parse_vec3(text: str) -> np.ndarray:
+    parts = [float(p) for p in text.replace(",", " ").split()]
+    if len(parts) != 3:
+        raise argparse.ArgumentTypeError(f"Expected 3 comma-separated numbers, got {text!r}")
+    return np.array(parts, dtype=np.float64)
+
+
+def detect_corners(image_path: Path, cols: int, rows: int) -> tuple[np.ndarray, tuple[int, int]]:
+    image = cv2.imread(str(image_path))
+    if image is None:
+        print(f"ERROR: Cannot read image {image_path}", file=sys.stderr)
+        sys.exit(1)
+    corners = cal.find_board_corners(image, cols, rows)
+    if corners is None:
+        print(
+            f"ERROR: No {cols}x{rows} checkerboard found in {image_path}. "
+            "Check lighting, focus, and the --board-cols/--board-rows flags.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    h, w = image.shape[:2]
+    return corners, (w, h)
+
+
+def resolve_intrinsics(args, repo_root: Path, board_args: tuple[int, int, float]) -> dict:
+    """Pre-computed file > cached > computed from --calib-images >
+    last-resort 2-view estimate from the wall+floor photos themselves."""
+    cols, rows, square_m = board_args
+
+    if args.intrinsics:
+        print(f"Intrinsics: loading {args.intrinsics}")
+        return cal.load_intrinsics(Path(args.intrinsics))
+
+    cache_path = repo_root / INTRINSICS_CACHE
+    if cache_path.exists() and not args.recalibrate_intrinsics:
+        print(f"Intrinsics: using cached {cache_path} (pass --recalibrate-intrinsics to redo)")
+        intr = cal.load_intrinsics(cache_path)
+        intr["source"] = "cached"
+        return intr
+
+    if args.calib_images:
+        paths = sorted(glob.glob(args.calib_images))
+        if len(paths) < 3:
+            print(
+                f"ERROR: --calib-images matched only {len(paths)} file(s); "
+                "need >= 3 checkerboard views for stable intrinsics.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        corner_sets, image_size = [], None
+        for p in paths:
+            corners, size = detect_corners(Path(p), cols, rows)
+            if image_size is None:
+                image_size = size
+            elif size != image_size:
+                print(f"ERROR: {p} has size {size}, expected {image_size}.", file=sys.stderr)
+                sys.exit(1)
+            corner_sets.append(corners)
+            print(f"  corners found: {p}")
+        intr = cal.compute_intrinsics(corner_sets, image_size, cols, rows, square_m)
+        print(f"Intrinsics: computed from {len(paths)} views, "
+              f"reprojection RMS {intr['reprojection_error_px']:.3f} px")
+        cal.save_bundle(intr, cache_path)  # plain JSON write; reused on next run
+        print(f"  cached to {cache_path}")
+        return intr
+
+    # Last resort: 2-view calibration from the extrinsic photos. Workable but
+    # weak -- warn loudly and recommend a proper multi-view pass.
+    print(
+        "WARNING: no --intrinsics / cache / --calib-images; estimating intrinsics "
+        "from the wall+floor photos alone (2 views, low quality). Prefer "
+        "--calib-images with 5-10 varied board views.",
+        file=sys.stderr,
+    )
+    corner_sets, image_size = [], None
+    for p in (args.wall_image, args.floor_image):
+        corners, size = detect_corners(Path(p), cols, rows)
+        image_size = image_size or size
+        corner_sets.append(corners)
+    intr = cal.compute_intrinsics(corner_sets, image_size, cols, rows, square_m)
+    intr["source"] = "two-view-fallback"
+    return intr
+
+
+def prompt_transceiver_geometry() -> dict:
+    """Tape-measure entry of ESP32 node positions in room coordinates."""
+    print()
+    print("Transceiver geometry -- enter one node per line:")
+    print("  <node-id> <x> <y> <z> [yaw_deg]     (meters, room frame; blank line to finish)")
+    print("  example:  esp32-s3-a 0.10 2.40 1.10 180")
+    nodes = []
+    while True:
+        try:
+            line = input("node> ").strip()
+        except EOFError:
+            break
+        if not line:
+            break
+        parts = line.split()
+        if len(parts) not in (4, 5):
+            print("  expected: <node-id> <x> <y> <z> [yaw_deg]", file=sys.stderr)
+            continue
+        try:
+            node = {"id": parts[0], "position_m": [float(parts[1]), float(parts[2]), float(parts[3])]}
+            if len(parts) == 5:
+                node["antenna_yaw_deg"] = float(parts[4])
+        except ValueError:
+            print("  positions must be numeric", file=sys.stderr)
+            continue
+        nodes.append(node)
+    if not nodes:
+        print("WARNING: no transceiver nodes entered; bundle will carry empty geometry.",
+              file=sys.stderr)
+    return {"nodes": nodes, "units": "meters", "source": "tape-measure-prompt"}
+
+
+def load_geometry_file(path: Path) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    nodes = data.get("nodes", data if isinstance(data, list) else None)
+    if nodes is None:
+        raise ValueError(f"{path}: expected {{'nodes': [...]}} or a top-level list")
+    for node in nodes:
+        if "id" not in node or "position_m" not in node:
+            raise ValueError(f"{path}: each node needs 'id' and 'position_m' [x,y,z]")
+    return {"nodes": nodes, "units": "meters", "source": "file"}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Two-checkerboard camera-room calibration (ADR-152 S2.1.3 / ADR-079)."
+    )
+    parser.add_argument("--wall-image", required=True,
+                        help="Photo of the checkerboard on the origin wall")
+    parser.add_argument("--floor-image", required=True,
+                        help="Photo of the checkerboard on the floor (camera NOT moved)")
+    parser.add_argument("--wall-origin", type=parse_vec3, default="0.5,0.0,1.6",
+                        help="Room xyz (m) of the wall board's first inner corner "
+                             "(default: 0.5,0.0,1.6)")
+    parser.add_argument("--floor-origin", type=parse_vec3, default="1.0,1.0,0.0",
+                        help="Room xyz (m) of the floor board's first inner corner "
+                             "(default: 1.0,1.0,0.0)")
+    parser.add_argument("--wall-axes", default="+x,-z",
+                        help="Wall board column,row directions in room frame (default: +x,-z)")
+    parser.add_argument("--floor-axes", default="+x,+y",
+                        help="Floor board column,row directions in room frame (default: +x,+y)")
+    parser.add_argument("--board-cols", type=int, default=cal.DEFAULT_BOARD_COLS,
+                        help=f"Inner corners per row (default: {cal.DEFAULT_BOARD_COLS})")
+    parser.add_argument("--board-rows", type=int, default=cal.DEFAULT_BOARD_ROWS,
+                        help=f"Inner corners per column (default: {cal.DEFAULT_BOARD_ROWS})")
+    parser.add_argument("--square-size-mm", type=float, default=cal.DEFAULT_SQUARE_SIZE_MM,
+                        help=f"Checkerboard square size in mm (default: {cal.DEFAULT_SQUARE_SIZE_MM})")
+    parser.add_argument("--intrinsics", help="Pre-computed intrinsics JSON (skips computation)")
+    parser.add_argument("--calib-images",
+                        help="Glob of >=3 checkerboard photos for intrinsics computation")
+    parser.add_argument("--recalibrate-intrinsics", action="store_true",
+                        help="Ignore the cached intrinsics and recompute")
+    parser.add_argument("--geometry",
+                        help="Transceiver geometry JSON ({nodes:[{id,position_m,[antenna_yaw_deg]}]}); "
+                             "omit to be prompted for tape-measure entry")
+    parser.add_argument("--output", default=None,
+                        help="Bundle output path (default: data/calibration/camera-room-<ts>.json)")
+    args = parser.parse_args()
+
+    if isinstance(args.wall_origin, str):
+        args.wall_origin = parse_vec3(args.wall_origin)
+    if isinstance(args.floor_origin, str):
+        args.floor_origin = parse_vec3(args.floor_origin)
+
+    repo_root = Path(__file__).resolve().parent.parent
+    cols, rows = args.board_cols, args.board_rows
+    square_m = args.square_size_mm / 1000.0
+
+    # --- Intrinsics ---
+    intrinsics = resolve_intrinsics(args, repo_root, (cols, rows, square_m))
+    camera_matrix = np.asarray(intrinsics["camera_matrix"], dtype=np.float64)
+    dist_coeffs = np.asarray(intrinsics["dist_coeffs"], dtype=np.float64)
+
+    # --- Corner detection on the two placed boards ---
+    wall_corners, wall_size = detect_corners(Path(args.wall_image), cols, rows)
+    floor_corners, floor_size = detect_corners(Path(args.floor_image), cols, rows)
+    if wall_size != floor_size:
+        print(f"ERROR: wall image {wall_size} and floor image {floor_size} differ in size; "
+              "both must come from the fixed collection camera.", file=sys.stderr)
+        sys.exit(1)
+    print(f"Corners detected: wall + floor boards ({cols}x{rows}, {args.square_size_mm} mm)")
+
+    # Re-scale intrinsics if they were computed at a different resolution
+    # than the extrinsic photos (the bundle always stores K at wall_size).
+    intr_size = tuple(intrinsics["image_size"])
+    if intr_size != wall_size:
+        sx, sy = wall_size[0] / intr_size[0], wall_size[1] / intr_size[1]
+        camera_matrix[0, 0] *= sx
+        camera_matrix[0, 2] *= sx
+        camera_matrix[1, 1] *= sy
+        camera_matrix[1, 2] *= sy
+        print(f"  intrinsics scaled {intr_size} -> {wall_size}")
+    intrinsics = {**intrinsics, "camera_matrix": camera_matrix.tolist(),
+                  "image_size": list(wall_size)}
+
+    # --- Room-frame corner positions from the measured placements ---
+    wall_u, wall_v = (cal.parse_axis(t) for t in args.wall_axes.split(","))
+    floor_u, floor_v = (cal.parse_axis(t) for t in args.floor_axes.split(","))
+    wall_room = cal.board_room_points(cols, rows, square_m, args.wall_origin, wall_u, wall_v)
+    floor_room = cal.board_room_points(cols, rows, square_m, args.floor_origin, floor_u, floor_v)
+
+    # --- Extrinsics: joint two-board solve (resolves per-board corner-order
+    # ambiguity -- a single planar board is centrosymmetric; the pair is not) ---
+    extrinsics = cal.solve_two_board_extrinsics(
+        wall_room, wall_corners, floor_room, floor_corners, camera_matrix, dist_coeffs
+    )
+    wall_rmse = extrinsics["per_board"]["wall"]["rmse_px"]
+    floor_rmse = extrinsics["per_board"]["floor"]["rmse_px"]
+    print(f"  joint solve: RMSE {extrinsics['rmse_px']:.3f} px "
+          f"(wall {wall_rmse:.3f} / floor {floor_rmse:.3f})")
+    print(f"  camera at room {np.round(extrinsics['translation_m'], 3).tolist()} m")
+    if max(wall_rmse, floor_rmse) > 3.0:
+        print(
+            "WARNING: high per-board reprojection error -- re-check the measured "
+            "board origins/axes and that the camera did not move between photos.",
+            file=sys.stderr,
+        )
+
+    # --- Transceiver geometry ---
+    if args.geometry:
+        geometry = load_geometry_file(Path(args.geometry))
+        print(f"Transceiver geometry: {len(geometry['nodes'])} node(s) from {args.geometry}")
+    else:
+        geometry = prompt_transceiver_geometry()
+
+    # --- Bundle ---
+    bundle = cal.make_bundle(
+        camera_intrinsics=intrinsics,
+        camera_to_room_extrinsics=extrinsics,
+        checkerboard_spec={"cols": cols, "rows": rows, "square_size_mm": args.square_size_mm},
+        transceiver_geometry=geometry,
+    )
+    if args.output:
+        out_path = Path(args.output)
+    else:
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        out_path = repo_root / "data" / "calibration" / f"camera-room-{ts}.json"
+    cal.save_bundle(bundle, out_path)
+
+    print()
+    print("=== Calibration bundle written ===")
+    print(f"  path:           {out_path}")
+    print(f"  calibration_id: {cal.calibration_id(bundle)}")
+    print(f"  next: python scripts/collect-ground-truth.py --calibration {out_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/calibration_lib.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""Camera-room calibration library for WiFi pose ground truth (ADR-152 S2.1.3).
+
+Implements the PerceptAlign-style two-checkerboard alignment adopted in
+ADR-152 S2.1.3 to defend the ADR-079 camera-supervised pipeline against
+"coordinate overfitting" (arXiv 2601.12252, MobiCom'26): models regressing
+CSI to raw camera-frame coordinates memorize the deployment layout and
+collapse cross-layout. The fix is to express camera AND WiFi transceivers
+in one shared 3D room frame, and stamp every training label with the
+calibration + transceiver geometry that produced it.
+
+Used by:
+    scripts/calibrate-camera-room.py   (produces the calibration bundle)
+    scripts/collect-ground-truth.py    (consumes it via --calibration)
+
+Room frame convention (right-handed, meters):
+    origin = a designated wall/floor corner of the room
+    +x     = along the origin wall
+    +y     = into the room (away from the origin wall)
+    +z     = up
+
+No-depth limitation (IMPORTANT): a single 2D camera keypoint constrains
+only a *ray* in the room frame, not a 3D point. The transform helpers here
+therefore return unit bearing rays from the camera center -- a projective
+alignment. Consumers that need metric 3D points must supply a depth
+assumption downstream (floor-plane intersection, known subject height,
+multi-view triangulation, ...). Raw image coordinates are always preserved
+alongside the room-frame rays so training can choose either representation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+BUNDLE_SCHEMA_VERSION = 1
+BUNDLE_METHOD = "two-checkerboard"
+
+# Default checkerboard: 9x6 inner corners, 25 mm squares (a common print).
+DEFAULT_BOARD_COLS = 9
+DEFAULT_BOARD_ROWS = 6
+DEFAULT_SQUARE_SIZE_MM = 25.0
+
+_AXIS_TOKENS = {
+    "+x": (1.0, 0.0, 0.0), "-x": (-1.0, 0.0, 0.0),
+    "+y": (0.0, 1.0, 0.0), "-y": (0.0, -1.0, 0.0),
+    "+z": (0.0, 0.0, 1.0), "-z": (0.0, 0.0, -1.0),
+}
+
+
+def parse_axis(token: str) -> np.ndarray:
+    """Parse an axis token like '+x' or '-z' into a room-frame unit vector."""
+    key = token.strip().lower()
+    if key in _AXIS_TOKENS:
+        return np.array(_AXIS_TOKENS[key], dtype=np.float64)
+    raise ValueError(f"Invalid axis token {token!r}; expected one of {sorted(_AXIS_TOKENS)}")
+
+
+# ---------------------------------------------------------------------------
+# Checkerboard geometry
+# ---------------------------------------------------------------------------
+
+def board_object_points(cols: int, rows: int, square_size_m: float) -> np.ndarray:
+    """Inner-corner positions in the board's own frame (z=0 plane), row-major.
+
+    Matches the corner ordering of cv2.findChessboardCorners for a
+    (cols, rows) pattern: cols varies fastest.
+    """
+    pts = np.zeros((rows * cols, 3), dtype=np.float64)
+    grid = np.mgrid[0:cols, 0:rows].T.reshape(-1, 2)  # (rows*cols, 2), cols fastest
+    pts[:, :2] = grid * square_size_m
+    return pts
+
+
+def board_room_points(
+    cols: int,
+    rows: int,
+    square_size_m: float,
+    origin: np.ndarray,
+    u_axis: np.ndarray,
+    v_axis: np.ndarray,
+) -> np.ndarray:
+    """Inner-corner positions in ROOM coordinates for a board placed at a
+    known position: first corner at `origin`, columns stepping along
+    `u_axis`, rows stepping along `v_axis` (both room-frame unit vectors).
+    """
+    local = board_object_points(cols, rows, square_size_m)
+    origin = np.asarray(origin, dtype=np.float64)
+    u = np.asarray(u_axis, dtype=np.float64)
+    v = np.asarray(v_axis, dtype=np.float64)
+    return origin[None, :] + local[:, 0:1] * u[None, :] + local[:, 1:2] * v[None, :]
+
+
+def find_board_corners(image: np.ndarray, cols: int, rows: int) -> np.ndarray | None:
+    """Detect and sub-pixel-refine checkerboard inner corners.
+
+    Returns (cols*rows, 2) float64 pixel coordinates, or None if not found.
+    """
+    gray = image if image.ndim == 2 else cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    flags = cv2.CALIB_CB_ADAPTIVE_THRESH | cv2.CALIB_CB_NORMALIZE_IMAGE
+    found, corners = cv2.findChessboardCorners(gray, (cols, rows), flags=flags)
+    if not found:
+        return None
+    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 1e-3)
+    corners = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
+    return corners.reshape(-1, 2).astype(np.float64)
+
+
+# ---------------------------------------------------------------------------
+# Intrinsics
+# ---------------------------------------------------------------------------
+
+def compute_intrinsics(
+    corner_sets: list[np.ndarray],
+    image_size: tuple[int, int],
+    cols: int,
+    rows: int,
+    square_size_m: float,
+) -> dict:
+    """Camera intrinsics from N checkerboard views via cv2.calibrateCamera.
+
+    corner_sets: list of (cols*rows, 2) pixel corner arrays.
+    image_size:  (width, height) of the calibration images.
+    """
+    obj = board_object_points(cols, rows, square_size_m).astype(np.float32)
+    obj_pts = [obj for _ in corner_sets]
+    img_pts = [c.reshape(-1, 1, 2).astype(np.float32) for c in corner_sets]
+    rms, camera_matrix, dist_coeffs, _, _ = cv2.calibrateCamera(
+        obj_pts, img_pts, tuple(image_size), None, None
+    )
+    return {
+        "image_size": [int(image_size[0]), int(image_size[1])],
+        "camera_matrix": camera_matrix.tolist(),
+        "dist_coeffs": dist_coeffs.ravel().tolist(),
+        "reprojection_error_px": float(rms),
+        "source": "computed",
+    }
+
+
+def load_intrinsics(path: Path) -> dict:
+    """Load a pre-computed intrinsics JSON ({camera_matrix, dist_coeffs, image_size})."""
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    # Accept either a bare intrinsics dict or a full calibration bundle.
+    intr = data.get("camera_intrinsics", data)
+    for key in ("camera_matrix", "dist_coeffs", "image_size"):
+        if key not in intr:
+            raise ValueError(f"Intrinsics file {path} missing key {key!r}")
+    intr = dict(intr)
+    intr["source"] = "file"
+    return intr
+
+
+# ---------------------------------------------------------------------------
+# Extrinsics (camera -> room rigid transform)
+# ---------------------------------------------------------------------------
+
+def reprojection_rmse(
+    room_points: np.ndarray,
+    image_points: np.ndarray,
+    rvec: np.ndarray,
+    tvec: np.ndarray,
+    camera_matrix: np.ndarray,
+    dist_coeffs: np.ndarray,
+) -> float:
+    proj, _ = cv2.projectPoints(room_points, rvec, tvec, camera_matrix, dist_coeffs)
+    err = proj.reshape(-1, 2) - image_points.reshape(-1, 2)
+    return float(np.sqrt(np.mean(np.sum(err**2, axis=1))))
+
+
+def _solve_pnp(
+    room_points: np.ndarray,
+    image_points: np.ndarray,
+    camera_matrix: np.ndarray,
+    dist_coeffs: np.ndarray,
+) -> dict | None:
+    """One solvePnP run (room->camera), inverted to camera->room. Returns
+    {rotation (3x3 camera->room), translation_m (camera center in room
+    frame), rmse_px} or None on failure.
+    """
+    ok, rvec, tvec = cv2.solvePnP(
+        room_points.reshape(-1, 1, 3),
+        image_points.reshape(-1, 1, 2),
+        camera_matrix,
+        dist_coeffs,
+        flags=cv2.SOLVEPNP_ITERATIVE,
+    )
+    if not ok:
+        return None
+    rmse = reprojection_rmse(room_points, image_points, rvec, tvec, camera_matrix, dist_coeffs)
+    r_room_to_cam, _ = cv2.Rodrigues(rvec)
+    r_cam_to_room = r_room_to_cam.T
+    camera_center_room = (-r_cam_to_room @ tvec).ravel()
+    return {
+        "rotation": r_cam_to_room.tolist(),
+        "translation_m": camera_center_room.tolist(),
+        "rmse_px": rmse,
+    }
+
+
+def solve_extrinsics(
+    room_points: np.ndarray,
+    image_points: np.ndarray,
+    camera_matrix: np.ndarray,
+    dist_coeffs: np.ndarray,
+) -> dict:
+    """Solve the camera->room rigid transform from 3D room-frame points and
+    their 2D pixel observations.
+
+    NOTE: the corner grid of a single planar checkerboard is centrosymmetric,
+    so the corner ordering returned by findChessboardCorners (which may
+    enumerate from either board end) cannot be disambiguated from one board
+    alone -- the reversed ordering fits a ghost pose with identical
+    reprojection error. Use solve_two_board_extrinsics for the full
+    two-checkerboard procedure, where the joint point set breaks the symmetry.
+    """
+    ext = _solve_pnp(room_points, image_points, camera_matrix, dist_coeffs)
+    if ext is None:
+        raise RuntimeError("solvePnP failed")
+    return ext
+
+
+def solve_two_board_extrinsics(
+    wall_room: np.ndarray,
+    wall_image: np.ndarray,
+    floor_room: np.ndarray,
+    floor_image: np.ndarray,
+    camera_matrix: np.ndarray,
+    dist_coeffs: np.ndarray,
+) -> dict:
+    """Joint camera->room solve over both checkerboards (the ADR-152 S2.1.3
+    two-checkerboard method).
+
+    Tries all 4 per-board corner-ordering combinations: each board's ordering
+    is individually ambiguous (centrosymmetric grid), but the combined
+    wall+floor point set is not, so exactly one combination reaches minimal
+    reprojection error. Returns the solve_extrinsics dict plus
+    {wall_flipped, floor_flipped, per_board: {wall|floor: {rmse_px}}}.
+    """
+    best = None
+    for wall_flipped in (False, True):
+        for floor_flipped in (False, True):
+            wi = wall_image[::-1].copy() if wall_flipped else wall_image
+            fi = floor_image[::-1].copy() if floor_flipped else floor_image
+            room = np.concatenate([wall_room, floor_room], axis=0)
+            img = np.concatenate([wi, fi], axis=0)
+            ext = _solve_pnp(room, img, camera_matrix, dist_coeffs)
+            if ext is None:
+                continue
+            if best is None or ext["rmse_px"] < best[0]["rmse_px"]:
+                ext["wall_flipped"] = wall_flipped
+                ext["floor_flipped"] = floor_flipped
+                rvec, _ = cv2.Rodrigues(np.asarray(ext["rotation"]).T)
+                tvec = -np.asarray(ext["rotation"]).T @ np.asarray(ext["translation_m"])
+                ext["per_board"] = {
+                    "wall": {"rmse_px": reprojection_rmse(
+                        wall_room, wi, rvec, tvec, camera_matrix, dist_coeffs)},
+                    "floor": {"rmse_px": reprojection_rmse(
+                        floor_room, fi, rvec, tvec, camera_matrix, dist_coeffs)},
+                }
+                best = (ext,)
+    if best is None:
+        raise RuntimeError("solvePnP failed for all corner-ordering combinations")
+    return best[0]
+
+
+def extrinsics_consistency(ext_a: dict, ext_b: dict) -> dict:
+    """Angular + translational disagreement between two extrinsic solutions
+    (the two single-board solves). Large values mean a mis-entered board
+    placement or a bad corner detection.
+    """
+    ra = np.asarray(ext_a["rotation"])
+    rb = np.asarray(ext_b["rotation"])
+    r_delta = ra.T @ rb
+    angle = float(np.degrees(np.arccos(np.clip((np.trace(r_delta) - 1.0) / 2.0, -1.0, 1.0))))
+    t_delta = float(
+        np.linalg.norm(np.asarray(ext_a["translation_m"]) - np.asarray(ext_b["translation_m"]))
+    )
+    return {"rotation_deg": angle, "translation_m": t_delta}
+
+
+# ---------------------------------------------------------------------------
+# Calibration bundle (the artifact written to disk)
+# ---------------------------------------------------------------------------
+
+def make_bundle(
+    camera_intrinsics: dict,
+    camera_to_room_extrinsics: dict,
+    checkerboard_spec: dict,
+    transceiver_geometry: dict,
+) -> dict:
+    return {
+        "schema_version": BUNDLE_SCHEMA_VERSION,
+        "method": BUNDLE_METHOD,
+        "calibrated_at": datetime.now(timezone.utc).isoformat(),
+        "room_frame": {
+            "description": "right-handed; origin at wall/floor corner; "
+            "+x along origin wall, +y into room, +z up",
+            "units": "meters",
+        },
+        "checkerboard_spec": checkerboard_spec,
+        "camera_intrinsics": camera_intrinsics,
+        "camera_to_room_extrinsics": camera_to_room_extrinsics,
+        "transceiver_geometry": transceiver_geometry,
+    }
+
+
+def calibration_id(bundle: dict) -> str:
+    """Stable content hash of a bundle -- stamped onto every emitted sample
+    so a label can always be traced to the exact calibration that framed it.
+    """
+    canonical = json.dumps(bundle, sort_keys=True, separators=(",", ":"))
+    return "sha256:" + hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def save_bundle(bundle: dict, path: Path) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(bundle, f, indent=2)
+        f.write("\n")
+
+
+def load_bundle(path: Path) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        bundle = json.load(f)
+    for key in ("camera_intrinsics", "camera_to_room_extrinsics", "transceiver_geometry"):
+        if key not in bundle:
+            raise ValueError(f"Calibration bundle {path} missing key {key!r}")
+    return bundle
+
+
+# ---------------------------------------------------------------------------
+# Keypoint transform (image -> room-frame bearing rays)
+# ---------------------------------------------------------------------------
+
+class CalibrationContext:
+    """Pre-computed transform state for a collection session.
+
+    Scales the bundle's intrinsics to the live capture resolution (MediaPipe
+    keypoints are normalized [0,1], so we need the actual frame size to get
+    back to pixels before undistorting).
+    """
+
+    def __init__(self, bundle: dict, frame_w: int, frame_h: int):
+        self.bundle = bundle
+        self.calibration_id = calibration_id(bundle)
+        self.transceiver_geometry = bundle["transceiver_geometry"]
+        self.frame_w = int(frame_w)
+        self.frame_h = int(frame_h)
+
+        intr = bundle["camera_intrinsics"]
+        k = np.asarray(intr["camera_matrix"], dtype=np.float64)
+        cal_w, cal_h = intr["image_size"]
+        sx = self.frame_w / float(cal_w)
+        sy = self.frame_h / float(cal_h)
+        k = k.copy()
+        k[0, 0] *= sx
+        k[0, 2] *= sx
+        k[1, 1] *= sy
+        k[1, 2] *= sy
+        self.camera_matrix = k
+        self.dist_coeffs = np.asarray(intr["dist_coeffs"], dtype=np.float64)
+
+        ext = bundle["camera_to_room_extrinsics"]
+        self.r_cam_to_room = np.asarray(ext["rotation"], dtype=np.float64)
+        self.origin_room = np.asarray(ext["translation_m"], dtype=np.float64)
+
+    def transform_keypoints(self, keypoints_norm: list[list[float]]) -> tuple[np.ndarray, np.ndarray]:
+        """Normalized [0,1] image keypoints -> unit bearing rays in the room
+        frame, anchored at the camera center.
+
+        Projective alignment ONLY (no depth): each returned ray is the locus
+        of room positions consistent with the 2D observation. Returns
+        (camera_origin_room (3,), ray_dirs (N, 3) unit vectors).
+        """
+        pts = np.asarray(keypoints_norm, dtype=np.float64)
+        pts_px = pts * np.array([self.frame_w, self.frame_h], dtype=np.float64)
+        undist = cv2.undistortPoints(
+            pts_px.reshape(-1, 1, 2), self.camera_matrix, self.dist_coeffs
+        ).reshape(-1, 2)
+        rays_cam = np.concatenate([undist, np.ones((len(undist), 1))], axis=1)
+        rays_cam /= np.linalg.norm(rays_cam, axis=1, keepdims=True)
+        rays_room = (self.r_cam_to_room @ rays_cam.T).T
+        return self.origin_room, rays_room
+
+
+def load_calibration_context(path: Path, frame_w: int, frame_h: int) -> CalibrationContext:
+    return CalibrationContext(load_bundle(path), frame_w, frame_h)
+
+
+def augment_record(record: dict, ctx: CalibrationContext | None) -> dict:
+    """Stamp a ground-truth record with room-frame rays + calibration metadata.
+
+    With ctx=None this is the identity -- the record (and hence the emitted
+    JSONL line) is byte-identical to the pre-calibration ADR-079 format.
+    Raw image-coordinate keypoints are kept untouched in both cases; the
+    room-frame representation is ADDED, never substituted, so training can
+    choose either (ADR-152 S2.1.3).
+    """
+    if ctx is None:
+        return record
+    if record.get("keypoints"):
+        _, rays = ctx.transform_keypoints(record["keypoints"])
+        record["keypoints_room"] = [[round(float(v), 5) for v in ray] for ray in rays]
+    else:
+        record["keypoints_room"] = []
+    record["camera_origin_room"] = [round(float(v), 5) for v in ctx.origin_room]
+    record["calibration_id"] = ctx.calibration_id
+    record["transceiver_geometry"] = ctx.transceiver_geometry
+    return record

scripts/collect-ground-truth.py

@@ -6,9 +6,19 @@ synchronizes with ESP32 CSI recording from the sensing server.
 
 Output: JSONL file in data/ground-truth/ with per-frame 17-keypoint COCO poses.
 
+With --calibration <bundle.json> (produced by scripts/calibrate-camera-room.py,
+ADR-152 S2.1.3), every record is additionally stamped with room-frame bearing
+rays for each keypoint, the calibration_id, and the transceiver geometry --
+the PerceptAlign-style defense against coordinate overfitting. Raw image
+coordinates are always kept; without depth the room-frame representation is
+a projective alignment (rays, not 3D points) -- see scripts/calibration_lib.py.
+Without --calibration the output is byte-identical to the original ADR-079
+format.
+
 Usage:
     python scripts/collect-ground-truth.py --preview --duration 60
     python scripts/collect-ground-truth.py --server http://192.168.1.10:3000
+    python scripts/collect-ground-truth.py --calibration data/calibration/camera-room.json
 """
 
 from __future__ import annotations
@@ -168,8 +178,23 @@ def main():
         default="data/ground-truth",
         help="Output directory (default: data/ground-truth)",
     )
+    parser.add_argument(
+        "--calibration",
+        default=None,
+        help="Camera-room calibration bundle JSON from scripts/calibrate-camera-room.py "
+        "(ADR-152 S2.1.3); adds room-frame keypoint rays + transceiver geometry "
+        "to every record",
+    )
     args = parser.parse_args()
 
+    if not args.calibration:
+        print(
+            "WARNING: no --calibration bundle; labels stay in raw camera coordinates "
+            "and are layout-brittle (coordinate overfitting, ADR-152 S2.1.3) -- run "
+            "scripts/calibrate-camera-room.py first.",
+            file=sys.stderr,
+        )
+
     # --- Resolve paths relative to repo root ---
     repo_root = Path(__file__).resolve().parent.parent
     output_dir = repo_root / args.output
@@ -193,6 +218,25 @@ def main():
     frame_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     print(f"Camera opened: {frame_w}x{frame_h}")
 
+    # --- Load calibration bundle (ADR-152 S2.1.3) ---
+    calib_ctx = None
+    if args.calibration:
+        # Lazy import keeps the no-calibration path identical to the original.
+        sys.path.insert(0, str(Path(__file__).resolve().parent))
+        import calibration_lib
+
+        try:
+            calib_ctx = calibration_lib.load_calibration_context(
+                Path(args.calibration), frame_w, frame_h
+            )
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            print(f"ERROR: Cannot load calibration bundle {args.calibration}: {exc}",
+                  file=sys.stderr)
+            sys.exit(1)
+        n_nodes = len(calib_ctx.transceiver_geometry.get("nodes", []))
+        print(f"Calibration: {calib_ctx.calibration_id[:23]}... "
+              f"({n_nodes} transceiver node(s)); emitting room-frame keypoint rays")
+
     # --- Create PoseLandmarker ---
     options = PoseLandmarkerOptions(
         base_options=BaseOptions(model_asset_path=str(model_path)),
@@ -287,6 +331,10 @@ def main():
                 "n_visible": n_visible,
                 "n_persons": n_persons,
             }
+            if calib_ctx is not None:
+                # Adds keypoints_room (bearing rays), camera_origin_room,
+                # calibration_id, transceiver_geometry (ADR-152 S2.1.3).
+                record = calibration_lib.augment_record(record, calib_ctx)
             out_file.write(json.dumps(record) + "\n")
             frame_count += 1
             total_confidence += confidence

scripts/csi-udp-relay.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Firewall-free CSI UDP relay for local Windows ESP32 testing.
+
+On Windows, a freshly-built binary (e.g. `wifi-densepose calibrate-serve`) is
+blocked from receiving inbound LAN UDP by Windows Defender Firewall unless an
+admin adds an allow rule. `python.exe` is typically already allowed. This relay
+binds the public CSI port, receives the ESP32's frames, and forwards each
+datagram verbatim to a loopback port where the calibration server listens
+(loopback is exempt from the inbound firewall). No admin required.
+
+Usage:
+    python scripts/csi-udp-relay.py --listen 5005 --forward 5006
+
+Then run the calibration server on the loopback port:
+    wifi-densepose calibrate-serve --udp-bind 127.0.0.1 --udp-port 5006
+
+Frames are passed through byte-for-byte; the relay never parses or mutates them.
+"""
+import argparse
+import socket
+import time
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Forward ESP32 CSI UDP to a loopback port (no admin).")
+    ap.add_argument("--listen", type=int, default=5005, help="public UDP port the ESP32 streams to")
+    ap.add_argument("--listen-host", default="0.0.0.0", help="bind address for the public port")
+    ap.add_argument("--forward", type=int, default=5006, help="loopback port the calibration server listens on")
+    ap.add_argument("--forward-host", default="127.0.0.1", help="loopback host to forward to")
+    ap.add_argument("--quiet", action="store_true", help="suppress the periodic stats line")
+    args = ap.parse_args()
+
+    rx = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    rx.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    rx.bind((args.listen_host, args.listen))
+    rx.settimeout(1.0)
+    tx = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    dst = (args.forward_host, args.forward)
+
+    print(f"[relay] {args.listen_host}:{args.listen}  ->  {dst[0]}:{dst[1]}  (Ctrl-C to stop)")
+    count = 0
+    last_report = time.time()
+    last_src = None
+    try:
+        while True:
+            try:
+                data, src = rx.recvfrom(2048)
+            except socket.timeout:
+                data = None
+            if data:
+                tx.sendto(data, dst)
+                count += 1
+                last_src = src
+            now = time.time()
+            if not args.quiet and now - last_report >= 5.0:
+                print(f"[relay] forwarded {count} frames (last src={last_src})")
+                last_report = now
+    except KeyboardInterrupt:
+        print(f"\n[relay] stopped after {count} frames")
+    finally:
+        rx.close()
+        tx.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/overnight-empty-capture.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Segmented overnight empty-room CSI capture (ADR-135 baseline / MAE corpus).
+
+Binds UDP once and writes fixed-duration JSONL segments with explicit names —
+no post-hoc renaming, no glob collisions with other recordings.
+
+Usage:
+    python scripts/overnight-empty-capture.py --segments 8 --segment-seconds 3300
+"""
+
+import argparse
+import json
+import os
+import socket
+import struct
+import time
+
+
+def parse_csi_packet(data):
+    """ADR-018 binary CSI packet → dict (same layout as record-csi-udp.py)."""
+    if len(data) < 8:
+        return None
+    node_id = data[4]
+    rssi = struct.unpack("b", bytes([data[6]]))[0]
+    channel = data[7]
+    iq = data[8:]
+    amplitudes = []
+    for i in range(0, len(iq) - 1, 2):
+        I = struct.unpack("b", bytes([iq[i]]))[0]
+        Q = struct.unpack("b", bytes([iq[i + 1]]))[0]
+        amplitudes.append(round((I * I + Q * Q) ** 0.5, 2))
+    return {
+        "type": "raw_csi",
+        "ts_ns": time.time_ns(),
+        "node_id": node_id,
+        "rssi": rssi,
+        "channel": channel,
+        "subcarriers": len(iq) // 2,
+        "amplitudes": amplitudes,
+        "iq_hex": iq.hex(),
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", type=int, default=5005)
+    ap.add_argument("--segments", type=int, default=8)
+    ap.add_argument("--segment-seconds", type=int, default=3300)
+    ap.add_argument("--output", default="data/recordings")
+    ap.add_argument("--prefix", default="overnight-empty")
+    args = ap.parse_args()
+
+    os.makedirs(args.output, exist_ok=True)
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.bind(("0.0.0.0", args.port))
+    sock.settimeout(2.0)
+
+    for seg in range(1, args.segments + 1):
+        path = os.path.join(
+            args.output, f"{args.prefix}-seg{seg}-{int(time.time())}.csi.jsonl"
+        )
+        n = 0
+        t_end = time.time() + args.segment_seconds
+        with open(path, "w", encoding="utf-8") as f:
+            while time.time() < t_end:
+                try:
+                    data, _ = sock.recvfrom(4096)
+                except socket.timeout:
+                    continue
+                rec = parse_csi_packet(data)
+                if rec is not None:
+                    f.write(json.dumps(rec) + "\n")
+                    n += 1
+        print(f"segment {seg}: {n} frames -> {path}", flush=True)
+
+    print("capture complete", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/prove.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# prove.sh — one-command reproduction harness for RuView / wifi-densepose.
+#
+# Mission: this project has been publicly accused of being "AI slop / fake."
+# The answer is reproducibility. Clone the repo, run THIS script, and every
+# headline claim is either VERIFIED on your machine (MEASURED) or printed as
+# "CLAIMED — not reproduced here (why)". Nothing is asserted without a command.
+#
+# Usage:
+#   bash scripts/prove.sh            # core gate + anti-slop assertion tests
+#   bash scripts/prove.sh --full     # also run the tch/GPU/dataset-gated claims
+#
+# Exit code 0 only if every NON-gated claim passes. Gated claims never fail the
+# run; they print exactly what they need (libtorch, a GPU, a dataset) so you can
+# reproduce them yourself.
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+FULL=0; [ "${1:-}" = "--full" ] && FULL=1
+
+pass=0; fail=0; skip=0
+PASS(){ echo "  [PASS] $1"; pass=$((pass+1)); }
+FAIL(){ echo "  [FAIL] $1"; fail=$((fail+1)); }
+SKIP(){ echo "  [CLAIMED — not reproduced here] $1"; skip=$((skip+1)); }
+hr(){ echo "------------------------------------------------------------"; }
+
+echo "RuView / wifi-densepose — PROOF harness"
+echo "repo: $ROOT"
+echo "date: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+hr
+
+# ── 1. HARD GATE: Rust workspace tests (no native libs required) ────────────
+echo "[1] Rust workspace tests  (cargo test --workspace --no-default-features)"
+if command -v cargo >/dev/null 2>&1; then
+  if ( cd v2 && cargo test --workspace --no-default-features ) > /tmp/prove_ws.log 2>&1; then
+    n=$(grep -oE "result: ok\. [0-9]+ passed" /tmp/prove_ws.log | grep -oE "[0-9]+" | awk '{s+=$1} END {print s}')
+    PASS "workspace tests green — ${n:-?} passed, 0 failed  (CARGO exit 0)"
+  else
+    FAIL "workspace tests — see /tmp/prove_ws.log (grep 'test result: FAILED')"
+  fi
+else
+  SKIP "cargo not installed — install Rust to run the workspace gate"
+fi
+hr
+
+# ── 2. HARD GATE: deterministic Python pipeline proof (SHA-256) ─────────────
+echo "[2] Deterministic CSI pipeline proof  (archive/v1/data/proof/verify.py)"
+if command -v python >/dev/null 2>&1; then
+  if python archive/v1/data/proof/verify.py > /tmp/prove_py.log 2>&1 && grep -q "VERDICT: PASS" /tmp/prove_py.log; then
+    PASS "Python proof VERDICT: PASS (bit-exact SHA-256 of reference features)"
+  else
+    FAIL "Python proof — see /tmp/prove_py.log"
+  fi
+else
+  SKIP "python not installed — install Python 3.10+ to run the deterministic proof"
+fi
+hr
+
+# ── 3. ANTI-SLOP ASSERTION TESTS — each encodes a headline MEASURED claim ────
+# Format: claim_test <crate> <test-name-filter> <human claim> [extra cargo args]
+claim_test(){
+  local crate="$1" filt="$2" desc="$3"; shift 3
+  if ! command -v cargo >/dev/null 2>&1; then SKIP "$desc (cargo missing)"; return; fi
+  if ( cd v2 && cargo test -p "$crate" "$@" "$filt" ) > /tmp/prove_claim.log 2>&1 \
+     && grep -qE "test result: ok\. [1-9]" /tmp/prove_claim.log; then
+    PASS "$desc"
+  else
+    # distinguish "didn't run" (feature/lib gated) from real failure
+    if grep -qE "0 passed|filtered out;? finished|error: no test target" /tmp/prove_claim.log \
+       && ! grep -q "test result: FAILED" /tmp/prove_claim.log; then
+      SKIP "$desc (test gated/absent in this build — see /tmp/prove_claim.log)"
+    else
+      FAIL "$desc — see /tmp/prove_claim.log"
+    fi
+  fi
+}
+
+# Variant for workspace-excluded crates (e.g. wasm-edge): run from the crate dir.
+claim_test_indir(){
+  local dir="$1" filt="$2" desc="$3"; shift 3
+  if ! command -v cargo >/dev/null 2>&1; then SKIP "$desc (cargo missing)"; return; fi
+  if ( cd "$dir" && cargo test "$@" "$filt" ) > /tmp/prove_claim.log 2>&1 \
+     && grep -qE "test result: ok\. [1-9]" /tmp/prove_claim.log; then
+    PASS "$desc"
+  else
+    if grep -qE "0 passed|error: no test target" /tmp/prove_claim.log \
+       && ! grep -q "test result: FAILED" /tmp/prove_claim.log; then
+      SKIP "$desc (test gated/absent — see /tmp/prove_claim.log)"
+    else
+      FAIL "$desc — see /tmp/prove_claim.log"
+    fi
+  fi
+}
+
+echo "[3] Anti-slop assertion tests (each fails on the pre-fix code)"
+echo "  ADR-156 §2.2 — fusion crafted-input DoS panics are closed:"
+claim_test wifi-densepose-ruvector triangulation_out_of_range_index_returns_none_no_panic \
+  "crafted out-of-range index returns None, no panic" --no-default-features
+
+echo "  Soul Signature §3.6 — the audit's 'identity does not lock' claim, MEASURED:"
+claim_test wifi-densepose-bfld cardiac_alone_cannot_separate_identity_matches_audit \
+  "WiFi-only cardiac+respiratory channels CANNOT separate two people (gap ~0.0005)"
+
+echo "  OccWorld — predict() is real (input-dependent), not random:"
+claim_test wifi-densepose-occworld-candle predict_is_deterministic_for_same_input \
+  "same occupancy input -> identical prediction (no randn stub)"
+
+echo "  ADR-159 A1 — pose runtime actually emits under its own default config:"
+claim_test cog-pose-estimation default_config_emits_frames_with_real_model \
+  "default install emits pose frames (confidence >= min_confidence)" --no-default-features
+
+echo "  ADR-159 A2 — person-count flags untrained classes (no count inflation):"
+claim_test cog-person-count untrained_class_argmax_is_flagged_low_confidence \
+  "argmax on an untrained class is flagged low_confidence" --no-default-features
+
+echo "  ADR-160 A1 — medical edge skills carry a not-a-medical-device disclaimer:"
+# wasm-edge is a workspace-excluded crate → run from its own directory.
+claim_test_indir v2/crates/wifi-densepose-wasm-edge a1_med_modules_have_clinical_disclaimer \
+  "every med_* module carries the experimental/non-clinical disclaimer" --features std
+hr
+
+# ── 4. DATA/HARDWARE-GATED claims — honestly NOT reproduced by this script ───
+echo "[4] DATA/HARDWARE-GATED claims (reproduce instructions, not asserted here)"
+if [ "$FULL" = "1" ]; then
+  echo "  (--full) attempting the gated claims; missing prereqs are reported, not failed:"
+  claim_test wifi-densepose-mat test_identical_vitals_no_location_dedup_to_one \
+    "ADR-158 §2 survivor dedup 3->1 (count-inflation fix)" --features mat
+else
+  SKIP "WiFlow-STD ~96% PCK@20 reproduction — needs an NVIDIA GPU + MM-Fi dataset; see benchmarks/wiflow-std/RESULTS.md"
+  SKIP "named person-identity — DATA-GATED: needs a real enrollment feeding the AETHER/body-resonance channel (see docs/research/soul/)"
+  SKIP "OccWorld trained accuracy — needs a trained checkpoint (predict() carries weights_trained=false until then)"
+  SKIP "native wlanapi 9.74 Hz scan — Windows-only; run: cargo test -p wifi-densepose-wifiscan -- --ignored measure_native_scan_rate"
+  echo "  (re-run with --full to attempt the feature-gated subset where prereqs exist)"
+fi
+hr
+
+# ── verdict ──────────────────────────────────────────────────────────────────
+echo "VERDICT:  $pass verified · $fail failed · $skip claimed-not-reproduced-here"
+if [ "$fail" -eq 0 ]; then
+  echo "RESULT: PASS — every reproducible claim verified on this machine."
+  exit 0
+else
+  echo "RESULT: FAIL — $fail claim(s) did not reproduce. See the /tmp/prove_*.log files."
+  exit 1
+fi

scripts/tests/conftest.py

@@ -0,0 +1,8 @@
+"""Make scripts/ importable for the calibration tests (ADR-152 S2.1.3)."""
+
+import sys
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))

scripts/tests/test_calibration.py

@@ -0,0 +1,326 @@
+#!/usr/bin/env python3
+"""Headless tests for the camera-room calibration pipeline (ADR-152 S2.1.3).
+
+Covers calibration_lib.py end to end on synthetic data -- no camera, no
+display, no MediaPipe:
+  * known extrinsics recovered from synthetic two-checkerboard corners
+  * calibration bundle JSON round-trip + stable content hash
+  * image->room keypoint transform correctness (rays pass through the
+    original 3D points -- the projective, no-depth alignment of ADR-079
+    labels into the shared room frame)
+  * collect-ground-truth's no-calibration record path is byte-identical
+    (augment_record with ctx=None is the identity)
+
+Run:  python -m pytest scripts/tests/ -q
+"""
+
+from __future__ import annotations
+
+import json
+
+import cv2
+import numpy as np
+import pytest
+
+import calibration_lib as cal
+
+# ---------------------------------------------------------------------------
+# Synthetic scene fixtures
+# ---------------------------------------------------------------------------
+
+IMG_W, IMG_H = 1280, 720
+K_GT = np.array(
+    [[800.0, 0.0, 640.0],
+     [0.0, 800.0, 360.0],
+     [0.0, 0.0, 1.0]]
+)
+DIST_ZERO = np.zeros(5)
+DIST_MILD = np.array([-0.10, 0.02, 0.001, -0.001, 0.0])
+
+BOARD_COLS, BOARD_ROWS = 9, 6
+SQUARE_M = 0.025
+
+
+def look_at_pose(camera_pos, target):
+    """Ground-truth camera pose: returns (R_cam_to_room, camera_center_room).
+
+    Camera convention: +z forward (optical axis), +x right, +y down.
+    """
+    c = np.asarray(camera_pos, dtype=np.float64)
+    fwd = np.asarray(target, dtype=np.float64) - c
+    fwd /= np.linalg.norm(fwd)
+    up_room = np.array([0.0, 0.0, 1.0])
+    x_cam = np.cross(fwd, -up_room)
+    x_cam /= np.linalg.norm(x_cam)
+    y_cam = np.cross(fwd, x_cam)
+    r_cam_to_room = np.stack([x_cam, y_cam, fwd], axis=1)  # columns = camera axes in room
+    return r_cam_to_room, c
+
+
+def room_to_cam(r_cam_to_room, center):
+    """Invert to the solvePnP (room->camera) convention: rvec, tvec."""
+    r_room_to_cam = r_cam_to_room.T
+    tvec = -r_room_to_cam @ center
+    rvec, _ = cv2.Rodrigues(r_room_to_cam)
+    return rvec, tvec.reshape(3, 1)
+
+
+def project_room_points(points_room, r_cam_to_room, center, k=K_GT, dist=DIST_ZERO):
+    rvec, tvec = room_to_cam(r_cam_to_room, center)
+    proj, _ = cv2.projectPoints(np.asarray(points_room, dtype=np.float64), rvec, tvec, k, dist)
+    return proj.reshape(-1, 2)
+
+
+@pytest.fixture
+def scene():
+    """A camera in the room looking at the wall + floor checkerboards."""
+    r_gt, c_gt = look_at_pose(camera_pos=[1.5, 3.0, 1.3], target=[1.0, 0.5, 0.8])
+    wall_room = cal.board_room_points(
+        BOARD_COLS, BOARD_ROWS, SQUARE_M,
+        origin=[0.5, 0.0, 1.6], u_axis=cal.parse_axis("+x"), v_axis=cal.parse_axis("-z"),
+    )
+    floor_room = cal.board_room_points(
+        BOARD_COLS, BOARD_ROWS, SQUARE_M,
+        origin=[1.0, 1.0, 0.0], u_axis=cal.parse_axis("+x"), v_axis=cal.parse_axis("+y"),
+    )
+    return r_gt, c_gt, wall_room, floor_room
+
+
+def make_bundle(r_gt, c_gt, dist=DIST_ZERO):
+    return cal.make_bundle(
+        camera_intrinsics={
+            "image_size": [IMG_W, IMG_H],
+            "camera_matrix": K_GT.tolist(),
+            "dist_coeffs": dist.tolist(),
+            "reprojection_error_px": 0.0,
+            "source": "synthetic",
+        },
+        camera_to_room_extrinsics={
+            "rotation": r_gt.tolist(),
+            "translation_m": c_gt.tolist(),
+            "rmse_px": 0.0,
+        },
+        checkerboard_spec={"cols": BOARD_COLS, "rows": BOARD_ROWS, "square_size_mm": 25.0},
+        transceiver_geometry={
+            "nodes": [
+                {"id": "esp32-s3-a", "position_m": [0.1, 2.4, 1.1], "antenna_yaw_deg": 180.0},
+                {"id": "esp32-c6-b", "position_m": [3.2, 0.3, 0.9]},
+            ],
+            "units": "meters",
+            "source": "file",
+        },
+    )
+
+
+# ---------------------------------------------------------------------------
+# Extrinsics recovery from synthetic checkerboard corners
+# ---------------------------------------------------------------------------
+
+class TestExtrinsicsRecovery:
+    def test_two_board_combined_recovers_known_pose(self, scene):
+        r_gt, c_gt, wall_room, floor_room = scene
+        room_pts = np.concatenate([wall_room, floor_room], axis=0)
+        img_pts = project_room_points(room_pts, r_gt, c_gt)
+
+        ext = cal.solve_extrinsics(room_pts, img_pts, K_GT, DIST_ZERO)
+
+        assert ext["rmse_px"] < 1e-3
+        np.testing.assert_allclose(np.asarray(ext["translation_m"]), c_gt, atol=1e-4)
+        r_delta = np.asarray(ext["rotation"]).T @ r_gt
+        angle_deg = np.degrees(np.arccos(np.clip((np.trace(r_delta) - 1) / 2, -1, 1)))
+        assert angle_deg < 0.01
+
+    def test_single_board_solves_agree(self, scene):
+        # With correct corner ordering, each board alone recovers the same pose.
+        r_gt, c_gt, wall_room, floor_room = scene
+        ext_wall = cal.solve_extrinsics(
+            wall_room, project_room_points(wall_room, r_gt, c_gt), K_GT, DIST_ZERO)
+        ext_floor = cal.solve_extrinsics(
+            floor_room, project_room_points(floor_room, r_gt, c_gt), K_GT, DIST_ZERO)
+        consistency = cal.extrinsics_consistency(ext_wall, ext_floor)
+        assert consistency["rotation_deg"] < 0.1
+        assert consistency["translation_m"] < 1e-3
+
+    def test_reversed_corner_order_auto_recovered(self, scene):
+        # findChessboardCorners may enumerate from either board end. A single
+        # board cannot disambiguate that flip (centrosymmetric grid), but the
+        # joint two-board solve can -- feed it a reversed wall ordering and
+        # require the true pose back.
+        r_gt, c_gt, wall_room, floor_room = scene
+        wall_img = project_room_points(wall_room, r_gt, c_gt)
+        floor_img = project_room_points(floor_room, r_gt, c_gt)
+        ext = cal.solve_two_board_extrinsics(
+            wall_room, wall_img[::-1].copy(), floor_room, floor_img,
+            K_GT, DIST_ZERO)
+        assert ext["wall_flipped"] is True
+        assert ext["floor_flipped"] is False
+        assert ext["rmse_px"] < 1e-3
+        np.testing.assert_allclose(np.asarray(ext["translation_m"]), c_gt, atol=1e-3)
+
+    def test_joint_solver_matches_unflipped(self, scene):
+        r_gt, c_gt, wall_room, floor_room = scene
+        ext = cal.solve_two_board_extrinsics(
+            wall_room, project_room_points(wall_room, r_gt, c_gt),
+            floor_room, project_room_points(floor_room, r_gt, c_gt),
+            K_GT, DIST_ZERO)
+        assert ext["wall_flipped"] is False and ext["floor_flipped"] is False
+        assert ext["per_board"]["wall"]["rmse_px"] < 1e-3
+        assert ext["per_board"]["floor"]["rmse_px"] < 1e-3
+
+    def test_intrinsics_recovered_from_synthetic_views(self):
+        # Several board views from different poses -> calibrateCamera should
+        # get focal length / principal point close to ground truth.
+        obj = cal.board_object_points(BOARD_COLS, BOARD_ROWS, SQUARE_M)
+        poses = [
+            ([0.05, 1.2, 0.05], [0.10, 0.0, 0.06]),
+            ([-0.25, 1.0, 0.20], [0.10, 0.0, 0.06]),
+            ([0.45, 0.9, -0.15], [0.10, 0.0, 0.06]),
+            ([0.10, 1.4, 0.30], [0.10, 0.0, 0.06]),
+            ([-0.15, 0.8, -0.20], [0.10, 0.0, 0.06]),
+        ]
+        corner_sets = []
+        for cam_pos, target in poses:
+            r, c = look_at_pose(cam_pos, target)
+            # Embed the board rigidly in the y=0 plane (u=+x, v=+z) and view it.
+            board_in_room = np.column_stack([obj[:, 0], obj[:, 2], obj[:, 1]])
+            corner_sets.append(project_room_points(board_in_room, r, c))
+        intr = cal.compute_intrinsics(corner_sets, (IMG_W, IMG_H),
+                                      BOARD_COLS, BOARD_ROWS, SQUARE_M)
+        k = np.asarray(intr["camera_matrix"])
+        assert abs(k[0, 0] - K_GT[0, 0]) / K_GT[0, 0] < 0.05
+        assert abs(k[1, 1] - K_GT[1, 1]) / K_GT[1, 1] < 0.05
+        assert intr["reprojection_error_px"] < 1.0
+
+
+# ---------------------------------------------------------------------------
+# Bundle round-trip + content hash
+# ---------------------------------------------------------------------------
+
+class TestBundle:
+    def test_save_load_roundtrip(self, scene, tmp_path):
+        r_gt, c_gt, _, _ = scene
+        bundle = make_bundle(r_gt, c_gt)
+        path = tmp_path / "camera-room.json"
+        cal.save_bundle(bundle, path)
+        loaded = cal.load_bundle(path)
+        assert loaded == bundle
+        assert cal.calibration_id(loaded) == cal.calibration_id(bundle)
+
+    def test_bundle_schema_fields(self, scene):
+        r_gt, c_gt, _, _ = scene
+        bundle = make_bundle(r_gt, c_gt)
+        for key in ("schema_version", "method", "calibrated_at", "room_frame",
+                    "checkerboard_spec", "camera_intrinsics",
+                    "camera_to_room_extrinsics", "transceiver_geometry"):
+            assert key in bundle
+        assert bundle["method"] == "two-checkerboard"
+
+    def test_calibration_id_changes_with_content(self, scene):
+        r_gt, c_gt, _, _ = scene
+        bundle_a = make_bundle(r_gt, c_gt)
+        bundle_b = json.loads(json.dumps(bundle_a))
+        bundle_b["transceiver_geometry"]["nodes"][0]["position_m"] = [0.2, 2.4, 1.1]
+        assert cal.calibration_id(bundle_a) != cal.calibration_id(bundle_b)
+        assert cal.calibration_id(bundle_a).startswith("sha256:")
+
+    def test_load_bundle_rejects_missing_keys(self, tmp_path):
+        path = tmp_path / "bad.json"
+        path.write_text('{"camera_intrinsics": {}}', encoding="utf-8")
+        with pytest.raises(ValueError, match="missing key"):
+            cal.load_bundle(path)
+
+
+# ---------------------------------------------------------------------------
+# Keypoint transform: image -> room-frame bearing rays (projective alignment)
+# ---------------------------------------------------------------------------
+
+class TestKeypointTransform:
+    PERSON_POINTS = np.array([
+        [1.2, 1.5, 1.7],   # head height
+        [1.1, 1.5, 1.4],   # shoulder
+        [1.3, 1.6, 0.9],   # hip
+        [1.2, 1.5, 0.1],   # ankle
+    ])
+
+    @pytest.mark.parametrize("dist", [DIST_ZERO, DIST_MILD], ids=["no-distortion", "mild-distortion"])
+    def test_rays_pass_through_original_points(self, scene, dist):
+        r_gt, c_gt, _, _ = scene
+        img = project_room_points(self.PERSON_POINTS, r_gt, c_gt, dist=dist)
+        kps_norm = (img / np.array([IMG_W, IMG_H])).tolist()
+
+        ctx = cal.CalibrationContext(make_bundle(r_gt, c_gt, dist=dist), IMG_W, IMG_H)
+        origin, rays = ctx.transform_keypoints(kps_norm)
+
+        np.testing.assert_allclose(origin, c_gt, atol=1e-9)
+        np.testing.assert_allclose(np.linalg.norm(rays, axis=1), 1.0, atol=1e-9)
+        for point, ray in zip(self.PERSON_POINTS, rays):
+            v = point - origin
+            # Distance from the true 3D point to the recovered ray ~ 0, and
+            # the point sits in FRONT of the camera along the ray.
+            dist_to_ray = np.linalg.norm(v - np.dot(v, ray) * ray)
+            assert dist_to_ray < 1e-4
+            assert np.dot(v, ray) > 0
+
+    def test_resolution_scaling(self, scene):
+        # Collection camera runs 640x360 while the bundle was made at
+        # 1280x720 -- normalized keypoints must land on the same rays.
+        r_gt, c_gt, _, _ = scene
+        img = project_room_points(self.PERSON_POINTS, r_gt, c_gt)
+        kps_norm = (img / np.array([IMG_W, IMG_H])).tolist()
+
+        ctx = cal.CalibrationContext(make_bundle(r_gt, c_gt), 640, 360)
+        origin, rays = ctx.transform_keypoints(kps_norm)
+        for point, ray in zip(self.PERSON_POINTS, rays):
+            v = point - origin
+            assert np.linalg.norm(v - np.dot(v, ray) * ray) < 1e-4
+
+
+# ---------------------------------------------------------------------------
+# collect-ground-truth record path (import-level; no camera loop)
+# ---------------------------------------------------------------------------
+
+class TestRecordAugmentation:
+    LEGACY_RECORD = {
+        "ts_ns": 1775300000000000000,
+        "keypoints": [[0.45, 0.12]] * 17,
+        "confidence": 0.92,
+        "n_visible": 14,
+        "n_persons": 1,
+    }
+
+    def test_no_calibration_is_byte_identical(self):
+        # The collector's no---calibration path must emit exactly the
+        # original ADR-079 JSONL line (back-compat guarantee).
+        record = json.loads(json.dumps(self.LEGACY_RECORD))
+        before = json.dumps(record)
+        out = cal.augment_record(record, None)
+        assert out is record
+        assert json.dumps(out) == before
+        assert set(out.keys()) == {"ts_ns", "keypoints", "confidence",
+                                   "n_visible", "n_persons"}
+
+    def test_calibrated_record_gains_room_fields(self, scene):
+        r_gt, c_gt, _, _ = scene
+        bundle = make_bundle(r_gt, c_gt)
+        ctx = cal.CalibrationContext(bundle, IMG_W, IMG_H)
+
+        record = json.loads(json.dumps(self.LEGACY_RECORD))
+        out = cal.augment_record(record, ctx)
+
+        # Raw image coords preserved untouched; room representation added.
+        assert out["keypoints"] == self.LEGACY_RECORD["keypoints"]
+        assert len(out["keypoints_room"]) == 17
+        assert all(len(ray) == 3 for ray in out["keypoints_room"])
+        assert out["calibration_id"] == cal.calibration_id(bundle)
+        assert out["transceiver_geometry"] == bundle["transceiver_geometry"]
+        assert len(out["camera_origin_room"]) == 3
+        json.dumps(out)  # remains JSONL-serializable
+
+    def test_empty_keypoints_record(self, scene):
+        r_gt, c_gt, _, _ = scene
+        ctx = cal.CalibrationContext(make_bundle(r_gt, c_gt), IMG_W, IMG_H)
+        record = {"ts_ns": 1, "keypoints": [], "confidence": 0.0,
+                  "n_visible": 0, "n_persons": 0}
+        out = cal.augment_record(record, ctx)
+        assert out["keypoints_room"] == []
+        assert "calibration_id" in out

v2/.gitignore

@@ -0,0 +1 @@
+baselines/

v2/Cargo.lock

@@ -3472,6 +3472,7 @@ dependencies = [
  "axum",
  "chrono",
  "dashmap",
+ "futures-util",
  "homecore",
  "http-body-util",
  "hyper 1.8.1",
@@ -3479,6 +3480,7 @@ dependencies = [
  "serde_json",
  "thiserror 1.0.69",
  "tokio",
+ "tokio-tungstenite",
  "tower 0.5.3",
  "tower-http",
  "tracing",
@@ -3552,9 +3554,13 @@ name = "homecore-plugins"
 version = "0.1.0-alpha.0"
 dependencies = [
  "async-trait",
+ "base64 0.22.1",
+ "ed25519-dalek",
+ "hex",
  "homecore",
  "serde",
  "serde_json",
+ "sha2",
  "thiserror 1.0.69",
  "tokio",
  "uuid",
@@ -7328,9 +7334,9 @@ dependencies = [
 
 [[package]]
 name = "ruvector-attention"
-version = "2.0.4"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb4233c1cecd0ea826d95b787065b398489328885042247ff5ffcbb774e864ff"
+checksum = "a92e8e456458188d04aee946579aa7cf96d7b8f276cbf6094532b2c3f6d8cc0b"
 dependencies = [
  "rand 0.8.5",
  "rayon",
@@ -7395,14 +7401,14 @@ dependencies = [
 
 [[package]]
 name = "ruvector-gnn"
-version = "2.0.5"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e17c1cf1ff3380026b299ff3c1ba3a5685c3d8d54700e6ab0b585b6cec21d7b"
+checksum = "a251f9ced8d3231395d922369edc803ef0fc513c7776128f7b4ef21f20dd1f4b"
 dependencies = [
  "anyhow",
  "dashmap",
  "libc",
- "ndarray 0.16.1",
+ "ndarray 0.17.2",
  "parking_lot",
  "rand 0.8.5",
  "rand_distr 0.4.3",
@@ -7415,9 +7421,9 @@ dependencies = [
 
 [[package]]
 name = "ruvector-mincut"
-version = "2.0.4"
+version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d62e10cbb7d80b1e2b72d55c1e3eb7f0c4c5e3f31984bc3baa9b7a02700741e"
+checksum = "d60947433f740d0f589a2911d7b72a02e07a916e7257e478b14386f0ff068fb7"
 dependencies = [
  "anyhow",
  "crossbeam",
@@ -7437,9 +7443,9 @@ dependencies = [
 
 [[package]]
 name = "ruvector-solver"
-version = "2.0.4"
+version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce69cbde4ee5747281edb1d987a8292940397723924262b6218fc19022cbf687"
+checksum = "9be7c4f61940ae8b451f88b9a629a08ee8ee5c8e6b00ab96ca10ecf59e70f558"
 dependencies = [
  "dashmap",
  "getrandom 0.2.17",
@@ -7456,35 +7462,6 @@ version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "753a07254fa68db183949ec6c7575d890da4d42404afabc11d610a720fcf570c"
 
-[[package]]
-name = "ruview-gamma"
-version = "0.3.0"
-dependencies = [
- "approx",
- "criterion",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
- "serde",
- "serde_json",
- "sha2",
- "thiserror 2.0.18",
-]
-
-[[package]]
-name = "ruview-gamma-clinic"
-version = "0.3.0"
-dependencies = [
- "axum",
- "ruview-gamma",
- "serde",
- "serde_json",
- "sha2",
- "tempfile",
- "thiserror 2.0.18",
- "tokio",
- "tower 0.4.13",
-]
-
 [[package]]
 name = "ruview-swarm"
 version = "0.1.0"
@@ -10840,12 +10817,27 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "wifi-densepose-calibration"
+version = "0.3.0"
+dependencies = [
+ "ndarray 0.17.2",
+ "num-complex",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "uuid",
+ "wifi-densepose-core",
+ "wifi-densepose-signal",
+]
+
 [[package]]
 name = "wifi-densepose-cli"
 version = "0.3.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
+ "axum",
  "chrono",
  "clap",
  "colored",
@@ -10861,9 +10853,12 @@ dependencies = [
  "tempfile",
  "thiserror 2.0.18",
  "tokio",
+ "tower 0.4.13",
+ "tower-http",
  "tracing",
  "tracing-subscriber",
  "uuid",
+ "wifi-densepose-calibration",
  "wifi-densepose-core",
  "wifi-densepose-mat",
  "wifi-densepose-signal",
@@ -10924,10 +10919,10 @@ dependencies = [
  "ruvector-mincut",
  "wifi-densepose-bfld",
  "wifi-densepose-core",
- "wifi-densepose-geo 0.1.0",
+ "wifi-densepose-geo",
  "wifi-densepose-ruvector",
  "wifi-densepose-signal",
- "wifi-densepose-worldgraph 0.3.0",
+ "wifi-densepose-worldgraph",
 ]
 
 [[package]]
@@ -10942,23 +10937,9 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "wifi-densepose-geo"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "092ea59d81e7be76d6d9c2d81628c1dbe768fd77591f0e82dd3c80e2963ff04a"
-dependencies = [
- "anyhow",
- "chrono",
- "reqwest 0.12.28",
- "serde",
- "serde_json",
- "tokio",
-]
-
 [[package]]
 name = "wifi-densepose-hardware"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "approx",
  "byteorder",
@@ -10978,7 +10959,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-mat"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "anyhow",
  "approx",
@@ -10997,6 +10978,7 @@ dependencies = [
  "ruvector-temporal-tensor",
  "serde",
  "serde_json",
+ "serialport",
  "thiserror 2.0.18",
  "tokio",
  "tokio-test",
@@ -11009,7 +10991,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-nn"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "anyhow",
  "candle-core 0.4.1",
@@ -11052,6 +11034,7 @@ dependencies = [
  "axum",
  "chrono",
  "clap",
+ "criterion",
  "dirs 5.0.1",
  "reqwest 0.12.28",
  "serde",
@@ -11062,11 +11045,11 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-ruvector"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "approx",
  "criterion",
- "ruvector-attention 2.0.4",
+ "ruvector-attention 2.1.0",
  "ruvector-attn-mincut",
  "ruvector-core",
  "ruvector-crv",
@@ -11082,7 +11065,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-sensing-server"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "axum",
  "chrono",
@@ -11107,16 +11090,16 @@ dependencies = [
  "ureq 2.12.1",
  "wifi-densepose-bfld",
  "wifi-densepose-engine",
- "wifi-densepose-geo 0.1.0",
+ "wifi-densepose-geo",
  "wifi-densepose-hardware",
  "wifi-densepose-signal",
  "wifi-densepose-wifiscan",
- "wifi-densepose-worldgraph 0.3.0",
+ "wifi-densepose-worldgraph",
 ]
 
 [[package]]
 name = "wifi-densepose-signal"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "chrono",
  "criterion",
@@ -11128,7 +11111,7 @@ dependencies = [
  "num-traits",
  "proptest",
  "rustfft",
- "ruvector-attention 2.0.4",
+ "ruvector-attention 2.1.0",
  "ruvector-attn-mincut",
  "ruvector-mincut",
  "ruvector-solver",
@@ -11143,7 +11126,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-train"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "anyhow",
  "approx",
@@ -11159,7 +11142,7 @@ dependencies = [
  "num-traits",
  "petgraph",
  "proptest",
- "ruvector-attention 2.0.4",
+ "ruvector-attention 2.1.0",
  "ruvector-attn-mincut",
  "ruvector-mincut",
  "ruvector-solver",
@@ -11181,8 +11164,9 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-vitals"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
+ "criterion",
  "serde",
  "serde_json",
  "tracing",
@@ -11212,46 +11196,34 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-wifiscan"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "serde",
  "tokio",
  "tracing",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "wifi-densepose-worldgraph"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "petgraph",
  "serde",
  "serde_json",
  "thiserror 2.0.18",
- "wifi-densepose-geo 0.1.0",
-]
-
-[[package]]
-name = "wifi-densepose-worldgraph"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13ad8df7b323061ed7afae1917dac7eedfbd24a463a668a55a16cde79df067e2"
-dependencies = [
- "petgraph",
- "serde",
- "serde_json",
- "thiserror 2.0.18",
- "wifi-densepose-geo 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "wifi-densepose-geo",
 ]
 
 [[package]]
 name = "wifi-densepose-worldmodel"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "serde",
  "serde_json",
  "thiserror 2.0.18",
  "tokio",
- "wifi-densepose-worldgraph 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "wifi-densepose-worldgraph",
 ]
 
 [[package]]

v2/Cargo.toml

@@ -28,6 +28,7 @@ members = [
     "crates/wifi-densepose-geo",
     "crates/wifi-densepose-worldgraph",  # ADR-139 — WorldGraph environmental digital twin
     "crates/wifi-densepose-engine",      # ADR-135..146 integration/composition layer
+    "crates/wifi-densepose-calibration", # ADR-151 — per-room calibration & specialist training
     "crates/nvsim",
     "crates/nvsim-server",
     "crates/homecore",                 # ADR-127 — HOMECORE state machine
@@ -71,8 +72,6 @@ members = [
     "crates/homecore-assist",      # ADR-133 — HOMECORE voice assistant + ruflo bridge
     "crates/homecore-server",      # iter-9 — HOMECORE integration binary (all 8 crates wired together)
     "crates/ruview-swarm",                         # ADR-148 — drone swarm control system
-    "crates/ruview-gamma",                         # ADR-250 — adaptive gamma entrainment (governed research platform)
-    "crates/ruview-gamma-clinic",                  # ADR-251 — clinical dashboard + hash-chained RuVector store
 ]
 # ADR-040: WASM edge crate targets wasm32-unknown-unknown (no_std),
 # excluded from workspace to avoid breaking `cargo test --workspace`.
@@ -188,15 +187,16 @@ midstreamer-temporal-compare = "0.2"
 midstreamer-attractor = "0.2"
 
 # ruvector integration (published on crates.io)
-# Vendored at v2.1.0 in vendor/ruvector; using crates.io versions until published.
+# Vendored at origin/main (a083bd77f) in vendor/ruvector; using crates.io versions
+# until published. Bumps per ADR-152 §2.6 (2026-06-10 vendor sync survey).
 ruvector-core = "2.2.0"
-ruvector-mincut = "2.0.4"
+ruvector-mincut = "2.0.6"
 ruvector-attn-mincut = "2.0.4"
 ruvector-temporal-tensor = "2.0.6"
-ruvector-solver = "2.0.4"
-ruvector-attention = "2.0.4"
+ruvector-solver = "2.0.6"
+ruvector-attention = "2.1.0"
 ruvector-crv = "0.1.1"
-ruvector-gnn = { version = "2.0.5", default-features = false }
+ruvector-gnn = { version = "2.2.0", default-features = false }
 
 
 # Internal crates

v2/crates/cog-ha-matter/Cargo.toml

@@ -5,7 +5,7 @@ edition.workspace = true
 authors.workspace = true
 license.workspace = true
 repository.workspace = true
-description = "Cognitum Cog: Home Assistant + Matter integration for the Seed (ADR-116). Wraps ADR-115's HA-DISCO + HA-MIND publisher as a Seed-installable artifact with mDNS, embedded broker, RuVector-backed thresholds, and Ed25519 witness."
+description = "Cognitum Cog: Home Assistant (MQTT) integration for the Seed (ADR-116). Wraps ADR-115's HA-DISCO + HA-MIND publisher as a Seed-installable artifact with mDNS, embedded broker, RuVector-backed thresholds, and Ed25519 witness. LAN-only (no TLS); Matter Bridge commissioning is deferred to v0.8 and not yet implemented."
 
 [[bin]]
 name = "cog-ha-matter"

v2/crates/cog-person-count/Cargo.toml

@@ -5,7 +5,7 @@ edition.workspace = true
 authors.workspace = true
 license.workspace = true
 repository.workspace = true
-description = "Cognitum Cog: learned multi-person counter from WiFi CSI (ADR-103). Replaces the PR #491 slot heuristic with a Candle-based count head + Stoer-Wagner multi-node fusion."
+description = "Cognitum Cog: WiFi-CSI presence detector + (data-gated) person count (ADR-103). Candle-based head trained on classes 0/1 (presence); the 8-class count head ships but counts above the trained range are flagged low_confidence. Stoer-Wagner multi-node fusion."
 
 [[bin]]
 name = "cog-person-count"

v2/crates/cog-person-count/src/inference.rs

@@ -24,6 +24,17 @@ pub const INPUT_TIMESTEPS: usize = 20;
 /// Count classification over {0, 1, ..., 7} persons.
 pub const COUNT_CLASSES: usize = 8;
 
+/// Highest class the shipped `count_v1` weights were actually **trained** on.
+///
+/// The count head has 8 logits, but `count_train_results.json` only has support
+/// for classes 0 and 1 (`per_class_accuracy` keys are `"0"` and `"1"`). The model
+/// is a presence detector (0 vs ≥1 person), **not** a calibrated multi-occupant
+/// counter. An argmax landing on classes 2..=7 is out-of-distribution: the logits
+/// there were never supervised against labelled data. We flag such outputs
+/// `low_confidence` so downstream consumers don't trust a fabricated headcount.
+/// (Multi-occupant *accuracy* is DATA-GATED — not fabricated here.)
+pub const MAX_TRAINED_CLASS: usize = 1;
+
 #[derive(Debug, Clone)]
 pub struct CsiWindow {
     pub data: Vec<f32>,
@@ -45,6 +56,23 @@ impl CountPrediction {
         self.probs.iter().all(|v| v.is_finite()) && self.confidence.is_finite()
     }
 
+    /// True when the maximum-likelihood class is beyond what the shipped weights
+    /// were trained on ([`MAX_TRAINED_CLASS`]). Such a prediction is out-of-
+    /// distribution — the count head's logits for classes 2..=7 were never
+    /// supervised, so the headcount is not trustworthy. Surfaced as the
+    /// `low_confidence` field on the `person.count` event (honest-clip pattern).
+    pub fn is_low_confidence(&self) -> bool {
+        self.argmax() > MAX_TRAINED_CLASS
+    }
+
+    /// Argmax clamped to [`MAX_TRAINED_CLASS`]. When the raw argmax is an
+    /// untrained class we clamp the *reported* count to the highest trained
+    /// class rather than emit a fabricated multi-occupant headcount. The raw
+    /// distribution is still available in `probs` for diagnostics.
+    pub fn clamped_count(&self) -> usize {
+        self.argmax().min(MAX_TRAINED_CLASS)
+    }
+
     /// Maximum-likelihood class.
     pub fn argmax(&self) -> usize {
         let mut best_i = 0;

v2/crates/cog-person-count/src/lib.rs

@@ -9,6 +9,7 @@
 
 pub mod fusion;
 pub mod inference;
+pub mod manifest;
 pub mod publisher;
 pub mod runtime;
 

v2/crates/cog-person-count/src/main.rs

@@ -12,7 +12,6 @@ use cog_person_count::{
     publisher, COG_ID, COG_VERSION,
 };
 use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
 use std::path::PathBuf;
 
 #[derive(Parser)]
@@ -83,19 +82,11 @@ fn cmd_version() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn cmd_manifest() -> Result<(), Box<dyn std::error::Error>> {
-    println!(
-        "{}",
-        serde_json::to_string_pretty(&json!({
-            "id": COG_ID,
-            "version": COG_VERSION,
-            "binary_url": Value::Null,
-            "binary_bytes": Value::Null,
-            "binary_sha256": Value::Null,
-            "binary_signature": Value::Null,
-            "installed_at": Value::Null,
-            "status": Value::Null,
-        }))?
-    );
+    // Emit the real, signed manifest embedded at compile time (ADR-159 §A4) —
+    // not the old hollow null skeleton. Parse-then-emit so a malformed embedded
+    // artifact fails loudly and the output is canonical JSON.
+    let spec = cog_person_count::manifest::embedded_manifest_value()?;
+    println!("{}", serde_json::to_string_pretty(&spec)?);
     Ok(())
 }
 

v2/crates/cog-person-count/src/manifest.rs

@@ -0,0 +1,77 @@
+//! Embedded signed cog manifest (ADR-100 §"manifest.json", ADR-159 §A4).
+//!
+//! The `cog-person-count manifest` subcommand emits the **real, signed**
+//! manifest the release pipeline produced — byte-for-byte the artifact served
+//! from GCS, with a real `binary_sha256`, `weights_sha256`, Ed25519
+//! `binary_signature`, and honest `build_metadata` (e.g. `training_class1_accuracy
+//! = 0.343`, not inflated). The previous implementation printed a hollow
+//! skeleton with `binary_sha256: null`, which made the CLI look unsigned even
+//! though the signed manifest existed on disk.
+//!
+//! The matching manifest for the build's target arch is selected via `cfg!`.
+
+/// Real signed manifest for `x86_64-unknown-linux-gnu`.
+pub const MANIFEST_X86_64: &str =
+    include_str!("../cog/artifacts/manifests/x86_64/manifest.json");
+
+/// Real signed manifest for `aarch64`/`arm` (the Seed appliance).
+pub const MANIFEST_ARM: &str = include_str!("../cog/artifacts/manifests/arm/manifest.json");
+
+/// The embedded signed manifest matching the build's target arch.
+pub fn embedded_manifest_str() -> &'static str {
+    if cfg!(any(target_arch = "aarch64", target_arch = "arm")) {
+        MANIFEST_ARM
+    } else {
+        MANIFEST_X86_64
+    }
+}
+
+/// Parse the embedded manifest into canonical JSON. Returns an error if the
+/// embedded artifact is malformed (so the CLI fails loudly rather than printing
+/// garbage).
+pub fn embedded_manifest_value() -> Result<serde_json::Value, serde_json::Error> {
+    serde_json::from_str(embedded_manifest_str())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// ADR-159 §A4 — the embedded manifest the CLI emits must carry a real
+    /// `binary_sha256` (the field the old hollow `cmd_manifest` left null).
+    #[test]
+    fn embedded_manifest_has_non_null_binary_sha256() {
+        let v = embedded_manifest_value().expect("embedded manifest parses");
+        let sha = v.get("binary_sha256").and_then(|s| s.as_str());
+        assert!(
+            sha.is_some(),
+            "embedded manifest must have a non-null binary_sha256 (got {:?})",
+            v.get("binary_sha256")
+        );
+        let sha = sha.unwrap();
+        assert_eq!(sha.len(), 64, "binary_sha256 must be a 32-byte hex digest");
+        assert!(
+            sha.chars().all(|c| c.is_ascii_hexdigit()),
+            "binary_sha256 must be hex"
+        );
+    }
+
+    #[test]
+    fn embedded_manifest_is_signed() {
+        let v = embedded_manifest_value().expect("parse");
+        assert!(
+            v.get("binary_signature").and_then(|s| s.as_str()).is_some(),
+            "embedded manifest must carry an Ed25519 binary_signature"
+        );
+        assert_eq!(
+            v.get("sig_algo").and_then(|s| s.as_str()),
+            Some("Ed25519")
+        );
+    }
+
+    #[test]
+    fn embedded_manifest_id_matches_cog() {
+        let v = embedded_manifest_value().expect("parse");
+        assert_eq!(v.get("id").and_then(|s| s.as_str()), Some(crate::COG_ID));
+    }
+}

v2/crates/cog-person-count/src/publisher.rs

@@ -45,20 +45,35 @@ pub fn run_started(cog_id: &str, sensing_url: &str, poll_ms: u64, model_path: &s
             "sensing_url": sensing_url,
             "poll_ms": poll_ms,
             "model_path": model_path,
+            // Honest disclosure: the count head has 8 classes but the shipped
+            // weights were only trained on classes 0..=MAX_TRAINED_CLASS
+            // (presence, not multi-occupant counting). Counts above this are
+            // flagged `low_confidence` on each person.count event.
+            "count_max_trained_class": crate::inference::MAX_TRAINED_CLASS,
+            "count_classes": crate::inference::COUNT_CLASSES,
         }),
     });
 }
 
 pub fn person_count(tick: u64, fused: &CountPrediction, n_nodes: usize) {
     let (lo, hi) = fused.p95_range();
+    let low_confidence = fused.is_low_confidence();
     emit_event(&Event {
         ts: now_secs(),
-        level: "info",
+        // An out-of-distribution count (argmax beyond the trained classes) is
+        // a warning, not a clean info reading.
+        level: if low_confidence { "warn" } else { "info" },
         event: "person.count",
         fields: json!({
             "tick": tick,
-            "count": fused.argmax(),
+            // Reported count is clamped to the trained range — we never emit a
+            // fabricated multi-occupant headcount the weights can't back.
+            "count": fused.clamped_count(),
+            // Raw argmax kept for diagnostics/audit.
+            "raw_count": fused.argmax(),
             "confidence": fused.confidence,
+            // True when argmax > MAX_TRAINED_CLASS (untrained class).
+            "low_confidence": low_confidence,
             "count_p95_low": lo,
             "count_p95_high": hi,
             "n_nodes": n_nodes,

v2/crates/cog-person-count/tests/smoke.rs

@@ -4,7 +4,7 @@ use cog_person_count::{
     fusion::{fuse_confidence_weighted, fuse_with_mincut_clip},
     inference::{
         CountPrediction, CsiWindow, InferenceEngine, SyntheticInput, COUNT_CLASSES,
-        INPUT_SUBCARRIERS, INPUT_TIMESTEPS,
+        INPUT_SUBCARRIERS, INPUT_TIMESTEPS, MAX_TRAINED_CLASS,
     },
 };
 
@@ -83,6 +83,51 @@ fn fusion_passes_through_single_node() {
     assert!((out.confidence - 0.6).abs() < 1e-6);
 }
 
+/// ADR-159 §A2 — the 8-class count head ships, but the weights were only
+/// trained on classes 0/1 (presence). A prediction whose argmax lands on an
+/// UNTRAINED class (2..=7) must be flagged `low_confidence` and the reported
+/// count clamped to the trained range, so we never emit a fabricated
+/// multi-occupant headcount. Fails on old code (no such flag/clamp existed).
+#[test]
+fn untrained_class_argmax_is_flagged_low_confidence() {
+    // Sanity: the trained ceiling is below the head width.
+    assert!(MAX_TRAINED_CLASS < COUNT_CLASSES - 1);
+
+    // Mass on an untrained class (5 persons) — out-of-distribution.
+    let mut probs = [0.0_f32; COUNT_CLASSES];
+    probs[5] = 0.9;
+    probs[1] = 0.1;
+    let oodp = CountPrediction {
+        probs,
+        confidence: 0.95, // even a "confident" softmax must be flagged
+    };
+    assert_eq!(oodp.argmax(), 5);
+    assert!(
+        oodp.is_low_confidence(),
+        "argmax beyond MAX_TRAINED_CLASS must be flagged low_confidence"
+    );
+    assert_eq!(
+        oodp.clamped_count(),
+        MAX_TRAINED_CLASS,
+        "reported count must clamp to the trained ceiling, not fabricate a headcount"
+    );
+
+    // A trained-range prediction (1 person) is NOT flagged.
+    let mut probs2 = [0.0_f32; COUNT_CLASSES];
+    probs2[1] = 0.8;
+    probs2[0] = 0.2;
+    let inp = CountPrediction {
+        probs: probs2,
+        confidence: 0.8,
+    };
+    assert_eq!(inp.argmax(), 1);
+    assert!(
+        !inp.is_low_confidence(),
+        "a trained-range count must not be flagged"
+    );
+    assert_eq!(inp.clamped_count(), 1);
+}
+
 #[test]
 fn mincut_clip_with_high_cap_is_noop() {
     let mut probs = [0.0_f32; COUNT_CLASSES];

v2/crates/cog-pose-estimation/cog/config.schema.json

@@ -26,8 +26,8 @@
       "type": "number",
       "minimum": 0,
       "maximum": 1,
-      "default": 0.3,
-      "description": "Drop frames where the inferred pose confidence is below this threshold."
+      "default": 0.185,
+      "description": "Drop frames where the inferred pose confidence is below this threshold. pose_v1 has no confidence head, so every frame carries the model's published per-frame confidence (0.185 = validation PCK@50); the default is pinned to that value so a default install actually emits frames. Raising it above 0.185 suppresses ALL pose.frame events (the runtime warns when this happens)."
     }
   },
   "required": ["model_path"]

v2/crates/cog-pose-estimation/src/config.rs

@@ -23,6 +23,13 @@ pub struct CogConfig {
     pub poll_ms: u64,
 
     /// Confidence threshold below which a frame's keypoints are not emitted.
+    ///
+    /// Defaults to [`crate::inference::MODEL_TYPICAL_CONFIDENCE`] (0.185) — the
+    /// model's published per-frame confidence. `pose_v1` has no confidence head,
+    /// so every frame carries this same value; a default above it would silently
+    /// suppress *all* `pose.frame` events while health still reports healthy.
+    /// The runtime warns at `run.started` if this is raised above the model's
+    /// typical confidence rather than dropping frames quietly.
     #[serde(default = "default_min_confidence")]
     pub min_confidence: f32,
 }
@@ -36,7 +43,9 @@ fn default_poll_ms() -> u64 {
 }
 
 fn default_min_confidence() -> f32 {
-    0.3
+    // Pinned to the model's typical/published confidence so a default install
+    // actually emits frames. See `min_confidence` doc and ADR-159 §A1.
+    crate::inference::MODEL_TYPICAL_CONFIDENCE
 }
 
 impl CogConfig {

v2/crates/cog-pose-estimation/src/inference.rs

@@ -27,6 +27,16 @@ pub const INPUT_SUBCARRIERS: usize = 56;
 pub const INPUT_TIMESTEPS: usize = 20;
 pub const OUTPUT_KEYPOINTS: usize = 17;
 
+/// The model's typical self-reported confidence. `pose_v1` has **no confidence
+/// head** (the head emits 34 keypoint coordinates only), so per-frame confidence
+/// is not available from the network. This is the validation-set PCK@50 (18.5%)
+/// the training run reported, used as the published per-frame confidence floor.
+///
+/// Surfaced as a public constant so the runtime can warn when a configured
+/// `min_confidence` threshold exceeds it — otherwise a default install would
+/// silently emit zero `pose.frame` events while health reports healthy.
+pub const MODEL_TYPICAL_CONFIDENCE: f32 = 0.185;
+
 #[derive(Debug, Clone)]
 pub struct CsiWindow {
     pub data: Vec<f32>, // length INPUT_SUBCARRIERS * INPUT_TIMESTEPS
@@ -283,12 +293,15 @@ impl InferenceEngine {
         let out = model.net.forward(&t)?; // [1, 34]
         let flat: Vec<f32> = out.flatten_all()?.to_vec1()?;
         // Confidence from pose_v1 is a published constant rather than per-frame —
-        // the trained model didn't emit a confidence head. Use the validation-set
-        // PCK@50 (18.5%) as the published self-reported confidence so downstream
-        // consumers can gate display decisions on it.
+        // the trained model has no confidence head (the head emits 34 keypoint
+        // coordinates only), so a real per-frame value is genuinely unavailable.
+        // We surface the validation-set PCK@50 (`MODEL_TYPICAL_CONFIDENCE`) as the
+        // honest self-reported confidence. The runtime's `min_confidence` default
+        // is pinned at or below this so a default install actually emits frames
+        // (and warns if an operator raises the threshold above the model's reach).
         Ok(PoseOutput {
             keypoints: flat,
-            confidence: 0.185,
+            confidence: MODEL_TYPICAL_CONFIDENCE,
         })
     }
 }

v2/crates/cog-pose-estimation/src/main.rs

@@ -113,6 +113,18 @@ fn cmd_run(
     let cfg = CogConfig::load(&config_path)?;
     emit_event(&Event::run_started(COG_ID, &cfg));
 
+    // Disclosure: pose_v1 has no confidence head, so every frame carries the
+    // same `MODEL_TYPICAL_CONFIDENCE`. A `min_confidence` above that silently
+    // suppresses *all* pose.frame events. Warn loudly rather than drop quietly.
+    if cfg.min_confidence > cog_pose_estimation::inference::MODEL_TYPICAL_CONFIDENCE {
+        tracing::warn!(
+            min_confidence = cfg.min_confidence,
+            model_typical_confidence = cog_pose_estimation::inference::MODEL_TYPICAL_CONFIDENCE,
+            "configured min_confidence exceeds the model's typical confidence; \
+             no pose.frame events will be emitted until this is lowered"
+        );
+    }
+
     let engine = InferenceEngine::with_adapter(adapter.as_deref())?;
     if engine.is_calibrated() {
         tracing::info!("per-room calibration adapter loaded");

v2/crates/cog-pose-estimation/tests/smoke.rs

@@ -172,3 +172,56 @@ fn manifest_roundtrips() {
     assert_eq!(back.id, "pose-estimation");
     assert_eq!(back.version, "0.0.1");
 }
+
+/// ADR-159 §A1 — the default-config min_confidence threshold must not silently
+/// suppress every `pose.frame`. With the old `default_min_confidence()=0.3` and
+/// the model's per-frame confidence pinned at 0.185, the runtime gate
+/// (`out.confidence >= cfg.min_confidence`) never fired, so a default install
+/// emitted ZERO frames while health reported healthy. This asserts the default
+/// install actually clears its own gate.
+#[test]
+fn default_config_emits_frames_with_real_model() {
+    use cog_pose_estimation::config::CogConfig;
+
+    // A minimal config (only the required model_path) exercises every
+    // `#[serde(default)]` path — i.e. the *default* install threshold.
+    let cfg: CogConfig =
+        serde_json::from_value(serde_json::json!({ "model_path": "pose_v1.safetensors" }))
+            .expect("default config parse");
+
+    // Real model when present; stub otherwise. Either way the per-frame
+    // confidence the runtime gates on must clear the default threshold,
+    // OR (stub case) the gate must still let the model's typical confidence
+    // through. We assert against the same value the runtime emits.
+    let weights = std::path::Path::new("cog/artifacts/pose_v1.safetensors");
+    let engine = if weights.exists() {
+        InferenceEngine::with_weights(Some(weights)).expect("load real weights")
+    } else {
+        InferenceEngine::new().expect("engine init")
+    };
+
+    // Core regression assertion (fails on the old `default_min_confidence()=0.3`):
+    // the default threshold must not exceed the model's published per-frame
+    // confidence (0.185), which is the exact value `infer()` emits for the real
+    // model. With 0.3 the runtime gate `out.confidence >= min_confidence` never
+    // fired → zero pose.frame events on a default install.
+    assert!(
+        cfg.min_confidence <= cog_pose_estimation::inference::MODEL_TYPICAL_CONFIDENCE,
+        "default min_confidence {} exceeds model typical confidence {} — \
+         a default install would emit zero pose.frame events",
+        cfg.min_confidence,
+        cog_pose_estimation::inference::MODEL_TYPICAL_CONFIDENCE
+    );
+
+    // End-to-end: when the real model is loaded, the value it actually emits
+    // must clear the default gate (i.e. the runtime would emit this frame).
+    if engine.backend().starts_with("candle-") {
+        let out = engine.infer(&SyntheticInput.as_window()).expect("infer");
+        assert!(
+            out.confidence >= cfg.min_confidence,
+            "default install must emit: infer confidence {} < default min_confidence {}",
+            out.confidence,
+            cfg.min_confidence
+        );
+    }
+}

v2/crates/homecore-api/Cargo.toml

@@ -33,8 +33,12 @@ chrono = { version = "0.4", features = ["serde"] }
 
 uuid = { version = "1", features = ["v4", "serde"] }
 dashmap = "6"
+futures-util = { version = "0.3", default-features = false, features = ["sink"] }
 
 [dev-dependencies]
 tower = { version = "0.5", features = ["util"] }
 hyper = "1"
 http-body-util = "0.1"
+# End-to-end WS handshake + reply tests (HC-WS-01/02, ADR-161).
+tokio-tungstenite = "0.24"
+futures-util = { version = "0.3", default-features = false }

v2/crates/homecore-api/src/app.rs

@@ -88,6 +88,11 @@ fn default_origins() -> Vec<HeaderValue> {
 mod tests {
     use super::*;
 
+    // `set_var`/`remove_var` mutate process-global state; serialize every test
+    // that touches HOMECORE_CORS_ORIGINS so they cannot race in parallel.
+    // Poison-tolerant: a panicking test must not cascade-fail the others.
+    static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
     #[test]
     fn default_origins_includes_vite_and_ha_ports() {
         let origins = default_origins();
@@ -98,6 +103,7 @@ mod tests {
 
     #[test]
     fn env_override_via_homecore_cors_origins() {
+        let _env = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
         std::env::set_var("HOMECORE_CORS_ORIGINS", "https://example.com,https://other.example.com");
         // build_cors_layer() returns a CorsLayer which doesn't expose
         // its origin list; we test the parse path indirectly by
@@ -112,6 +118,7 @@ mod tests {
 
     #[test]
     fn env_empty_falls_back_to_defaults() {
+        let _env = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
         std::env::set_var("HOMECORE_CORS_ORIGINS", "   ");
         let raw = std::env::var("HOMECORE_CORS_ORIGINS").ok();
         let trimmed = raw.as_deref().map(|s| s.trim()).unwrap_or("");

v2/crates/homecore-api/src/bin/server.rs

@@ -1,15 +1,31 @@
 //! `homecore-api-server` binary. Boots a HomeCore runtime and serves
-//! the HA-compat REST + WS API on `:8123`.
+//! the HA-compat REST + WS API.
 //!
-//! P1: bare-minimum bring-up. No persistence, no plugins, no auth
-//! beyond "any non-empty bearer". Useful for `curl` smoke tests of
-//! the wire format from the existing HA companion app:
+//! ## Auth (ADR-161, HC-WS-08)
+//!
+//! Token provisioning matches `homecore-server`: if `HOMECORE_TOKENS`
+//! is set (comma-separated bearer tokens) the API enforces that
+//! whitelist on both the REST and WS paths. If it is **unset**, the
+//! binary falls back to an explicitly-logged DEV mode (any non-empty
+//! bearer accepted) — before this fix the bin unconditionally used
+//! `allow_any_non_empty()` with no env path, so a provisioned operator
+//! had no way to lock it down.
+//!
+//! ## Bind address
+//!
+//! Defaults to `127.0.0.1` (loopback only) so a bare `cargo run` of
+//! this dev binary is not network-exposed. Override with
+//! `HOMECORE_BIND=0.0.0.0:8123` for a LAN deployment (and provision
+//! `HOMECORE_TOKENS` when you do).
 //!
 //!     cargo run -p homecore-api --bin homecore-api-server
-//!     curl -H "Authorization: Bearer test" http://127.0.0.1:8123/api/
+//!     HOMECORE_TOKENS=secret curl -H "Authorization: Bearer secret" \
+//!         http://127.0.0.1:8123/api/
+
+use std::net::SocketAddr;
 
 use homecore::HomeCore;
-use homecore_api::{router, SharedState, DEFAULT_PORT};
+use homecore_api::{router, LongLivedTokenStore, SharedState, DEFAULT_PORT};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -21,10 +37,34 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .init();
 
     let homecore = HomeCore::new();
-    let state = SharedState::new(homecore);
+
+    // Token provisioning (HC-WS-08). Prefer the HOMECORE_TOKENS env
+    // whitelist; fall back to DEV mode (warn-logged) only when unset.
+    let tokens = if std::env::var("HOMECORE_TOKENS")
+        .map(|v| !v.trim().is_empty())
+        .unwrap_or(false)
+    {
+        let s = LongLivedTokenStore::from_env();
+        let n = s.len().await;
+        tracing::info!("LongLivedTokenStore provisioned with {n} bearer token(s) from HOMECORE_TOKENS");
+        s
+    } else {
+        tracing::warn!(
+            "HOMECORE_TOKENS not set — token store in DEV mode (any non-empty bearer \
+             accepted). Set HOMECORE_TOKENS before exposing this binary to the network."
+        );
+        LongLivedTokenStore::allow_any_non_empty()
+    };
+
+    let state = SharedState::with_tokens(homecore, "Home", env!("CARGO_PKG_VERSION"), tokens);
     let app = router(state);
 
-    let addr = std::net::SocketAddr::from(([0, 0, 0, 0], DEFAULT_PORT));
+    // Default to loopback so `cargo run` is not network-exposed; allow
+    // an explicit HOMECORE_BIND override for LAN deployments.
+    let addr: SocketAddr = match std::env::var("HOMECORE_BIND") {
+        Ok(v) if !v.trim().is_empty() => v.parse()?,
+        _ => SocketAddr::from(([127, 0, 0, 1], DEFAULT_PORT)),
+    };
     tracing::info!("HOMECORE-API listening on http://{addr}  (HA-compat /api + /api/websocket)");
 
     let listener = tokio::net::TcpListener::bind(addr).await?;

v2/crates/homecore-api/src/ws.rs

@@ -9,6 +9,16 @@
 //!
 //! `ha_version` is the homecore version string — see ADR-130 Q1 for the
 //! companion-app feature-detect concern.
+//!
+//! ## Security (ADR-161)
+//!
+//! The `auth` token is validated against [`crate::tokens::LongLivedTokenStore`]
+//! via `state.tokens().is_valid()` — the *same* store the REST path uses
+//! (`auth::BearerAuth`). A wrong token receives `auth_invalid` and the socket
+//! is closed. (HC-WS-01 closed the prior bypass where any non-empty token was
+//! accepted.) Command replies are transmitted by a dedicated writer task that
+//! drains the response channel onto the socket (HC-WS-02 closed the prior
+//! reply-theater where responses were logged and discarded).
 
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
@@ -18,7 +28,7 @@ use axum::extract::State;
 use axum::response::IntoResponse;
 use serde::{Deserialize, Serialize};
 use tokio::sync::broadcast;
-use tracing::{debug, warn};
+use tracing::warn;
 
 use homecore::{Context, ServiceCall, ServiceName, SystemEvent};
 
@@ -58,11 +68,18 @@ async fn handle_socket(mut socket: WebSocket, state: SharedState) {
         _ => return,
     };
 
-    // P1: accept any non-empty token. P2: validate against store.
-    if token.trim().is_empty() {
+    // Validate the bearer token against the same store the REST path
+    // uses (`state.tokens().is_valid()` — see `rest.rs` /
+    // `auth::BearerAuth`). Before the HC-WS-01 fix this checked only
+    // `token.trim().is_empty()` and accepted ANY non-empty token even
+    // with a provisioned `HOMECORE_TOKENS` whitelist — a full WS auth
+    // bypass. `is_valid()` rejects the empty token internally and, in
+    // DEV (`allow_any`) mode, still accepts any non-empty bearer (with
+    // a warn) so smoke tests keep working.
+    if !state.tokens().is_valid(&token).await {
         let _ = socket
             .send(Message::Text(
-                serde_json::json!({"type":"auth_invalid","message":"empty token"}).to_string(),
+                serde_json::json!({"type":"auth_invalid","message":"invalid token"}).to_string(),
             ))
             .await;
         return;
@@ -140,54 +157,71 @@ impl Connection {
         }
     }
 
-    async fn run(self, mut socket: WebSocket) {
+    async fn run(self, socket: WebSocket) {
+        use futures_util::{SinkExt, StreamExt};
+
         let conn = Arc::new(self);
+        // Split the socket so a dedicated writer task can drain `rx` onto
+        // the wire while the reader task processes commands concurrently.
+        // Before the HC-WS-02 fix the socket was moved into a recv-only
+        // task and the only `rx` consumer just `debug!`-logged and
+        // DISCARDED every message — so no `result`/`pong`/`event` ever
+        // reached the client. Now `rx` feeds `socket.send`.
+        let (mut sink, mut stream) = socket.split();
         let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<String>();
 
-        let sender_tx = tx.clone();
-        let recv_task = {
-            let conn = Arc::clone(&conn);
-            tokio::spawn(async move {
-                while let Some(frame) = socket.recv().await {
-                    match frame {
-                        Ok(Message::Text(raw)) => {
-                            let cmd: WsCommand = match serde_json::from_str(&raw) {
-                                Ok(c) => c,
-                                Err(e) => {
-                                    warn!("bad ws command: {e}");
-                                    continue;
-                                }
-                            };
-                            conn.handle_cmd(cmd, &sender_tx).await;
-                        }
-                        Ok(Message::Ping(p)) => {
-                            let _ = sender_tx.send(format!("__pong:{}", p.len()));
-                        }
-                        Ok(Message::Close(_)) | Err(_) => break,
-                        _ => {}
-                    }
+        // Writer task: drain replies onto the socket. A `__pong:<n>`
+        // sentinel maps to a binary Pong control frame; everything else
+        // is a JSON text frame.
+        let writer_task = tokio::spawn(async move {
+            while let Some(msg) = rx.recv().await {
+                let send_result = if let Some(n) = msg.strip_prefix("__pong:") {
+                    let len: usize = n.parse().unwrap_or(0);
+                    sink.send(Message::Pong(vec![0u8; len])).await
+                } else {
+                    sink.send(Message::Text(msg)).await
+                };
+                if send_result.is_err() {
+                    break;
                 }
-                // Cancel all subscriptions on disconnect.
-                for entry in conn.subs.iter() {
-                    entry.value().abort.abort();
-                }
-            });
+            }
+        });
 
-            tokio::spawn(async move {
-                while let Some(msg) = rx.recv().await {
-                    if msg.starts_with("__pong:") {
-                        // pong handled inline; skip
-                        continue;
+        // Reader task: parse and dispatch commands; responses are pushed
+        // into `tx` and transmitted by the writer task above.
+        let reader_tx = tx.clone();
+        {
+            let conn = Arc::clone(&conn);
+            while let Some(frame) = stream.next().await {
+                match frame {
+                    Ok(Message::Text(raw)) => {
+                        let cmd: WsCommand = match serde_json::from_str(&raw) {
+                            Ok(c) => c,
+                            Err(e) => {
+                                warn!("bad ws command: {e}");
+                                continue;
+                            }
+                        };
+                        conn.handle_cmd(cmd, &reader_tx).await;
                     }
-                    // Use the socket from the recv task via a one-shot mpsc
-                    // (in this minimal P1, the recv task owns the socket
-                    // and we ack inline below — this branch is for the
-                    // subscription fan-out emit path)
-                    debug!("ws emit: {msg}");
+                    Ok(Message::Ping(p)) => {
+                        let _ = reader_tx.send(format!("__pong:{}", p.len()));
+                    }
+                    Ok(Message::Close(_)) | Err(_) => break,
+                    _ => {}
                 }
-            })
-        };
-        let _ = recv_task.await;
+            }
+            // Cancel all subscriptions on disconnect.
+            for entry in conn.subs.iter() {
+                entry.value().abort.abort();
+            }
+        }
+
+        // Reader loop ended → drop the senders so the writer task's `rx`
+        // closes and the task exits cleanly.
+        drop(tx);
+        drop(reader_tx);
+        let _ = writer_task.await;
     }
 
     async fn handle_cmd(&self, cmd: WsCommand, tx: &tokio::sync::mpsc::UnboundedSender<String>) {

v2/crates/homecore-api/tests/server_bin_auth.rs

@@ -0,0 +1,77 @@
+//! HC-WS-08 (ADR-161): the `homecore-api-server` bin must honor the
+//! `HOMECORE_TOKENS` env whitelist instead of unconditionally accepting
+//! any non-empty bearer.
+//!
+//! `main()` is not directly callable, so this reproduces the bin's exact
+//! token-provisioning path (`LongLivedTokenStore::from_env()` when
+//! `HOMECORE_TOKENS` is set) and drives a real HTTP request through the
+//! router. On the pre-fix bin — which used `SharedState::new()` →
+//! `allow_any_non_empty()` with NO env path — a wrong bearer was
+//! accepted; this test asserts it is now rejected with 401.
+
+use axum::body::Body;
+use axum::http::{Request, StatusCode};
+use homecore::HomeCore;
+use homecore_api::{router, LongLivedTokenStore, SharedState};
+use tower::ServiceExt; // for `oneshot`
+
+/// Build the same state the bin builds when HOMECORE_TOKENS is set.
+async fn provisioned_state(valid: &str) -> SharedState {
+    // Mirror `from_env()` deterministically without mutating process
+    // env (which would race other tests): an `empty()` store with the
+    // one provisioned token registered is exactly what
+    // `from_env()` produces for `HOMECORE_TOKENS=<valid>`.
+    let store = LongLivedTokenStore::empty();
+    store.register(valid).await;
+    SharedState::with_tokens(HomeCore::new(), "Home", "test", store)
+}
+
+#[tokio::test]
+async fn provisioned_bin_rejects_wrong_bearer() {
+    let app = router(provisioned_state("the_real_token").await);
+    let resp = app
+        .oneshot(
+            Request::builder()
+                .uri("/api/states")
+                .header("Authorization", "Bearer the_wrong_token")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(
+        resp.status(),
+        StatusCode::UNAUTHORIZED,
+        "a provisioned token store must reject a wrong bearer (HC-WS-08)"
+    );
+}
+
+#[tokio::test]
+async fn provisioned_bin_accepts_correct_bearer() {
+    let app = router(provisioned_state("the_real_token").await);
+    let resp = app
+        .oneshot(
+            Request::builder()
+                .uri("/api/states")
+                .header("Authorization", "Bearer the_real_token")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn from_env_path_enforces_whitelist() {
+    // Exercise the literal `from_env()` constructor the bin uses, under
+    // a serialized env mutation, to prove the env path itself enforces.
+    std::env::set_var("HOMECORE_TOKENS", "env_token_1, env_token_2");
+    let store = LongLivedTokenStore::from_env();
+    std::env::remove_var("HOMECORE_TOKENS");
+
+    assert!(store.is_valid("env_token_1").await);
+    assert!(store.is_valid("env_token_2").await);
+    assert!(!store.is_valid("not_in_whitelist").await);
+    assert!(!store.is_dev_mode().await, "from_env must NOT be dev mode");
+}

v2/crates/homecore-api/tests/ws_handshake.rs

@@ -0,0 +1,168 @@
+//! End-to-end WebSocket handshake + reply tests (ADR-161, HC-WS-01/02).
+//!
+//! These bind a real `TcpListener`, serve the full router, and connect
+//! with a real WS client (`tokio-tungstenite`). They exercise the wire
+//! path the in-crate unit tests cannot.
+//!
+//! - `wrong_token_is_rejected` — FAILS on the pre-fix `ws.rs` that only
+//!   checked `token.trim().is_empty()` and accepted any non-empty token
+//!   (HC-WS-01: WS auth bypass).
+//! - `result_reply_is_received` — FAILS on the pre-fix `ws.rs` that moved
+//!   the socket into a recv-only task and discarded every reply with
+//!   `debug!("ws emit: {msg}")` (HC-WS-02: reply theater).
+
+use std::net::SocketAddr;
+
+use futures_util::{SinkExt, StreamExt};
+use homecore::HomeCore;
+use homecore_api::{router, LongLivedTokenStore, SharedState};
+use tokio_tungstenite::connect_async;
+use tokio_tungstenite::tungstenite::Message;
+
+/// Spawn the API on an ephemeral port with a real (non-dev) token store
+/// containing exactly one valid token. Returns the bound address.
+async fn spawn_server_with_token(valid_token: &str) -> SocketAddr {
+    let hc = HomeCore::new();
+    let tokens = LongLivedTokenStore::empty();
+    tokens.register(valid_token).await;
+    let state = SharedState::with_tokens(hc, "Test", "test-version", tokens);
+    let app = router(state);
+
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+    tokio::spawn(async move {
+        axum::serve(listener, app).await.unwrap();
+    });
+    addr
+}
+
+/// Read text frames until one parses as JSON; returns the parsed value.
+async fn next_json<S>(ws: &mut S) -> serde_json::Value
+where
+    S: StreamExt<Item = Result<Message, tokio_tungstenite::tungstenite::Error>> + Unpin,
+{
+    loop {
+        match ws.next().await {
+            Some(Ok(Message::Text(raw))) => {
+                if let Ok(v) = serde_json::from_str::<serde_json::Value>(&raw) {
+                    return v;
+                }
+            }
+            Some(Ok(_)) => continue,
+            other => panic!("expected text frame, got {other:?}"),
+        }
+    }
+}
+
+#[tokio::test]
+async fn wrong_token_is_rejected() {
+    // HC-WS-01: a provisioned store with one good token must reject a
+    // DIFFERENT (non-empty) token over the WS handshake. The old code
+    // sent `auth_ok` for any non-empty token — this asserts the fix.
+    let addr = spawn_server_with_token("good_token_abc").await;
+    let url = format!("ws://{addr}/api/websocket");
+    let (mut ws, _resp) = connect_async(&url).await.unwrap();
+
+    // Server → auth_required
+    let req = next_json(&mut ws).await;
+    assert_eq!(req["type"], "auth_required");
+
+    // Client → auth with the WRONG token
+    ws.send(Message::Text(
+        serde_json::json!({"type":"auth","access_token":"wrong_token_xyz"}).to_string(),
+    ))
+    .await
+    .unwrap();
+
+    // Server → auth_invalid (NOT auth_ok)
+    let resp = next_json(&mut ws).await;
+    assert_eq!(
+        resp["type"], "auth_invalid",
+        "wrong token must be rejected with auth_invalid, got: {resp}"
+    );
+    assert_ne!(resp["type"], "auth_ok", "wrong token must NOT receive auth_ok");
+}
+
+#[tokio::test]
+async fn correct_token_is_accepted() {
+    let addr = spawn_server_with_token("good_token_abc").await;
+    let url = format!("ws://{addr}/api/websocket");
+    let (mut ws, _resp) = connect_async(&url).await.unwrap();
+
+    let req = next_json(&mut ws).await;
+    assert_eq!(req["type"], "auth_required");
+
+    ws.send(Message::Text(
+        serde_json::json!({"type":"auth","access_token":"good_token_abc"}).to_string(),
+    ))
+    .await
+    .unwrap();
+
+    let resp = next_json(&mut ws).await;
+    assert_eq!(resp["type"], "auth_ok", "correct token should be accepted, got: {resp}");
+}
+
+#[tokio::test]
+async fn result_reply_is_received() {
+    // HC-WS-02: after a successful auth, a `get_states` command must
+    // produce a `result` reply RECEIVED over the socket. The old code
+    // discarded all replies in the rx-draining task, so this hangs/
+    // fails on the pre-fix source.
+    let addr = spawn_server_with_token("good_token_abc").await;
+    let url = format!("ws://{addr}/api/websocket");
+    let (mut ws, _resp) = connect_async(&url).await.unwrap();
+
+    let req = next_json(&mut ws).await;
+    assert_eq!(req["type"], "auth_required");
+
+    ws.send(Message::Text(
+        serde_json::json!({"type":"auth","access_token":"good_token_abc"}).to_string(),
+    ))
+    .await
+    .unwrap();
+    let auth = next_json(&mut ws).await;
+    assert_eq!(auth["type"], "auth_ok");
+
+    // Send a command and assert we RECEIVE a result reply.
+    ws.send(Message::Text(
+        serde_json::json!({"id": 1, "type": "get_states"}).to_string(),
+    ))
+    .await
+    .unwrap();
+
+    let reply = tokio::time::timeout(std::time::Duration::from_secs(5), next_json(&mut ws))
+        .await
+        .expect("did not receive a reply within 5s — reply theater (HC-WS-02)");
+    assert_eq!(reply["type"], "result", "expected a result reply, got: {reply}");
+    assert_eq!(reply["id"], 1);
+    assert_eq!(reply["success"], true);
+}
+
+#[tokio::test]
+async fn ping_pong_reply_is_received() {
+    // The `ping` command must produce a `pong` reply on the wire — also
+    // exercises the writer task that HC-WS-02 introduced.
+    let addr = spawn_server_with_token("good_token_abc").await;
+    let url = format!("ws://{addr}/api/websocket");
+    let (mut ws, _resp) = connect_async(&url).await.unwrap();
+
+    let _ = next_json(&mut ws).await; // auth_required
+    ws.send(Message::Text(
+        serde_json::json!({"type":"auth","access_token":"good_token_abc"}).to_string(),
+    ))
+    .await
+    .unwrap();
+    let _ = next_json(&mut ws).await; // auth_ok
+
+    ws.send(Message::Text(
+        serde_json::json!({"id": 7, "type": "ping"}).to_string(),
+    ))
+    .await
+    .unwrap();
+
+    let reply = tokio::time::timeout(std::time::Duration::from_secs(5), next_json(&mut ws))
+        .await
+        .expect("did not receive pong within 5s");
+    assert_eq!(reply["type"], "pong");
+    assert_eq!(reply["id"], 7);
+}

v2/crates/homecore-assist/Cargo.toml

@@ -43,5 +43,13 @@ regex = "1"
 # Structured logging.
 tracing = "0.1"
 
+[features]
+default = ["semantic"]
+# Enables SemanticIntentRecognizer's embedding-based exact cosine k-NN match.
+# Self-contained: deterministic feature-hash embeddings + an in-memory cosine
+# scan, with no external index/storage dependency (the small intent vocabularies
+# make an exact scan faster and far more robust than an ANN backend).
+semantic = []
+
 [dev-dependencies]
 tokio = { version = "1", features = ["full", "test-util"] }