fix: resolve all 10 confirmed code-review findings (7-angle review, 20/20 verified)

wiflow_std: min_feature_width (default 15) replaces the keypoints->stride
coupling — for_keypoints(17) now provably builds the trained [2,2,2,2]
graph and pools 15->17, matching the validated Python protocol (pinned by
tests); param_count() total on invalid configs; random_mask returns Result
and rejects non-finite/out-of-range ratios; trainer checkpoints switched
to safetensors (.pt VarStore roundtrip broken on Windows torch 2.11).

ieee80211bf: SBP proxy now re-triggers instances and relays reports via
Action::RelaySbpReport -> SensingFrame::SbpReport (clients consume via
their existing path); missed_instances reset on success = consecutive
semantics; SessionTable gains a guarded SBP entry point + unknown-id drop
counter; initiator-role sessions reject inbound setup/SBP requests
(RejectedNotSupported) closing the idle hijack; StartSetup/StartSbp
outside Idle return InvalidStateForCommand; SBP validation unified
through evaluate_setup with a 1:1 SetupStatus->SbpStatus mapping.
events.rs split out to honor the 500-line cap.

calibration/cli: enrollment geometry now actually reaches trained banks —
both production call sites attach .with_geometry; --geometry flag on
train-room and POST /enroll/geometry + train-body geometry on
calibrate-serve give production a recording surface; geometry-free banks
log the ADR-152 §2.1.2 note.

benchmarks: corruption masks committed as ground truth (unregenerable
after in-place cleaning; verified bit-identical regeneration from the
pristine copy) + generate_corruption_masks.py producer; _bench_common.py
dedups the 5x-copied shim/evaluate/seed/remap (post-refactor PCK@20
re-verified equal to the last digit); remote scripts get the mmap patch;
tiny_edge --calib validated multiple-of-64; onnx_bench --help no longer
executes (and overwrote) the export — artifact restored byte-exact.

Workspace: 2,963 tests passed, 0 failed; Python proof PASS.

Co-Authored-By: claude-flow <ruv@ruv.net>

benchmarks/wiflow-std/.gitignore

@@ -17,3 +17,10 @@ downloads/
 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

@@ -66,6 +66,19 @@ mostly would-be *training* data — so this is not a split mismatch):
    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

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

@@ -17,41 +17,17 @@ import argparse
 import json
 import os
 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)
 
+from _bench_common import RESULTS, evaluate  # noqa: E402
 from quantize_bench import build_test_subset  # noqa: E402  (sets up upstream imports)
 
-sys.path.insert(0, os.path.join(HERE, "upstream"))
-from utils.metrics import calculate_mpjpe, calculate_pck  # noqa: E402
-
 
 def evaluate_ort(sess, loader, label):
-    inp = sess.get_inputs()[0].name
-    totals = {0.2: 0.0, 0.5: 0.0}
-    total_mpe, n = 0.0, 0
-    t0 = time.time()
-    for batch_idx, (bx, by) in enumerate(loader):
-        out = torch.from_numpy(sess.run(None, {inp: bx.numpy()})[0])
-        pck = calculate_pck(out, by, thresholds=[0.2, 0.5])
-        mpe = calculate_mpjpe(out, by)
-        bs = by.size(0)
-        total_mpe += mpe * bs
-        for t in totals:
-            totals[t] += pck[t] * bs
-        n += bs
-        if batch_idx % 50 == 0:
-            print(f"  [{label}] batch {batch_idx}: n={n} "
-                  f"pck20={totals[0.2]/n:.4f} mpjpe={total_mpe/n:.4f} "
-                  f"({time.time()-t0:.0f}s)", flush=True)
-    return {"samples": n, "pck@20": totals[0.2] / n, "pck@50": totals[0.5] / n,
-            "mpjpe": total_mpe / n, "wall_seconds": time.time() - t0}
+    """ORT-session evaluation via the canonical _bench_common.evaluate loop."""
+    return evaluate(sess, loader, label=label)
 
 
 def main():

benchmarks/wiflow-std/eval_repro.py

@@ -15,56 +15,18 @@ Usage:
 import argparse
 import json
 import os
-import random
 import sys
-import time
 
-import numpy as np
 import torch
 from torch.utils.data import DataLoader
 
-UPSTREAM = os.path.join(os.path.dirname(os.path.abspath(__file__)), "upstream")
-sys.path.insert(0, UPSTREAM)
+from _bench_common import (UPSTREAM, evaluate, import_upstream,
+                           load_remapped_state, set_seed)
 
-# Upstream bug: models/__init__.py imports TemporalConvNet, which models/tcn.py
-# does not define (it defines TemporalBlock) — 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__.
-import types  # noqa: E402
+import_upstream()  # sys.path + models stub + >1GB np.load mmap patch
 
-_models_pkg = types.ModuleType("models")
-_models_pkg.__path__ = [os.path.join(UPSTREAM, "models")]
-sys.modules["models"] = _models_pkg
-
-import dataset as upstream_dataset  # noqa: E402
 from dataset import PreprocessedCSIKeypointsDataset, create_preprocessed_train_val_test_loaders  # noqa: E402
 from models.pose_model import WiFlowPoseModel  # noqa: E402
-from utils.metrics import calculate_pck, calculate_mpjpe  # noqa: E402
-
-# csi_windows.npy is ~13 GB; mmap large arrays instead of loading into RAM.
-_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)
-
-
-upstream_dataset.np.load = _np_load_mmap
-
-
-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
 
 
 def find_data_dir(root):
@@ -74,35 +36,6 @@ def find_data_dir(root):
     return None
 
 
-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 = 0.0
-    n = 0
-    t0 = time.time()
-    with torch.no_grad():
-        for batch_idx, (batch_x, batch_y) in enumerate(loader):
-            batch_x = batch_x.to(device)
-            batch_y = batch_y.to(device)
-            outputs = model(batch_x)
-            mpe = calculate_mpjpe(outputs, batch_y)
-            pck = calculate_pck(outputs, batch_y, thresholds=[0.1, 0.2, 0.3, 0.4, 0.5])
-            bs = batch_y.size(0)
-            total_mpe += mpe * bs
-            for t in totals:
-                totals[t] += pck[t] * bs
-            n += bs
-            if batch_idx % 50 == 0:
-                print(f"  batch {batch_idx}: n={n} pck20={totals[0.2]/n:.4f} "
-                      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 totals},
-        "wall_seconds": time.time() - t0,
-    }
-
-
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--data-dir", required=True,
@@ -134,13 +67,9 @@ def main():
         dataset=dataset, batch_size=args.batch_size, num_workers=0, random_seed=42)
 
     model = WiFlowPoseModel(dropout=0.5).to(device)
-    state = torch.load(args.checkpoint, map_location=device, weights_only=True)
     # released checkpoint predates the published code: modules were renamed
     # att -> attention, final_conv -> decoder (param count identical, 2.23M)
-    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()}
+    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)")
@@ -154,13 +83,13 @@ def main():
                "device": str(device)}
 
     print("=== test set (full, drop_last=False) ===")
-    results["test_full"] = evaluate(model, test_loader, device)
+    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)
+    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)

benchmarks/wiflow-std/export_to_safetensors.py

@@ -41,24 +41,14 @@ Usage:
 import json
 import os
 import re
-import sys
 
 import numpy as np
 import torch
 from safetensors.torch import save_file
 
-HERE = os.path.dirname(os.path.abspath(__file__))
-UPSTREAM = os.path.join(HERE, "upstream")
-RESULTS = os.path.join(HERE, "results")
-sys.path.insert(0, UPSTREAM)
+from _bench_common import RESULTS, import_upstream, remap_legacy_keys
 
-# Upstream models/__init__.py is broken as published (imports a name tcn.py
-# does not define); register a stub package so it never executes.
-import types  # noqa: E402
-
-_models_pkg = types.ModuleType("models")
-_models_pkg.__path__ = [os.path.join(UPSTREAM, "models")]
-sys.modules["models"] = _models_pkg
+import_upstream()  # sys.path + models stub
 
 from models.pose_model import WiFlowPoseModel  # noqa: E402
 
@@ -125,11 +115,8 @@ def main():
                 state = state[wrapper]
                 break
 
-    # Legacy upstream names predate the published code (eval_repro.py).
-    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()}
+    # Legacy upstream names predate the published code (_bench_common).
+    state = remap_legacy_keys(state)
 
     mapped = {}
     dropped = 0

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

@@ -21,40 +21,22 @@ import json
 import os
 import platform
 import statistics
-import sys
 import time
 import traceback
 
 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")
-sys.path.insert(0, UPSTREAM)
+from _bench_common import RESULTS, import_upstream, load_wiflow_model
 
-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
+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():
-    state = torch.load(CHECKPOINT, map_location="cpu", 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 = WiFlowPoseModel(dropout=0.5)
-    model.load_state_dict(state, strict=True)
-    model.eval()
-    return model
+    return load_wiflow_model(CHECKPOINT)
 
 
 def try_export(model, path, batch, dynamic, opset=17):
@@ -115,6 +97,16 @@ def bench_ort(sess, batch, n_runs):
 
 
 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 = {

benchmarks/wiflow-std/quantize_bench.py

@@ -28,7 +28,6 @@ import json
 import os
 import platform
 import statistics
-import sys
 import time
 
 import numpy as np
@@ -36,55 +35,21 @@ import torch
 import torch.nn as nn
 from torch.utils.data import DataLoader
 
-HERE = os.path.dirname(os.path.abspath(__file__))
-UPSTREAM = os.path.join(HERE, "upstream")
-RESULTS = os.path.join(HERE, "results")
-sys.path.insert(0, UPSTREAM)
+from _bench_common import HERE, RESULTS, evaluate, import_upstream, load_wiflow_model
 
-# Upstream models/__init__.py is broken as published (imports a name tcn.py
-# does not define); register a stub package so it never executes.
-import types  # noqa: E402
+import_upstream()  # sys.path + models stub + >1GB np.load mmap patch
 
-_models_pkg = types.ModuleType("models")
-_models_pkg.__path__ = [os.path.join(UPSTREAM, "models")]
-sys.modules["models"] = _models_pkg
-
-import dataset as upstream_dataset  # noqa: E402
 from dataset import (  # noqa: E402
     PreprocessedCSIKeypointsDataset,
     create_preprocessed_train_val_test_loaders,
 )
-from models.pose_model import WiFlowPoseModel  # noqa: E402
-from utils.metrics import calculate_mpjpe, calculate_pck  # noqa: E402
 
 CHECKPOINT = os.path.join(RESULTS, "retrained_best_pose_model.pth")
 
-# csi_windows.npy is ~13 GB; mmap large arrays instead of loading into RAM
-# (same trick as eval_repro.py).
-_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)
-
-
-upstream_dataset.np.load = _np_load_mmap
-
 
 def load_fp32_model():
-    state = torch.load(CHECKPOINT, map_location="cpu", weights_only=True)
-    # legacy upstream names, harmless no-op on 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()}
-    model = WiFlowPoseModel(dropout=0.5)
-    model.load_state_dict(state, strict=True)
-    model.eval()
-    return 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):
@@ -138,33 +103,6 @@ def build_test_subset(data_dir, subset_size, batch_size=64):
     return loader, len(clean)
 
 
-def evaluate(model, loader, dtype=torch.float32, label=""):
-    totals = {0.2: 0.0, 0.5: 0.0}
-    total_mpe, n = 0.0, 0
-    t0 = time.time()
-    with torch.no_grad():
-        for batch_idx, (bx, by) in enumerate(loader):
-            out = model(bx.to(dtype)).float()
-            pck = calculate_pck(out, by, thresholds=[0.2, 0.5])
-            mpe = calculate_mpjpe(out, by)
-            bs = by.size(0)
-            total_mpe += mpe * bs
-            for t in totals:
-                totals[t] += pck[t] * bs
-            n += bs
-            if batch_idx % 50 == 0:
-                print(f"  [{label}] batch {batch_idx}: n={n} "
-                      f"pck20={totals[0.2]/n:.4f} mpjpe={total_mpe/n:.4f} "
-                      f"({time.time()-t0:.0f}s)", flush=True)
-    return {
-        "samples": n,
-        "pck@20": totals[0.2] / n,
-        "pck@50": totals[0.5] / n,
-        "mpjpe": total_mpe / n,
-        "wall_seconds": time.time() - t0,
-    }
-
-
 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."""
@@ -272,7 +210,7 @@ def main():
         for name, (model, dtype, _f) in variants.items():
             print(f"\n=== accuracy: {name} ===")
             results["variants"][name]["accuracy"] = evaluate(
-                model, loader, dtype, label=name)
+                model, loader, dtype=dtype, label=name)
             print(json.dumps(results["variants"][name]["accuracy"], indent=2))
 
     # ---- merge into edge_optimization.json ---------------------------------

benchmarks/wiflow-std/remote/eval_retrained.py

@@ -3,6 +3,11 @@
 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
 
@@ -10,6 +15,20 @@ 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

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

@@ -54,6 +54,11 @@ Pre-registered protocol (followed exactly):
 
 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

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

@@ -17,6 +17,11 @@ Usage:
   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
@@ -30,6 +35,20 @@ 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'))

benchmarks/wiflow-std/static_ptq_bench.py

@@ -45,10 +45,11 @@ 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)
 
+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

benchmarks/wiflow-std/tiny_edge_bench.py

@@ -38,7 +38,8 @@ machinery on the tiny checkpoint:
 
 Usage:
   PYTHONUTF8=1 .venv/Scripts/python.exe tiny_edge_bench.py \
-      [--data-dir <preprocessed_csi_data>] [--subset 10000] [--calib 500]
+      [--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".
 """
@@ -211,6 +212,13 @@ def main():
     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']}, "