docs: describe RuView-focused README animation

docs: focus animation on RuView sensing and spatial awareness
docs: add ruOS animation below RuView header
2026-10-20 05:40:14 -05:00 · 2026-10-06 09:25:36 -07:00 · 2026-10-06 09:25:34 -07:00 · 2026-10-06 09:12:38 -07:00 · 2026-10-06 09:12:36 -07:00 · 2026-10-05 13:52:42 -07:00
923 changed files with 148885 additions and 154658 deletions
@@ -10,6 +10,11 @@
      "name": "ruview",
      "source": "./plugins/ruview",
      "description": "End-to-end RuView toolkit: getting started, ESP32 hardware setup, configuration, sensing applications (presence / vitals / pose / sleep / MAT), camera-free + camera-supervised model training, advanced multistatic sensing, CLI / API / WASM, mmWave radar, and witness verification"
+    },
+    {
+      "name": "ruview-live",
+      "source": "./harness/ruview/mod",
+      "description": "Claude Code mod: /ruview opens a live pane with your CSI nodes (ESP32, Realtek) and ESPHome radar (presence, distance, device-reported vitals), refreshed on a timer, plus a one-line status. Read-only; ships inside @ruvnet/ruview. Mods are early access (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1)."
    }
  ]
 }
@@ -1 +1 @@
-{"sessionId":"d80c93c2-51b7-42e8-a0fc-dc47cff1200f","pid":45748,"acquiredAt":1779668018388}
+{"sessionId":"905385c4-b13f-5091-96df-5752fb109cf5","pid":509,"procStart":"527","acquiredAt":1786922977672}
@@ -0,0 +1,3 @@
+# The contributor harness hashes provenance inputs byte-for-byte. Keep text
+# files in this boundary on LF even when Windows enables core.autocrlf.
+harness/ruview/** text=auto eol=lf
@@ -135,6 +135,10 @@ async function runProcess(command, args, {
        resolve(result);
      });
    });
+    // A child that never reads stdin (e.g. `git check-ignore`) may exit and
+    // close the pipe before this write flushes; the resulting EPIPE is not a
+    // failure of the command, whose real outcome the 'close' handler reports.
+    child.stdin.on('error', () => {});
    child.stdin.end(input);
  });
 }
@@ -0,0 +1,43 @@
+name: BFI Research Tools
+
+on:
+  pull_request:
+    paths:
+      - 'tools/bfi/**'
+      - 'tools/bfi_learning/**'
+      - '.github/workflows/bfi-research.yml'
+  push:
+    branches: [main]
+    paths:
+      - 'tools/bfi/**'
+      - 'tools/bfi_learning/**'
+      - '.github/workflows/bfi-research.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: bfi-research-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  offline-tests:
+    name: BFI offline tests (Linux, CPU)
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1
+        with:
+          python-version: '3.13'
+      - name: Install numeric test dependencies
+        run: python -m pip install numpy==2.4.2 scipy==1.17.1
+      - name: Install CPU PyTorch
+        run: python -m pip install torch==2.11.0 --index-url https://download.pytorch.org/whl/cpu
+      - name: Test capture parsing and bounded runners
+        run: python -B -m unittest discover -s tools/bfi -v
+      - name: Test offline learning and data admission
+        run: python -B -m unittest discover -s tools/bfi_learning -v
@@ -204,7 +204,7 @@ jobs:
        node-version: '22'

    - name: Run UI unit tests
-      run: node --test ui/sw.test.mjs ui/services/ws-ticket.test.mjs ui/services/websocket.service.test.mjs
+      run: node --test ui/sw.test.mjs ui/services/ws-ticket.test.mjs ui/services/websocket.service.test.mjs ui/services/sensing.service.test.mjs ui/components/DashboardTab.test.mjs v2/crates/wifi-densepose-desktop/ui/build-config.test.mjs

  # Unit and Integration Tests
  # Python pytest matrix — runs against the archived v1 Python tree.
@@ -0,0 +1,53 @@
+name: CSI data policy (ADR-299)
+
+# ADR-299 repository CSI data-incident guard. Fails when CSI-format files
+# (*.csi.jsonl / *.csi.meta.json) or oversized JSONL captures are tracked in
+# git. Raw CSI is person data and must never be committed (CLAUDE.md, ADR-299).
+#
+# NOTE: the tree currently still contains the pre-existing incident recordings
+# under data/recordings/ and v2/data/recordings/, whose removal is gated on
+# data-owner sign-off (ADR-299). Until they are removed this job is EXPECTED to
+# fail, and that failure documents the incident. To make it green in a
+# follow-up without weakening the guard for NEW files, set CSI_POLICY_BASELINE
+# to a file listing the acknowledged paths (see the script header).
+#
+# Checker: scripts/csi-data-policy-check.sh   Run locally: bash the same script.
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  csi-data-policy:
+    name: CSI data policy check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+
+      - name: Self-test the policy checker (deterministic, offline)
+        run: bash scripts/csi-data-policy-check.sh --self-test
+
+      - name: Enforce CSI data policy on tracked files
+        # CSI_POLICY_BASELINE can point at an acknowledged-paths file once the
+        # owner remediates the tree; unset here so a regression fails loudly.
+        run: bash scripts/csi-data-policy-check.sh --tracked
+
+      - name: Summarize result
+        if: always()
+        run: |
+          {
+            echo '### CSI data policy (ADR-299)'
+            echo ''
+            echo '```'
+            bash scripts/csi-data-policy-check.sh --tracked 2>&1 || true
+            echo '```'
+          } >> "$GITHUB_STEP_SUMMARY"
@@ -53,7 +53,9 @@ jobs:
            sdkconfig: sdkconfig.defaults
            partition_table_name: partitions_display.csv
            size_warn_kb: 1100
-            size_limit_kb: 1152
+            # Current 8 MB image is 1163 KiB after USB onboarding. The OTA app
+            # partition is 2048 KiB; retain a 1200 KiB hard gate and warning.
+            size_limit_kb: 1200
            artifact_app: esp32-csi-node.bin
            artifact_pt: partition-table.bin
          - variant: 4mb
@@ -92,12 +94,11 @@ jobs:
          idf.py set-target ${{ matrix.target }}
          idf.py build

-      - name: Build and run host-side ADR-110 unit tests
+      - name: Build and run host-side firmware unit tests
        if: matrix.variant == 'c6-4mb'
        working-directory: firmware/esp32-csi-node/test
        run: |
-          make test_adr110
-          ./test_adr110
+          make host_tests

      - name: Verify binary size budget
        working-directory: firmware/esp32-csi-node
@@ -162,10 +163,14 @@ jobs:
          mkdir -p release-staging
          cp build/esp32-csi-node.bin                      release-staging/${{ matrix.artifact_app }}
          cp build/partition_table/partition-table.bin     release-staging/${{ matrix.artifact_pt }}
-          if [ "${{ matrix.variant }}" = "8mb" ]; then
-            cp build/bootloader/bootloader.bin             release-staging/bootloader.bin
-            cp build/ota_data_initial.bin                  release-staging/ota_data_initial.bin
-          fi
+          cp build/bootloader/bootloader.bin               release-staging/bootloader.bin
+          cp build/ota_data_initial.bin                    release-staging/ota_data_initial.bin
+          cp version.txt                                   release-staging/version.txt
+          (cd release-staging && sha256sum \
+            "${{ matrix.artifact_app }}" \
+            "${{ matrix.artifact_pt }}" \
+            bootloader.bin ota_data_initial.bin version.txt \
+            > SHA256SUMS.txt)
          ls -la release-staging/

      - name: Check QEMU ESP32-S3 support status
@@ -180,3 +185,54 @@ jobs:
          name: esp32-csi-node-firmware-${{ matrix.variant }}
          path: firmware/esp32-csi-node/release-staging/
          retention-days: 90
+
+  build-c6-idf6:
+    name: Build XIAO C6 external antenna (ESP-IDF 6.0.2)
+    runs-on: ubuntu-latest
+    container:
+      image: espressif/idf:v6.0.2
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          submodules: recursive
+
+      - name: Build the IDF 6 canary image
+        working-directory: firmware/esp32-csi-node
+        run: |
+          . $IDF_PATH/export.sh
+          idf.py -D SDKCONFIG_DEFAULTS="sdkconfig.defaults;sdkconfig.defaults.esp32c6;sdkconfig.defaults.xiao-external" set-target esp32c6
+          idf.py build
+          test "$(stat -c%s build/esp32-csi-node.bin)" -le $((1152 * 1024))
+          strings build/esp32-csi-node.bin | grep -F "external U.FL"
+
+  publish-release-assets:
+    name: Publish firmware release assets
+    if: github.ref_type == 'tag'
+    needs: [version-guard, build, build-c6-idf6]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Download the exact-run firmware artifacts
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+        with:
+          pattern: esp32-csi-node-firmware-*
+          path: release-downloads
+
+      - name: Package variants without filename collisions
+        run: |
+          mkdir -p release-assets
+          for directory in release-downloads/esp32-csi-node-firmware-*; do
+            variant="${directory##*/}"
+            tar -C "$directory" -czf "release-assets/${variant}.tar.gz" .
+          done
+          (cd release-assets && sha256sum *.tar.gz > SHA256SUMS.txt)
+
+      - name: Publish the downloadable firmware bundles
+        uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65
+        with:
+          name: ESP32 firmware ${{ github.ref_name }}
+          body: |
+            Exact-run ESP32-S3 8 MB, ESP32-S3 4 MB, and ESP32-C6 4 MB firmware bundles.
+            Verify each archive against `SHA256SUMS.txt` before flashing.
+          files: release-assets/*
@@ -0,0 +1,70 @@
+name: iPhone LiDAR integration
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'integrations/iphone-lidar/**'
+      - 'docs/adr/ADR-340-iphone-lidar-sensor-bridge.md'
+      - '.github/workflows/iphone-lidar.yml'
+  pull_request:
+    paths:
+      - 'integrations/iphone-lidar/**'
+      - 'docs/adr/ADR-340-iphone-lidar-sensor-bridge.md'
+      - '.github/workflows/iphone-lidar.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  web:
+    name: Node relay and codec
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: integrations/iphone-lidar/web
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+
+      - name: Set up Node
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
+        with:
+          node-version: '22'
+          cache: npm
+          cache-dependency-path: integrations/iphone-lidar/web/package-lock.json
+
+      - name: Install dependencies
+        run: npm ci --ignore-scripts
+
+      - name: Run tests
+        run: npm test
+
+      - name: Audit runtime dependencies
+        run: npm audit --omit=optional --audit-level=high
+
+  ios:
+    name: iOS 17 compile
+    runs-on: macos-15
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+
+      - name: Compile native sources with strict concurrency
+        shell: bash
+        run: |
+          set -euo pipefail
+          sdk="$(xcrun --sdk iphoneos --show-sdk-path)"
+          build_dir="$RUNNER_TEMP/ruview-lidar-build"
+          mkdir -p "$build_dir"
+          cd "$build_dir"
+          xcrun swiftc \
+            -parse-as-library \
+            -target arm64-apple-ios17.0 \
+            -sdk "$sdk" \
+            -module-name RuViewLiDAR \
+            -strict-concurrency=complete \
+            -warnings-as-errors \
+            -emit-module \
+            -emit-module-path "$build_dir/RuViewLiDAR.swiftmodule" \
+            -c "$GITHUB_WORKSPACE"/integrations/iphone-lidar/native/RuViewLiDAR/*.swift
@@ -0,0 +1,67 @@
+name: Model release gate (ADR-298)
+
+# ADR-298 model-release sanity gates (issue #1521): structural checks that
+# block a degenerate/mislabeled classifier head (unreachable decision
+# boundary, near-constant output, degenerate class balance, a metric
+# surfaced under a task name it wasn't computed as) before it ships.
+#
+# Checker: v2/crates/wifi-densepose-train/src/model_gates.rs
+#
+# IMPORTANT — the honest scope of this job: it protects the *checker itself*
+# from regressing (the gate logic + its issue-1521 regression fixture are
+# exercised on every push/PR that touches this crate), and running it is
+# required before ADR-298 can be called "wired in" at all. It does NOT gate
+# an actual model publish — this repository does not automate uploading to
+# the HuggingFace model repo (`ruvnet/wifi-densepose-pretrained`); that
+# remains a manual, human-run step. Before publishing or replacing a model
+# artifact there, run this gate against the real head weights locally:
+#
+#   cargo test -p wifi-densepose-train model_gates
+#
+# and, until a CLI entry point exists to run `evaluate_linear_head` against an
+# arbitrary `.safetensors`/`.rvf` file, load the head's `weight`/`bias` in a
+# short script and call `wifi_densepose_train::evaluate_linear_head` directly.
+
+on:
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - "v2/crates/wifi-densepose-train/**"
+  pull_request:
+    paths:
+      - "v2/crates/wifi-densepose-train/**"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  model-release-gate:
+    name: Model release gate check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+          submodules: recursive
+
+      - name: Install Rust toolchain
+        run: rustup toolchain install stable --profile minimal
+
+      - name: Run the model-release gate's own test suite
+        working-directory: v2
+        run: cargo test -p wifi-densepose-train --no-default-features model_gates -- --nocapture
+
+      - name: Summarize result
+        if: always()
+        run: |
+          {
+            echo '### Model release gate (ADR-298)'
+            echo ''
+            echo 'This job protects `model_gates.rs` from regressing. It does not itself'
+            echo 'gate a real HuggingFace model publish — that upload is a manual step'
+            echo 'outside this repository; run `cargo test -p wifi-densepose-train model_gates`'
+            echo 'against real head weights before publishing one.'
+          } >> "$GITHUB_STEP_SUMMARY"
@@ -40,8 +40,13 @@ jobs:
          - dir: harness/ruview
            build: false
            publishable: true
-            # ADR-283: brain + local hosts + replay assets; still runtime-dependency-free.
-            unpacked_budget: 131072
+            # ADR-283/325: brain + local hosts + replay assets + guarded Spaces OAuth adapter;
+            # still runtime-dependency-free. ADR-369..374 add the SDK, firmware
+            # flashing, training runner/gate, doctor, device access, and SSH
+            # hosts. ADR-375 adds the MCP Apps console widget (~12 KB), the
+            # Streamable HTTP transport and the terminal UI (384 KiB); ADR-378 the
+            # ruview-live showcase views (~37 KB): 448 KiB reviewed ceiling.
+            unpacked_budget: 458752
          - dir: harness/homecore
            build: false
            publishable: true
@@ -130,13 +135,19 @@ jobs:
          npm i --no-fund --no-audit "$TGZ"
          case "${{ matrix.package.dir }}" in
            harness/ruview)
-              ./node_modules/.bin/ruview --version
-              ./node_modules/.bin/ruview doctor
+              ./node_modules/.bin/ruview-harness --version
+              ./node_modules/.bin/ruview-harness doctor
              # the honesty gate must fail closed on empty input (ADR-263 F1)
-              if ./node_modules/.bin/ruview claim-check; then
+              if ./node_modules/.bin/ruview-harness claim-check; then
                echo 'claim-check passed with no input — fail-open regression'; exit 1
              fi
              node --input-type=module -e "const m = await import('@ruvnet/ruview'); if (!m.TOOLS) process.exit(1);"
+              # ADR-369: the typed SDK resolves and the evidence gate refuses a baseline-free score
+              node --input-type=module -e "const { createRuView } = await import('@ruvnet/ruview/sdk'); const r = createRuView(); if (r.tools().length < 22) process.exit(1); const g = await r.training.gate({ model_score: 0.93 }); if (g.verdict !== 'FAIL') process.exit(1);"
+              ./node_modules/.bin/ruview-harness doctor --json --group runtime,harness,firmware > doctor.json
+              if ./node_modules/.bin/ruview-harness train-gate --model-score 0.93 > /dev/null; then
+                echo 'train-gate passed without a baseline'; exit 1
+              fi
              ;;
            harness/homecore)
              ./node_modules/.bin/homecore --version
@@ -0,0 +1,627 @@
+name: RuForecast Rust CI
+
+on:
+  push:
+    branches: [main, develop, 'feat/*', 'feature/*']
+    paths:
+      - 'v2/crates/ruforecast'
+      - 'v2/Cargo.toml'
+      - 'v2/Cargo.lock'
+      - 'v2/rust-toolchain.toml'
+      - 'scripts/csi-data-policy-check.sh'
+      - 'scripts/run-ruforecast-benchmarks.sh'
+      - 'docs/adr/ADR-348-*.md'
+      - 'docs/adr/ADR-349-*.md'
+      - 'docs/adr/ADR-350-*.md'
+      - 'docs/adr/README.md'
+      - 'docs/benchmarks/ruforecast.md'
+      - 'docs/huggingface/RUVIEW_FORECAST_MODEL_CARD_TEMPLATE.md'
+      - 'docs/security/ruview-forecast-*'
+      - 'docs/validation/ruforecast-requirements-evidence.md'
+      - '.github/workflows/ruforecast-ci.yml'
+  pull_request:
+    branches: [main, develop]
+    paths:
+      - 'v2/crates/ruforecast'
+      - 'v2/Cargo.toml'
+      - 'v2/Cargo.lock'
+      - 'v2/rust-toolchain.toml'
+      - 'scripts/csi-data-policy-check.sh'
+      - 'scripts/run-ruforecast-benchmarks.sh'
+      - 'docs/adr/ADR-348-*.md'
+      - 'docs/adr/ADR-349-*.md'
+      - 'docs/adr/ADR-350-*.md'
+      - 'docs/adr/README.md'
+      - 'docs/benchmarks/ruforecast.md'
+      - 'docs/huggingface/RUVIEW_FORECAST_MODEL_CARD_TEMPLATE.md'
+      - 'docs/security/ruview-forecast-*'
+      - 'docs/validation/ruforecast-requirements-evidence.md'
+      - '.github/workflows/ruforecast-ci.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ruforecast-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_PROFILE_DEV_DEBUG: '0'
+  CARGO_PROFILE_TEST_DEBUG: '0'
+  CARGO_PROFILE_BENCH_DEBUG: '0'
+  CARGO_PROFILE_RELEASE_DEBUG: '0'
+
+jobs:
+  contract-rust-189:
+    name: Forecast contract and feature-off boundary (Rust 1.89)
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - name: Checkout recursively
+        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+          submodules: recursive
+
+      - name: Install Rust 1.89 with lint components
+        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4
+        with:
+          toolchain: 1.89.0
+          components: rustfmt,clippy
+
+      - name: Cache Cargo artifacts
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32
+        with:
+          workspaces: v2/crates/ruforecast
+          key: ruforecast-rust-189
+
+      - name: Validate benchmark runner and evidence contract
+        shell: bash
+        run: |
+          set -euo pipefail
+          bash -n scripts/run-ruforecast-benchmarks.sh
+          test -x scripts/run-ruforecast-benchmarks.sh
+          test -f docs/benchmarks/ruforecast.md
+          test -f docs/huggingface/RUVIEW_FORECAST_MODEL_CARD_TEMPLATE.md
+          test -f docs/security/ruview-forecast-clean-room.md
+          test -f docs/security/ruview-forecast-threat-model.md
+          test -f docs/validation/ruforecast-requirements-evidence.md
+
+          for adr_number in 348 349 350; do
+            mapfile -t adr_files < <(
+              find docs/adr -maxdepth 1 -type f -name "ADR-${adr_number}-*.md" -print
+            )
+            if [[ "${#adr_files[@]}" -ne 1 ]]; then
+              echo "Expected exactly one ADR-${adr_number} file, found ${#adr_files[@]}" >&2
+              exit 1
+            fi
+            grep -q "^# ADR-${adr_number}:" "${adr_files[0]}"
+            grep -Eq '^[-*] \*\*Status\*\*: (Proposed|Accepted|Superseded|Deprecated)( |$|—)|^## Status' "${adr_files[0]}"
+          done
+
+          grep -q '^## Requirements' docs/adr/ADR-348-*.md
+          grep -q '^## Acceptance gates' docs/adr/ADR-348-*.md
+          grep -q '^## Requirements and acceptance' docs/adr/ADR-349-*.md
+          grep -q '^## Requirements and acceptance' docs/adr/ADR-350-*.md
+          for adr_number in 348 349 350; do
+            grep -q "| \[ADR-${adr_number}\](ADR-${adr_number}-" docs/adr/README.md \
+              || { echo "ADR-${adr_number} is missing from the ADR index" >&2; exit 1; }
+          done
+
+          for number in $(seq 1 12); do
+            requirement="$(printf 'RF-%03d' "$number")"
+            grep -q "| ${requirement} |" docs/validation/ruforecast-requirements-evidence.md \
+              || { echo "Missing evidence row for ${requirement}" >&2; exit 1; }
+          done
+          for number in $(seq 1 8); do
+            requirement="$(printf 'FT-%03d' "$number")"
+            grep -q "| ${requirement} |" docs/validation/ruforecast-requirements-evidence.md \
+              || { echo "Missing evidence row for ${requirement}" >&2; exit 1; }
+          done
+          for number in $(seq 1 9); do
+            requirement="$(printf 'PM-%03d' "$number")"
+            grep -q "| ${requirement} |" docs/validation/ruforecast-requirements-evidence.md \
+              || { echo "Missing evidence row for ${requirement}" >&2; exit 1; }
+          done
+
+          python3 - <<'PY'
+          from pathlib import Path
+          import tomllib
+
+          root = Path("v2/crates/ruforecast/crates")
+          core = tomllib.loads((root / "ruforecast-core/Cargo.toml").read_text())
+          model = tomllib.loads((root / "ruforecast-model/Cargo.toml").read_text())
+          train = tomllib.loads((root / "ruforecast-train/Cargo.toml").read_text())
+
+          assert core.get("features", {}).get("default", []) == []
+          assert model["features"]["default"] == [], "model defaults must stay backend-free"
+          assert train["features"]["default"] == [], "train defaults must stay backend-free"
+          assert {"model", "cpu", "cuda", "wgpu", "ruvector"} <= model["features"].keys()
+          assert {"cpu", "cuda", "training", "cli", "server", "fal-client"} <= train["features"].keys()
+          assert {"model", "dep:burn-ndarray"} <= set(model["features"]["cpu"])
+          assert {"model", "dep:burn-cuda"} <= set(model["features"]["cuda"])
+          assert {"model", "dep:burn-wgpu"} <= set(model["features"]["wgpu"])
+          assert "dep:ruvector-core" in model["features"]["ruvector"]
+          assert {"ruforecast-model/cpu", "training"} <= set(train["features"]["cpu"])
+          assert {"ruforecast-model/cuda", "training"} <= set(train["features"]["cuda"])
+
+          bins = {entry["name"]: entry for entry in train.get("bin", [])}
+          assert bins["ruforecast"]["required-features"] == ["cli"]
+
+          model_benches = {entry["name"]: entry for entry in model.get("bench", [])}
+          train_benches = {entry["name"]: entry for entry in train.get("bench", [])}
+          assert model_benches["forecast_inference"]["harness"] is False
+          assert model_benches["forecast_inference"]["required-features"] == ["cpu"]
+          assert train_benches["data_pipeline"]["harness"] is False
+          assert train_benches["data_pipeline"]["required-features"] == ["cpu"]
+          PY
+
+      - name: Check formatting for forecast packages only
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.89.0 fmt
+          -p ruforecast-core
+          -p ruforecast-model
+          -p ruforecast-train
+          -- --check
+
+      - name: Prove feature-off graph excludes Burn and CubeCL
+        working-directory: v2/crates/ruforecast
+        shell: bash
+        run: |
+          set -euo pipefail
+          : > forecast-feature-off-tree.txt
+          for package in ruforecast-core ruforecast-model ruforecast-train; do
+            cargo +1.89.0 tree --locked -e normal,build -p "$package" --no-default-features \
+              >> forecast-feature-off-tree.txt
+          done
+          if grep -Eiq '(^|[[:space:]])(burn|cubecl)(-|[[:space:]])' forecast-feature-off-tree.txt; then
+            echo 'Burn/CubeCL entered the Rust 1.89 feature-off dependency graph.' >&2
+            cat forecast-feature-off-tree.txt >&2
+            exit 1
+          fi
+
+      - name: Check feature-off packages
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.89.0 check --locked
+          -p ruforecast-core
+          -p ruforecast-model
+          -p ruforecast-train
+          --no-default-features --all-targets
+
+      - name: Test model-neutral core
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.89.0 test --locked
+          -p ruforecast-core
+          --no-default-features --lib --tests
+
+      - name: Test model contracts without a model backend
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.89.0 test --locked
+          -p ruforecast-model
+          --no-default-features --lib --tests
+
+      - name: Test RuVector retrieval boundary without a model backend
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.89.0 test --locked
+          -p ruforecast-model
+          --no-default-features --features ruvector --lib --tests
+
+      - name: Clippy RuVector retrieval boundary
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.89.0 clippy --locked
+          -p ruforecast-model
+          --no-default-features --features ruvector --all-targets -- -D warnings
+
+      - name: Clippy forecast packages without backend features
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.89.0 clippy --locked
+          -p ruforecast-core
+          -p ruforecast-model
+          -p ruforecast-train
+          --no-default-features --all-targets -- -D warnings
+
+      - name: Upload feature-off dependency tree
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        with:
+          name: ruforecast-feature-off-tree
+          path: v2/crates/ruforecast/forecast-feature-off-tree.txt
+          if-no-files-found: error
+
+  hosted-boundaries-rust-189:
+    name: Forecast hosted boundaries and privacy contract (Rust 1.89)
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - name: Checkout recursively
+        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+          submodules: recursive
+
+      - name: Install Rust 1.89 with Clippy
+        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4
+        with:
+          toolchain: 1.89.0
+          components: clippy
+
+      - name: Cache Cargo artifacts
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32
+        with:
+          workspaces: v2/crates/ruforecast
+          key: ruforecast-hosted-rust-189
+
+      - name: Enforce clean-room source, secret, and hosted-wire boundary
+        shell: bash
+        run: |
+          set -euo pipefail
+          python3 - <<'PY'
+          from pathlib import Path
+          import re
+          import sys
+
+          roots = [
+              Path("v2/crates/ruforecast/crates/ruforecast-core"),
+              Path("v2/crates/ruforecast/crates/ruforecast-model"),
+              Path("v2/crates/ruforecast/crates/ruforecast-train"),
+          ]
+          text_suffixes = {".json", ".py", ".rs", ".sh", ".toml", ".yaml", ".yml"}
+          forbidden_source = re.compile(r"(?i)\b(?:times[ _-]?fm|google[ _/-]?research)\b")
+          secret_patterns = {
+              "private key": re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"),
+              "AWS access key": re.compile(r"\bAKIA[0-9A-Z]{16}\b"),
+              "JWT": re.compile(r"\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b"),
+              "presigned URL": re.compile(r"(?i)[?&](?:X-Amz-Signature|X-Goog-Signature)="),
+              "literal FAL_KEY": re.compile(r"(?i)\bFAL_KEY\b\s*[:=]\s*['\"][^'$<{\"\n]{8,}['\"]"),
+          }
+          forbidden_blobs = {".ckpt", ".mpk", ".npy", ".npz", ".onnx", ".pt", ".pth", ".safetensors"}
+
+          errors = []
+          for root in roots:
+              for path in root.rglob("*"):
+                  if not path.is_file() or "target" in path.parts:
+                      continue
+                  if path.suffix.lower() in forbidden_blobs:
+                      errors.append(f"forbidden checked-in model/data blob: {path}")
+                      continue
+                  if path.suffix.lower() not in text_suffixes:
+                      continue
+                  text = path.read_text(encoding="utf-8")
+                  if forbidden_source.search(text):
+                      errors.append(f"forbidden clean-room source/import reference: {path}")
+                  for label, pattern in secret_patterns.items():
+                      if pattern.search(text):
+                          errors.append(f"possible {label} in {path}")
+
+          fal_source = Path("v2/crates/ruforecast/crates/ruforecast-train/src/fal.rs").read_text()
+          for struct_name in ("HostedOptimizer", "HostedBudget", "HostedSyntheticPayload"):
+              match = re.search(
+                  rf"pub struct {struct_name}\s*\{{(?P<body>.*?)^\}}",
+                  fal_source,
+                  flags=re.MULTILINE | re.DOTALL,
+              )
+              if match is None:
+                  errors.append(f"missing hosted wire struct: {struct_name}")
+                  continue
+              body = match.group("body")
+              fields = re.findall(r"^\s*pub\s+([A-Za-z0-9_]+)\s*:", body, re.MULTILINE)
+              forbidden_fields = (
+                  "account", "data_policy", "dataset", "device", "identity", "path",
+                  "person", "room", "session", "site", "split", "subject", "tenant",
+                  "workspace",
+              )
+              for field in fields:
+                  lowered = field.lower()
+                  if any(fragment in lowered for fragment in forbidden_fields):
+                      errors.append(f"forbidden hosted field {struct_name}.{field}")
+                  if "bytes" in lowered and field not in {
+                      "max_artifact_bytes",
+                      "max_memory_bytes",
+                  }:
+                      errors.append(f"unapproved hosted byte field {struct_name}.{field}")
+              if "DataPolicy" in body:
+                  errors.append(f"DataPolicy entered hosted wire struct {struct_name}")
+
+          if errors:
+              print("\n".join(errors), file=sys.stderr)
+              raise SystemExit(1)
+          PY
+
+      - name: Enforce tracked-data policy
+        run: |
+          set -euo pipefail
+          bash scripts/csi-data-policy-check.sh --self-test
+          bash scripts/csi-data-policy-check.sh --tracked
+
+      - name: Validate minimal fal deployment archive policy
+        run: >-
+          python3
+          v2/crates/ruforecast/crates/ruforecast-train/deploy/fal/deploy.py
+          self-test
+
+      - name: Prove hosted feature graph excludes Burn and CubeCL
+        working-directory: v2/crates/ruforecast
+        shell: bash
+        run: |
+          set -euo pipefail
+          cargo +1.89.0 tree --locked -e normal,build \
+            -p ruforecast-train \
+            --no-default-features --features cli,server,fal-client \
+            > forecast-hosted-feature-tree.txt
+          if grep -Eiq '(^|[[:space:]])(burn|cubecl)(-|[[:space:]])' \
+            forecast-hosted-feature-tree.txt; then
+            echo 'Burn/CubeCL entered the Rust 1.89 hosted dependency graph.' >&2
+            cat forecast-hosted-feature-tree.txt >&2
+            exit 1
+          fi
+
+      - name: Require named hosted boundary regressions
+        working-directory: v2/crates/ruforecast
+        shell: bash
+        env:
+          FAL_KEY: ''
+        run: |
+          set -euo pipefail
+          cargo +1.89.0 test --locked \
+            -p ruforecast-train \
+            --no-default-features --features cli,server,fal-client \
+            --lib --bins --tests -- --list \
+            | tee hosted-boundary-tests.txt
+          for regression in \
+            fal_app_rejects_path_and_host_confusion \
+            fal_urls_require_exact_origin_path_and_no_query \
+            fal_submit_headers_disable_retry_and_omit_store_io \
+            hosted_payload_dto_has_no_customer_fields \
+            queue_status_discards_provider_error_body \
+            result_url_accepts_exact_response_suffix \
+            artifact_file_url_uses_expected_api_path \
+            fal_key_debug_is_redacted \
+            hosted_payload_rejects_app_field \
+            hosted_reservation_cannot_exceed_source_retention \
+            artifact_handoff_expiry_boundary_is_fail_closed \
+            fal_result_enforces_cumulative_artifact_budget_boundary \
+            fal_download_rejects_over_budget_without_writing \
+            direct_server_train_requires_request_id_header \
+            request_id_rejects_path_injection \
+            unknown_cancel_is_not_success \
+            privacy_external_dataset_payload_is_denied; do
+            grep -q "$regression" hosted-boundary-tests.txt \
+              || { echo "Missing hosted boundary regression: $regression" >&2; exit 1; }
+          done
+
+      - name: Exercise hosted external-data rejection
+        working-directory: v2/crates/ruforecast
+        env:
+          FAL_KEY: ''
+        run: >-
+          cargo +1.89.0 test --locked
+          -p ruforecast-train
+          --no-default-features --features cli,server,fal-client
+          privacy_external_dataset_payload_is_denied
+
+      - name: Test server and fal client with mock integrations
+        working-directory: v2/crates/ruforecast
+        env:
+          FAL_KEY: ''
+        run: >-
+          cargo +1.89.0 test --locked
+          -p ruforecast-train
+          --no-default-features --features cli,server,fal-client
+          --lib --bins --tests
+
+      - name: Clippy server and fal client boundaries
+        working-directory: v2/crates/ruforecast
+        env:
+          FAL_KEY: ''
+        run: >-
+          cargo +1.89.0 clippy --locked
+          -p ruforecast-train
+          --no-default-features --features cli,server,fal-client
+          --all-targets -- -D warnings
+
+      - name: Clippy standalone CLI feature boundary
+        working-directory: v2/crates/ruforecast
+        env:
+          FAL_KEY: ''
+        run: >-
+          cargo +1.89.0 clippy --locked
+          -p ruforecast-train
+          --no-default-features --features cli
+          --bin ruforecast -- -D warnings
+
+      - name: Upload hosted dependency tree
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        with:
+          name: ruforecast-hosted-feature-tree
+          path: v2/crates/ruforecast/forecast-hosted-feature-tree.txt
+          if-no-files-found: error
+
+  burn-cpu-rust-192:
+    name: Forecast Burn CPU tests and bench compile (Rust 1.92)
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    steps:
+      - name: Checkout recursively
+        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+          submodules: recursive
+
+      - name: Install Rust 1.92 with Clippy
+        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4
+        with:
+          toolchain: 1.92.0
+          components: clippy
+
+      - name: Cache Cargo artifacts
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32
+        with:
+          workspaces: v2/crates/ruforecast
+          key: ruforecast-rust-192-cpu
+
+      - name: Test model with Burn CPU backend
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 test --locked
+          -p ruforecast-model
+          --no-default-features --features cpu --lib --tests
+
+      - name: Test trainer and CLI with Burn CPU backend
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 test --locked
+          -p ruforecast-train
+          --no-default-features --features cpu,cli --lib --bins
+
+      - name: Run one-step local JSONL training smoke
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 test --locked
+          -p ruforecast-train
+          --no-default-features --features cpu
+          --test local_jsonl_smoke --
+          --exact local_hash_addressed_jsonl_executes_one_real_optimizer_step
+
+      - name: Run idempotent synthetic CLI training smoke
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 test --locked
+          -p ruforecast-train
+          --no-default-features --features cpu,cli
+          --test cli_smoke --
+          --exact cli_smoke_trains_and_writes_the_complete_candidate_set
+
+      - name: Test combined CPU and hosted feature surface
+        working-directory: v2/crates/ruforecast
+        env:
+          FAL_KEY: ''
+        run: >-
+          cargo +1.92.0 test --locked
+          -p ruforecast-train
+          --no-default-features --features cpu,cli,server,fal-client
+          --lib --bins
+
+      - name: Clippy model with Burn CPU backend
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 clippy --locked
+          -p ruforecast-model
+          --no-default-features --features cpu --all-targets -- -D warnings
+
+      - name: Clippy trainer and CLI with Burn CPU backend
+        working-directory: v2/crates/ruforecast
+        env:
+          FAL_KEY: ''
+        run: >-
+          cargo +1.92.0 clippy --locked
+          -p ruforecast-train
+          --no-default-features --features cpu,cli,server,fal-client
+          --all-targets -- -D warnings
+
+      - name: Compile forecast inference benchmark
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 bench --locked
+          -p ruforecast-model
+          --no-default-features --features cpu
+          --bench forecast_inference --no-run
+
+      - name: Compile forecast data-pipeline benchmark
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 bench --locked
+          -p ruforecast-train
+          --no-default-features --features cpu
+          --bench data_pipeline --no-run
+
+      - name: Run quick inference benchmark for trend visibility
+        continue-on-error: true
+        timeout-minutes: 15
+        working-directory: v2/crates/ruforecast
+        run: |
+          set -o pipefail
+          mkdir -p ../../bench-out/ruforecast
+          cargo +1.92.0 bench --locked \
+            -p ruforecast-model \
+            --no-default-features --features cpu \
+            --bench forecast_inference -- \
+            --warm-up-time 1 --measurement-time 2 --sample-size 10 \
+            | tee ../../bench-out/ruforecast/forecast-inference.txt
+
+      - name: Run quick data-pipeline benchmark for trend visibility
+        continue-on-error: true
+        timeout-minutes: 15
+        working-directory: v2/crates/ruforecast
+        run: |
+          set -o pipefail
+          mkdir -p ../../bench-out/ruforecast
+          cargo +1.92.0 bench --locked \
+            -p ruforecast-train \
+            --no-default-features --features cpu \
+            --bench data_pipeline -- \
+            --warm-up-time 1 --measurement-time 2 --sample-size 10 \
+            | tee ../../bench-out/ruforecast/data-pipeline.txt
+
+      - name: Upload informational benchmark logs
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        with:
+          name: ruforecast-informational-cpu-benchmarks
+          path: bench-out/ruforecast/
+          if-no-files-found: warn
+
+  burn-cuda-compile-rust-192:
+    name: Forecast Burn CUDA/WGPU compile checks only (Rust 1.92)
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout recursively
+        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+          submodules: recursive
+
+      - name: Install Rust 1.92
+        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4
+        with:
+          toolchain: 1.92.0
+
+      - name: Cache Cargo artifacts
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32
+        with:
+          workspaces: v2/crates/ruforecast
+          key: ruforecast-rust-192-cuda-check
+
+      - name: Check model CUDA feature
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 check --locked
+          -p ruforecast-model
+          --no-default-features --features cuda --lib
+
+      - name: Check model WGPU feature
+        working-directory: v2/crates/ruforecast
+        run: >-
+          cargo +1.92.0 check --locked
+          -p ruforecast-model
+          --no-default-features --features wgpu --lib
+
+      - name: Check trainer CUDA and hosted-server feature combination
+        working-directory: v2/crates/ruforecast
+        env:
+          FAL_KEY: ''
+        run: >-
+          cargo +1.92.0 check --locked
+          -p ruforecast-train
+          --no-default-features --features cuda,cli,server
+          --lib --bins
@@ -0,0 +1,68 @@
+# ADR-373/374 — device-access end-to-end through the real @ruvnet/ruview CLI.
+# MR60BHA2 (60 GHz) and RPLIDAR are emulated on pseudo-terminals and read via
+# real pyserial; an ESP32 node is emulated over UDP; the iPhone LiDAR path
+# uses the repository's real relay. All results are SYNTHETIC: this proves
+# the transports and parsers, not hardware behaviour.
+
+name: ruview device e2e
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'harness/ruview/src/**'
+      - 'harness/ruview/bin/**'
+      - 'harness/ruview/test/e2e/**'
+      - 'integrations/iphone-lidar/web/**'
+      - '.github/workflows/ruview-device-e2e.yml'
+  pull_request:
+    paths:
+      - 'harness/ruview/src/**'
+      - 'harness/ruview/bin/**'
+      - 'harness/ruview/test/e2e/**'
+      - 'integrations/iphone-lidar/web/**'
+      - '.github/workflows/ruview-device-e2e.yml'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ruview-device-e2e-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  devices:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
+        with:
+          node-version: '22'
+
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1
+        with:
+          python-version: '3.12'
+
+      - name: Install pyserial
+        run: python -m pip install pyserial==3.5
+
+      - name: Install the iPhone LiDAR relay
+        working-directory: integrations/iphone-lidar/web
+        run: npm ci --ignore-scripts
+
+      - name: Install harness
+        working-directory: harness/ruview
+        run: npm ci --ignore-scripts
+
+      # Missing prerequisites fail instead of skipping (RUVIEW_E2E_REQUIRE).
+      # The suite links each emulator pty to /dev/ttyRUVIEWE2E<n> with
+      # `sudo -n`, because the harness refuses /dev/pts/* port names.
+      - name: Device e2e (SYNTHETIC devices)
+        working-directory: harness/ruview
+        env:
+          RUVIEW_E2E_REQUIRE: '1'
+        run: npm run test:e2e:devices
@@ -0,0 +1,132 @@
+# ADR-368 — @ruvnet/ruview-kernel: build the WASM and napi-rs transports from
+# source on every OS, run the Rust ABI tests, the package unit/security/e2e
+# tests with the native addon REQUIRED, the wasm↔napi parity check, artifact
+# verification, and the cross-package e2e through the @ruvnet/ruview
+# metaharness. No publish step: publication stays CI-only via the release
+# workflow and requires explicit maintainer approval (ADR-265).
+
+name: ruview-kernel npm
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'v2/crates/ruview-kernel/**'
+      - 'v2/crates/ruview-kernel-napi/**'
+      - 'v2/crates/wifi-densepose-vitals/**'
+      - 'harness/ruview-kernel/**'
+      - 'harness/ruview/src/kernel.js'
+      - 'harness/ruview/test/kernel.test.mjs'
+      - '.github/workflows/ruview-kernel-npm.yml'
+  pull_request:
+    paths:
+      - 'v2/crates/ruview-kernel/**'
+      - 'v2/crates/ruview-kernel-napi/**'
+      - 'v2/crates/wifi-densepose-vitals/**'
+      - 'harness/ruview-kernel/**'
+      - 'harness/ruview/src/kernel.js'
+      - 'harness/ruview/test/kernel.test.mjs'
+      - '.github/workflows/ruview-kernel-npm.yml'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ruview-kernel-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  kernel:
+    name: kernel (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+          # The v2 workspace lists submodule crates as members; cargo must be
+          # able to load every member manifest.
+          submodules: recursive
+
+      - name: Install Rust + wasm32 target
+        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4
+        with:
+          targets: wasm32-unknown-unknown
+
+      # v2/rust-toolchain pins its own channel; the target must be installed
+      # for that toolchain, not only for the action's default `stable`.
+      - name: Add wasm32 target to the pinned v2 toolchain
+        working-directory: v2
+        run: rustup target add wasm32-unknown-unknown
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32
+        with:
+          workspaces: |
+            v2 -> target
+            v2/crates/ruview-kernel-napi -> target
+
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
+        with:
+          node-version: '22'
+
+      - name: Rust ABI tests
+        run: cargo test --manifest-path v2/Cargo.toml -p ruview-kernel --locked
+
+      - name: Build WASM + napi-rs artifacts from source
+        working-directory: harness/ruview-kernel
+        run: npm run build
+
+      - name: Verify artifacts (checksums, zero WASM imports, ABI)
+        working-directory: harness/ruview-kernel
+        run: node scripts/verify-artifacts.mjs --require-wasm
+
+      - name: Package tests (napi required)
+        working-directory: harness/ruview-kernel
+        env:
+          RUVIEW_KERNEL_REQUIRE_NAPI: '1'
+        run: npm test
+
+      - name: Doctor, self-test, and wasm↔napi parity (SYNTHETIC)
+        working-directory: harness/ruview-kernel
+        run: |
+          node bin/cli.js doctor --strict-napi
+          node bin/cli.js selftest --backend wasm
+          node bin/cli.js selftest --backend napi
+          node bin/cli.js parity
+
+      - name: Pack
+        working-directory: harness/ruview-kernel
+        run: |
+          npm pack --dry-run
+          # Relative destination: Windows runner temp paths contain
+          # backslashes that bash globbing would mangle.
+          mkdir -p dist-pack
+          npm pack --pack-destination dist-pack
+
+      - name: Cross-package e2e through the @ruvnet/ruview metaharness
+        working-directory: harness/ruview
+        run: |
+          npm ci --ignore-scripts
+          npm install --no-save --ignore-scripts ../ruview-kernel/dist-pack/ruvnet-ruview-kernel-*.tgz
+          node --test test/kernel.test.mjs
+          node bin/cli.js kernel --backend auto
+
+      - name: Upload built artifacts
+        if: matrix.os == 'ubuntu-latest'
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: ruview-kernel-linux-x64
+          path: |
+            harness/ruview-kernel/wasm/ruview_kernel.wasm
+            harness/ruview-kernel/wasm/SHA256SUMS
+            harness/ruview-kernel/native/*.node
+            harness/ruview-kernel/native/SHA256SUMS
+          retention-days: 14
@@ -104,8 +104,10 @@ jobs:
        run: |
          set -euo pipefail
          case "${{ inputs.package }}" in
-            # ADR-283: brain + local hosts + replay assets; no runtime deps.
-            harness/ruview) export UNPACKED_BUDGET=131072 ;;
+            # ADR-283/325/369-374: brain + hosts + replay + Spaces OAuth + SDK,
+            # flashing, training, doctor, device access, SSH hosts; ADR-375 console
+            # widget, HTTP transport, terminal UI; ADR-378 mod showcase; no runtime deps.
+            harness/ruview) export UNPACKED_BUDGET=458752 ;;
            # ADR-285: CLI + MCP + reviewed brain + WASM-kernel adapter.
            harness/homecore) export UNPACKED_BUDGET=180000 ;;
            # ADR-264 O2: map-free tarball (was 188 kB with maps).
@@ -140,12 +142,12 @@ jobs:
          npm i --no-fund --no-audit "$TGZ"
          case "${{ inputs.package }}" in
            harness/ruview)
-              ./node_modules/.bin/ruview --version
-              ./node_modules/.bin/ruview doctor
-              ./node_modules/.bin/ruview guidance --topic homecore --query restore --limit 1 \
+              ./node_modules/.bin/ruview-harness --version
+              ./node_modules/.bin/ruview-harness doctor
+              ./node_modules/.bin/ruview-harness guidance --topic homecore --query restore --limit 1 \
                | grep -q '"homecore-runtime-restore"'
              # the honesty gate must fail closed on empty input (ADR-263 F1)
-              if ./node_modules/.bin/ruview claim-check; then
+              if ./node_modules/.bin/ruview-harness claim-check; then
                echo 'claim-check passed with no input — fail-open regression'; exit 1
              fi
              node --input-type=module -e "const m = await import('@ruvnet/ruview'); if (!m.TOOLS) process.exit(1);"
@@ -14,6 +14,33 @@ env:
  PYTHON_VERSION: '3.11'

 jobs:
+  # Rust dependency advisories are deterministic for the checked-in lockfile,
+  # so this job gates the PR and retains the exact machine-readable report.
+  rust-audit:
+    name: Rust Dependency Audit
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+
+    - name: Install cargo-audit
+      run: cargo install cargo-audit --locked --version 0.22.2
+
+    - name: Audit the checked-in Rust lockfile
+      run: |
+        set -o pipefail
+        cargo audit --file v2/Cargo.lock --json | tee v2/cargo-audit.json
+
+    - name: Upload Rust advisory report
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+      if: always()
+      with:
+        name: cargo-audit-report
+        path: v2/cargo-audit.json
+        if-no-files-found: error
+
  # Static Application Security Testing (SAST)
  sast:
    name: Static Application Security Testing
@@ -28,6 +28,7 @@ on:
      - 'v2/crates/wifi-densepose-wifiscan/**'
      - 'v2/crates/wifi-densepose-bfld/**'
      - 'v2/crates/cog-ha-matter/**'
+      - 'v2/crates/homecore*/**'
      - 'v2/Cargo.toml'
      - 'v2/Cargo.lock'
      - 'ui/**'
@@ -17,19 +17,29 @@ firmware/esp32-csi-node/sdkconfig.defaults.bak
 firmware/esp32-hello-world/sdkconfig.old

 # Host-built firmware test binaries (compiled from test/*.c, not source)
-firmware/esp32-csi-node/test/test_adr110
-firmware/esp32-csi-node/test/test_vitals
-firmware/esp32-csi-node/test/fuzz_serialize
-firmware/esp32-csi-node/test/fuzz_edge
-firmware/esp32-csi-node/test/fuzz_nvs
+# Compiled host-test and fuzz binaries. The Makefile writes them beside their
+# sources, so they land in a tracked directory. Ignore them by SHAPE rather
+# than by name: every source here carries an extension and no binary does.
+#
+# This replaced a hand-maintained list of five targets, which had gone stale --
+# test_csi_sanitize, test_mmwave_detect and test_thermal were all built by
+# `make host_tests`, ignored by nothing, and got committed by accident.
+firmware/esp32-csi-node/test/test_*
+firmware/esp32-csi-node/test/fuzz_*
+!firmware/esp32-csi-node/test/*.*
 firmware/esp32-csi-node/test/*.exe
 firmware/esp32-csi-node/test/*.obj

 # Claude Flow swarm runtime state
 .swarm/

-# CSI recordings (local training data, machine-specific)
+# CSI recordings (local training/capture data — CSI is person data per
+# CLAUDE.md; never commit). Covers current and legacy layouts. See ADR-299.
+data/recordings/
+v2/data/recordings/
 rust-port/wifi-densepose-rs/data/recordings/
+**/*.csi.jsonl
+**/*.csi.meta.json

 # NVS partition images and CSVs (contain WiFi credentials)
 nvs.bin
@@ -298,4 +308,20 @@ ruvector.db
 # sensing-server runtime artifacts written by its test suite (trained model
 # snapshots + the generated session-secret) — never tracked
 v2/crates/wifi-densepose-sensing-server/data/
+# The server also writes this secret when launched from v2/. Keep the rule
+# file-specific so tracked datasets below v2/data remain visible.
+/v2/data/session-secret
 *.proptest-regressions
+
+# ADR-324: wasm-bindgen output for ruview-offaxis is generated locally
+# (see the crate README); never commit generated artifacts.
+v2/crates/ruview-offaxis/pkg/
+
+# fal.ai visual-teacher LoRA training data/weights -- regenerable, never
+# commit training images or model weights (ADR-353)
+scripts/fal-visual-teacher/training-data/
+scripts/fal-visual-teacher/training-data.zip
+scripts/fal-visual-teacher/output/
+
+# Trained adaptive classifier (auto-created at runtime; #2135)
+/v2/data/adaptive_model.json
@@ -33,3 +33,7 @@
 	path = vendor/metaharness
 	url = https://github.com/ruvnet/metaharness
 	branch = main
+[submodule "v2/crates/ruforecast"]
+	path = v2/crates/ruforecast
+	url = https://github.com/ruvnet/RuForecast.git
+	branch = main
@@ -47,17 +47,18 @@ from the current tree when needed.

 ## RuView contributor harness

-`@ruvnet/ruview@0.3.1` is the runtime-dependency-free contributor interface
+`@ruvnet/ruview@0.5.0` is the runtime-dependency-free contributor interface
 defined by ADR-283.

 ```bash
-npx @ruvnet/ruview@0.3.1 doctor
-npx @ruvnet/ruview@0.3.1 guidance --topic homecore --query "restore and plugins"
-npx @ruvnet/ruview@0.3.1 agent run \
+npx @ruvnet/ruview@0.5.0 doctor
+npx @ruvnet/ruview@0.5.0 guidance --topic homecore --query "restore and plugins"
+npx @ruvnet/ruview@0.5.0 agent run \
  --host codex --repo . --prompt "Find the nearest tests and cite files"
-npx @ruvnet/ruview@0.3.1 brain search --query "community memory"
-npx @ruvnet/ruview@0.3.1 brain verify --repo .
-npx @ruvnet/ruview@0.3.1 mcp start
+npx @ruvnet/ruview@0.5.0 brain search --query "community memory"
+npx @ruvnet/ruview@0.5.0 brain verify --repo .
+npx @ruvnet/ruview@0.5.0 spaces
+npx @ruvnet/ruview@0.5.0 mcp start
 ```

 Start unfamiliar repository work with `ruview_guidance`. It returns reviewed
@@ -7,8 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+### Community batch (PRs #2100-#2157 by aepod, reviewed and integrated)
+
+Integrated as one set: conflicts resolved, review findings fixed, validated on the integrated branch. Hardware figures cited by the PRs are the author's own live runs on ESP32-S3 nodes and were not independently reproduced here.
+
+- **Security and honest status.** Refuse a routable HTTP bind when API auth is off (#2134). `--privacy-mode` now strips biometrics from REST, WebSocket and recordings, not only MQTT (#2125; the stripped-key list is an exact-match allowlist, so a new biometric field must be added to it). `/api/v1/status` waits for a real frame and unknown `--source` values are rejected (#2126; breaking for `--source macos|linux|windows`). A stale `/sensing/latest` reports `{"status":"stale"}` after 10 s (#2119). Measured stream fps and real WebSocket client counts (#2127). Absent nodes no longer count as one person (#2132). ESP32 frames with zero antennas or subcarriers are dropped (#2118). Dead nodes are evicted on a timer (#2120). Recordings and models stay under `--data-dir` (#2129). Boolean env flags accept 1/0/yes/no/on/off (#2108). Docker UDP ingest posture is explicit (#2107).
+- **CSI pipeline.** The grid gate locks on the majority frame shape and `/health` reports a stalled pipeline (#2157; a partial fix, mixed 192/306 frame shapes still drop frames, so it does not close #1894). Phase is combined across nodes only when they declare a shared reference (#2156). Point-cloud and hardware parsers use the ADR-018 layout and accept more than 256 subcarriers (#2155; the bandwidth rule for counts above 64 is CLAIMED, inferred from the datasheet). Per-node adaptive training from real recordings (#2101, #2103); a run that fell back to the live buffer now reports `degraded: true`. Gaussian decay no longer compounds across calls (#2140).
+- **MediaTek (ADR-266/267).** Legacy and unknown PPDU types in MTC1 (#2112), per-device ingest capped at 64 devices (#2113), a labelled amplitude heuristic and activity index (#2114; CLAIMED, not an occupancy estimate), an MT7981 bridge (#2115), and the OpenWrt WN586X3 patch set and guide (#2116; the vendored CSI patch is BSD-3-Clause-Clear, see `NOTICE`).
+- **MQTT / Home Assistant.** Semantic states wired into the publisher, entities announced only when sourced, persisted client id (#2117). Existing Home Assistant installs keep retained discovery configs for the six removed entities until they are cleared manually.
+- **Provisioning and firmware.** Wi-Fi password kept owner-only and out of argv and `--state` (#2153); state keyed by board MAC (#2152); `--dry-run` and a failed `--reset` leave state intact (#2111); OTA images confirmed by a bounded health check, which means only "reached the network and sent CSI" (#2100, ADR-379).
+- **Ground truth and spatial.** Radar window adapter and auto-labeller with a session-disjoint split and a median count baseline; radar labels carry `evidence: CLAIMED` (#2143, #2144). Node self-survey, check-only (#2145, ADR-381). The `spatial.evidence.v1` export defaults to the CODE proof grade and MEASURED requires a reproducer (#2141, ADR-382). Loopback UDP tee (#2102, ADR-380).
+- **Tooling.** `prove.sh` reports INCOMPLETE instead of PASS when a gate is skipped (#2130); ADR-018 capture scripts (#2131); API token on the ground-truth script (#2104); the UI asks for the API token instead of retrying forever (#2128); macOS redacted-link handling (#2105).
+- **Not included:** #2106 (MacWifi.app, draft) and #2142 (MR60 probe change, needs a captured MR60BHA2 boot log). `v2/data/adaptive_model.json` (41.5% training accuracy) is no longer tracked (#2135).
+
 ### Added

+- **`@ruvnet/ruview` 0.9.1: live sensing views inside Claude Code (ADR-377, ADR-378).** The package now ships `ruview-live`, a Claude Code mod. Type `/ruview` and a pane opens next to the conversation showing what your sensors see right now, refreshed automatically. It has three views, switched with keys `1` `2` `3` or with `/ruview overview|waterfall|radar`:
+  - **Overview**: the CSI nodes streaming to your machine (rate, packet loss, signal strength) and an optional 60 GHz radar kit (presence, distance, heart and breathing rates).
+  - **CSI waterfall**: the Wi-Fi signal itself, the strength of every subcarrier over time, drawn in colour and scrolling as frames arrive. The new `ruview esp32 --spectrum` option supplies the data.
+  - **Radar**: a top-down range fan with an animated ping out to the measured distance, plus heart, breathing and distance charts.
+
+  Every reading is labelled honestly: MEASURED or SYNTHETIC from the packets themselves; radar vitals as "device-reported, not validated"; range-only radar as "distance, not direction". The pane only reads; it never flashes or configures a device.
+
+  Verified on real hardware: an ESP32-C6 streaming CSI and a Seeed MR60BHA2 radar kit (MEASURED; reproducer `npx @ruvnet/ruview esp32 --seconds 4 --spectrum --json`). The package's size ceiling rises from 384 KiB to 448 KiB; it still has no runtime dependencies.
 - **`wifi-densepose-sar` — coherent wideband RF tomography research crate (ADR-287).** New standalone leaf crate (the `nvsim` pattern; zero coupling to `wifi-densepose-hardware` or any real ingestion path) implementing the synthetic-aperture-radar reconstruction primitive a handheld through-wall RF imaging device would need — motivated by comparison against Applied Electrodynamics' "WaveSight" launch, and explicitly scoped below ADR-278's RISE/DiffRadar/GeRaF reproduction gates. Ships: (1) a stepped-frequency, multi-position complex forward measurement simulator (`y_{m,k} = Σ σ_j/R² · exp(-i·4π·f·R/c) + noise`, deterministic ChaCha20 seeding); (2) delay-and-sum backprojection reconstruction onto a 3D voxel grid, rayon-parallelized over voxels; (3) threshold + local-maximum point-cloud extraction; (4) closed-form range/cross-range resolution and antenna-pose coherence-budget formulas (`ΔR=c/2B`, `δ_CR≈λR/2L`, `Δp≤λ/8`) checked against the reconstruction's *actual* behavior in `tests/physics_validation.rs` rather than merely documented — forward-simulating two targets at controlled separations and proving they resolve or merge exactly where the formulas predict, and that reconstructed focus at a known target degrades as injected antenna-pose error grows. Every number is SYNTHETIC/L0 (ADR-282) — no real wideband RF hardware backs this crate; see the crate README and `docs/tutorials/coherent-rf-tomography-backprojection.md` for the full honesty boundary and a worked walkthrough. `focus_at_point` exploits the evenly-spaced-by-construction frequency sweep (an arithmetic progression in per-term phase) to evaluate each pose's phasor once and advance it by a fixed complex-multiply step per frequency instead of one `sin`/`cos` pair per frequency — **MEASURED ~4.4-4.5x faster** (criterion regression detection, p < 0.001) than the first-shipped direct-computation version, proven equivalent (not just faster) to an independently reimplemented reference across four sweep sizes and on-/off-target points. 25 tests (22 unit + 3 integration), 0 failed, clippy-clean; MEASURED backprojection throughput ~1.7-2.3M voxels/sec (criterion, 21 poses × 32 freq steps).
 - **HOMECORE platform runtime completion — secure native/Wasmtime plugins, authenticated HAP IP, expanded Home Assistant APIs, durable restoration/migration, and voice protocols.** `homecore-server` now owns deterministic compiled-in native plugin registration plus explicitly configured, path-bounded, Ed25519 publisher-verified Wasm packages executed through Wasmtime with setup/state-change/teardown lifecycle; arbitrary native dynamic libraries remain intentionally unsupported. The optional HAP server implements persisted accessory identity and controller records, SRP-6a Pair-Setup M1–M6, X25519/Ed25519 Pair-Verify M1–M4, HKDF-SHA512/ChaCha20-Poly1305 record framing, authenticated/admin endpoint gates, replay/tamper closure, live entity synchronization, and paired-state `_hap._tcp` mDNS updates (45 focused tests; external Apple certification is not claimed). Startup restores device/entity registries and deterministic latest recorder states before plugins, and migration now atomically preserves forward-compatible device/config-entry fields. The HA-compatible surface adds events, templates, config checks, components, registries, history/logbook with SQL-enforced global response bounds, calendar/camera provider routes, and modern WebSocket negotiation while retaining a machine-readable limitations matrix for integration-specific behavior. Assist adds bounded PCM16, async STT/TTS contracts, an end-to-end speech pipeline, and an authenticated satellite session protocol; real deployments still provide the speech engines.
 - **`ruview-unified` increment 3 — Gaussian update-loop completion, separable delay-Doppler, and property-tested boundary hardening.** (1) `GaussianMap::merge_overlapping` (ADR-275 step 5: mutual-Mahalanobis + semantic-compatibility dedup catching drift the insert-time gate misses) and lifetime-aware decay (`τ_eff = τ·(1+ln(1+lifetime/τ))` — confirmed structures outlive transients at equal nominal τ). (2) `delay_doppler_map` reimplemented separably (`O(B²S+S²B)`), proven equivalent to the direct reference to <1e-10 and **measured 8.3× faster** (520 µs vs 4.34 ms at 56×8). (3) `tests/security_boundaries.rs` — 8 `proptest` properties over the boundary surfaces (arbitrary values incl. NaN/±inf via `f64::from_bits`) that found and fixed three input-controlled defects: a BLE-CS phase-unwrap infinite loop on non-finite phases and an ~1e299-iteration loop on finite-huge phases (now O(1) modular unwrap + plausibility bound), and a subnormal Gaussian scale overflowing `1/σ²` to NaN density (now physical σ/occupancy bounds). (4) New criterion benches for all increment-2 hot paths (`to_canonical` 38 µs, `ble_cs_range` 481 ns, AoI planner 647 ns/200 regions, coherent fusion 1.5 µs/32 members, factorized pose 521 ns). ruview-unified now 98 tests (87 lib + 3 acceptance + 8 security), 0 failed, clippy-clean.
@@ -25,6 +46,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`archive/v1` (the original pure-Python implementation) formally deprecated (ADR-187)** — commits `1fb5397dd`, `b1417fb6e`; refs #509, #1125. Added `archive/v1/DEPRECATED.md` (a loud tombstone) and a `> ⚠️ DEPRECATED` notice atop `archive/v1/README.md`, both pointing at the maintained `v2/` workspace and the `wifi-densepose 2.x` / `ruview` pip wheel (ADR-117). Records the honest fact behind #509: `archive/v1`'s `DensePoseHead` is **architecture-only** — random `kaiming_normal_` init with **zero committed checkpoints** under `archive/v1/` (MEASURED by Glob over `**/*.{pth,onnx,safetensors,pt,ckpt,bin}`). The ADR-028 deterministic proof `archive/v1/data/proof/verify.py` stays live and is explicitly out of scope. The same effort added a **"Model weights: what's real, what's not" three-tier table** to `README.md` + `docs/user-guide.md`, separating real-and-validated checkpoints (presence 82.3% held-out temporal-triplet, MM-Fi pose 82.69% torso-PCK@20, `count_v1`) from the real-but-weak on-device `pose_v1` (PCK@20 = 3.0%, runtime `confidence=0` stub, below the ADR-079 ≥35% target) from the architecture-only `archive/v1` head — and caveated every live single-ESP32 17-keypoint advertisement accordingly. Docs/labeling only; no code or model behavior changed.

 ### Fixed
+- **Pose-vitals, desktop, and repository-integrity issue remediation.** Breathing confidence now measures periodic autocorrelation at the estimated respiratory frequency instead of penalizing clean sinusoidal signals via crest factor (#1610). The desktop launcher resolves the Windows `.exe`, uses `where` for PATH lookup, and passes log filtering through `RUST_LOG`; its React versions, Vite type declarations, and Tauri UI hook working directories are aligned (#1516, #1517, #1518). Runtime session secrets written from `v2/` are ignored, and contributor-harness provenance inputs are pinned to LF across Windows checkouts (#1519, #1520). With explicit owner authorization, the six raw CSI/person-data capture and metadata files identified by ADR-299 were removed from the current tree; historical copies remain pending separately coordinated incident response.
 - **`docs/huggingface/MODEL_CARD.md` had drifted from the model card actually published on the Hub (issue #1481).** Every filename in its "Files in this repo" table (`pretrained-encoder.onnx`, `pretrained-heads.onnx`, `pretrained.rvf`, `room-profiles.json`) pointed at files never uploaded to `ruvnet/wifi-densepose-pretrained` — only `config.json` existed. Replaced the in-repo card with the content actually live on the Hub (`model.safetensors`, `model-q{2,4,8}.bin`, `node-{1,2}.json`, `presence-head.json`, `csi-embed-v2.*`, honest v1→v2 retraction of the single-class "100%" presence claim) and added a "Using with the Rust sensing server (RVF conversion)" section documenting the `--convert-model`/`--convert-out` and `--model` auto-convert paths that neither card previously mentioned.
 - **`--convert-model` failed on the published `model.safetensors`: NUL-padded safetensors header rejected by strict JSON parse (issue #1480, #894 follow-up).** The reference safetensors format pads its JSON header to an 8-byte boundary with trailing NUL bytes; `safetensors_to_rvf` (`wifi-densepose-sensing-server/src/model_format.rs`) fed the full declared-length header slice straight to `serde_json::from_slice`, which rejects the padding as "trailing characters." Since the only published full-precision weight file exercises this padding, `--convert-model` could not convert it at all. Fixed by trimming trailing NUL/whitespace bytes before parsing. Pinned by `safetensors_nul_padded_header_converts` (a header padded to the 8-byte boundary, matching the real HF file, converts and round-trips its weights through `ProgressiveLoader`).
 - **In-server training reconnected — "Start Training" no longer silently no-ops; `/ws/train/progress` streams real progress (ADR-186, issue #1233).** The dashboard's Start Training button POSTed a config, got `success:true`, and nothing happened: `/api/v1/train/start` was a stub that flipped a status string and logged one line, and `/ws/train/progress` 404'd. The full pure-Rust trainer in `training_api.rs` (loads recorded CSI, gradient-descent, exports a `.rvf`) already existed but was **orphaned** — never declared as a module (no `mod training_api;`), so it wasn't compiled at all. Fix (`wifi-densepose-sensing-server`): declared the module, reconciled `AppStateInner` (replaced the `training_status`/`training_config` stub fields with a shared `TrainingState` status handle + cooperative cancel flag + a `training_progress_tx` broadcast), deleted the stub handlers, and merged the real `training_api::routes()` (so `/api/v1/train/{start,stop,status,pretrain,lora}` and `/ws/train/progress` resolve under the existing `/api/v1/*` bearer gate). The training core was decoupled from the ~60-field server state so it is unit-testable. **P5 honesty guarantee:** with `RUVIEW_DISABLE_SERVER_TRAINING` set, start returns a structured `{enabled:false, cli:"wifi-densepose train-room"}` HTTP 409 — never a silent success — and the dashboard disables the Start buttons with a CLI tooltip (enablement is surfaced on `/api/v1/train/status`). Pinned by 8 new tests incl. a **live-socket** test that completes a genuine 101 WebSocket handshake and receives a real progress frame after a POST start, a full POST→poll-status→`.rvf`-exists round-trip, a path-traversal rejection, cancellation, and the disabled-409 path. `cargo test -p wifi-densepose-sensing-server -p wifi-densepose-train --no-default-features` — 0 failed.
@@ -45,7 +45,7 @@ retrieved memories, generated proposals, and old test counts are not.
 Do not hardcode crate, ADR, or test counts in instructions; derive them when a
 task needs them.

-## Contributor metaharness (`@ruvnet/ruview@0.3.1`)
+## Contributor metaharness (`@ruvnet/ruview@0.4.0`)

 ADR-283 defines the current community metaharness. It adds secure local
 Claude/Codex execution, a reviewed shared brain, default-deny MCP mutation
@@ -54,21 +54,24 @@ free of runtime dependencies.

 ```bash
 # Diagnose the installed harness
-npx @ruvnet/ruview@0.3.1 doctor
+npx @ruvnet/ruview@0.4.0 doctor

 # Get a source-cited capability map before unfamiliar work
-npx @ruvnet/ruview@0.3.1 guidance --topic homecore --query "restore and plugins"
+npx @ruvnet/ruview@0.4.0 guidance --topic homecore --query "restore and plugins"

 # Explore this trusted checkout through Claude Code (stdin, plan/safe mode)
-npx @ruvnet/ruview@0.3.1 agent run \
+npx @ruvnet/ruview@0.4.0 agent run \
  --host claude-code --repo . --prompt "Map the relevant subsystem and cite files"

 # Search reviewed, source-cited repository knowledge
-npx @ruvnet/ruview@0.3.1 brain search --query "community memory"
-npx @ruvnet/ruview@0.3.1 brain verify --repo .
+npx @ruvnet/ruview@0.4.0 brain search --query "community memory"
+npx @ruvnet/ruview@0.4.0 brain verify --repo .
+
+# Read the OAuth-bound Cognitum Spaces projection
+npx @ruvnet/ruview@0.4.0 spaces

 # Run the dependency-free RuView MCP server
-npx @ruvnet/ruview@0.3.1 mcp start
+npx @ruvnet/ruview@0.4.0 mcp start
 ```

 `ruview_guidance` returns reviewed capability maturity, repository citations,
@@ -0,0 +1,22 @@
+RuView third-party notices
+
+This repository is licensed MIT OR Apache-2.0 (see LICENSE). The items below
+are vendored third-party material that keeps its own licence and is not
+covered by that dual licence.
+
+firmware/openwrt-wn586x3/patches/1001-mtk-mt76-mt7915-csi-implement-csi-support-REBASED.patch
+  What:     MediaTek's mt76 mt7915 CSI patch, rebased onto openwrt/mt76
+            eb567bc7 (the revision pinned by OpenWrt 24.10.8).
+  Author:   Bo Jiao <Bo.Jiao@mediatek.com> (original author line kept in the
+            patch header); copyright MediaTek Inc.
+  Origin:   mediatek/mtk-openwrt-feeds @ a15454c888f4f4144c50e33b5feef4f247c5f78b
+  Licence:  BSD-3-Clause-Clear (SPDX identifier,
+            https://spdx.org/licenses/BSD-3-Clause-Clear.html). The patch
+            carries the SPDX tags and MediaTek copyright lines in its added
+            files; the licence text is not reproduced here.
+  Scope:    A vendored patch applied to an OpenWrt/mt76 build. It is not part
+            of the Rust crates, is not compiled by the Cargo workspace, and is
+            not linked into any RuView binary.
+
+See firmware/openwrt-wn586x3/README.md for the other patches in that
+directory and the licence each one keeps.
@@ -2,20 +2,17 @@

 <p align="center">
  <a href="https://cognitum.one/seed">
-    <img src="assets/ruview-seed.png" alt="RuView - WiFi DensePose" width="100%">
+    <img src="assets/ruview-hero-h3-v3.gif" alt="RuView - WiFi DensePose — animated visualization of real-time pose estimation, breathing, and heart-rate sensing through WiFi" width="100%">
  </a>
 </p>
+
 <p align="center">
-  <a href="https://cognitum.one/marketplace">
-    <img src="assets/musica-promo.png" alt="Cognitum Musica" width="100%">
-  </a>
-</p>
-<p align="center">
-  <a href="https://github.com/ruvnet/RuCelium">
-    <img src="assets/rucelium-hero.png" alt="RuCelium — environmental intelligence" width="100%">
+  <a href="https://ruos.cognitum.one">
+    <img src="assets/ruos-animated.svg" alt="RuView — WiFi becomes spatial awareness, with Ruflo coordination and a ruOS sensing workspace" width="100%">
  </a>
 </p>

+
 ## **See through walls with WiFi** ##

 **Turn ordinary WiFi into a spatial intelligence / sensing system.** Detect people, measure breathing and heart rate, track movement, and monitor rooms — through walls, in the dark, with no cameras or wearables. Just physics.
@@ -49,28 +46,56 @@ Every WiFi router already fills your space with radio waves. When people move, b
 <details>
 <summary><strong>RuView MetaHarness</strong> — guided operation for humans and AI agents</summary>

-The RuView-specific metaharness we created is published as [`@ruvnet/ruview`](harness/ruview/README.md). It provides source-cited guidance, guarded Claude Code/Codex agents, deterministic verification, and an honesty check for accuracy claims.
+The RuView-specific metaharness we created is published as [`@ruvnet/ruview`](harness/ruview/README.md). It provides:
+- source-cited guidance;
+- device access for CSI nodes, radar and LiDAR;
+- firmware flashing with boot evidence;
+- one MCP server, usable over stdio or HTTP for ChatGPT, with a live console widget;
+- a Claude Code mod;
+- guarded Claude Code/Codex agents;
+- deterministic verification;
+- an honesty check for accuracy claims.
+
+Companion packages: [`homecore`](harness/homecore/README.md) (Homecore developer metaharness) and [`@ruvnet/ruview-kernel`](harness/ruview-kernel/README.md) (the vitals pipeline as WASM).

 ```bash
 # Check the local setup and get source-cited guidance
-npx @ruvnet/ruview@0.3.1 doctor
-npx @ruvnet/ruview@0.3.1 guidance --topic sensing --query "model loading"
+npx @ruvnet/ruview@0.9.1 doctor
+npx @ruvnet/ruview@0.9.1 guidance --topic sensing --query "model loading"
+
+# Hardware: what is plugged in, live CSI from your nodes, a 60 GHz radar kit
+npx @ruvnet/ruview@0.9.1 devices
+npx @ruvnet/ruview@0.9.1 esp32 --watch                       # ESP32 + Realtek RAC1 nodes, live view
+npx @ruvnet/ruview@0.9.1 esp32 --seconds 45 --analyze        # live CSI through the vitals kernel
+npx @ruvnet/ruview@0.9.1 mmwave --source esphome --host <kit-ip>
+
+# Agents: MCP over stdio, or over HTTP for ChatGPT (token-protected, read tools only)
+npx @ruvnet/ruview@0.9.1 mcp start
+RUVIEW_MCP_GRANTS=device-access npx @ruvnet/ruview@0.9.1 mcp start --http
+
+# Claude Code: a live sensing pane (/ruview), shipped in the package
+npx @ruvnet/ruview@0.9.1 mod

 # Run a read-only RuView agent through Codex
-npx @ruvnet/ruview@0.3.1 agent run --host codex --repo . \
+npx @ruvnet/ruview@0.9.1 agent run --host codex --repo . \
  --prompt "Find the nearest tests and cite the source files"

-# Search or verify the reviewed contributor brain
-npx @ruvnet/ruview@0.3.1 brain search --query "calibration"
-npx @ruvnet/ruview@0.3.1 brain verify --repo .
-
-# Check claims, replay the deterministic proof, or expose the MCP server
-npx @ruvnet/ruview@0.3.1 claim-check --file REPORT.md
-npx @ruvnet/ruview@0.3.1 verify
-npx @ruvnet/ruview@0.3.1 mcp start
+# Check claims, replay the deterministic proof, search the reviewed brain
+npx @ruvnet/ruview@0.9.1 claim-check --file REPORT.md
+npx @ruvnet/ruview@0.9.1 verify
+npx @ruvnet/ruview@0.9.1 brain search --query "calibration"
 ```

-Agent runs are read-only by default. Workspace writes require both `--allow-write` and `--confirm`; retrieved brain content is evidence, not authority.
+**Safety:**
+- Agent runs are read-only by default. Workspace writes require both `--allow-write` and `--confirm`.
+- Hardware reads need the `device-access` grant.
+- Flashing and calibration never run over the HTTP transport.
+- Device-reported vitals are labelled as unvalidated.
+- Retrieved brain content is evidence, not authority.
+
+A single `npx ruview` package bundling all of this is ready (ADR-376). It is waiting on npm to release the unscoped name.
+
+Full walkthrough: [user guide → RuView npm toolkit](docs/user-guide.md#ruview-npm-toolkit-ruvnetruview).

 </details>

@@ -122,8 +147,11 @@ RuView turns ordinary WiFi into a contactless sensor. A $9 ESP32 board reads the
 ```bash
 # Option 1: Docker (simulated data, no hardware needed)
 docker pull ruvnet/wifi-densepose:latest
-docker run -p 3000:3000 ruvnet/wifi-densepose:latest
+export RUVIEW_API_TOKEN=$(openssl rand -hex 32)   # required; the container exits 64 without it
+docker run -p 127.0.0.1:3000:3000 -e RUVIEW_API_TOKEN ruvnet/wifi-densepose:latest
 # Open http://localhost:3000
+# ESP32 nodes in Docker also need a UDP source guard (RUVIEW_UDP_ALLOW);
+# see docs/user-guide.md "Receiving ESP32 frames in Docker".

 # Option 2a: Live sensing with ESP32-S3 hardware ($9)
 # Flash firmware, provision WiFi, and start sensing:
@@ -223,7 +251,7 @@ huggingface-cli download ruvnet/wifi-densepose-pretrained --local-dir models/wif

 | Consumer | Format used | Status |
 |----------|-------------|--------|
-| Python training / evaluation / embedding extraction | `model.safetensors` | ✅ Works — load with `safetensors.torch.load_file` |
+| Python training / evaluation / embedding extraction | `model.safetensors` | ⚠️ The published file's header is NUL-padded, which the reference `safetensors.torch.load_file` rejects (issue [#1522](https://github.com/ruvnet/RuView/issues/1522)) — pending a corrected re-upload. `csi-embed-v2.safetensors` in the same repo is unaffected and loads normally. |
 | Inspect / re-export the bundle | `model.rvf.jsonl` (line-by-line JSON) | ✅ Works — plain JSONL |
 | Sensing-server `--model <PATH>` flag | native RVF, `model.safetensors`, or `model.rvf.jsonl` | ✅ Native RVF loads directly; safetensors and JSONL auto-convert in memory |

@@ -244,8 +272,8 @@ See the measured benchmarks, witness records, and one-command reproducibility ch
 |------|-------|---------|
 | **MM-Fi pose model (SOTA)** | [`ruvnet/wifi-densepose-mmfi-pose`](https://huggingface.co/ruvnet/wifi-densepose-mmfi-pose) | 82.69% torso-PCK@20 (single) · 83.59% (ensemble+TTA) · 75K-param micro variant 74.30% |
 | **AetherArena benchmark Space** | [`ruvnet/aether-arena`](https://huggingface.co/spaces/ruvnet/aether-arena) | self-correcting, auditable MM-Fi leaderboard |
-| **Full MM-Fi study (honest picture)** | [`docs/benchmarks/mmfi-wifi-sensing-study.md`](docs/benchmarks/mmfi-wifi-sensing-study.md) | pose + action; zero-shot cross-subject ~64%, +~30 s in-room calibration → 72.2% |
-| **Efficiency frontier** | [`docs/benchmarks/wifi-pose-efficiency-frontier.md`](docs/benchmarks/wifi-pose-efficiency-frontier.md) | SOTA-beating WiFi pose in a 20 KB int4 edge model |
+| **Full MM-Fi study (honest picture)** | [`docs/benchmarks/mmfi-wifi-sensing-study.md`](docs/benchmarks/mmfi-wifi-sensing-study.md) | pose + action; zero-shot cross-subject ~64%, labeled in-room calibration → 72.2% |
+| **Efficiency frontier** | [`docs/benchmarks/wifi-pose-efficiency-frontier.md`](docs/benchmarks/wifi-pose-efficiency-frontier.md) | SOTA-beating MM-Fi pose in a ~37 KB int4 model; live ESP32 compatibility not established |
 | **Pretrained encoder** | [`ruvnet/wifi-densepose-pretrained`](https://huggingface.co/ruvnet/wifi-densepose-pretrained) | 82.3% held-out temporal-triplet, 8 KB int4 |
 | **Reproducible proof (Trust Kill Switch)** | [`archive/v1/data/proof/verify.py`](archive/v1/data/proof/verify.py) + [`expected_features.sha256`](archive/v1/data/proof/expected_features.sha256) | one-command deterministic pipeline replay (SHA-256 of output vs published hash) |
 | **Benchmark-proof ADR** | [ADR-168](docs/adr/ADR-168-benchmark-proof.md) | how the numbers are produced and verified |
@@ -487,12 +515,20 @@ Neural Network: processed signals → 17 body keypoints + vital signs + room mod
 Output: real-time pose, breathing, heart rate, room fingerprint, drift alerts
 ```

-No training cameras required — the [Self-Learning system (ADR-024)](docs/adr/ADR-024-contrastive-csi-embedding-model.md) bootstraps from raw WiFi data alone. [MERIDIAN (ADR-027)](docs/adr/ADR-027-cross-environment-domain-generalization.md) ensures the model works in any room, not just the one it trained in.
+The [Self-Learning system (ADR-024)](docs/adr/ADR-024-contrastive-csi-embedding-model.md) provides
+camera-free representation-learning components. Cross-room pose remains a separate, data-gated
+problem: [MERIDIAN (ADR-027)](docs/adr/ADR-027-cross-environment-domain-generalization.md) is
+**Proposed**, while the measured calibration reference requires labeled CSI/keypoint pairs and
+model-specific adapters. See the [model compatibility boundary](docs/user-guide.md#model-and-capture-compatibility).

 ---

 ## 🏢 Use Cases & Applications

+> **Safety boundary:** these are research and prototype applications, not medical devices,
+> emergency systems, or safety-certified controls. Vital-sign and pose outputs require independent
+> validation on the exact hardware, room, subjects, and failure conditions before operational use.
+
 WiFi sensing works anywhere WiFi exists. No new hardware in most cases — just software on existing access points or a $8 ESP32 add-on. Because there are no cameras, deployments avoid privacy regulations (GDPR video, HIPAA imaging) by design.

 **Scaling:** Each AP distinguishes ~3-5 people (56 subcarriers). Multi-AP multiplies linearly — a 4-AP retail mesh covers ~15-20 occupants. No hard software limit; the practical ceiling is signal physics.
@@ -527,7 +563,7 @@ WiFi sensing works anywhere WiFi exists. No new hardware in most cases — just
 | Use Case | What It Does | Hardware | Key Metric | Edge Module |
 |----------|-------------|----------|------------|-------------|
 | **Smart home automation** | Room-level presence triggers (lights, HVAC, music) that work through walls — no dead zones, no motion-sensor timeouts | 2-3 ESP32-S3 nodes ($24) | Through-wall range ~5m | [HVAC Presence](docs/edge-modules/building.md), [Lighting Zones](docs/edge-modules/building.md) |
-| **Fitness & sports** | Rep counting, posture correction, breathing cadence during exercise — no wearable, no camera in locker rooms | 3+ ESP32-S3 mesh | Pose: 17 keypoints | [Breathing Sync](docs/edge-modules/exotic.md), [Gait Analysis](docs/edge-modules/medical.md) |
+| **Fitness & sports research** | Explore motion and breathing cadence without a wearable or camera; reliable posture correction requires a validated compatible pose model | 3+ ESP32-S3 mesh + edge host | Prototype; no live S3 pose accuracy claim | [Breathing Sync](docs/edge-modules/exotic.md), [Gait Analysis](docs/edge-modules/medical.md) |
 | **Childcare & schools** | Naptime breathing monitoring, playground headcount, restricted-area alerts — privacy-safe for minors | 2-4 ESP32-S3 per zone | Breathing: ±1 BPM | [Sleep Apnea](docs/edge-modules/medical.md), [Perimeter Breach](docs/edge-modules/security.md) |
 | **Event venues & concerts** | Crowd density mapping, crush-risk detection via breathing compression, emergency evacuation flow tracking | Multi-AP mesh (4-8 APs) | Density per m² | [Customer Flow](docs/edge-modules/retail.md), [Panic Motion](docs/edge-modules/security.md) |
 | **Stadiums & arenas** | Section-level occupancy for dynamic pricing, concession staffing, emergency egress flow modeling | Enterprise AP grid | 15-20 per AP mesh | [Dwell Heatmap](docs/edge-modules/retail.md), [Queue Length](docs/edge-modules/retail.md) |
@@ -694,7 +730,13 @@ claude --plugin-dir ./plugins/ruview

 Verify the plugin structure: `bash plugins/ruview/scripts/smoke.sh`. Full details: [`plugins/ruview/README.md`](plugins/ruview/README.md).

-For the portable RuView MetaHarness, use `npx @ruvnet/ruview@0.3.1`; the quick commands and fuller explanation are in the collapsed MetaHarness section near the top of this README and in [`harness/ruview/`](harness/ruview/README.md).
+**Live sensing pane (Claude Code mod):** the same marketplace also lists `ruview-live`, a Claude Code mod.
+- Install it with `/plugin install ruview-live@ruview`, or run `npx @ruvnet/ruview@0.9.1 mod` for its path inside the npm package.
+- `/ruview` opens a pane beside the transcript with your CSI nodes and radar, refreshed on a timer, plus a one-line status.
+- It is read-only.
+- Mods are early access; if `/ruview` is missing, start Claude Code with `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1`. See [ADR-377](docs/adr/ADR-377-ruview-live-claude-code-mod.md).
+
+For the portable RuView MetaHarness, use `npx @ruvnet/ruview@0.9.1`. The quick commands and a fuller explanation are in the collapsed MetaHarness section near the top of this README, in [`harness/ruview/`](harness/ruview/README.md), and in the [user guide](docs/user-guide.md#ruview-npm-toolkit-ruvnetruview).

 </details>

@@ -719,6 +761,8 @@ Start with the user, build, and calibration guides; expand for the full referenc
 | [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 |
 | [Portable harness — `npx @ruvnet/ruview`](harness/ruview/README.md) | MetaHarness-minted, host-portable RuView operator harness — `ruview.*` MCP tools + the MEASURED-vs-CLAIMED honesty guardrail enforced in code ([ADR-182](docs/adr/ADR-182-npx-ruview-harness-via-metaharness.md)). A lighter, multi-host companion to the in-repo plugin. |
+| [CSI Frame Selection — Measured](docs/csi-frame-selection-measured.md) | Which rate gate actually buys cross-node pairing, measured on a nine-node ESP32-C6 fleet as a 2x2 factorial in three Latin-square blocks. Selecting frames by 802.11 `rx_seq` roughly doubled pairing (+31.7 pp) while mesh-time alignment bought +0.5 pp, inside noise. Includes the trade it makes, a prediction that turned out wrong, the limits of the measurement, and `run_arms.py` so the comparison can be re-run rather than taken on trust. |
+| [ESP32-C6 Firmware Runbook](firmware/esp32-csi-node/RUNBOOK.md) | What to run, in what order, and what to check: the three-file build that keeps OTA rollback compiled in, a five-key pre-flash gate, which flash regions OTA can and cannot reach, a single-board diagnostic flash with a revert path, and the tunables whose right value depends on your house rather than on the chip. |
 | [Architecture Decisions](docs/adr/README.md) | 205 ADRs — why each technical choice was made, organized by domain (hardware, signal processing, ML, platform, infrastructure) |
 | [Domain Models](docs/ddd/README.md) | 8 DDD models (RuvSense, Signal Processing, Training Pipeline, Hardware Platform, Sensing Server, WiFi-Mat, CHCI, rvCSI) — bounded contexts, aggregates, domain events, and ubiquitous language |
 | [rvCSI — edge RF sensing runtime](https://github.com/ruvnet/rvcsi) | Rust-first / TypeScript-accessible / hardware-abstracted CSI runtime: multi-source ingestion (incl. real nexmon_csi `.pcap` from a **Raspberry Pi 5** / Pi 4 / Pi 3B+ — CYW43455 / BCM43455c0) → validation → DSP → typed events → RuVector RF memory ([ADR-095](docs/adr/ADR-095-rvcsi-edge-rf-sensing-platform.md), [ADR-096](docs/adr/ADR-096-rvcsi-ffi-crate-layout.md), [domain model](docs/ddd/rvcsi-domain-model.md)). Now its own repo — [`ruvnet/rvcsi`](https://github.com/ruvnet/rvcsi) — vendored here under `vendor/rvcsi`; 9 `rvcsi-*` crates on crates.io, `@ruv/rvcsi` on npm, plus a Claude Code plugin. |
@@ -1,8 +1,14 @@
 # RuView Calibration Service (reference implementation)

-Turn a **shared WiFi-CSI pose base model** into a room-specific one with a **30-second labeled
-calibration** and a **~11 KB per-room LoRA adapter**. This is the deployable resolution of the
-cross-subject / cross-environment generalization problem (full study: [ADR-150 §3.3–3.6](../../docs/adr/ADR-150-rf-foundation-encoder.md)).
+Fit a room-specific **~11 KB LoRA adapter** for a shared WiFi-CSI pose base from a short **labeled
+capture**. This is a measured MM-Fi reference path for cross-subject / cross-environment adaptation
+(full study: [ADR-150 §3.3–3.6](../../docs/adr/ADR-150-rf-foundation-encoder.md)); it is not proof of
+plug-and-play adaptation from a live ESP32 stream.
+
+> **Not the proposed MERIDIAN fast path.** Both producers below require paired CSI and keypoint
+> labels, and their tensor shapes and adapter files are model-specific. ADR-027's automatic,
+> unlabeled 10-second MERIDIAN calibration remains **Proposed** and is not implemented as an
+> end-to-end deployment command.

 ## Why

@@ -66,8 +72,8 @@ Adapters are **model-specific**. There are two calibration producers here:
 | `cog_calibrate.py` | cog **conv+MLP** (`pose_v1.safetensors`, 56×20) | `[N,56,20]` | `.safetensors` (`fc1.a`/`fc1.b`/`fc2.a`/`fc2.b`) | Rust `cog-pose-estimation run --adapter` |

 ```bash
-# Produce a cog-format per-room adapter for the deployed Rust pose engine:
-python cog_calibrate.py --base pose_v1.safetensors --data calib.npz --out room.safetensors
+# Produce a cog-format per-room adapter from X:[N,56,20], Y:[N,17,2]:
+python cog_calibrate.py --base pose_v1.safetensors --data cog-calib.npz --out room.safetensors
 # then in the cog runtime:
 cog-pose-estimation run --config <cfg> --adapter room.safetensors
 ```
@@ -10,6 +10,39 @@ func main() {
        exit(1)
    }

+    // One connected-link RSSI sample for the Rust adapter. Keep the legacy
+    // no-argument 10 Hz stream below unchanged for Python callers.
+    if CommandLine.arguments.contains("--scan-once") {
+        guard interface.powerOn(),
+              let channel = interface.wlanChannel(),
+              interface.rssiValue() < 0 else {
+            fputs("WiFi is not connected\n", stderr)
+            exit(1)
+        }
+        let sample: [String: Any] = [
+            // Always the connected link. macOS redacts ssid/bssid without
+            // Location Services; rssi/noise/channel stay real, so mark the
+            // sample as the connected link for the Rust adapter.
+            "connected": true,
+            "ssid": interface.ssid() ?? "",
+            "bssid": interface.bssid() ?? "00:00:00:00:00:00",
+            "channel": channel.channelNumber,
+            "rssi": interface.rssiValue(),
+            "noise": interface.noiseMeasurement(),
+            "timestamp": Date().timeIntervalSince1970,
+            "tx_rate": interface.transmitRate()
+        ]
+        do {
+            let data = try JSONSerialization.data(withJSONObject: sample, options: [.sortedKeys])
+            FileHandle.standardOutput.write(data)
+            FileHandle.standardOutput.write(Data([0x0a]))
+        } catch {
+            fputs("Could not encode WiFi sample: \(error)\n", stderr)
+            exit(1)
+        }
+        return
+    }
+
    // Flush stdout automatically to prevent buffering issues with Python subprocess
    setbuf(stdout, nil)

@@ -0,0 +1,7 @@
+{
+  "endpoint": "fal-ai/flux-lora",
+  "lora_url": "https://v3b.fal.media/files/b/0aa8c60d/OjaBs6Gi8pMhZqMo79iym_pytorch_lora_weights.safetensors",
+  "prompt": "ruviewstyle room visualization, a living room with a glowing cyan pose skeleton overlay, wifi signal arcs radiating across the space, a vitals readout panel, dark tech aesthetic, synthetic sensor visualization",
+  "scale": 1.0,
+  "source_image_url": "https://v3b.fal.media/files/b/0aa8cf67/JH1qyC3GCKQ9ojkrAUXe9.png"
+}
@@ -0,0 +1,87 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="640" height="360" viewBox="0 0 960 540" role="img" aria-labelledby="title desc">
+<title id="title">RuView · WiFi becomes spatial awareness.</title><desc id="desc">RuView-focused animation showing WiFi sensors, spatial perception, Ruflo coordination and an illustrative ruOS sensing workspace. Room occupancy and actions are synthetic examples, not live measurements.</desc>
+<defs><radialGradient id="bg"><stop stop-color="#151518" /><stop offset="1" stop-color="#07080b" /></radialGradient><radialGradient id="aura"><stop stop-color="#edc65a" stop-opacity=".23" /><stop offset=".4" stop-color="#ba8823" stop-opacity=".07" /><stop offset="1" stop-color="#ba8823" stop-opacity="0" /></radialGradient><linearGradient id="gold" x1="0" y1="0" x2="1" y2="1"><stop stop-color="#fff4b1" /><stop offset=".5" stop-color="#ebc456" /><stop offset="1" stop-color="#96702f" /></linearGradient><linearGradient id="panel" x2="0" y2="1"><stop stop-color="#191a20" /><stop offset="1" stop-color="#0d0e13" /></linearGradient><pattern id="grid" width="36" height="36" patternUnits="userSpaceOnUse"><circle cx="18" cy="18" r=".65" fill="#d4c78e" opacity=".22" /></pattern><filter id="bloom" x="-100%" y="-100%" width="300%" height="300%"><feGaussianBlur stdDeviation="4" /></filter><clipPath id="frame"><rect width="960" height="540" rx="18" /></clipPath><clipPath id="line1"><rect x="64" y="155" width="850" height="93" /></clipPath><clipPath id="line2"><rect x="64" y="244" width="850" height="100" /></clipPath><g id="crown" fill="url(#gold)"><path d="M0 5l8 7L15 0l7 12 8-7-4 23H4z" /><rect x="4" y="31" width="22" height="3" rx="1" /></g>
+<style>
+text{font-family:Arial,Helvetica,sans-serif;fill:#f4f2ed}.mono{font-family:monospace}.muted{fill:#888993}.gold{fill:#e8c565}.scene{opacity:0}.end{opacity:1}.wire{fill:none;stroke:#c2a155;stroke-width:1}.all{animation-duration:18s;animation-iteration-count:infinite;animation-timing-function:cubic-bezier(.22,.65,.3,1)}
+@keyframes intro{0%,17%{opacity:1;transform:translateY(0)}22%,94%{opacity:0;transform:translateY(-12px)}100%{opacity:1;transform:translateY(0)}}
+@keyframes network{0%,20%{opacity:0;transform:translateY(18px) scale(.98)}25%,44%{opacity:1;transform:translateY(0) scale(1)}49%,100%{opacity:0;transform:translateY(-15px) scale(1.02)}}
+@keyframes work{0%,46%{opacity:0;transform:translateY(18px)}51%,66%{opacity:1;transform:translateY(0)}71%,100%{opacity:0;transform:translateY(-14px)}}
+@keyframes finale{0%,69%{opacity:0}74%,92%{opacity:1}97%,100%{opacity:0}}
+.intro{animation-name:intro}.network{animation-name:network;transform-origin:480px 270px}.work{animation-name:work}.end{animation-name:finale}
+@keyframes reveal1{0%,69%{transform:translateY(100px)}77%,100%{transform:translateY(0)}}@keyframes reveal2{0%,73%{transform:translateY(110px)}81%,100%{transform:translateY(0)}}.headline1{animation-name:reveal1}.headline2{animation-name:reveal2}
+@keyframes breathe{50%{opacity:.6;transform:scale(1.12)}}.breathe{animation:breathe 4.5s ease-in-out infinite;transform-origin:480px 239px}
+@keyframes spin{to{transform:rotate(360deg)}}.orbit{animation:spin 18s linear infinite;transform-origin:480px 239px}
+@keyframes send{0%,9%{transform:translate(0,0)}14%,100%{transform:translate(-14px,-19px)}}.cursor{animation-name:send}
+@keyframes type{0%,2%{clip-path:inset(0 100% 0 0)}12%,100%{clip-path:inset(0 0 0 0)}}.typing{animation-name:type;animation-timing-function:steps(26,end)}
+@keyframes task{0%,49%{transform:translateY(25px);opacity:0}55%,100%{transform:translateY(0);opacity:1}}.task{animation-name:task}.task2{animation-delay:.3s}.task3{animation-delay:.6s}
+@keyframes grow{0%,54%{transform:scaleX(0)}63%,100%{transform:scaleX(1)}}.grow{animation-name:grow;transform-box:fill-box;transform-origin:left}
+@keyframes tick{0%,62%{opacity:0}65%,100%{opacity:1}}.tick{animation-name:tick}
+@keyframes trace{0%,22%{stroke-dashoffset:1}38%,100%{stroke-dashoffset:0}}.trace{stroke-dasharray:1;animation-name:trace}
+@keyframes drift{50%{transform:translateY(-10px);opacity:.8}}.dust{animation:drift 9s ease-in-out infinite}
+@media(prefers-reduced-motion:reduce){*{animation:none!important}.scene{opacity:0}.end{opacity:1}.moving{display:none}}
+
+@keyframes signal{0%,13%{transform:translate(480px,205px)}20%{transform:translate(708px,301px)}26%,43%{transform:translate(480px,239px)}49%{transform:translate(215px,155px)}55%{transform:translate(479px,155px)}61%{transform:translate(743px,155px)}72%,93%{transform:translate(782px,307px)}100%{transform:translate(480px,205px)}}
+.signal{animation-name:signal}.signal-glow{animation:shimmer 3s ease-in-out infinite}@keyframes shimmer{50%{opacity:.45}}
+@keyframes haloExpand{0%,12%{opacity:0;transform:scale(.5)}16%{opacity:.7}23%,100%{opacity:0;transform:scale(2.5)}}.clickring{animation-name:haloExpand;transform-origin:708px 301px}
+@keyframes aurora{0%,100%{transform:translate(-30px,10px) rotate(-4deg)}50%{transform:translate(30px,-10px) rotate(4deg)}}.aurora{animation:aurora 18s ease-in-out infinite;transform-origin:480px 270px}
+@keyframes dash{to{stroke-dashoffset:-80}}.stream{stroke-dasharray:2 18;animation:dash 3s linear infinite}
+@keyframes count{0%,52%{opacity:0;transform:translateY(8px)}58%,100%{opacity:1;transform:translateY(0)}}.detail{animation-name:count}
+@keyframes buildLine{0%,51%{stroke-dashoffset:1}64%,100%{stroke-dashoffset:0}}.buildLine{stroke-dasharray:1;animation-name:buildLine}
+@keyframes underline{0%,78%{transform:scaleX(0)}85%,100%{transform:scaleX(1)}}.underline{animation-name:underline;transform-origin:66px 350px}
+@keyframes dock{0%,49%{opacity:0;transform:translateY(14px)}55%,100%{opacity:1;transform:translateY(0)}}.dock{animation-name:dock}
+@media(prefers-reduced-motion:reduce){.signal,.clickring{display:none}}
+
+@keyframes vortexCW{to{transform:rotate(360deg)}}@keyframes vortexCCW{to{transform:rotate(-360deg)}}
+.vortex{transform-origin:480px 270px;animation:vortexCW 36s linear infinite}.counter{transform-origin:480px 270px;animation:vortexCCW 54s linear infinite}
+@keyframes current{to{stroke-dashoffset:-1200}}.current{animation:current 9s linear infinite}
+@keyframes bgEnergy{0%,12%,100%{opacity:.22}22%,40%{opacity:.6}52%,65%{opacity:.4}74%,84%{opacity:.7}94%{opacity:.28}}.bgEnergy{animation:bgEnergy 18s ease-in-out infinite}
+@keyframes wave{0%{opacity:0;transform:scale(.3)}20%{opacity:.35}80%{opacity:.07}100%{opacity:0;transform:scale(1.9)}}.wave{transform-origin:480px 270px;animation:wave 9s cubic-bezier(.15,.35,.5,1) infinite}
+@keyframes glimmer{0%,100%{opacity:.08}50%{opacity:.72}}.glimmer{animation:glimmer 6s ease-in-out infinite}
+@keyframes comet{0%{opacity:0;transform:translate(-160px,70px)}12%{opacity:.65}58%{opacity:.25}75%,100%{opacity:0;transform:translate(1060px,-300px)}}.comet{animation:comet 9s linear infinite}
+@keyframes beam{0%,100%{transform:translate(-150px,0) rotate(-12deg);opacity:0}35%{opacity:.18}65%{opacity:.07;transform:translate(1050px,0) rotate(-12deg)}80%{opacity:0}}.beam{animation:beam 18s ease-in-out infinite;transform-origin:center}
+@media(prefers-reduced-motion:reduce){.dynamic-bg{display:none}}
+
+.all{animation-duration:24s}
+@keyframes work{0%,46%{opacity:0;transform:translateY(18px)}50%,72%{opacity:1;transform:translateY(0)}76%,100%{opacity:0;transform:translateY(-14px)}}
+@keyframes finale{0%,75%{opacity:0}79%,93%{opacity:1}97%,100%{opacity:0}}
+@keyframes reveal1{0%,75%{transform:translateY(100px)}82%,100%{transform:translateY(0)}}
+@keyframes reveal2{0%,78%{transform:translateY(110px)}85%,100%{transform:translateY(0)}}
+@keyframes signal{0%,13%{transform:translate(480px,205px)}20%{transform:translate(708px,301px)}26%,43%{transform:translate(480px,239px)}49%{transform:translate(803px,182px)}55%{transform:translate(803px,235px)}63%,72%{transform:translate(803px,288px)}80%,93%{transform:translate(782px,307px)}100%{transform:translate(480px,205px)}}
+@keyframes browserOpen{0%,48%{opacity:0;transform:translateY(20px) scale(.96)}53%,100%{opacity:1;transform:translateY(0) scale(1)}}.browserOpen{animation-name:browserOpen;transform-origin:380px 230px}
+@keyframes terminalOpen{0%,53%{opacity:0;transform:translateY(14px)}58%,100%{opacity:1;transform:translateY(0)}}.terminalOpen{animation-name:terminalOpen}
+@keyframes terminalText{0%,57%{opacity:0}60%,100%{opacity:1}}.terminalText{animation-name:terminalText}
+@keyframes done{0%,65%{opacity:0}69%,100%{opacity:1}}.done{animation-name:done}
+@keyframes pointerMove{0%,50%{transform:translate(350px,275px)}55%{transform:translate(529px,267px)}59%{transform:translate(570px,325px)}66%,100%{transform:translate(738px,346px)}}.desktopPointer{animation-name:pointerMove}
+@keyframes chartGrow{0%,53%{transform:scaleY(.05)}63%,100%{transform:scaleY(1)}}.chartGrow{animation-name:chartGrow;transform-box:fill-box;transform-origin:bottom}
+</style><radialGradient id="readability"><stop stop-color="#08090e" stop-opacity=".58" /><stop offset=".65" stop-color="#08090e" stop-opacity=".38" /><stop offset="1" stop-color="#08090e" stop-opacity="0" /></radialGradient><linearGradient id="beamGold"><stop stop-color="#e7bf56" stop-opacity="0" /><stop offset=".5" stop-color="#efd57f" stop-opacity=".45" /><stop offset="1" stop-color="#e7bf56" stop-opacity="0" /></linearGradient></defs><g clip-path="url(#frame)"><rect width="960" height="540" fill="url(#bg)" /><rect width="960" height="540" fill="url(#grid)" opacity=".35" /><ellipse cx="490" cy="250" rx="460" ry="320" fill="url(#aura)" />
+<g><g class="aurora" fill="none" stroke="#c6a457" opacity=".11"><ellipse cx="480" cy="260" rx="470" ry="156" transform="rotate(-18 480 260)" /><ellipse cx="480" cy="260" rx="480" ry="166" transform="rotate(-18 480 260)" /><ellipse cx="480" cy="260" rx="495" ry="180" transform="rotate(-18 480 260)" /></g></g><g><g class="dynamic-bg"><g class="bgEnergy"><rect class="beam" x="0" y="-120" width="160" height="850" fill="url(#beamGold)" /><ellipse cx="480" cy="270" rx="280" ry="150" fill="none" stroke="#dcb55e" stroke-width=".9" class="wave" style="animation-delay:-0s" /><ellipse cx="480" cy="270" rx="280" ry="150" fill="none" stroke="#dcb55e" stroke-width=".9" class="wave" style="animation-delay:-3s" /><ellipse cx="480" cy="270" rx="280" ry="150" fill="none" stroke="#dcb55e" stroke-width=".9" class="wave" style="animation-delay:-6s" /><g class="vortex" fill="none"><ellipse cx="480" cy="270" rx="355" ry="160" transform="rotate(0 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="355" ry="160" transform="rotate(0 480 270)" stroke="#f7d884" stroke-width="2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-0.0s" opacity=".65" /><ellipse cx="480" cy="270" rx="392" ry="184" transform="rotate(19 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="392" ry="184" transform="rotate(19 480 270)" stroke="#f7d884" stroke-width="1.2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-1.5s" opacity=".65" /><ellipse cx="480" cy="270" rx="429" ry="208" transform="rotate(38 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="429" ry="208" transform="rotate(38 480 270)" stroke="#f7d884" stroke-width="2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-3.0s" opacity=".65" /><ellipse cx="480" cy="270" rx="466" ry="232" transform="rotate(57 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="466" ry="232" transform="rotate(57 480 270)" stroke="#f7d884" stroke-width="1.2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-4.5s" opacity=".65" /><ellipse cx="480" cy="270" rx="503" ry="256" transform="rotate(76 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="503" ry="256" transform="rotate(76 480 270)" stroke="#f7d884" stroke-width="2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-6.0s" opacity=".65" /><ellipse cx="480" cy="270" rx="540" ry="280" transform="rotate(95 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="540" ry="280" transform="rotate(95 480 270)" stroke="#f7d884" stroke-width="1.2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-7.5s" opacity=".65" /></g><g class="counter" fill="none"><ellipse cx="480" cy="270" rx="355" ry="160" transform="rotate(0 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="355" ry="160" transform="rotate(0 480 270)" stroke="#f7d884" stroke-width="2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-0.0s" opacity=".65" /><ellipse cx="480" cy="270" rx="392" ry="184" transform="rotate(-19 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="392" ry="184" transform="rotate(-19 480 270)" stroke="#f7d884" stroke-width="1.2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-1.5s" opacity=".65" /><ellipse cx="480" cy="270" rx="429" ry="208" transform="rotate(-38 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="429" ry="208" transform="rotate(-38 480 270)" stroke="#f7d884" stroke-width="2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-3.0s" opacity=".65" /><ellipse cx="480" cy="270" rx="466" ry="232" transform="rotate(-57 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="466" ry="232" transform="rotate(-57 480 270)" stroke="#f7d884" stroke-width="1.2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-4.5s" opacity=".65" /><ellipse cx="480" cy="270" rx="503" ry="256" transform="rotate(-76 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="503" ry="256" transform="rotate(-76 480 270)" stroke="#f7d884" stroke-width="2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-6.0s" opacity=".65" /><ellipse cx="480" cy="270" rx="540" ry="280" transform="rotate(-95 480 270)" stroke="#b89342" stroke-width=".6" opacity=".3" /><ellipse cx="480" cy="270" rx="540" ry="280" transform="rotate(-95 480 270)" stroke="#f7d884" stroke-width="1.2" stroke-dasharray="18 6 4 420 65 800" class="current" style="animation-delay:-7.5s" opacity=".65" /></g><circle cx="10.1" cy="303.9" r="1.3" fill="#ffe4a0Line truncated
+<g class="scene intro all"><circle cx="480" cy="205" r="125" fill="url(#aura)" /><circle cx="480" cy="205" r="28" stroke="#f3d576" stroke-width="1" fill="none" /><text x="480" y="126" text-anchor="middle" font-size="32" letter-spacing="-1">Your room is already sending signals.</text>
+<rect x="215" y="269" width="530" height="64" rx="12" fill="url(#panel)" stroke="#554b31" /><text x="239" y="307" font-size="17" class="mono typing all">Sense. Understand. Act.</text><rect x="689" y="282" width="38" height="38" rx="9" fill="url(#gold)" /><path d="M708 307v-13m-5 5 5-5 5 5" fill="none" stroke="#222018" stroke-width="2" stroke-linecap="round" />
+<path class="cursor all" d="M731 323l0 27 7-8 8 1z" fill="#faf8e7" stroke="#151515" stroke-width="1.4" />
+<text x="480" y="382" text-anchor="middle" font-size="11" letter-spacing="3" class="mono muted">WIFI SENSING. NO CAMERAS.</text><g><circle class="clickring all" cx="708" cy="301" r="25" fill="none" stroke="#fae29b" /></g><g><g fill="none" stroke="#e7c467" opacity=".65"><path d="M437 214Q480 161 523 214" /><path d="M420 205Q480 133 540 205" opacity=".4" /><path d="M404 196Q480 108 556 196" opacity=".2" /></g></g></g>
+<g class="scene network all"><text x="480" y="107" text-anchor="middle" font-size="30" letter-spacing="-.7">From radio signals to useful actions.</text>
+<g><path d="M480 239C548 323 639 357 735 350" class="stream" fill="none" stroke="#f1d98f" stroke-width="1.5" opacity=".45" /></g><g><path d="M480 239C420 328 311 358 225 350" class="stream" fill="none" stroke="#f1d98f" stroke-width="1.5" opacity=".45" /></g><g><path d="M480 239C520 143 640 148 714 193" class="stream" fill="none" stroke="#f1d98f" stroke-width="1.5" opacity=".45" /></g><g><path d="M480 239C440 148 322 143 247 193" class="stream" fill="none" stroke="#f1d98f" stroke-width="1.5" opacity=".45" /></g><path d="M480 239C440 148 322 143 247 193" class="wire" opacity=".2" /><path d="M480 239C440 148 322 143 247 193" class="wire trace all" pathLength="1" /><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C440 148 322 143 247 193" dur="2.4s" begin="-0.0s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C440 148 322 143 247 193" dur="2.4s" begin="-0.0s" repeatCount="indefinite" /></circle></g><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C440 148 322 143 247 193" dur="2.4s" begin="-1.2s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C440 148 322 143 247 193" dur="2.4s" begin="-1.2s" repeatCount="indefinite" /></circle></g><path d="M480 239C520 143 640 148 714 193" class="wire" opacity=".2" /><path d="M480 239C520 143 640 148 714 193" class="wire trace all" pathLength="1" /><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C520 143 640 148 714 193" dur="2.4s" begin="-0.2s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C520 143 640 148 714 193" dur="2.4s" begin="-0.2s" repeatCount="indefinite" /></circle></g><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C520 143 640 148 714 193" dur="2.4s" begin="-1.4s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C520 143 640 148 714 193" dur="2.4s" begin="-1.4s" repeatCount="indefinite" /></circle></g><path d="M480 239C420 328 311 358 225 350" class="wire" opacity=".2" /><path d="M480 239C420 328 311 358 225 350" class="wire trace all" pathLength="1" /><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C420 328 311 358 225 350" dur="2.4s" begin="-0.4s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C420 328 311 358 225 350" dur="2.4s" begin="-0.4s" repeatCount="indefinite" /></circle></g><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C420 328 311 358 225 350" dur="2.4s" begin="-1.6s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C420 328 311 358 225 350" dur="2.4s" begin="-1.6s" repeatCount="indefinite" /></circle></g><path d="M480 239C548 323 639 357 735 350" class="wire" opacity=".2" /><path d="M480 239C548 323 639 357 735 350" class="wire trace all" pathLength="1" /><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C548 323 639 357 735 350" dur="2.4s" begin="-0.6000000000000001s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C548 323 639 357 735 350" dur="2.4s" begin="-0.6000000000000001s" repeatCount="indefinite" /></circle></g><g class="moving"><circle r="7" fill="#f6cf63" opacity=".5" filter="url(#bloom)"><animateMotion path="M480 239C548 323 639 357 735 350" dur="2.4s" begin="-1.8s" repeatCount="indefinite" /></circle><circle r="2.6" fill="#ffeaa1"><animateMotion path="M480 239C548 323 639 357 735 350" dur="2.4s" begin="-1.8s" repeatCount="indefinite" /></circle></g><circle cx="480" cy="239" r="98" fill="url(#aura)" class="breathe" /><circle cx="480" cy="239" r="57" fill="#111115" stroke="#6c5830" /><circle cx="480" cy="239" r="66" fill="none" stroke="#eac55e" stroke-opacity=".6" stroke-dasharray="38 170" class="orbit" /><use href="#crown" transform="translate(465 221)" /><rect x="147" y="169" width="200" height="55" rx="10" fill="url(#panel)" stroke="#51462e" /><circle cx="164" cy="191" r="3" fill="#e8c667" /><text x="177" y="195" font-size="18">WiFi sensors</text><text x="177" y="212" font-size="8" class="mono muted" letter-spacing="1.8">CAPTURE</text><rect x="614" y="169" width="200" height="55" rx="10" fill="url(#panel)" stroke="#51462e" /><circle cx="631" cy="191" r="3" fill="#e8c667" /><text x="644" y="195" font-size="18">RuView</text><text x="644" y="212" font-size="8" class="mono muted" letter-spacing="1.8">PERCEIVE</text><rect x="125" y="326" width="200" height="55" rx="10" fill="url(#panel)" stroke="#51462e" /><circle cx="142" cy="348" r="3" fill="#e8c667" /><text x="155" y="352" font-sizeLine truncated
+<g class="scene work all"><g><text x="480" y="92" text-anchor="middle" font-size="28" letter-spacing="-.6">A sensing workspace, powered by RuView.</text>
+<rect x="58" y="113" width="844" height="331" rx="12" fill="#090c12" stroke="#6a5931" />
+<path d="M70 144H890" stroke="#292b31" /><circle cx="76" cy="129" r="3" fill="#dcbf65" /><circle cx="87" cy="129" r="3" fill="#5b5c64" /><circle cx="98" cy="129" r="3" fill="#5b5c64" /><text x="480" y="133" text-anchor="middle" class="mono muted" font-size="9">ruOS / Desktops / ruview-workspace</text>
+<rect x="59" y="145" width="125" height="287" fill="#0c0e13" />
+<use href="#crown" transform="translate(72 158) scale(.4)" /><text x="91" y="170" font-size="15" font-weight="700">ruOS</text>
+<rect x="67" y="209" width="107" height="25" rx="5" fill="#302819" stroke="#63512c" />
+<rect x="76" y="194" width="7" height="6" rx="1" fill="none" stroke="#686b79" /><text x="91" y="201" font-size="10" class="muted">Overview</text><rect x="76" y="222" width="7" height="6" rx="1" fill="none" stroke="#e1c577" /><text x="91" y="229" font-size="10" class="gold">Desktops</text><rect x="76" y="250" width="7" height="6" rx="1" fill="none" stroke="#686b79" /><text x="91" y="257" font-size="10" class="muted">Terminal</text><rect x="76" y="278" width="7" height="6" rx="1" fill="none" stroke="#686b79" /><text x="91" y="285" font-size="10" class="muted">Swarms</text><rect x="76" y="306" width="7" height="6" rx="1" fill="none" stroke="#686b79" /><text x="91" y="313" font-size="10" class="muted">Network</text><rect x="76" y="334" width="7" height="6" rx="1" fill="none" stroke="#686b79" /><text x="91" y="341" font-size="10" class="muted">Usage</text><rect x="76" y="362" width="7" height="6" rx="1" fill="none" stroke="#686b79" /><text x="91" y="369" font-size="10" class="muted">Settings</text><text x="200" y="169" font-size="14" font-weight="700">RuView workspace</text><circle cx="364" cy="165" r="3" fill="#b9cb91" /><text x="374" y="169" font-size="9" class="muted">Running</text>
+<text x="882" y="167" text-anchor="end" font-size="8" class="mono gold">SYNTHETIC DEMO</text>
+<rect x="197" y="183" width="469" height="244" rx="7" fill="#14131a" stroke="#32313d" /><path d="M197 373Q370 180 666 285M197 330Q440 390 666 210" fill="none" stroke="#b49548" opacity=".18" />
+<g class="browserOpen all"><rect x="209" y="195" width="308" height="163" rx="7" fill="#191d26" stroke="#5a5961" />
+<rect x="209" y="195" width="308" height="24" rx="7" fill="#262a33" /><text x="221" y="211" font-size="8" class="mono muted">RuView / Room overview</text><circle cx="503" cy="207" r="2" fill="#e3c477" />
+<text x="225" y="241" font-size="13" font-weight="700">Room activity</text><text x="225" y="257" font-size="9" class="muted">Synthetic scene · Presence and motion</text>
+<rect x="224" y="329" width="83" height="16" rx="4" fill="#4a3d22" /><text x="233" y="340" font-size="8" class="gold">Sensor connected</text><g><path d="M229 270H494V318H229zM390 270v18m0 12v18" fill="#121921" stroke="#727781" stroke-width="1.5" /><path d="M235 278h34v15h-34zM464 280h22v24h-22z" fill="#303843" stroke="#707786" /><circle cx="285" cy="300" r="4" fill="#f0cd70" /><circle cx="285" cy="300" r="16" fill="none" stroke="#d8b353" opacity=".4" /><circle cx="326" cy="287" r="5" fill="#b7cbd0" /><path d="M326 293v12m-7-8h14m-7 8-5 8m5-8 5 8" fill="none" stroke="#b7cbd0" stroke-width="2" /><path d="M292 290Q310 273 326 287M294 306Q312 312 326 302" fill="none" stroke="#e1bd5f" stroke-dasharray="3 5" class="stream" /></g></g>
+<g class="terminalOpen all"><rect x="366" y="287" width="284" height="117" rx="6" fill="#090c12" stroke="#777061" /><rect x="367" y="288" width="282" height="21" rx="5" fill="#25272f" /><text x="380" y="302" font-size="9" class="mono">Terminal</text>
+<text x="380" y="324" font-size="9" class="mono gold">› Room event received</text><g class="terminalText all"><text x="380" y="343" font-size="9" class="mono muted">✓ Presence detected (demo)</text><text x="380" y="358" font-size="9" class="mono muted">✓ Rule checked</text></g><text x="380" y="384" font-size="10" class="mono gold done all">✓ Action ready for review</text></g>
+<rect x="680" y="183" width="207" height="244" rx="7" fill="#12151d" stroke="#33333c" /><text x="695" y="204" font-size="12" font-weight="700">Ruflo agent team</text><path d="M694 216h178" stroke="#34323a" />
+<circle cx="699" cy="235" r="5" fill="#272317" stroke="#be9f54" /><text x="713" y="239" font-size="11">Sense</text><text x="713" y="254" font-size="8" class="muted">Read room events from RuView</text><circle cx="699" cy="288" r="5" fill="#272317" stroke="#be9f54" /><text x="713" y="292" font-size="11">Evaluate</text><text x="713" y="307" font-size="8" class="muted">Check the configured rule</text><circle cx="699" cy="341" r="5" fill="#272317" stroke="#be9f54" /><text x="713" y="345" font-size="11">Act</text><text x="713" y="360" font-size="8" class="muted">Request an approved action</text><g class="done all"><rect x="693" y="381" width="181" height="29" rx="5" fill="#332b1b" stroke="#89713b" /><text x="784" y="400" text-anchor="middle" font-size="10" class="gold">✓ Room event processed</text></g>
+<g class="desktopPointer all"><path d="M0 0v20l5-6 8 1z" fill="#fff2ce" stroke="#18181a" stroke-width="1" /></g>
+<text x="480" y="469" text-anchor="middle" class="gold" font-size="14">Example: room activity → rule check → action review.</text></g></g><g class="scene end all"><ellipse cx="810" cy="290" rx="260" ry="240" fill="url(#aura)" />
+<text x="66" y="133" class="mono gold" font-size="11" letter-spacing="3">RUVIEW PERCEPTION. RUFLO COORDINATION.</text>
+<g clip-path="url(#line1)"><text class="headline1 all" x="61" y="233" font-size="72" font-weight="700" letter-spacing="-3">WiFi becomes</text></g>
+<g clip-path="url(#line2)"><text class="headline2 all" x="61" y="322" font-size="72" font-weight="700" letter-spacing="-3">spatial awareness<tspan class="gold">.</tspan></text></g>
+<path d="M66 382H894" stroke="#3b3528" /><text x="66" y="420" class="mono gold" font-size="17">ruos.cognitum.one</text><text x="892" y="420" text-anchor="end" font-size="10" class="mono muted" letter-spacing="2">BY COGNITUM</text><g><path class="underline all" d="M66 350h310" stroke="url(#gold)" stroke-width="2" /></g></g>
+<path d="M40 490H920" stroke="#26242a" /><text x="40" y="513" class="mono muted" font-size="9" letter-spacing="1.5">RUVIEW + RUFLO + RUOS</text><circle cx="853" cy="509" r="2.5" fill="#dfbf67" /><text x="866" y="512" class="mono gold" font-size="9">READY</text><g><g class="signal all"><circle r="45" fill="url(#aura)" class="signal-glow" /><circle r="10" fill="#ebc65d" opacity=".5" filter="url(#bloom)" /><circle r="4.5" fill="#ffe5a1" /><circle r="8" fill="none" stroke="#e9c56c" opacity=".3" /></g></g></g></svg>
@@ -1,15 +0,0 @@
-{
-  "id": "pretrain-1775182186",
-  "name": "pretrain-1775182186",
-  "label": "mixed-activity",
-  "started_at": "2026-04-03T02:09:46Z",
-  "ended_at": "2026-04-03T02:11:46Z",
-  "duration_secs": 120,
-  "frame_count": 5783,
-  "file_size_bytes": 2580539,
-  "file_path": "data/recordings\\pretrain-1775182186.csi.jsonl",
-  "nodes": {
-    "2": 2886,
-    "1": 2897
-  }
-}
@@ -37,6 +37,31 @@ services:
      #   volumes: ["/path/to/models:/app/models"]
      #   MODELS_DIR=/app/models
      - MODELS_DIR=${MODELS_DIR:-data/models}
+      # Auth (issue #864). The entrypoint refuses to start (exit 64) unless
+      # RUVIEW_API_TOKEN is set. Export it before `docker compose up`:
+      #   export RUVIEW_API_TOKEN=$(openssl rand -hex 32)
+      # Bare names pass the host value through only when it is set.
+      - RUVIEW_API_TOKEN
+      # ESP32 UDP ingest (ADR-296, issue #2089). The UDP receiver defaults to
+      # 127.0.0.1, which cannot receive from the published 5005/udp port.
+      # Set ONE source guard and the entrypoint binds 0.0.0.0:
+      #   RUVIEW_UDP_ALLOW=<node-ip-or-cidr>  restrict sources (preferred)
+      #   RUVIEW_UDP_INSECURE_LAN=true        accept the spoofing risk
+      # Docker Desktop and OrbStack on macOS rewrite the source address to the
+      # bridge gateway, so a LAN-subnet allowlist drops every frame. There,
+      # allow the gateway instead:
+      #   docker network inspect <project>_default \
+      #     --format '{{(index .IPAM.Config 0).Gateway}}'
+      #   RUVIEW_UDP_ALLOW=<gateway>/32
+      # The gateway admits anything that reaches the published port, so keep
+      # 5005/udp off untrusted networks.
+      - RUVIEW_UDP_ALLOW
+      - RUVIEW_UDP_INSECURE_LAN
+      - RUVIEW_UDP_BIND
+      # Browsing the UI from another machine also needs the host name or IP
+      # in SENSING_ALLOWED_HOSTS (otherwise 421), and the TCP ports above
+      # published beyond 127.0.0.1.
+      - SENSING_ALLOWED_HOSTS
    security_opt:
      - no-new-privileges:true
    cap_drop:
@@ -22,6 +22,10 @@
 #                  Default is `auto`. Set CSI_SOURCE=simulated when you want
 #                  fake data tagged as such; never set it implicitly.
 #   MODELS_DIR   — directory to scan for .rvf model files (default: data/models)
+#   RUVIEW_UDP_ALLOW / RUVIEW_UDP_INSECURE_LAN — ADR-296 UDP source guard.
+#                  Setting either makes the entrypoint bind UDP on 0.0.0.0 so
+#                  ESP32 frames on the published 5005/udp port can arrive.
+#   RUVIEW_UDP_BIND — explicit UDP bind; overrides the choice above.
 set -e

 # ── Issue #864: fail-closed on default posture ───────────────────────────────
@@ -34,8 +38,8 @@ set -e
 #
 # Escape hatches (operator must opt in explicitly):
 #   * Set RUVIEW_API_TOKEN to a strong secret → auth enabled on /api/v1/*.
-#   * Set RUVIEW_ALLOW_UNAUTHENTICATED=1 → preserves the pre-fix behaviour;
-#     only safe on an isolated trust boundary.
+#   * Set RUVIEW_ALLOW_UNAUTHENTICATED=1 (or true/yes/on, any case) →
+#     preserves the pre-fix behaviour; only safe on an isolated trust boundary.
 #   * Set RUVIEW_BIND_ADDR to a loopback / private interface → unauth is fine
 #     when the socket isn't reachable. The auto-bind nudges toward 127.0.0.1.
 #
@@ -45,7 +49,12 @@ set -e
 case "${1:-}" in
    cog-ha-matter|ha-matter|homecore|homecore-server) ;;
    *)
-        if [ -z "${RUVIEW_API_TOKEN:-}" ] && [ "${RUVIEW_ALLOW_UNAUTHENTICATED:-}" != "1" ]; then
+        # Same spellings the sensing-server accepts for its boolean env flags.
+        case "${RUVIEW_ALLOW_UNAUTHENTICATED:-}" in
+            1|[Tt][Rr][Uu][Ee]|[Yy][Ee][Ss]|[Oo][Nn]) __allow_unauth=1 ;;
+            *) __allow_unauth=0 ;;
+        esac
+        if [ -z "${RUVIEW_API_TOKEN:-}" ] && [ "$__allow_unauth" != "1" ]; then
            # If the operator hasn't overridden the bind, refuse outright on
            # the default 0.0.0.0. If they've nailed it to loopback (or a
            # specific private address they trust), let it run.
@@ -97,6 +106,50 @@ esac
 # server binary so users can just pass flags:
 #   docker run <image> --source esp32 --tick-ms 500
 if [ "${1#-}" != "$1" ] || [ -z "$1" ]; then
+    # ── Issue #2089: UDP CSI ingest posture inside a container ───────────────
+    # ADR-296 defaults the UDP receiver to 127.0.0.1. Inside a container that
+    # bind can never receive from a published port, so no node ever appears.
+    # We bind 0.0.0.0 only when the operator has configured an ADR-296 guard
+    # (RUVIEW_UDP_ALLOW or RUVIEW_UDP_INSECURE_LAN); without one the server
+    # would refuse a routable bind, so we keep loopback and say why instead.
+    # An explicit RUVIEW_UDP_BIND or --udp-bind always wins.
+    # The binary parses RUVIEW_UDP_INSECURE_LAN itself (1/yes/on/true, any
+    # case); here we only need to know whether it is truthy to pick the bind.
+    __insecure_lan=0
+    case "$(printf '%s' "${RUVIEW_UDP_INSECURE_LAN:-}" | tr 'A-Z' 'a-z')" in
+        1|true|yes|on) __insecure_lan=1 ;;
+    esac
+    __udp_bind_arg=0
+    __udp_guard_arg=0
+    for __arg in "$@"; do
+        case "$__arg" in
+            --udp-bind|--udp-bind=*) __udp_bind_arg=1 ;;
+            --udp-allow|--udp-allow=*|--udp-insecure-lan) __udp_guard_arg=1 ;;
+        esac
+    done
+    if [ -z "${RUVIEW_UDP_BIND:-}" ] && [ "$__udp_bind_arg" = 0 ]; then
+        if [ -n "${RUVIEW_UDP_ALLOW:-}" ] || [ "$__insecure_lan" = 1 ] \
+            || [ "$__udp_guard_arg" = 1 ]; then
+            export RUVIEW_UDP_BIND=0.0.0.0
+            echo "[entrypoint] UDP CSI receiver: binding 0.0.0.0 inside the container" >&2
+            echo "[entrypoint]   (a source guard is set: RUVIEW_UDP_ALLOW or RUVIEW_UDP_INSECURE_LAN)." >&2
+        else
+            case "${CSI_SOURCE:-auto}" in
+                simulated|simulate) ;;
+                *)
+                    echo "[entrypoint] NOTE: UDP CSI receiver stays on 127.0.0.1 (ADR-296 default)." >&2
+                    echo "[entrypoint]   Inside a container that bind cannot receive ESP32 frames from" >&2
+                    echo "[entrypoint]   a published 5005/udp port, so no node will appear. To ingest:" >&2
+                    echo "[entrypoint]     -e RUVIEW_UDP_ALLOW=<node-ip-or-cidr>   (restrict sources), or" >&2
+                    echo "[entrypoint]     -e RUVIEW_UDP_INSECURE_LAN=true         (accept spoofing risk)" >&2
+                    echo "[entrypoint]   Docker Desktop/OrbStack on macOS rewrite the source to the bridge" >&2
+                    echo "[entrypoint]   gateway, so the allowlist must name <gateway>/32, not the LAN subnet." >&2
+                    echo "[entrypoint]   See https://github.com/ruvnet/RuView/issues/2089" >&2
+                    ;;
+            esac
+        fi
+    fi
+
    set -- /app/sensing-server \
        --source "${CSI_SOURCE:-auto}" \
        --tick-ms 100 \
@@ -4,6 +4,7 @@
 |-------|-------|
 | **Status** | Proposed |
 | **Date** | 2026-03-01 |
+| **Updated** | 2026-10-01: macOS 27 also redacts SSID without Location Services; the connected link is kept with a synthetic id, and `auto`+wifi keeps UDP bound (see Amendment 1) |
 | **Deciders** | ruv |
 | **Codename** | **ORCA** — OS-native Radio Channel Acquisition |
 | **Relates to** | ADR-013 (Feature-Level Sensing Commodity Gear), ADR-022 (Windows WiFi Enhanced Fidelity), ADR-014 (SOTA Signal Processing), ADR-018 (ESP32 Dev Implementation) |
@@ -313,3 +314,22 @@ All verification on Mac Mini (M2 Pro, macOS 26.3).
 - ADR-022: Windows WiFi Enhanced Fidelity (analogous platform adapter)
 - ADR-013: Feature-Level Sensing from Commodity Gear
 - Issue [#56](https://github.com/ruvnet/wifi-densepose/issues/56): macOS support request
+
+---
+
+## Amendment 1 (2026-10-01): SSID is also redacted; keep the connected link
+
+**Observed on macOS 27 (M-series Mac, CoreWLAN, unsigned CLI helper).** Without Location Services, `mac_wifi --scan-once` returns `"ssid":""` and `"bssid":"00:00:00:00:00:00"`, while `rssi`, `noise`, `channel` and `tx_rate` are real. The §1 assumption that "SSID + RSSI + channel" survive no longer holds. An unsigned CLI helper never calls `CLLocationManager`, so it never appears in Location Services and cannot be granted access.
+
+Before this amendment, `resolve_bssid` abstained when both identities were blank (to avoid merging unrelated networks), so every macOS scan was dropped and `--source wifi` produced nothing, with no error.
+
+**Change.**
+1. `--scan-once` marks its single sample `"connected": true`. It is always the one connected link, so it cannot collide with another network.
+2. A redacted sample marked `connected` gets a stable, locally administered synthetic BSSID derived from a reserved key plus the channel. The SSID stays empty; none is invented. Unmarked redacted lines still abstain.
+3. `--source auto` that resolves to host WiFi now also binds the UDP receiver, and `wifi_task` yields while the source is a live `esp32`. ESP32 nodes that start after the 2 s boot probe still promote the source, matching the #1004 rule for the simulator.
+4. A missing helper logs one clear error with the build command instead of a warning on every tick.
+
+**Measured (2026-10-01, this change):** `--source wifi` → source `wifi:unnamed`, sensing ticks advance. `--source auto` on a quiet port → `wifi` with `udp_receiver=true`; relaying real ADR-018 frames promoted the source to `esp32`, with all 5 nodes listed.
+
+**Still open:** real BSSID/SSID would need a signed `.app` helper with `NSLocationWhenInUseUsageDescription` that requests authorization. The helper still lives under `archive/v1` with no build step.
+
@@ -4,6 +4,7 @@
 |-------|-------|
 | **Status** | Proposed |
 | **Date** | 2026-03-02 |
+| **Updated** | 2026-10-04 — multistatic fusion combines phase across nodes only when every frame declares the same shared phase reference; independent ESP32 nodes and the amplitude-only server bridge fuse amplitude only and report the reason (`phase_fusion` in `/health/ready`, issue #1752). |
 | **Deciders** | ruv |
 | **Codename** | **RuvSense** -- RuVector-Enhanced Sensing for Multistatic Fidelity |
 | **Relates to** | ADR-012 (ESP32 Mesh), ADR-014 (SOTA Signal Processing), ADR-016 (RuVector Training), ADR-017 (RuVector Signal+MAT), ADR-018 (ESP32 Implementation), ADR-024 (AETHER Embeddings), ADR-026 (Survivor Track Lifecycle), ADR-027 (MERIDIAN Generalization) |
@@ -3,7 +3,7 @@
 | Field | Value |
 |-------|-------|
 | **Status** | **Accepted** (MQTT track P1–P7 + P8a + P9 + P10 shipped 2026-05-23 in PR #778, 410 lib tests, witness bundle VERIFIED) / **Proposed** (Matter SDK wiring P8b deferred to v0.7.1 per §9.10) |
-| **Date** | 2026-05-23 |
+| **Date** | 2026-05-23 (amended 2026-10-02: P4.5 status note, §11) |
 | **Deciders** | ruv |
 | **Codename** | **HA-DISCO** (MQTT) + **HA-FABRIC** (Matter) + **HA-MIND** (semantic primitives) |
 | **Relates to** | ADR-018 (CSI binary frame format), ADR-021 (ESP32 vitals), ADR-031 (RuView sensing-first), ADR-039 (edge vitals packet 0xC511_0002), ADR-079 (camera ground-truth), ADR-103 (cog-person-count), ADR-110 (ESP32-C6 firmware), ADR-114 (cog-quantum-vitals) |
@@ -440,7 +440,7 @@ This means: **adding a new primitive is one file change**. No MQTT schema rev, n
 | **P2** | HA discovery message emitter. New module `mqtt_discovery.rs`. Emits all entity `config` topics on connect + every `--mqtt-refresh-secs`. Schema-validated against HA's published JSON schema. | pending |
 | **P3** | State publication. Subscribe to internal `tokio::broadcast` channel (the one `tx.send(json)` writes to on line 3983 of `main.rs`). Translate `edge_vitals` / `sensing_update` / `pose_data` messages into per-entity state payloads. Apply rate-limit + privacy-mode filters. | pending |
 | **P4** | Integration tests: dockerised mosquitto in CI (extend `.github/workflows/firmware-qemu.yml` pattern), schema-validate every emitted config against HA's `homeassistant/components/mqtt` JSON schemas (pin to a tested HA version). Add a smoke test that brings up sensing-server in `--source mock --mqtt`, subscribes with `paho-mqtt` test client, asserts on entity creation. | pending |
-| **P4.5** | **Semantic inference layer (HA-MIND).** New module `semantic_inference.rs` implementing the 10 v1 primitives from §3.12. Output broadcast channel consumed by both MQTT publisher (P3) and Matter bridge (P8). Per-primitive precision/recall baselines published to `docs/integrations/semantic-primitives-metrics.md`. Unit tests per FSM + integration tests via replay of ADR-079 paired captures. | pending |
+| **P4.5** | **Semantic inference layer (HA-MIND).** New module `semantic_inference.rs` implementing the 10 v1 primitives from §3.12. Output broadcast channel consumed by both MQTT publisher (P3) and Matter bridge (P8). Per-primitive precision/recall baselines published to `docs/integrations/semantic-primitives-metrics.md`. Unit tests per FSM + integration tests via replay of ADR-079 paired captures. | partial — 6 of 10 primitives on the live MQTT publisher; see §11 |
 | **P5** | Docs: new `docs/integrations/home-assistant.md` with screenshots of the HA UI after auto-discovery completes, example HA dashboard YAML (Lovelace card configs), 8 starter blueprints from §3.12.2 (distress notify, wake routine, hallway dim, elderly anomaly alert, meeting lights, bathroom fan, fall-risk escalate, auto-arm security), and the raw-channel example automations: "turn on hall light when presence ON", "send notification on fall_detected event", "log HR/BR to InfluxDB". | pending |
 | **P6** | Ship `--mqtt` in the next sensing-server release (target: v0.7.0). Demo end-to-end on `cognitum-v0` against a Mosquitto add-on running on a Home Assistant OS install. Update README hardware-options table with "Works with Home Assistant" badge. | pending |
 | **P7** | Matter Bridge spike: build a throwaway prototype with `matter-rs` exposing one `OccupancySensor` endpoint + one `GenericSwitch` for fall. Pair against Apple Home, Google Home, and HA's Matter integration. Decision gate: if pairing works on all three, proceed to P8; if blocked, switch to chip-tool FFI and re-spike. | pending |
@@ -667,4 +667,57 @@ Empty as of 2026-05-23. New questions discovered during implementation will be f

 ---

+## 11. Status note: P4.5 semantic states on the live publisher (2026-10-02)
+
+Issues [#2085](https://github.com/ruvnet/RuView/issues/2085) and [#2093](https://github.com/ruvnet/RuView/issues/2093) found that discovery announced 20 entities per device while only 6 ever received state, that `presence/state` was published on every CSI frame, and that HA device ids changed on every restart. The FSMs in `crate::semantic` existed but had no caller outside their tests. This note records what is now wired and what is not.
+
+### 11.1 What changed
+
+- **Semantic primitives run on the live path.** `mqtt::planner` holds one `SemanticBus` per node, sampled at 1 Hz (the rate the FSM constants assume). The bus feeds only the MQTT publisher. Matter does not consume it yet, so the "output broadcast channel shared with Matter" in P4.5 is not built.
+- **Announce only what has a source.** Six primitives are announced: `room_active`, `no_movement`, `elderly_inactivity_anomaly`, `someone_sleeping`, `possible_distress` and `fall_risk_elevated`. Four are not: `meeting_in_progress` needs a 1–20 % motion level, but per-node motion is a three-level classification; `bathroom_occupied`, `bed_exit` and `multi_room_transition` need zones, and the broadcast carries none (the §3.12.5 zone file is not implemented). For the same reason `zone_occupancy` (§3.1) and `pose` are not announced: `pose_keypoints` is never populated on the broadcast, and `persons[].keypoints` are synthesized.
+- **Per-entity availability (§3.6).** An announced entity is `online` only while its input exists: vitals while the calibration-gated estimate is published, `fall` while the node sends `edge_vitals`, `motion_energy` and `rssi` while present, and semantic primitives after the 60 s warmup (sleeping and distress also need breathing or heart rate, fall risk needs the fall detector). Otherwise it is `offline` and no state is sent. Transitions publish at once; all availability topics are re-sent every 30 s.
+- **No default values.** `motion_energy` was always `0.0` (MEASURED: 176 of 176 samples) because the bridge never set it. It now carries the node's `motion_band_power`, or the room value, or nothing. `fall` is driven by the rising edge of `edge_vitals.fall_detected`. Only `sensing_update` produces snapshots, which removes the phantom aggregate device that `edge_vitals` frames created. `present_still` now maps to 0 % motion instead of 100 %.
+- **Rates (§3.7).** Binary states publish on change, plus a 60 s retained heartbeat, as §3.5 already specified. Sensors keep their configured rates.
+- **Stable device identity (§3.8).** The default client id is now `wifi-densepose-<8 hex>`, persisted in `<data-dir>/mqtt_client_id`. §3.8 specified `wifi-densepose-<hostname>`; a persisted random id avoids a hostname dependency and survives hostname changes. `--mqtt-client-id` still overrides it.
+
+### 11.2 Evidence
+
+Unit tests (CODE-DERIVED, run with `cargo test -p wifi-densepose-sensing-server --features mqtt --lib -- mqtt:: semantic::`): `mqtt::planner::tests` covers the entity → state mapping, unavailable-without-source, warmup, on-change with heartbeat at a 73 frame/s input, sensor rates, reset and privacy mode. `mqtt::bridge::tests` covers message-type filtering, fall edges and motion energy. `mqtt::config::tests` covers client-id persistence across two "restarts" in a temp dir, override and malformed-file recovery.
+
+Live measurement (MEASURED, 2026-10-02): one ESP32 node streaming CSI and `edge_vitals` over UDP to a macOS host; `sensing-server --source esp32 --mqtt` against `eclipse-mosquitto:2` in Docker on a non-default port; every topic captured with a `paho-mqtt` subscriber on `#`. "Before" is `03a89793` (main), "after" is this change, built `--release --features mqtt`, same command and window.
+
+```bash
+# Broker: mosquitto.conf = "listener 1883 0.0.0.0 / allow_anonymous true / persistence false"
+docker run -d --rm -p 127.0.0.1:18830:1883 \
+  -v "$PWD/mosquitto.conf:/mosquitto/config/mosquitto.conf:ro" eclipse-mosquitto:2
+# Run A (180 s, then SIGTERM) and run B (restart, 45 s) share one --data-dir.
+# A paho-mqtt subscriber on '#' starts 2 s before each run.
+RUVIEW_API_TOKEN=<random> sensing-server --source esp32 --udp-port 5006 \
+  --udp-bind 0.0.0.0 --udp-allow <node-subnet> --http-port 3000 --ws-port 3001 \
+  --no-mdns --data-dir <dir> --mqtt --mqtt-host 127.0.0.1 --mqtt-port 18830
+```
+
+| Measure (180 s window unless noted) | Before (`03a89793`) | After |
+|---|---|---|
+| HA devices announced in run A | 2 (one phantom aggregate + `-node1`) | 1 (`-node1`) |
+| Entities announced per device | 20 | 15 |
+| Entities that received state (node device) | 6 | 10 |
+| Announced entities without state that still reported `online` | 14 | 1 (`fall`: an event, and no fall occurred) |
+| `presence/state` messages (node device) | 6,814 (37.9 / s) | 4 (one per change, plus 60 s heartbeat) |
+| `motion_energy` values | `0.0` in 176 of 176 | node band power, 177 samples |
+| Device id, run A → run B (restart, same `--data-dir`) | `wifi-densepose-<pid A>` → `<pid B>` (4 devices on the broker after B) | same persisted id in both runs (1 device) |
+| `offline` published on SIGTERM | no | no (unchanged; see 11.3) |
+| Same, plus `--privacy-mode` (75 s, fresh `--data-dir`) | — | 13 entities announced; no `heart_rate`, `breathing_rate` or `pose` topic for that device |
+
+After the change, five announced entities had no state: `heart_rate` and `breathing_rate`, because no calibration had been run; `someone_sleeping` and `possible_distress`, which depend on them; and `fall`, which is an event and no fall occurred. The first four were `offline`. `fall` was `online`, because the node sent `edge_vitals`. Before the change all 14 entities without state still reported `online`. Only one node was streaming during this measurement. #2085 used five nodes and measured about 73 `presence` messages per second per node.
+
+### 11.3 Not done
+
+- Semantic precision/recall on real captures. The figures in `semantic-primitives-metrics.md` have no reproducer in the repository and stay CLAIMED.
+- Zone and threshold files, `--semantic*` / `--no-semantic` flags on `sensing-server`, the `reason` attribute (§3.12.4), and `semantic_events.jsonl`.
+- MQTT last-will and offline-on-shutdown (§3.6). The server registers no LWT and SIGTERM does not publish `offline`, so availability stays as last published after the server stops.
+- Matter consumption of the semantic states.
+
+---
+
 *ADR-115 is the integration story that turns RuView from "another sensing platform" into "drop-in upgrade for any HA install **and** any Matter-controller home." MQTT carries the rich, differentiated telemetry; Matter carries the standardised subset across every controller ecosystem. Numbers 111 and 112 remain reserved per the project ADR-numbering policy.*
@@ -139,6 +139,32 @@ Implement the §3.3 mapping: `effective_class → PrivacyClass`, `cog-ha-matter`
 Add an opt-in `/ws/field` endpoint (or a `field_events` array on `SensingUpdate` behind a flag) carrying the signed `FieldEvent` + a privacy badge. Add an ingest route to `rufield-viewer` (it has none today — `server.rs:63-72`) so it can replay RuView's live feed instead of only `SyntheticSim`. **Gate:** a WS integration test asserting a connected client receives a privacy-badged, signature-verifiable `FieldEvent`; a viewer test asserting the new ingest route renders a live event. The `cognitum` appliance can speak RuField by consuming this endpoint (it already runs `ruview-vitals-worker`); deferred to its own ADR.

 **P4 — fusion composition + multi-modality (ARCHITECTURE, optional).**
+
+> **Update — second modality landed as a library.** Open question 5 below asked
+> whether the second modality should be `rvcsi`. It is **ultrasonic**, because
+> the cost collapsed: `rufield-adapters` now ships `UltrasonicReplayAdapter`,
+> the first adapter for `Modality::Ultrasonic` (registry code 7, empty since
+> v0.1), which parses, validates and signs [BatVu](https://github.com/ruvnet/batvu)
+> range profiles upstream. RuView only has to decide what it will put on a wire.
+>
+> `wifi-densepose-rufield::ultrasonic` is that decision, and it is expressed
+> structurally: the adapter is configured for its 32-bin coarse output (`P1`,
+> egress-safe) rather than its full per-bin frame (`P0`, edge-local), because a
+> consumer cannot un-coarsen a coarse profile whereas a runtime check can be
+> reordered. The `network_egress_allowed` gate still runs and is asserted to
+> drop nothing.
+>
+> Gates: `tests/ultrasonic_gates.rs`, 12 tests — round-trip, signature-verify,
+> fusion ingest, P1 on **both** tensor and observation, structural unreachability
+> of P4/P5, trust-tier refusal in both directions, determinism, whole-file
+> rejection of a malformed recording. Plus one asserting the honest negative
+> result: **an ultrasonic scan produces no fused inferences at all**, because the
+> adapter declines to populate `presence` (one transducer pair cannot tell a
+> person from a coat on a chair) and the engine's feature vocabulary is entirely
+> statements about a body. RuField v0.1 has no predicate for static geometry.
+>
+> Not wired into the running server. P1 shipped as a library before P3 wired it
+> in; this follows the same staging.
 Wire a second modality (cheapest: an `rvcsi`-sourced event, or recorded mmWave) into `RuFieldFusion` alongside the WiFi event, proving cross-modality fusion above ruvsense. **Gate:** a fusion test with two modalities producing ≥1 cross-modal inference, with provenance coverage 100%.

 ---
@@ -2,7 +2,7 @@

 | Field | Value |
 |-------|-------|
-| **Status** | Accepted — **implemented** (O1–O9 in `@ruvnet/ruview@0.2.0`; security/community extension in `0.3.0`, ADR-283; source-cited guidance in `0.3.1`): fail-closed schemas and MCP policy, async dispatch, zero runtime dependencies, bounded/redacted local Claude/Codex adapters, reviewed shared brain, source-checked capability guidance, and replay-verified Darwin/Flywheel gate. CI gate: `ruview-harness-flywheel.yml` |
+| **Status** | Accepted — **implemented** (O1–O9 in `@ruvnet/ruview@0.2.0`; security/community extension in `0.3.0`, ADR-283; source-cited guidance in `0.3.1`; guarded Cognitum Spaces OAuth read in `0.4.0`, ADR-325): fail-closed schemas and MCP policy, async dispatch, zero runtime dependencies, bounded/redacted local Claude/Codex adapters, reviewed shared brain, source-checked capability guidance, credential-gated external reads, and replay-verified Darwin/Flywheel gate. CI gate: `ruview-harness-flywheel.yml` |
 | **Date** | 2026-07-02 |
 | **Deciders** | ruv |
 | **Codename** | **RUVIEW-NPM-REVIEW-1** |
@@ -66,10 +66,64 @@ hardware claims.
  timestamps, sequence behavior, calibration, maximum size, and report rate.
 - Validate OpenWrt One first, then BPI-R3 4x4, before considering MT7996/MLO.

+## Amendment 1 — vendor CSI on MT7981, still unvalidated
+
+- **Date**: 2026-09-19, recorded here 2026-10-01
+- **Status**: proposed. One board model (two units). The hardware gates below are still open.
+
+The 2026-07-18 decision said the public `mt76` tree has no supported CSI export,
+and that a firmware change might be required before physical CSI exists. Both
+statements need a narrower reading.
+
+Mainline `openwrt/mt76` still has no CSI export. MediaTek's public OpenWrt feed
+does: vendor id `0x0ce7`, MCU event `0xc2`, patch
+`1001-wifi-mt76-mt7915-csi-implement-csi-support`. On a Wavlink WL-WN586X3
+Rev A (MT7981BA + MT7976CN + MT7531AE) that patch, rebased onto the `mt76`
+revision pinned by OpenWrt 24.10.8, produced complex samples without a firmware
+blob swap. The `0xc2` hook is already in the MT7981 firmware that the OpenWrt
+24.10.8 image carries. The
+rebased patch and the two userspace fixes are in `firmware/openwrt-wn586x3/`.
+
+What the first capture was: one record, 2.4 GHz, 20 MHz, legacy OFDM, 64
+subcarriers, a single chain. CSI arrived only while a client sent frames.
+The rate is client traffic, not a sensor sample clock. The capture is not in
+this repository.
+
+What it was not:
+
+- Not a calibration, a sequence check, a timestamp check, or a repeatability run.
+  The label on the wire is `mediatek:physical-unvalidated`. Plain `mediatek` stays
+  reserved for a frame that has passed those gates.
+- Not a 4x4 array. Each radio is two chains. The four antennas are a 2.4 GHz pair
+  and a 5 GHz pair. Two routers are two receivers. Cross-box phase is not a
+  shared local oscillator, so it is not a beam.
+- Not the OpenWrt One or the BPI-R3. Those remain the upstream-friendly targets
+  in the original decision. The WN586X3 is the board this path was actually run on.
+
+`wifi-densepose-mtk-bridge` translates `mt76-vendor` JSON, or an MtkCSIdump
+datagram, into ADR-267 MTC1 and sends it to the sensing server. The server keeps
+one snapshot and a bounded ring of per-subcarrier amplitude and phase per
+`device_id`. It runs `mediatek-amplitude-heuristic-v0` on mean and peak amplitude,
+and `activity-index-v0` on per-subcarrier fluctuation. Both are `CLAIMED`. Neither
+is the ESP32 vital-sign path.
+
+One measured property supports further work, and nothing more. Offline, on six
+local dump captures from two units (2.4 GHz, HT20, chains rx0 and rx1 of transmit
+stream 0), the cross-chain phase `arg(H0·conj(H1))`, summed over subcarriers,
+moved 0.014-0.039 rad (p50) between adjacent frames for well-sampled
+transmitters. Raw per-chain phase moved about 1.56 rad (p50), which is what
+uniformly random phase gives (MEASURED; reproducer
+`scripts/mediatek-csi-phase-stability.py`). That shows a stable observable inside
+one radio. It does not show that the observable tracks people.
+
+The operator guide is [`docs/mediatek-router-csi.md`](../mediatek-router-csi.md).
+
 ## Links

 - [ADR-123: BFLD capture path](ADR-123-bfld-capture-path-nexmon-and-esp32.md)
 - [ADR-264: RTL8720F radar wire protocol](ADR-264-rtl8720f-radar-wire-protocol.md)
+- [ADR-267: MediaTek MIMO CSI wire protocol](ADR-267-mediatek-mimo-csi-wire-protocol.md)
+- [MediaTek router CSI guide](../mediatek-router-csi.md)
 - [upstream mt76](https://github.com/openwrt/mt76)
 - [OpenWrt One](https://openwrt.org/toh/openwrt/one)
 - [MediaTek OpenWrt feed](https://git01.mediatek.com/openwrt/feeds/mtk-openwrt-feeds/)
@@ -34,6 +34,81 @@ Define `MTC1` version 1 as a little-endian, self-delimiting envelope:
 - Flags distinguish calibrated, saturated, time-synchronized, dropped-predecessor,
  and synthetic frames. Synthetic provenance cannot be cleared by downstream code.

+## Amendment 1 — PPDU types `Legacy` and `Unknown`
+
+- **Date**: 2026-09-19
+- **Status**: proposed. Demonstrated on one WL-WN586X3 capture. Not a maintainer acceptance.
+- **Scope**: `PpduType` discriminants only. The 72-byte header layout, CRC,
+  payload ordering, flags, and caps are unchanged.
+
+### What changed
+
+`PpduType` gains two variants:
+
+| Value | Name | Meaning |
+|---|---|---|
+| 6 | `Legacy` | Pre-HT: 802.11b CCK or 802.11a/g OFDM |
+| 7 | `Unknown` | A PPDU format the producer could not classify |
+
+Values 1-5 (`Ht`, `Vht`, `HeSu`, `HeMu`, `Eht`) are untouched.
+
+### Why
+
+The original set assumed every CSI report would be HT or later. The first real
+MT7981 capture disproved that. A Wavlink WL-WN586X3 (MT7981B + MT7976C) running
+an OpenWrt 24.10.8 image built with the patches in `firmware/openwrt-wn586x3/`
+reported `rx_mode = 1` (`MT_PHY_TYPE_OFDM`) for a client associated on 2.4 GHz
+channel 6 at 20 MHz. The bridge had no way to express it and dropped the frame.
+
+That was a real data loss, not a corner case. MediaTek's CSI driver treats legacy
+OFDM as a first-class mode: `mt7915_vendor_csi_tone_mask` skips only
+`MT_PHY_TYPE_CCK`, and its `mode_map` is keyed by `MT_PHY_TYPE_OFDM`, `_HT`,
+`_VHT` and `_HE_SU`, giving OFDM its own tone-mask group
+(`1001-wifi-mt76-mt7915-csi-implement-csi-support.patch:1070-1088`). Association
+and management exchanges are legacy-rate by design, so a sensing deployment will
+see these continuously.
+
+`Unknown` exists so the enum's gaps (5-7 and 12 in `mt76_phy_type`) and future
+modes are carried explicitly rather than guessed at or dropped. It also covers
+transports that omit the field: the MtkCSIdump UDP datagram carries no `rx_mode`,
+and reporting `Unknown` there is honest where defaulting to a concrete format was
+not.
+
+### Compatibility
+
+- **Forward, not backward.** A decoder built before this amendment rejects
+  discriminants 6 and 7 with `UnknownPpduType`, because the original parser
+  rejects unknown types by design. `TryFrom<u8>` returns `Err` rather than
+  panicking, so an old decoder fails safely — it just drops legacy frames, and
+  does so silently. **Rebuild MTC1 consumers after this codec change.**
+- **Scope is narrower than "the workspace".** `wifi-densepose-hardware` defines
+  three independent `PpduType` enums — `csi_frame.rs` (ESP32),
+  `qualcomm_csi.rs`, and `mediatek_csi.rs` — and this amendment touches only the
+  MediaTek one. Neither of the others changes, so no other vendor bridge is
+  affected. The complete set of `mediatek_csi::PpduType` consumers is:
+  `wifi-densepose-hardware`'s own `mediatek-csi-sim` binary,
+  `wifi-densepose-mtk-bridge`, and `wifi-densepose-sensing-server`, which renders the
+  value with `{:?}` and so needed no code change. In particular the
+  `ppdu_type > 3` bound in `bootstrap_baseline.rs` is fed from the **ESP32**
+  enum via `CsiGridKey::from_frame(&Esp32Frame)`, not from MediaTek frames, so
+  `Legacy` and `Unknown` cannot reach it.
+- Because the variants were added rather than renumbered, and Rust requires
+  exhaustive matches, the compiler locates any consumer that must be updated.
+  Nothing outside the files above needed one.
+- Producers must emit 6 only for frames that genuinely are pre-HT, and 7 only
+  where the format is truly unclassified. Neither is a dumping ground for a
+  mapping the producer has not done.
+- The mapping from `rx_mode` to `PpduType` is now infallible, so no MTC1 producer
+  may drop a frame on PPDU grounds.
+- Unchanged: synthetic provenance still cannot be cleared by downstream code.
+
+### Observed dimensions
+
+The same capture assembled to 1x1x64. That is the client's behaviour, not a
+protocol limit: the handset sent single-stream frames to a 2.4 GHz 20 MHz AP.
+Expect 1x2 or 2x2 on 5 GHz, and size consumers for the chipset profile's
+`max_chains` rather than for what one capture happened to show.
+
 ## Consequences

 ### Positive
@@ -59,3 +134,8 @@ Define `MTC1` version 1 as a little-endian, self-delimiting envelope:
 - [ADR-266: MediaTek Filogic CSI platform](ADR-266-mediatek-filogic-csi-platform.md)
 - [ADR-018: ESP32 binary CSI framing](ADR-018-esp32-csi-frame-protocol.md)
 - [ADR-264: RTL8720F radar wire protocol](ADR-264-rtl8720f-radar-wire-protocol.md)
+- Amendment 1 implementation: `v2/crates/wifi-densepose-hardware/src/mediatek_csi.rs`
+  (codec) and `v2/crates/wifi-densepose-mtk-bridge` (`ppdu_from_rx_mode`). The
+  motivating capture is a lab record and is not in this tree: it contains a
+  client transmitter address and raw CSI. The in-repo check is a fabricated
+  legacy-OFDM record in `wifi-densepose-mtk-bridge/tests/hardware_capture.rs`.
@@ -31,6 +31,26 @@ bounded output/time, secret redaction and realpath-based RuView checkout
 validation. Write mode requires two explicit flags and never uses permission or
 sandbox bypasses.

+## Credentialed external reads
+
+Read-only cloud access is not equivalent to an uncredentialed local read. The
+Cognitum Spaces adapter therefore delegates OAuth and response validation to
+the Rust `wifi-densepose` client, never accepts bearer tokens or API keys, and
+removes the API-key compatibility environment from the child process. Its MCP
+tool is denied unless the server operator grants `credential-use`; MCP callers
+cannot select a credential path or API origin. The adapter uses only an
+installed `wifi-densepose` binary; it never executes Cargo build scripts from
+an auto-detected checkout while holding credential authority. The tool is
+marked open-world and independently rechecks response size, structure, privacy
+class, and prohibited raw fields.
+
+An expiring access token may rotate the stored refresh credential. The MCP
+annotation is therefore non-read-only and non-idempotent even though the cloud
+data operation is read-only. That bounded authentication side effect is
+disclosed in the schema and result. It does not change the cloud operation from
+read-only and confers no write or action authority. ADR-325 remains authoritative
+for the Spaces data and policy boundary.
+
 ## Shared brain

 The public brain is committed JSONL, not a shared mutable database. Canonical
@@ -67,5 +87,6 @@ autonomously promotes or publishes an evolved candidate.
 Contributors can explore RuView with either major local CLI and share durable
 findings without sharing secrets. Improvements become reproducible proposals
 with frozen evaluation evidence. The cost is a larger development-only npm
-lockfile, a 128 KiB unpacked-package budget (the current tarball is below that
-bound), and explicit maintenance of the corpus, genome and gate.
+lockfile, a 160 KiB unpacked-package budget after adding the duplicated host
+playbook and bounded OAuth adapter (the package remains runtime-dependency-free),
+and explicit maintenance of the corpus, genome and gate.
@@ -0,0 +1,231 @@
+# ADR-288: VEIL — a compliant-waveform privacy shield against unauthorized WiFi sensing
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed — implemented (P1 reference model) |
+| **Date** | 2026-08-09 |
+| **Deciders** | ruv |
+| **Codename** | **VEIL** — Verifiable Emission-shaping for Identity-Leakage prevention |
+| **Codebase target** | new leaf crate `v2/crates/wifi-densepose-privshield` |
+| **Parent** | ADR-118 (BFLD — the detection layer VEIL is the countermeasure to), ADR-282 (mandatory L0–L5 evidence ladder) |
+| **Relates to** | ADR-120/121 (BFLD privacy class + identity-risk scoring — the trigger source), ADR-141 (privacy control plane / runtime attestation — the audit consumer), ADR-280 (active sensing / governed actuation — VEIL is a defensive sensing action), ADR-185 §13 (`wifi-densepose-aether` — the pure-compute leaf pattern this crate follows) |
+| **Research bundle** | [`docs/research/privacy-shield/`](../research/privacy-shield/) (9 files) |
+| **Tracking issue** | TBD |
+
+## 0. PROOF discipline
+
+Every defense number this crate produces is **SYNTHETIC / evidence level L0**
+(ADR-282): generated by the crate's own model (`identity::Channel`), attacked by
+the crate's own classifier (`attacker::NearestCentroidAttacker`), and scored
+against its own known labels. Nothing here has been validated against real WiFi
+silicon, and the crate contains no radio integration and cannot emit RF. External
+attack/defense results cited from the literature (BFId, LeakyBeam, DySPAN-2026,
+IRShield, FCC statutes) are **EXTERNAL** evidence and labelled MEASURED/CLAIMED in
+the research bundle. The single measured claim about *our own behavior* is the
+pinned deterministic witness in `proof.rs`.
+
+## 1. Context
+
+### 1.1 The gap
+
+IEEE 802.11ac/ax beamforming feedback (BFI) — the compressed Givens-rotation
+angle matrices (φ/ψ) a client sends the AP — is transmitted **unencrypted on the
+management plane**. Any device in monitor mode can capture it for every station
+at once, no network access, and the target need carry no device. The literature
+establishes the severity: **BFId** (ACM CCS 2025) re-identifies individuals from
+BFI; **LeakyBeam** (NDSS 2025) detects occupancy through walls at 20 m from BFI;
+**BeamSense** recognizes activities at up to 99.28%. IEEE Std **802.11bf-2025**
+(published 26 Sep 2025) standardizes the sensing measurement/feedback surface
+these attacks abuse — and a 2023 proposal for a BFI secure-transmission mechanism
+(802.11-23/0782) was **withdrawn**, so the standard shipped with no privacy
+protections.
+
+RuView already has a *detection* layer for this: **BFLD** (ADR-118/121) measures
+the identity-leakage of each frame and gates what leaves the node. But BFLD
+protects *RuView's own outputs*; it does nothing about a **third-party sniffer**
+capturing the room's plaintext BFI off the air. There is no RuView component, and
+per our market survey no shipping product anywhere, that prevents that.
+
+### 1.2 Constraint: compliant waveform controls, never jamming
+
+The defense must preserve normal communications and must not interfere with any
+other station. Jamming (47 U.S.C. §333/§302a) is defined by *adding energy to
+interfere with others' transmissions*. Any acceptable control must shape only the
+node's **own** standards-conformant emission.
+
+### 1.3 The separability insight
+
+Identity leaks through the *fine* cross-subcarrier phase structure of a
+beamforming report; data throughput rides the *dominant* beam direction. These
+are (mostly) separable subspaces — so a transform confined to the fine subspace
+can wreck re-identification while sparing the beam the link depends on. DySPAN-2026
+independently MEASURED that shaping fine-resolution feedback is near-free in
+throughput, corroborating the insight.
+
+## 2. Decision
+
+Ship **`wifi-densepose-privshield`** (VEIL) as a standalone pure-compute leaf
+crate (the `wifi-densepose-aether`/`nvsim` pattern: dependency-free, deterministic,
+WASM-ready, zero coupling to any radio or ingestion path), implementing:
+
+1. **A SYNTHETIC two-subspace BFI model** (`identity.rs`): each identity owns a
+   stable fine-block signature; sessions add environmental nuisance; the comm
+   block is identity-free and carries throughput.
+2. **The protector** (`protector.rs`): compliant waveform controls, primarily a
+   **per-session keyed orthogonal rotation of the fine subspace, composed from
+   extra Givens rotations** — the report's native primitive. Plus feedback
+   quantization/dither, sounding-cadence randomization, and a `SensingDetector`
+   that engages the shield only when sensing activity is observed.
+3. **The adversary** (`attacker.rs`): a passive nearest-centroid re-identifier
+   modeling the BFId threat, with selectable Euclidean/Cosine metrics.
+4. **A throughput model** (`throughput.rs`):
+   `(1 − sounding − feedback_airtime) · C(SNR·(1−ρ))/C(SNR)`, where the residual
+   `ρ` falls with feedback bits and the feedback airtime rises with them — giving
+   a genuine interior throughput optimum in feedback resolution.
+5. **A compliance audit** (`compliance.rs`): the rotation is orthogonal ⇒
+   energy-preserving ⇒ adds no interfering energy ⇒ **not jamming**, turned into a
+   checked `ComplianceReport` (energy ratio ≈ 1.0).
+6. **The experiment** (`experiment.rs`): runs the attacker against unprotected and
+   protected traffic and reports both accuracies vs. chance, plus throughput and
+   compliance, with a single `passed()` verdict.
+7. **The hyper-optimizer** (`optimize.rs`): derives the shipped shield config
+   rather than hand-picking it — the throughput-optimal feedback resolution and
+   the minimum rotation-mixing budget that collapses re-ID robustly (across both
+   attacker metrics and N∈{16,32}), plus a Pareto frontier.
+8. **A deterministic proof** (`proof.rs`): a pinned FNV-1a witness over the
+   reference experiment (the `nvsim`/`verify.py` discipline).
+
+### 2.1 Why the keyed Givens rotation
+
+It is simultaneously **orthogonal** (energy-preserving ⇒ compliant),
+**key-reversible** (the associated AP shares the session key and recovers the true
+precoder ⇒ throughput preserved), and **fresh per session** (a sniffer sees a new
+random rotation of the signature each session and cannot average it back ⇒ the
+enrollment attack collapses; over unknown rotations the signature carries no
+stable discriminative information ⇒ re-ID → chance). It is the shared-secret
+precoding idea (cf. MIMOCrypt) specialized to the identity-bearing subspace.
+
+### 2.2 Measured behavior (SYNTHETIC / L0)
+
+Reference experiment at the hyper-optimized operating point (§opt), default
+scene, N=16 identities, `cargo test`:
+
+| Metric | Shield off | Shield on |
+|---|---|---|
+| Passive re-ID accuracy | 100.0% | **4.7%** (chance 6.25%) |
+| Link throughput ratio | 100% | **97.6%** |
+| Emission energy ratio | — | **1.000000** (compliant) |
+
+All 35 unit/proof tests + doctest pass; the crate builds for
+`wasm32-unknown-unknown` and is clippy-clean.
+
+### opt. Hyper-optimization (`optimize.rs`)
+
+The shipped shield config is the optimizer's output, not a guess, and
+`ShieldConfig::default()` is asserted equal to it:
+
+- **Feedback resolution = 5 bits.** Throughput has an interior optimum in
+  feedback bits (residual falls, feedback airtime rises); the unconstrained
+  optimum is 3 bits (matching DySPAN-2026), and 5 is the throughput-best value in
+  the spec-allowed 802.11 {5,7,9} set.
+- **Givens passes = 96.** The proven minimum for robust collapse — across both
+  attacker metrics *and* N∈{16,32} — is **48**; the shipped 96 is a free 2×
+  privacy margin, since the keyed rotation is derived from the shared secret and
+  never signaled (extra passes cost compute, not airtime). The original
+  hand-picked 112 was 2.3× over-provisioned.
+
+Net vs. the original hand-picked (112 passes / 7 bits): the optimum is strictly
+better on **both** privacy (re-ID 0.047 vs 0.078) and throughput (0.976 vs 0.974),
+and is now verified rather than assumed. See
+`docs/research/privacy-shield/08-optimization.md`.
+
+### harness. Native terminal harness + TUI (`src/bin/veil.rs`)
+
+A custom, dependency-free binary (`veil`) ships with the crate — the in-repo,
+native counterpart to the npm metaharness (ADR-289). It drives the same public
+API the tests use, as an interactive ANSI dashboard plus scriptable subcommands
+(`report`, `sweep`, `optimize`, `adaptive <N>`, `proof`, `doctor`, `tui`).
+Std-only (no `crossterm`/`ratatui`): the TUI is a command-driven redraw loop, so
+it runs in any terminal, pipe, or CI and keeps the crate a pure leaf. It reports
+only SYNTHETIC/L0 numbers and never relabels them. The wasm leaf story is
+unchanged (validated with `--lib`; the bin is native-only).
+
+### sota. 2025–2026 evidence update (verified)
+
+A cited, adversarially-verified SOTA sweep
+(`docs/research/privacy-shield/09-sota-update-2026.md`) refines the threat and
+positioning. Load-bearing points for this ADR:
+
+- **Threat is broader and cheaper than §1.1 stated.** A passive, keyless,
+  single-antenna sniffer at ~20 m and *through walls* can identify people
+  (BFId, 99.5%/N=197, `MEASURED`), read **breathing** from stationary occupants
+  and **keystrokes/PINs** (LeakyBeam / WiKI-Eve / SThief, `MEASURED`), and —
+  decisively — **reconstruct full CSI from the sniffed BFI** (BFIAttack,
+  ≥93% single-antenna, `MEASURED`). VEIL's obfuscation must therefore degrade
+  *reconstructed-CSI* utility, not merely raw-BFI feature noise; because VEIL's
+  rotation is a **secret orthogonal** transform, the attacker has no key and no
+  closed-form to invert — this is now a claim to **test**, not assume.
+- **VEIL's family is independently validated.** AP-side per-packet random
+  unitary on the LTF (LeakyBeam defense, 89.7%→~51%, `MEASURED`) and RIS
+  obfuscation (PrivISAC, 93%→~30%, robust to a retrained multi-location
+  attacker, `MEASURED`) confirm standard-permitted beamforming-surface
+  obfuscation works; DP-Givens quantization (`SYNTHETIC`) offers a formal ε knob.
+- **Compliance precedent.** BeamDancer (IEEE TWC 2024, `MEASURED`) argues
+  native-beamforming obfuscation is 802.11-compliant while jamming/geofencing
+  are not — cite it as precedent. (Its ">96% PDR" figure was **refuted** in
+  verification; do not cite it.)
+- **Security honesty.** Obfuscation shields have published counter-attacks
+  ("Defeating CSI obfuscation", SnoopFi), so VEIL's own shield security is
+  `CLAIMED`, not proven-secure, until it withstands learned de-obfuscation.
+- **Governance gap.** No claim on 802.11bf-2025 privacy provisions survived
+  verification; that pillar remains an open question, not an asserted fact.
+
+The derived, prioritized improvement backlog lives in the SOTA-update file (§4).
+
+## 3. What this explicitly is NOT
+
+- **Not a radio driver.** No RF frontend, no transmit path, no
+  `wifi-densepose-hardware` coupling. VEIL cannot emit and cannot jam.
+- **Not a defense against the associated AP.** That party holds the session key by
+  construction (threat class A3); protecting against a malicious AP is BFLD's
+  detection/privacy-class problem (ADR-118/141), not this shield's.
+- **Not a full motion-obfuscation claim.** A fixed per-session rotation does not
+  hide coarse within-session motion; identity *re-ID* is the guaranteed target,
+  motion is partial/future work.
+- **Not a real-hardware performance claim.** All defense numbers are SYNTHETIC/L0
+  until a two-node capture with a boot/runtime-log witness exists (CLAUDE.md
+  hardware rule; roadmap P5).
+- **Not RF denial or camera-grade anything.**
+
+## 4. Simplifications (honesty boundary)
+
+- The two-subspace split is an abstraction; on real radios comm and identity
+  information are only *approximately* separable, so the real throughput cost of
+  fully hiding identity may exceed the model's ~2%. DySPAN-2026's MEASURED curve
+  bounds it as *small* at fine resolution, not zero.
+- The attacker is nearest-centroid. The collapse argument is classifier-independent
+  (it is about the marginalized signal), but P2/P5 must confirm a learned attacker
+  also collapses.
+- The crate's PRNG is SplitMix64 — deterministic and WASM-safe but **not
+  cryptographic**; a deployment derives the rotation key from the negotiated link
+  secret, never from this PRNG.
+
+## 5. Consequences
+
+- RuView gains the *countermeasure* half of its RF-privacy story: BFLD detects
+  leakage, VEIL acts on it — a defensible, standards-anchored, gap-filling
+  position (see `docs/research/privacy-shield/06-market-and-buyers.md`).
+- The compliance audit gives regulators/auditors a machine-checkable "not jamming"
+  artifact that composes with ADR-141 attestation.
+- Future integration (BFLD `identity_risk` → `SensingDetector`, ADR-280 governed
+  actuation, firmware feedback shaping, two-node hardware measurement) is staged in
+  the research bundle roadmap and deliberately deferred so the model validates in
+  isolation first.
+
+## 6. Validation
+
+```bash
+cargo test -p wifi-densepose-privshield --no-default-features
+cargo build -p wifi-densepose-privshield --target wasm32-unknown-unknown
+cargo clippy -p wifi-densepose-privshield --all-targets
+```
@@ -0,0 +1,95 @@
+# ADR-289: `wifi-densepose-privshield-harness` — a MetaHarness for the VEIL privacy shield
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed — implemented (P1) |
+| **Date** | 2026-08-09 |
+| **Parent** | ADR-288 (`wifi-densepose-privshield` / VEIL, the crate this harness assists development on) |
+| **Relates to** | ADR-286 (`wifi-densepose-sar-harness`, the per-crate harness scaffold this one mirrors), ADR-285 (`harness/homecore/`, the WASM-first `@metaharness/kernel` pattern), ADR-182 (`harness/ruview/`, the first minted harness), ADR-282 (L0–L5 evidence ladder) |
+| **Location** | `harness/wifi-densepose-privshield/` |
+
+## 0. PROOF discipline
+
+Every claim below about what is "real" versus "illustrative"/"SYNTHETIC" is
+checked by a test in this harness's own suite (router + flywheel + install-smoke
+ guidance). The dependency-free `guidance` surface is covered by
+`__tests__/guidance.test.ts`, which runs even before `npm install`. Nothing here
+asserts a MEASURED defense result — the harness surfaces the VEIL crate's
+SYNTHETIC/L0 numbers with that label intact.
+
+## 1. Context
+
+`wifi-densepose-privshield` (ADR-288) is the VEIL privacy shield — a new,
+narrowly-scoped crate. Following the pattern ADR-286 set for
+`wifi-densepose-sar`, it gets a dedicated per-crate MetaHarness rather than a
+bespoke setup: the `vertical:coding` scaffold (architect/implementer/reviewer/
+test-writer, `doctor`) with `@metaharness/router`, `@metaharness/flywheel`, and
+Darwin Mode wired in, plus a VEIL-specific, dependency-free `guidance` surface.
+
+## 2. Decision
+
+Land the harness at `harness/wifi-densepose-privshield/`, mirroring
+`wifi-densepose-sar-harness`, with two deliberate improvements:
+
+1. **Dynamic dependency imports.** `bin/cli.js` imports the `@metaharness/*`
+   packages *inside* the commands that need them, not at module top. So
+   `guidance`, `--help`, and the guidance test run with **zero dependencies
+   installed** — useful for offline/air-gapped review and for this repo's CI
+   before `npm install`. Only `init`/`doctor`/`route`/`flywheel` touch the
+   kernel/host/router/flywheel packages.
+2. **A VEIL `guidance` command.** A self-contained, source-cited, read-only
+   capability map (topics: `overview`, `threat`, `countermeasure`,
+   `compliance`, `optimization`, `experiment`), each entry carrying a summary,
+   repo-relative source citations, focused validation commands, and explicit
+   limitations — the `ruview_guidance` shape, specialized to VEIL. It labels all
+   defense evidence `SYNTHETIC/L0` and states plainly that guidance is
+   navigation, not authority.
+
+The standard three self-improvement/cost pieces are wired as real npm
+dependencies (not stubs):
+
+- **`@metaharness/darwin`** (devDependency) — `npm run evolve` / `evolve:dry`
+  mutates the harness's own operating config, keeping only measurable gains.
+- **`@metaharness/router`** — `src/router.ts` wires a real cost-optimal `Router`
+  (`qualityBar: 0.8`, k=1) over two model tiers, with four VEIL-shaped task axes
+  (threatModeling / complianceReview / optimizerTuning / docWriting). Labelled
+  examples are illustrative seed data (honesty note in-file).
+- **`@metaharness/flywheel`** — `src/flywheel.ts` wires the real
+  `runFlywheelGenerations` promotion loop (propose → evaluate → gate → promote,
+  Ed25519-signed, independently replayable) with a SYNTHETIC proposer/evaluator
+  (`dataSource: 'SYNTHETIC'`, no model call), over VEIL policy levers
+  (`complianceReview`, `threatTriage`).
+
+## 3. What this explicitly is NOT
+
+- **Not a VEIL runtime.** The harness does not run a radio, emit RF, or jam. It
+  assists *development* on the crate; it cannot execute the shield on hardware.
+- **Not evolving the crate.** Darwin/Flywheel mutate the harness's own policy
+  (agent prompts, review-checklist depth), not VEIL's Rust code. The crate's
+  actual hyper-optimization (ADR-288 §opt) was done directly, in the crate.
+- **Not a live routing/promotion system.** The router's examples are seed data;
+  the flywheel's proposer/evaluator are deterministic stand-ins — both honestly
+  labelled in-source and in `CLAUDE.md`.
+- **Not a replacement for the crate's gates.** The authoritative check for a
+  VEIL change remains `cargo test -p wifi-densepose-privshield`.
+- **Not a re-labeller.** The harness must never present VEIL's SYNTHETIC results
+  as MEASURED, and never scaffold interference-based ("jamming") defenses — both
+  are hard rules in the harness `CLAUDE.md`.
+
+## 4. Consequences
+
+- The harness ships `guidance`/`doctor`/`init`/`route`/`flywheel`; `guidance`
+  and `--help` work offline (validated here via `node bin/cli.js`), the rest
+  after `npm install` + `npm run build` (CI).
+- `.harness/manifest.json` + `manifest.sha256` are generated with real per-file
+  hashes at creation (unlike ADR-286's scaffold, whose manifest was historical).
+- Scoped to its own name: its plugin, permissions, and (future) MCP surface only
+  read/assist on `wifi-densepose-privshield`. No risk to other harnesses/crates.
+
+## 5. Validation
+
+```bash
+cd harness/wifi-densepose-privshield
+node bin/cli.js guidance --topic overview   # dependency-free
+npm ci && npm run build && npm test          # full suite (CI; needs registry access)
+```
@@ -0,0 +1,94 @@
+# ADR-290: VEIL end-to-end hardware implementation program (multi-provider firmware)
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed — P4 scaffolding (build-only); portable core validated on host |
+| **Date** | 2026-08-09 |
+| **Parent** | ADR-288 (VEIL shield), ADR-289 (harness), ADR-282 (L0–L5 evidence ladder) |
+| **Location** | `firmware/privshield/` |
+| **Relates to** | `firmware/esp32-csi-node/` (the CSI sensor/attacker node), ADR-280 (governed actuation), ADR-141 (attestation) |
+
+## 0. PROOF discipline
+
+The **only** artifact validated here is the portable C core
+(`firmware/privshield/core/`): a host test (`make test`) checks energy
+conservation, reversibility, wrong-key failure, and — pinned — that its
+SplitMix64 key schedule is **byte-identical to the Rust crate's** PRNG. That is
+`build`/host-level evidence, not silicon. Every per-provider adapter is a
+**build-only scaffold** with `TODO(hw)` markers: `SYNTHETIC / L0`, no captured
+log, no `MEASURED` claim. Nothing in this ADR asserts VEIL works on real
+hardware; it asserts a *plan and a shared core* to get there (P5).
+
+## 1. Context
+
+ADR-288 shipped VEIL as a deterministic, no-radio Rust model, and the 2025–2026
+SOTA sweep (ADR-288 §sota) confirmed the mechanism's family is real and
+standard-permitted. The open question left was **"does this run on real WiFi
+hardware, and on which?"** — including the user asks: *can OpenWRT / open WiFi
+software implement it, and can ESP32 help scramble signals?* Answering requires
+committing to the platform reality rather than assuming a uniform "firmware"
+target.
+
+## 2. Decision
+
+Stand up `firmware/privshield/` as a **multi-provider E2E program** around one
+shared, validated core:
+
+1. **A portable C shield core** (`core/veil_shield.{h,c}`) — the keyed
+   Givens-rotation obfuscation, `no_std`-friendly C99 (no malloc/libc I/O), with
+   a SplitMix64 key schedule matching the Rust crate so on-air behavior is
+   identical everywhere and every adapter links the *same* math. Host-tested.
+2. **Per-provider adapters**, each built and graded by a hardware research
+   agent, honest about what its stack can actually touch:
+   - **`openwifi/`** (open PHY/MAC on SDR/FPGA) — the highest-capability path and
+     the one that can host the **keyed-reversible** design end-to-end
+     (protector + AP-side compensation). Carries the **P5 measurement protocol**
+     (`MEASUREMENT.md`) that yields the first `MEASURED` result with a witness.
+   - **`openwrt/`** (Linux `mac80211`, mt76/ath9k…) — the commodity path.
+     Sounding-cadence randomization, MU-group and stream-mapping control are
+     feasible from the driver/hostapd; the per-packet unitary on the LTF spatial
+     mapping is firmware-deep on most parts. Partial.
+   - **`nexmon/`** (Broadcom/Cypress C firmware patches) — the commodity
+     C-firmware route; the read path is proven (Wi-BFI/nexmon_csi), the transmit
+     report-shaping path is research-grade/partial.
+   - **`esp32/`** (ESP-IDF) — **not** a feedback protector (the beamforming path
+     is a closed blob): ESP32 shapes CSI *read*, not transmitted feedback. Its
+     legitimate roles are a **sensing detector** (trigger the AP-side shield) and
+     an **RIS controller** (drive an external reconfigurable surface to scramble
+     the sensing direction — the honest way ESP32 "helps scramble", via an
+     external surface, not its own PHY).
+3. **Compliance stance carried into hardware:** every control shapes the node's
+   own standards-conformant emission and preserves energy; the ESP32
+   decoy/cover-traffic idea is documented as *legally sensitive / not
+   recommended* precisely because it edges toward the interference line.
+
+Per-provider feasibility grades live in each subdir README and the top-level
+feasibility matrix; they are the answer to the "which hardware" question.
+
+## 3. What this explicitly is NOT
+
+- **Not validated firmware.** No adapter has run on silicon; there is no witness.
+  The scaffolds compile-*shaped*, not compile-*guaranteed* on their toolchains
+  (which are absent in this environment).
+- **Not a claim that ESP32 can shield beamforming feedback** — it cannot; it is a
+  detector/RIS-controller only.
+- **Not jamming, on any platform.** Compliant waveform shaping only.
+- **Not a MEASURED result.** That is P5, gated on a captured log.
+
+## 4. Consequences
+
+- One validated core, four honest provider scaffolds, and a concrete P5
+  measurement plan — a real path from model to silicon, with the effort/blocker
+  reality made explicit per platform.
+- The shared core keeps every future hardware result consistent with the crate
+  and with each other.
+- Scope stays inside `firmware/privshield/`; no other crate/firmware is touched
+  (the existing `esp32-csi-node` remains the sensor/attacker node).
+
+## 5. Validation
+
+```bash
+cd firmware/privshield/core && make test    # host: energy/reversibility/PRNG parity
+# per-provider builds require their toolchains (ESP-IDF, OpenWRT SDK, Nexmon,
+# Vivado) and real hardware — see each subdir's BUILD/INTEGRATION notes.
+```
@@ -0,0 +1,106 @@
+# ADR-291: Public-benchmark evaluation harness — Widar3.0 ingest, standard split protocols, leakage guards
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-10
+- **Deciders**: ruv
+- **Tags**: training, evaluation, benchmarks, widar, mm-fi, leakage, honesty
+
+## Context
+
+RuView implements the field's key techniques (CSI ratio, BVP features, MAE
+pretraining, rapid adaptation) but reports results only on self-collected data
+with self-defined metrics (e.g. the README's held-out temporal-triplet
+accuracy). A 2026 deep-research sweep of the WiFi-sensing literature found:
+
+1. Cross-domain generalization is the field's central unsolved problem; the
+   only widely reproduced cross-domain result is Widar3.0's BVP benchmark.
+2. MM-Fi (NeurIPS 2023) is the standard WiFi-pose benchmark, with defined
+   cross-subject and cross-environment protocols.
+3. The field had a documented leakage reckoning in 2024–2025: window-level
+   random splits on continuous recordings inflate accuracy (one dataset's F1
+   collapsed from ~90% to ~22% under subject-disjoint splits — Sensors
+   24(10):3159; Signals 6(4):59).
+
+`wifi-densepose-train` already has an `MmFiDataset` NPY loader and a
+deterministic `SyntheticCsiDataset`, but no Widar3.0 ingest, no standard split
+protocols, and no structural leakage guard. CLAUDE.md already requires
+mean-pose baselines and leakage-free held-out splits for pose PCK; nothing in
+the code enforces this.
+
+Without leaderboard-comparable numbers, RuView's claims cannot be ranked
+against published systems, which blocks both scientific credibility and
+commercial (OEM licensing) conversations.
+
+## Options considered
+
+1. **Do nothing; keep self-collected metrics.** Rejected: perpetuates the
+   comparability gap.
+2. **Port a Python eval stack (SenseFi) alongside the Rust pipeline.**
+   Rejected: violates the v2 Rust-workspace direction and adds an unreviewed
+   dependency surface.
+3. **Extend `wifi-densepose-train` with native loaders + protocol machinery.**
+   Chosen.
+
+## Decision
+
+Extend `v2/crates/wifi-densepose-train` with three additions:
+
+### 1. Widar3.0 ingest (`dataset::widar`)
+
+- A parser for the Intel 5300 `.dat` CSI log format ("bfee" records) used by
+  the Widar3.0 raw distribution: framed records with a 3-byte header
+  (2-byte little-endian length + 1-byte code 0xBB), a 20-byte bfee header
+  (timestamp_low, bfee_count, Nrx, Ntx, RSSI a/b/c, noise, agc, antenna_sel,
+  len, rate), and a packed 10-bit-per-component complex CSI payload of
+  30 subcarrier groups. Invalid records are skipped with a warning, not a
+  panic — untrusted file input is validated at the boundary per CLAUDE.md.
+- A `WidarDataset` implementing the existing `CsiDataset` trait, mapping
+  Widar's `Nrx × Ntx × 30` CSI into windowed `CsiSample`s via the existing
+  subcarrier interpolation, with domain metadata (user, room, orientation,
+  gesture) parsed from Widar's documented directory/file naming convention.
+- No network access: the loader reads a local dataset root. Dataset download
+  remains a documented manual step.
+
+### 2. Split protocols (`protocols`)
+
+- A `SplitProtocol` type expressing the standard evaluations: cross-subject
+  (MM-Fi style), cross-environment/room, cross-orientation (Widar style), and
+  random-baseline (explicitly labelled as leakage-prone, for comparison only).
+- Split assignment is a pure function of sample metadata + a seed — fully
+  deterministic, no RNG state.
+
+### 3. Leakage guards (`protocols::leakage`)
+
+- A structural `LeakageAudit` that, given a proposed train/test split,
+  verifies: (a) subject-disjointness, (b) environment-disjointness where the
+  protocol claims it, (c) no two windows from the same continuous recording
+  span both sides of the split. A failed audit is an `Err`, not a warning.
+- PCK/accuracy reporting requires a `MeanPoseBaseline` computed from the
+  training split only, and reports model-vs-baseline together, enforcing the
+  CLAUDE.md rule in the type system rather than by convention.
+- Evaluation output is an evidence-tagged report (`MEASURED` requires a
+  reproducer command line embedded in the report; anything else is emitted as
+  `SYNTHETIC` or `CLAIMED`).
+
+## Consequences
+
+- RuView results become comparable to published numbers (Widar3.0 cross-domain
+  gesture; MM-Fi cross-subject pose) for the first time.
+- The leakage audit will make some existing internal numbers look worse. That
+  is the point.
+- Parsing a legacy binary format adds maintenance surface; mitigated by
+  fixture-based tests with synthetic, deterministically generated `.dat`
+  bytes (no dataset redistribution).
+- Widar's raw distribution is Intel 5300-specific; ESP32-captured data
+  continues through existing loaders. The protocols/leakage machinery is
+  loader-agnostic.
+
+## Validation
+
+- `cargo test -p wifi-densepose-train` — unit tests for the bfee parser
+  (truncated, corrupt, and valid synthetic fixtures), split determinism,
+  leakage-audit rejection cases, and mean-pose baseline math.
+- `cargo bench -p wifi-densepose-train` — criterion benchmark for parser
+  throughput and split assignment on synthetic corpora.
+- No accuracy numbers are claimed by this ADR; it delivers the machinery to
+  produce MEASURED ones.
@@ -0,0 +1,91 @@
+# ADR-292: Wideband 802.11ax CSI ingest — FeitCSI/AX210 adapter and subcarrier-agnostic plumbing
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-10
+- **Deciders**: ruv
+- **Tags**: hardware, csi, 80211ax, ax210, feitcsi, ingest, mat
+
+## Context
+
+RuView's CSI ingest (`wifi-densepose-mat/src/integration/hardware_adapter.rs`)
+supports ESP32 serial streams, the legacy Intel 5300 tool, and Atheros/Nexmon
+paths. All of these are 802.11n-class: ≤40 MHz bandwidth, ≤114 subcarriers,
+2.4/5 GHz.
+
+The 2026 research sweep found the field's center of gravity has moved to
+Intel AX200/AX210 NICs via PicoScenes (closed-source core) and FeitCSI
+(open-source, GPL): 802.11ax CSI at up to 160 MHz / 1992 subcarriers,
+including the 6 GHz band. This is both the research-grade tier today and the
+shape of the data 802.11bf silicon will deliver from ~2026 onward. RuView's
+`wifi-densepose-hardware` crate already models 802.11bf session types, but no
+ingest path can carry wideband CSI into the pipeline.
+
+Without a wideband path, RuView cannot develop against the best available
+signal, cannot compare ESP32-grade results to wideband upper bounds, and will
+meet 802.11bf silicon with no tested plumbing for >114-subcarrier frames.
+
+## Options considered
+
+1. **PicoScenes `.csi` ingest.** Rejected for now: the format is produced by a
+   closed-source core and is versioned/complex; parsing it without a
+   maintained spec invites silent corruption.
+2. **Raw pcap + radiotap parsing.** Rejected: duplicates what FeitCSI already
+   does on-device, and pulls a packet-capture dependency into the pipeline.
+3. **FeitCSI file/stream ingest.** Chosen: FeitCSI is open-source (its header
+   layout is auditable against the source), targets AX200/AX210, covers
+   20–160 MHz including 6 GHz, and emits a compact binary record per frame.
+
+## Decision
+
+Extend `v2/crates/wifi-densepose-mat/src/integration` with:
+
+### 1. `feitcsi` record parser
+
+- A validated parser for FeitCSI's binary CSI record layout (header with
+  CSI buffer length, rate/bandwidth/channel metadata, antenna counts, RSSI,
+  timestamp, followed by interleaved complex CSI). The parser is written
+  against the documented layout, is version-checked, and rejects
+  records whose declared dimensions disagree with the buffer length —
+  untrusted file/stream input is validated at the boundary.
+- Bounded allocation: a hard cap on subcarrier count (4096) and antenna
+  count (8) so a corrupt length field cannot cause unbounded allocation.
+
+### 2. `DeviceType::FeitCsi` in the hardware adapter
+
+- File-replay mode (read a recorded FeitCSI capture deterministically) and a
+  streaming mode fed by an external process writing to a path/pipe. No
+  privileged operations inside the crate: RuView does not configure the NIC;
+  FeitCSI's own tooling owns that, per least-authority.
+
+### 3. Subcarrier-agnostic plumbing
+
+- Ingest carries native subcarrier dimensionality end-to-end and converts to
+  pipeline width explicitly via the existing interpolation/decimation stage,
+  recording the native → pipeline mapping in frame metadata so downstream
+  consumers know the true spectral resolution. Bandwidth (20–160 MHz) and
+  band (2.4/5/6 GHz) become first-class frame metadata.
+
+## Consequences
+
+- RuView gains a research-grade wideband development path and a tested
+  ingest shape for future 802.11bf reporting (truncated CIR is a natural
+  extension of the same plumbing).
+- GPL FeitCSI is used as an external tool, never linked: only its output
+  format is parsed. No licensing contamination of the MIT workspace.
+- The parser tracks an external project's format; version checks fail loudly
+  on mismatch rather than misparse.
+- ESP32 remains the deployed sensor tier; wideband is a development/
+  validation tier. Accuracy claims from wideband captures must be tagged with
+  the capture hardware.
+
+## Validation
+
+- `cargo test -p wifi-densepose-mat` — parser tests over synthetic fixtures:
+  valid records at 20/80/160 MHz shapes, truncated buffer, dimension
+  mismatch, version mismatch, allocation-cap enforcement; adapter replay
+  determinism.
+- `cargo bench -p wifi-densepose-mat` — criterion benchmark for record parse
+  throughput at 1992-subcarrier frames.
+- Hardware validation on real AX210 silicon is explicitly out of scope for
+  this PR and remains required (per CLAUDE.md) before any capture-path
+  hardware claim; the file-replay path is testable without silicon.
@@ -0,0 +1,93 @@
+# ADR-293: Vitals ground-truth rig — reference ingest, time alignment, and agreement metrics
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-10
+- **Deciders**: ruv
+- **Tags**: vitals, validation, ground-truth, bland-altman, evidence, honesty
+
+## Context
+
+`wifi-densepose-vitals` (ADR-021) extracts breathing (0.1–0.5 Hz) and heart
+rate (0.8–2.0 Hz) from CSI. The 2026 research sweep found that every credible
+vitals result in the literature ships with reference-sensor ground truth
+(chest strap, pulse oximeter, ECG, or PSG), and that WiFi heart-rate numbers
+without stated scope (single person, static, line-of-sight, short range) are
+systematically misleading. RuView currently has no way to produce a MEASURED
+vitals number: there is no reference-signal ingest, no time alignment between
+CSI-derived estimates and a reference device, and no agreement statistics.
+
+CLAUDE.md requires accuracy statements to be tagged MEASURED (with a
+reproducer), CLAIMED, or SYNTHETIC. For vitals, MEASURED is currently
+unreachable.
+
+## Options considered
+
+1. **Live BLE/ANT+ integration with reference devices.** Rejected for now:
+   drivers and pairing are a hardware/product concern; the blocking gap is
+   the evaluation math, not the radio link.
+2. **File-based reference ingest + offline agreement analysis.** Chosen:
+   every consumer reference device (Polar, Garmin, oximeters) exports
+   timestamped series; a file boundary keeps the crate dependency-free and
+   the pipeline deterministic.
+
+## Decision
+
+Add a `groundtruth` module to `v2/crates/wifi-densepose-vitals`:
+
+### 1. Reference series ingest
+
+- `ReferenceSeries`: timestamped samples (unix millis + value) for one
+  measurand (`HeartRateBpm` or `BreathingRateBrpm`), with device metadata
+  (make/model, measurement principle). Parsed from CSV (`timestamp_ms,value`
+  with a header line); malformed rows are rejected with row-numbered errors —
+  untrusted file input validated at the boundary. Non-monotonic timestamps
+  are an error, not silently sorted.
+
+### 2. Time alignment
+
+- Constant-offset estimation by maximizing normalized cross-correlation of
+  the estimate series against the reference over a bounded lag window
+  (default ±30 s), on a common resampled grid (nearest-sample, no
+  interpolation of physiological values across gaps larger than a
+  configurable limit).
+- Optional linear clock-drift fit (offset + rate) for long sessions.
+  Alignment parameters are reported, never silently applied.
+
+### 3. Agreement metrics
+
+- `AgreementReport`: n paired samples, coverage fraction (time where both
+  series had valid samples), MAE, RMSE, mean error (bias), Bland–Altman
+  95% limits of agreement, and percentage-within-tolerance (configurable,
+  default ±2 bpm HR / ±1 brpm breathing).
+- Session scope is mandatory metadata: subject count, motion state
+  (static/moving), line-of-sight (LOS/NLOS/through-wall), distance band.
+  A report without scope cannot be constructed.
+
+### 4. Evidence tagging
+
+- `EvidenceGrade::Measured` is only constructible when the report carries a
+  reference device, non-zero paired samples, minimum coverage, and a
+  reproducer command string; otherwise the report grades as `Claimed` (real
+  data, no reference) or `Synthetic` (generated input). This mirrors
+  ADR-291's enforcement-in-types approach and the CLAUDE.md tagging rule.
+
+## Consequences
+
+- RuView can convert vitals claims from CLAIMED to MEASURED with a
+  reproducible offline analysis, session by session, scope by scope.
+- Honest reporting will likely show heart-rate performance below marketing
+  intuition, especially NLOS/moving — that is the purpose.
+- CSV ingest means a manual export step per session; acceptable at current
+  scale, and the format is the de-facto export of consumer reference gear.
+- No clinical claim is implied: agreement statistics against consumer
+  reference devices are engineering evidence, not medical validation.
+
+## Validation
+
+- `cargo test -p wifi-densepose-vitals` — CSV rejection cases, alignment
+  recovery of known synthetic offsets/drifts, agreement metrics against
+  hand-computed fixtures, evidence-grade constructibility rules.
+- `cargo bench -p wifi-densepose-vitals` — criterion benchmark for alignment
+  over hour-scale synthetic sessions.
+- Real-session validation (ESP32 capture + chest strap) remains a follow-up
+  requiring hardware evidence per CLAUDE.md.
@@ -0,0 +1,83 @@
+# ADR-294: WiFi Veil integration — emission-shaping countermeasure as an advisory BFLD dependency
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-10
+- **Deciders**: ruv
+- **Tags**: privacy, bfld, bfi, wifi-veil, countermeasure, dependency
+
+## Context
+
+RuView's BFLD layer (ADR-118, ADR-141) senses via beamforming feedback while
+enforcing structural privacy invariants on data entering the node. The 2026
+research sweep identified the complementary, unaddressed surface: a node's own
+*outgoing* BFI is unencrypted and enables passive third-party
+re-identification (BFId, ACM CCS 2025); IEEE 802.11bf-2025 shipped with no
+privacy mechanism; and no commercial product occupies the countermeasure
+category.
+
+[`wifi-veil`](https://github.com/ruvnet/wifi-veil) (codename VEIL, extracted
+from this monorepo as a standalone crate) models a compliant emission-shaping
+defense: keyed Givens rotations over the fine subspace of compressed
+beamforming reports, energy-preserving (never jamming), reversible by a
+keyed legitimate receiver. The crate is dependency-free, deterministic,
+std-only, WASM-ready, dual MIT/Apache-2.0, and explicitly SYNTHETIC/L0: it
+models waveform controls and never drives a radio.
+
+RuView should consume this capability rather than re-implement it, giving the
+sensing stack a defensive counterpart under one evidence regime.
+
+## Options considered
+
+1. **Vendor the veil sources into a RuView crate.** Rejected: forks the
+   witness-pinned upstream and duplicates maintenance.
+2. **crates.io dependency.** Not yet available (v0.1.0 unpublished at
+   decision time); revisit when released.
+3. **Git dependency pinned to an exact rev, feature-gated in
+   `wifi-densepose-bfld`.** Chosen.
+
+## Decision
+
+- Add `wifi-veil` to `v2/Cargo.toml` `[workspace.dependencies]` as a git
+  dependency pinned to rev `018468b5d2bf41f35c552910f35659830af0eb91`
+  (v0.1.0). Exact-rev pinning preserves provenance and reproducibility for a
+  pre-release upstream; bumping the rev is an explicit, reviewable change.
+- Gate it in `wifi-densepose-bfld` behind a new `veil` feature
+  (`veil = ["std", "dep:wifi-veil"]`), off by default — the default build
+  remains dependency-light and unchanged.
+- New `bfld::veil` module (advisory-only):
+  - `ShieldAssessment`: stable projection of wifi-veil's deterministic
+    attacker-vs-protector `ExperimentReport` (re-ID accuracy shield-off/on,
+    chance level, throughput ratio, energy-conservation audit), always
+    carrying the `SYNTHETIC/L0` evidence label.
+  - `assess` / `assess_default`: run the deterministic experiment.
+  - `optimized_shield`: wrap `hyper_optimize` to derive the
+    optimizer-shipped shield config plus its verifying assessment.
+- Boundaries, stated structurally and in docs:
+  - **Advisory only.** Nothing in the integration emits RF, alters frames,
+    or relaxes any BFLD gate/invariant (I1–I3 untouched).
+  - **Evidence honesty.** Every veil-derived figure is labeled
+    `SYNTHETIC/L0`; no MEASURED claim is possible from this path (hardware
+    validation lives in wifi-veil's own P5 roadmap).
+  - ESP32 nodes cannot shield their own feedback (per wifi-veil's platform
+    matrix); the integration therefore informs posture and reporting, not
+    on-node emission control.
+
+## Consequences
+
+- RuView gains a sense-and-defend posture no commercial offering has, under
+  a single claim taxonomy.
+- First git dependency in the workspace: builds now fetch one pinned
+  external rev. Acceptable: the crate is dependency-free, small, witness-
+  pinned upstream, and license-compatible (MIT OR Apache-2.0 into MIT).
+- Feature-gated consumers (e.g. sensing-server privacy reporting, the
+  desktop UI) can surface shield assessments later without new deps.
+- When wifi-veil publishes to crates.io, switch the workspace entry to a
+  version requirement in a follow-up ADR amendment.
+
+## Validation
+
+- `cargo test -p wifi-densepose-bfld --features veil` — determinism,
+  shield-reduces-re-ID, compliance (energy conservation), chance-band
+  attainment, evidence labeling, optimizer wrapper.
+- `cargo test -p wifi-densepose-bfld` (default features) — unchanged
+  behavior with the feature off.
@@ -0,0 +1,64 @@
+# ADR-295: Source provenance state machine — synthetic can never present as live
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: provenance, honesty, ui, sensing-server, security
+
+## Context
+
+An August 2026 external review found two provenance defects on the release
+path:
+
+1. The pose-fusion simulator starts in demo mode; on any page port other than
+   3000 the WebSocket target falls back to `localhost:8765`, and if the
+   connection fails the simulator keeps running while the status still reads
+   "ready" — producing a convincing moving visualization with no live CSI
+   (issue 1557).
+2. The main sensing client labels the source **live** when the authenticated
+   status endpoint returns an error for lack of authorization, until a real
+   frame happens to correct it (issue 1526).
+
+The common root cause: source state is a boolean (live vs not), so "unknown"
+collapses to "live". CLAUDE.md requires MEASURED/CLAIMED/SYNTHETIC labeling
+and forbids presenting synthetic output as real.
+
+## Decision
+
+Define one canonical, mutually exclusive `SourceState` enum shared by the
+sensing server and every UI/client that renders a source:
+
+- `Synthetic` — generated data (simulator/replay of synthetic fixtures).
+- `LiveVerified` — frames from an authenticated, attested source.
+- `LiveUnverified` — frames arriving but provenance not yet confirmed.
+- `Stale` — last frame older than a configured freshness window.
+- `Disconnected` — no source.
+
+Rules enforced structurally:
+
+- **`Unknown` is not a state.** Any ambiguous condition resolves to
+  `LiveUnverified`, `Stale`, or `Disconnected` — never `LiveVerified`.
+- A status-endpoint error resolves to `Disconnected`/`LiveUnverified`, never
+  live-verified.
+- The simulator constructs `Synthetic` and cannot transition to any `Live*`
+  state without a verified frame.
+- `Synthetic` is watermarked in every view and every export.
+- Transitions are a pure function of (last-frame-age, auth-status,
+  source-kind) so they are unit-testable without a clock or a socket.
+
+Scope of this PR: the shared `SourceState` type + transition function + tests
+in the sensing server, and wiring of the two identified surfaces (pose-fusion
+simulator status, sensing client source label). Broader UI adoption follows.
+
+## Consequences
+
+- Closes the "synthetic shown as live" and "unknown shown as live" classes.
+- A small breaking change to any consumer currently reading a boolean source
+  flag; mitigated by exposing a compatibility accessor during migration.
+
+## Validation
+
+- Unit tests for every transition, especially: auth-error → not-live;
+  simulator → never live without a verified frame; freshness expiry → `Stale`;
+  watermark present on synthetic export.
+- `cargo test -p wifi-densepose-sensing-server`.
@@ -0,0 +1,59 @@
+# ADR-296: Sensor data-plane hardening — UDP bind control and source allowlist (step one)
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: security, udp, sensor-ingest, sensing-server
+
+## Context
+
+The CSI UDP receiver binds `0.0.0.0:{udp_port}` unconditionally
+(`main.rs:5706`), with no equivalent of the HTTP `--bind-addr` flag (which
+correctly defaults to `127.0.0.1`), no source allowlist, no message
+authentication, no device identity, and no replay defense. Any host that can
+reach the UDP port can inject a valid-shaped frame, flip an auto-detecting
+server into a live source state, and influence presence/vital/automation
+outputs (issue 1394).
+
+An IP allowlist does not stop LAN spoofing, but bind control plus an allowlist
+is the correct, shippable first step; per-device keys + authenticated
+encryption + monotonic sequence + freshness window + replay rejection is the
+full fix and is larger.
+
+## Decision
+
+**This PR (step one):**
+
+- Add `--udp-bind` (env `RUVIEW_UDP_BIND`), **defaulting to `127.0.0.1`**.
+  Binding to a routable address is now an explicit operator choice, mirroring
+  the HTTP path. Desktop/appliance defaults stay loopback.
+- Add an optional source IP/CIDR allowlist (`--udp-allow`); when set, frames
+  from other sources are dropped and counted. Loopback is always allowed.
+- Emit a startup security log line stating the bind scope and whether an
+  allowlist is active; refuse a routable bind without an allowlist unless an
+  explicit `--udp-insecure-lan` override is passed (parallel to the existing
+  Docker HTTP refusal).
+- Publish a `SECURITY.md`/advisory note describing the threat model and safe
+  deployment.
+
+**Explicitly deferred to a follow-up ADR (step two):** per-device provisioned
+keys, MAC/AEAD, device identifiers, monotonic sequence numbers, freshness
+window, and replay rejection. This ADR documents that gap rather than
+implying the data plane is authenticated.
+
+## Consequences
+
+- Removes the default open-to-LAN exposure with a one-line-safe default.
+- Not spoof-proof on a trusted LAN — the advisory says so plainly, and the
+  override name (`--udp-insecure-lan`) makes the residual risk legible.
+- A behavior change for anyone relying on the old implicit `0.0.0.0` default;
+  called out in the changelog and the startup log.
+
+## Validation
+
+- Unit tests: default bind is loopback; routable bind without allowlist is
+  refused unless overridden; allowlist accept/drop with counting; loopback
+  always allowed.
+- `cargo test -p wifi-densepose-sensing-server`.
+- Real-silicon validation of the LAN path remains required before any
+  deployment claim.
@@ -0,0 +1,58 @@
+# ADR-297: Multi-node semantic correctness — per-node inference, node-keyed rate limiting, stale state
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: multi-node, mqtt, home-assistant, correctness, sensing-server
+
+## Context
+
+The external review confirmed three defects on the multi-node path — the core
+mechanism RuView uses to reduce blind spots and room dependence:
+
+1. The active `NodeInfo` payload carries RSSI/position/subcarrier/sync but **no
+   per-node classification**; the MQTT mapper reads `node.classification` and
+   falls back to the room aggregate when absent, so every node can publish the
+   same aggregate presence value (issues 1540, 1554).
+2. The MQTT `RateLimiter` is keyed by `EntityKind` only
+   (`mqtt/state.rs:65`), so one node consumes the numeric publish slot and the
+   others are suppressed until the interval expires, while availability still
+   says online (issue 1541).
+3. In the UDP vital path, top-level classification is taken from the
+   latest-arriving node while other features are fused, so with disagreeing
+   nodes room presence can flip at packet frequency (issue 1555).
+
+## Decision
+
+- **Separate the types.** Introduce `NodeInference` (per-node classification +
+  confidence + freshness) distinct from `RoomInference` (the fused room
+  aggregate). `NodeInfo` carries a `NodeInference`; the room aggregate is
+  computed explicitly and never overwrites node state. No silent fallback from
+  node to room.
+- **Key the rate limiter by (node, entity).** `RateLimiter` becomes keyed on
+  `(NodeId, EntityKind)` so nodes no longer starve each other; per-entity
+  behavior per node is preserved.
+- **Deterministic fusion.** Room classification is a pure function of the set
+  of current per-node inferences (e.g. freshness-weighted vote), not
+  last-writer-wins; identical inputs yield identical room state.
+- **Stale entities cannot stay online.** An entity whose backing node has not
+  reported within N expected publish intervals transitions to unavailable/
+  stale rather than holding a frozen value while availability says online.
+
+## Consequences
+
+- Multi-node HA/MQTT output becomes semantically correct; distinct nodes
+  report distinct state and no longer suppress one another.
+- Schema change to `NodeInfo`/the MQTT contract; existing single-node
+  deployments keep working (one node = one inference). Consumers reading the
+  old aggregate-only shape need the migration accessor.
+- Aligns with ADR-295 (freshness) and the review's call for one canonical
+  `NodeInference`/`RoomInference` contract.
+
+## Validation
+
+- Unit/integration tests: per-node classification round-trips through the MQTT
+  mapper with no room fallback; two nodes with different rates both publish
+  (no starvation); disagreeing nodes produce deterministic, non-flapping room
+  state; a silent node's entities go stale, not frozen-online.
+- `cargo test -p wifi-densepose-sensing-server`.
@@ -0,0 +1,60 @@
+# ADR-298: Model release sanity gates — block degenerate and mislabeled model artifacts
+
+- **Status**: Accepted — initial implementation (this PR)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: models, evaluation, release-gate, honesty, presence
+
+## Context
+
+The external review (corroborating issue 1521) showed the published presence
+head is mathematically degenerate: with L2-normalized embeddings, a weight
+norm ≈ 3.67 against a bias ≈ 8.19 makes the smallest possible logit positive,
+so predicted presence probability is ≥ ~0.989 for every valid input — the
+decision boundary is unreachable and the head is effectively constant. The
+README then labeled a temporal-triplet accuracy (a representation-ordering
+metric) as "presence accuracy" — a category error.
+
+Nothing in the release path catches a constant classifier, an unreachable
+boundary, or a metric-name mismatch. A machine check would have.
+
+## Decision
+
+Add a `model_gates` module (in `wifi-densepose-train`) plus a CI gate that,
+for any classifier artifact proposed for release, fails on:
+
+- **Constant output** — output variance below a threshold across a diverse
+  probe set (including the degenerate-embedding probe from issue 1521).
+- **Unreachable decision boundary** — for a normalized-embedding linear head,
+  check whether `bias` sign dominates `‖weight‖` so the logit cannot change
+  sign; fail if the boundary is analytically unreachable.
+- **Degenerate class balance** — predicted-positive rate at/above a ceiling
+  (e.g. > 99%) on a balanced probe set.
+- **Missing/blank baseline** — a report without a paired mean-pose/majority
+  baseline (ties into ADR-291 `EvaluationReport`).
+- **Metric-name provenance** — a metric may not be surfaced under a task name
+  that does not match its computed kind (temporal-triplet ≠ presence);
+  enforced by making the metric carry its kind and the label derive from it.
+
+Each gate emits a structured, human-readable failure explaining the defect and
+the offending numbers.
+
+## Consequences
+
+- The specific degenerate presence head cannot ship again, and the
+  temporal-triplet-as-presence mislabel is structurally prevented.
+- Some existing artifacts will fail the gate on introduction — intended; they
+  should fail.
+- The gate is heuristic, not a correctness proof; it catches the known
+  failure shapes, not all bad models.
+
+## Validation
+
+- Unit tests: the issue-1521 weights fail the unreachable-boundary and
+  constant-output gates; a healthy synthetic head passes; a temporal-triplet
+  metric cannot be constructed with a presence label.
+- `cargo test -p wifi-densepose-train`; the CI gate runs in the model-check
+  workflow.
+- This ADR does **not** withdraw the already-published artifact (an
+  outward-facing action requiring maintainer sign-off) — it prevents
+  recurrence and documents the model-card correction.
@@ -0,0 +1,52 @@
+# ADR-299: Repository CSI data-incident controls — ignore rules and a pre-commit/CI policy check
+
+- **Status**: Accepted — controls and current-tree remediation implemented; history coordination pending
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: privacy, data-governance, ci, security, incident
+
+## Context
+
+The external review found ~64.6 MB of tracked raw CSI recordings under
+`data/recordings/` and `v2/data/recordings/` (largest an ~61.8 MB overnight
+capture). CLAUDE.md explicitly prohibits committing CSI or person data. The
+`.gitignore` rule pointed only at a pre-rename path
+(`rust-port/wifi-densepose-rs/data/recordings/`) and did not cover the active
+directories, which is how the captures were committed. Raw CSI is person data
+(it encodes breathing, movement, presence), so this is a data incident, not a
+formatting nit.
+
+## Decision
+
+**Implemented now (mechanical, no data-ownership judgment):**
+
+- Fix `.gitignore` to cover `data/recordings/`, `v2/data/recordings/`, the
+  legacy path, and `*.csi.jsonl` / `*.csi.meta.json` globs (done in this PR).
+- Add a policy check (pre-commit hook + CI job) that fails when CSI-format
+  files (`*.csi.jsonl`, `*.csi.meta.json`) or large JSONL captures are staged
+  or present as tracked files, with a message pointing here. Tests may use
+  only synthetic or expressly-consented minimal fixtures.
+
+**Owner-authorized current-tree remediation (2026-08-15):**
+
+- The data owner authorized removal of the six known CSI capture and metadata
+  files from the current tree. The removal is recoverable from Git history and
+  does not claim to erase existing clones, forks, caches, or release artifacts.
+- Any history rewrite remains a separate coordinated incident-response action.
+  It requires an inventory of affected refs and releases, downstream notice,
+  credential and artifact review, and an explicit execution plan.
+
+## Consequences
+
+- No new CSI captures can be committed (ignore + policy check).
+- The six known tracked recordings are absent from the current tree. Historical
+  copies remain until a separately authorized and coordinated history rewrite.
+- CI gains one fast policy job; contributors get a local pre-commit check.
+
+## Validation
+
+- Policy-check unit tests: a staged `*.csi.jsonl` fails; a synthetic fixture
+  under an allowed test path passes; the check is deterministic and offline.
+- Manual confirmation that the new ignore globs cover both active directories.
+- `bash scripts/csi-data-policy-check.sh --tracked` passes after the authorized
+  current-tree removal.
@@ -0,0 +1,189 @@
+# ADR-300: RuView perception substrate — a phased program for the calibration, evidence, trust, and deployment layer
+
+- **Status**: Accepted — program framing; child ADRs carry their own status
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: program, architecture, calibration, evidence, provenance, fusion, fleet, epic
+
+## Context
+
+Three independent analyses converged on the same conclusion in 2026: a deep
+research sweep of the WiFi-sensing state of the art, an external technical and
+industry review, and an internal strategic assessment. All three found that
+RuView's gap is **not another sensing modality** but the horizontal layer that
+turns RF research into repeatable spatial infrastructure — measurement,
+calibration, out-of-distribution awareness, evidence accounting, authenticated
+identity, a canonical spatial model, and fleet deployment.
+
+Several of these primitives already have foundations in the tree and should be
+**unified and made to produce signed, expiring certificates**, not rebuilt:
+
+- `wifi-densepose-calibration` (enrollment, bank, anchor, runtime, specialist).
+- `frame::EvidenceLevel` L0–L5 as mandatory policy (ADR-282).
+- AetherArena benchmark infrastructure — v0 complete, CI-gated, witness ledger,
+  live HF Space (ADR-149); board intentionally empty (benchmark-first).
+- RuField provenance/signature types (ADR-260/262/277/279) and BFLD
+  attestation (ADR-141).
+- `worldgraph` crate; `wifi-densepose-mat/tracking` (tracker, fingerprint).
+- The in-flight ADR-295 (provenance state machine), ADR-296 (authenticated
+  data plane, step one), ADR-298 (model sanity gates) — the first bricks.
+
+## What RuView is optimizing for
+
+Not inference capability — **epistemic reliability**:
+
+```
+signal → observation → calibration → inference → uncertainty → evidence
+       → certificate → policy → governed action
+```
+
+That pipeline is the product. The defensible category is not "RuView perceives
+the physical world" but "RuView determines what machines are justified in
+believing about it, proves why, and constrains what they may do with that
+belief."
+
+### Four non-negotiable program rules
+
+Every child ADR and implementation is bound by these:
+
+1. **UNKNOWN is a first-class output, never an error condition.** A surface that
+   cannot answer says UNKNOWN and stays legible; it does not throw, default to a
+   confident class, or silently hold a stale value.
+2. **Capability certificates bind cryptographically.** Hardware, environment,
+   model, calibration, metrics, expiry, and evidence level are bound under one
+   signature (ADR-318/ADR-305). An unsigned or partially-bound certificate is
+   not a certificate.
+3. **One canonical semantics downstream.** Every surface (MQTT, REST, WebSocket,
+   RuField, Matter, agents, UI) consumes the same Observation → Inference →
+   GovernedEvent types (ADR-306). No transport- or UI-specific reinterpretation.
+4. **Benchmarks expose worst-domain performance and confidence intervals.**
+   Pooled accuracy is never sufficient for promotion (ADR-317).
+
+### Certificate conditionality (the staleness guard)
+
+The central architectural risk is **certificate staleness**: a room can remain
+syntactically calibrated while its RF distribution has drifted enough to
+invalidate the certificate. Therefore a capability certificate is **conditional
+on a continuously evaluated domain signature** (ADR-302), not a one-time stamp.
+Crossing the OOD threshold automatically degrades state and triggers
+recalibration rather than silently continuing:
+
+```
+VALID → DEGRADED → UNKNOWN   (auto-degrade on domain drift; triggers recalibration)
+```
+
+This binds ADR-301 (calibration), ADR-302 (OOD), ADR-318 (certificate), and
+ADR-321 (policy): a degraded/unknown domain must invalidate the affected
+capability *before* a false confident inference reaches an actuator.
+
+### Commercial framing — three primitives, not one product
+
+- **RuView Runtime** — provides perception.
+- **RuView Certify** — establishes what a deployment can legitimately claim
+  (calibration + evidence + capability certificate + policy).
+- **RuView Trust / Fleet** — keeps that claim valid across hardware, firmware,
+  models, and environmental drift (ADR-316).
+
+Certify and Trust are the parts that are hard to commoditize; presence
+detection alone is not.
+
+## Decision
+
+Adopt a **21-primitive phased program**. Each primitive gets a child ADR
+(ADR-301…ADR-321) that owns its detailed decision, status, and validation.
+This ADR owns the framing, the dependency order, and the phase assignment.
+
+### Primitive → ADR map
+
+| # | Primitive | ADR | Phase |
+|---|---|---|---|
+| 1 | Automatic domain calibration | ADR-301 | 1 |
+| 2 | Out-of-distribution detection | ADR-302 | 1 |
+| 3 | Ground-truth synchronization | ADR-303 | 2 |
+| 4 | Evidence engine | ADR-304 | 1 |
+| 5 | Authenticated sensor identity | ADR-305 | 1 |
+| 6 | Canonical spatial ontology | ADR-306 | 1 |
+| 7 | Persistent identity & tracking | ADR-307 | 2 |
+| 8 | Sensor placement optimizer | ADR-308 | 3 |
+| 9 | Active sensing | ADR-309 | 3 |
+| 10 | 802.11bf-native architecture | ADR-310 | 2 |
+| 11 | Real sensor fusion | ADR-311 | 2 |
+| 12 | Long-term spatial memory | ADR-312 | 3 |
+| 13 | Counterfactual inference | ADR-313 | 3 |
+| 14 | Information-gain scheduler | ADR-314 | 3 |
+| 15 | Digital RF twin | ADR-315 | 3 |
+| 16 | Fleet control plane | ADR-316 | 2 |
+| 17 | Real benchmark service (multi-domain scorecard) | ADR-317 | 1 |
+| 18 | Capability certificates | ADR-318 | 1 |
+| 19 | Witness chain | ADR-319 | 1 |
+| 20 | RuView sensor HAL | ADR-320 | 2 |
+| 21 | Decision policy — action authorization | ADR-321 | 1 |
+
+### Dependency order (why phase, not score, drives sequencing)
+
+```
+        ADR-306 spatial ontology ──┐
+        ADR-305 auth identity ─────┼──► ADR-301 calibration cert ──► ADR-302 OOD gating
+                                   │             │                        │
+                                   └──► ADR-319 witness chain             │ (VALID→DEGRADED→UNKNOWN)
+                                                 │                        ▼
+                                   ADR-304 evidence engine ──► ADR-318 capability certificate
+                                                 │                        │ (conditional on domain signature)
+                                                 │                        ▼
+                                                 │              ADR-321 decision policy ──► governed action
+                                                 └──► ADR-317 benchmark scorecard (per-PR gate)
+```
+
+- **Phase 1 (the certificate spine, built now):** foundational roots 303, 302,
+  301, 298 (implemented first, in their own crates); then the dependent wave
+  316, 299, 315, 314, 318. This set is exactly the acceptance test decomposed
+  and is buildable without new hardware (types, logic, signatures, tests). The
+  dependent wave adds the staleness guard (299 auto-degrades 315) and the
+  action gate (318) that denies at the actuator on a degraded/unknown domain.
+- **Phase 2 (integration & operations):** 300 ground truth, 304 tracking, 307
+  802.11bf-native, 308 fusion, 313 fleet, 317 HAL. Depends on the spine.
+- **Phase 3 (higher-ceiling, research-forward):** 305 placement optimizer, 306
+  active sensing, 309 spatial memory, 310 counterfactual, 311 info-gain
+  scheduler, 312 RF twin. Sit on top of the fused world state.
+
+Phase-2 and phase-3 child ADRs are authored as **Proposed** (design intent,
+validation plan) and are not implemented by the phase-1 swarm.
+
+### Acceptance test A — onboarding (from the strategic assessment)
+
+> Connect a new sensor type in an unseen room. Within 30 minutes RuView should
+> identify the hardware (HAL, ADR-320), calibrate the environment (ADR-301),
+> quantify whether it can reliably sense the requested phenomenon (ADR-302),
+> generate a signed capability certificate (ADR-318), expose governed spatial
+> events (ADR-306), and return UNKNOWN whenever evidence falls outside that
+> certificate (ADR-302).
+
+### Acceptance test B — drift invalidation (the staleness guard)
+
+> Deliberately change the room after certification — move furniture, change the
+> AP channel, or substitute hardware. RuView should detect distribution drift
+> (ADR-302), invalidate the affected capability (ADR-318) **before** a false
+> confident inference reaches an actuator (ADR-321 denies with the specific
+> failed condition), emit UNKNOWN, preserve the complete witness chain
+> (ADR-319), and explain exactly which certificate condition failed.
+
+Test B is the load-bearing one: it proves the substrate fails safe, not just
+that it perceives well. Phase 1 makes every clause except HAL testable in
+software; HAL (phase 2)
+closes the "identify the hardware" clause.
+
+## Consequences
+
+- One coherent substrate replaces overlapping ad-hoc schemas; every surface
+  (MQTT, REST, WebSocket, RuField, Matter, agents) eventually consumes the
+  ADR-306 ontology and the ADR-318 certificate.
+- Headline applications (pose/vitals/pointcloud models) are explicitly **not**
+  the investment focus during this program, per the strategic direction.
+- Later ADRs may be revised as the spine lands; that is expected for a phased
+  program and is why phase-2/3 ADRs ship as Proposed.
+
+## Validation
+
+- Each child ADR defines its own tests. The program-level exit is the
+  acceptance test above, run end-to-end once phase 1 lands, and encoded as an
+  AetherArena scenario (ADR-317).
@@ -0,0 +1,149 @@
+# ADR-301: Automatic domain calibration — signed, versioned, invalidatable room fingerprint
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: calibration, provenance, drift, evidence, honesty, substrate
+
+## Context
+
+This ADR is primitive 1 of the perception-substrate program (ADR-300) and the
+first brick of that program's "certificate spine" (ADR-300 phase 1). It depends
+on the canonical spatial ontology (ADR-306) to name *which space* it
+characterizes, on authenticated sensor identity (ADR-305) to bind a fingerprint
+to *which signed device* produced it, and on the witness chain (ADR-319) to
+anchor the resulting artifact. Its output is consumed directly by
+out-of-distribution detection (ADR-302).
+
+WiFi sensing is only reproducible inside the environment it was tuned for.
+Multipath, furniture geometry, transceiver placement, and AP channel all shape
+the CSI distribution, so a model that reads a room correctly one week can drift
+silently the next. RuView already has the raw ingredients for room-aware
+sensing but not a single portable, signed, expiring artifact that says "this is
+the room, here is when it was measured, and here is the evidence that it is
+still the same room."
+
+Existing scaffolding to build on, not rebuild (`v2/crates/wifi-densepose-calibration`):
+
+- `enrollment` / `anchor` — guided human anchors with an adaptive quality gate.
+- `bank` / `specialist` / `runtime` — a versioned bank of small specialist
+  models and a confidence-gated mixture runtime (`RoomState`), including the
+  crate's existing honest `STALE` degradation when the ADR-135 empty-room
+  baseline drifts.
+- `geometry` / `geometry_embedding` — transceiver-geometry record and its
+  fixed-length conditioning featurization (ADR-152).
+
+What is missing is (a) an *automatic* observe-only characterization phase that
+does not require a human enrollment ritual, (b) empty-vs-occupied baseline
+separation as a first-class pair, (c) a signed, versioned, comparable
+`CalibrationCertificate` artifact, and (d) explicit invalidation on drift rather
+than a soft `STALE` flag buried in the runtime.
+
+## Options considered
+
+1. **Keep calibration internal to the runtime (status quo).** Rejected: the
+   room characterization exists only as in-process state; it cannot be signed,
+   shipped, compared across time, or presented as evidence to ADR-302/ADR-318.
+2. **Build a new calibration crate.** Rejected: `wifi-densepose-calibration`
+   already owns enrollment, the specialist bank, geometry embedding, and the
+   baseline-drift concept. A parallel crate would fork the room model.
+3. **Extend `wifi-densepose-calibration` with an automatic characterization
+   phase and a signed certificate artifact.** Chosen.
+
+## Decision
+
+Extend `v2/crates/wifi-densepose-calibration` with an `autocal` characterization
+phase and a `certificate` artifact module. The target UX is:
+
+> install → observe (~10 min) → room fingerprint → calibration certificate →
+> sensing.
+
+### 1. Automatic characterization (`autocal`)
+
+- An observe-only pass (default ~10 minutes, configurable) that collects CSI
+  without requiring guided human anchors, reusing the `anchor` quality gate to
+  reject frames it cannot trust. It layers on the existing ADR-135 empty-room
+  baseline rather than replacing it.
+- Produces a `RoomFingerprint`: a bounded, fixed-length statistical summary of
+  the room's CSI distribution (subcarrier amplitude/phase moments, multipath
+  structure, occupancy-band energy), plus the `geometry_embedding` when a
+  geometry record is present. The fingerprint is the distance-comparable object
+  ADR-302 measures against; its schema is versioned.
+
+### 2. Empty / occupied baseline pair
+
+- Characterization establishes a paired baseline: an **empty** distribution
+  (no occupant motion) and an **occupied** distribution (motion present),
+  separated by the existing occupancy signal rather than a manual label. Both
+  are stored on the fingerprint so downstream OOD gating can distinguish "the
+  empty room changed" (furniture/geometry drift) from "occupancy statistics
+  changed" (different subject dynamics).
+
+### 3. `CalibrationCertificate` artifact
+
+- A serializable `CalibrationCertificate` binding: the `RoomFingerprint`; a
+  space identifier from the ADR-306 ontology; the signing sensor identity from
+  ADR-305; `captured_at_unix_s`; a monotonic `version`; a schema version; the
+  calibration `tier`; and an `EvidenceLevel` (L0–L5, ADR-282) — an automatic
+  characterization on real captured CSI is at most L1/L2 and is labelled as
+  such, never L3+.
+- The certificate is **signed** using RuField provenance/signature types
+  (ADR-260/262/277/279) and anchored in the witness chain (ADR-319). Signature
+  and witness anchoring are mandatory: an unsigned certificate is not a valid
+  certificate.
+- Two certificates for the same space are **comparable**: `distance(a, b)`
+  returns a bounded fingerprint distance, which is the primitive ADR-302 uses
+  to gate KNOWN → DEGRADED → UNKNOWN.
+
+### 4. Invalidation and continuous drift compensation
+
+- A certificate carries an explicit validity policy: it is invalidated when
+  fingerprint distance against live traffic exceeds a threshold, when the AP
+  channel or transceiver geometry changes, when the signing device identity
+  changes, or on age expiry. Invalidation is an explicit state transition that
+  emits a witness record (ADR-319), not a silent `STALE` flag.
+- Continuous drift compensation runs as a bounded online update of the
+  fingerprint within a **compatibility envelope**: small drift is absorbed and
+  logged; drift beyond the envelope invalidates the certificate and forces
+  re-characterization. Compensation never silently rewrites a signed
+  certificate — it produces a new version, preserving the append-only history.
+
+### Provenance and honesty discipline
+
+- No accuracy number is claimed by this ADR; it delivers the artifact and the
+  distance/invalidation machinery. Any certificate produced from generated CSI
+  is L0/`Synthetic` by construction; the constructor rejects labelling
+  synthetic characterization as measured (ADR-279 invariant 6, ADR-282 ladder).
+- Certificates never leave the edge except through the governed control plane
+  (ADR-277); a room fingerprint is treated as potentially sensitive spatial
+  data, not free telemetry.
+
+## Consequences
+
+- Room characterization becomes a portable, signed, versioned artifact that
+  ADR-302 (OOD), ADR-318 (capability certificates), and ADR-317 (benchmark)
+  can consume without re-deriving room state.
+- The automatic observe-only path lowers deployment friction (no mandatory
+  enrollment ritual) but yields a weaker evidence level than guided enrollment;
+  the certificate states which path produced it so consumers can weight it.
+- Explicit invalidation means RuView will sometimes refuse to sense a changed
+  room until re-characterization. That refusal is the intended honest behavior,
+  surfaced by ADR-302, not a regression.
+- The existing enrollment/bank/runtime path is preserved; `autocal` is an
+  additional entry point that produces the same `RoomFingerprint` object the
+  guided path can also emit.
+
+## Validation
+
+- `cargo test -p wifi-densepose-calibration` — fingerprint determinism from
+  fixed synthetic CSI; empty/occupied separation on synthetic occupancy;
+  certificate signing/verification round-trip and tamper rejection;
+  `distance()` monotonicity on progressively perturbed fixtures; invalidation
+  transitions (channel change, geometry change, age, drift-envelope breach)
+  each emit the expected witness record; constructor rejects synthetic→measured
+  mislabeling.
+- Cross-ADR: an ADR-302 test consumes a certificate and asserts the gating
+  state transitions on a drifted fingerprint.
+- Real-silicon characterization (ESP32 capture over a real 10-minute window)
+  remains a follow-up requiring hardware evidence per CLAUDE.md; a successful
+  build or synthetic run is not hardware evidence.
@@ -0,0 +1,135 @@
+# ADR-302: Out-of-distribution detection — KNOWN / DEGRADED / UNKNOWN gating
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: ood, calibration, uncertainty, quality, evidence, honesty, substrate
+
+## Context
+
+This ADR is primitive 2 of the perception-substrate program (ADR-300) and part
+of the phase-1 certificate spine. It sits directly downstream of automatic
+domain calibration (ADR-301): the `CalibrationCertificate` and its
+`RoomFingerprint` are the reference distribution this ADR measures against. It
+reuses fusion-layer quality scoring (ADR-137) as one of its inputs and feeds
+its state into the evidence engine (ADR-304) and capability certificates
+(ADR-318).
+
+The central unsolved problem of WiFi sensing is cross-domain generalization: a
+model trained (or calibrated) in one room degrades unpredictably in another, or
+in the same room after furniture moves, the AP changes channel, or the radio
+hardware is swapped. A model that keeps returning confident classifications
+under these conditions is the single most misleading failure mode in the field,
+and it is the failure the strategic assessment (ADR-300) named explicitly.
+Confidence alone is insufficient: a softmax head is perfectly capable of being
+confidently wrong on out-of-distribution input. RuView must be able to say
+"I do not recognize this situation" instead of guessing.
+
+Today RuView has partial signals but no unified gate:
+
+- ADR-301 produces a comparable `RoomFingerprint` and a `distance()` metric.
+- ADR-137 `QualityScore` carries fusion coherence, evidence references, and
+  contradiction flags per fused frame.
+- Model heads emit confidence/uncertainty, but nothing combines domain
+  distance, signal quality, calibration compatibility, and uncertainty into a
+  single decision, and nothing forces a model to stop emitting confident labels
+  when it leaves its calibrated domain.
+
+## Options considered
+
+1. **Threshold on model confidence alone.** Rejected: confidently-wrong OOD
+   predictions are exactly the failure mode; confidence is necessary but not
+   sufficient.
+2. **A per-model bespoke OOD check inside each task head.** Rejected:
+   duplicates logic, cannot be audited uniformly, and does not compose with the
+   calibration certificate or the evidence engine.
+3. **A shared OOD gate that every inference passes through, fusing four signals
+   against the ADR-301 certificate.** Chosen.
+
+## Decision
+
+Add an out-of-distribution gate — implemented in a shared crate consumed by the
+task-head runtime (`wifi-densepose-calibration::runtime` and the model serving
+path) — that attaches a `DomainState` to **every** inference.
+
+### 1. Four inputs, one decision
+
+Each inference carries four measured quantities:
+
+1. **Domain distance** — fingerprint distance (ADR-301 `distance()`) between
+   live traffic and the active `CalibrationCertificate`, split into the
+   empty-baseline and occupied-baseline components so geometry drift and
+   occupancy-statistics drift are distinguishable.
+2. **Signal quality** — reuse the ADR-137 quality scoring signals (fusion
+   coherence, contradiction flags) plus per-frame SNR/validity.
+3. **Calibration compatibility** — is a valid, non-invalidated certificate
+   present for this space (ADR-306) and this signed device (ADR-305)? An
+   expired, invalidated, or device-mismatched certificate is itself a
+   compatibility failure.
+4. **Uncertainty** — the model head's own predictive uncertainty.
+
+### 2. State machine: KNOWN → DEGRADED → UNKNOWN
+
+- **KNOWN** — domain distance within the certificate's compatibility envelope,
+  quality above threshold, certificate valid and compatible, uncertainty low.
+  Confident classifications are returned.
+- **DEGRADED** — one or more signals crossed a soft threshold (e.g. moderate
+  fingerprint drift within the envelope, elevated uncertainty, a tolerated
+  ADR-137 contradiction flag). Classifications are returned but flagged
+  degraded with the specific reason; downstream consumers must treat them as
+  lower-evidence.
+- **UNKNOWN** — the room changed materially (empty-baseline drift beyond the
+  envelope, AP channel change, transceiver-geometry change, hardware/device
+  change, or an invalidated/absent certificate). RuView **stops returning
+  confident classifications** and returns UNKNOWN with the triggering cause.
+  This is the required behavior, not an error.
+
+State transitions are hysteretic (separate enter/exit thresholds) so the gate
+does not flap on noise. The state, the four input values, and the triggering
+cause are all reported — never a bare label.
+
+### 3. Certificate-bound, honest by construction
+
+- The gate is meaningless without a certificate: with no valid ADR-301
+  certificate for the current space/device, the default state is UNKNOWN, not
+  KNOWN. Absence of evidence is treated as absence of capability.
+- The `DomainState` and its inputs are emitted to the evidence engine
+  (ADR-304) as part of every inference record, and are an input to the ADR-318
+  capability certificate (a model's capability is bounded by the domain it can
+  hold KNOWN in).
+- No accuracy number is claimed here; the ADR delivers the gating machinery.
+  The gate's own thresholds are calibration parameters, reported with each
+  decision.
+
+## Consequences
+
+- RuView gains a uniform, auditable answer to "should I trust this inference?"
+  that combines domain, quality, calibration, and uncertainty rather than
+  confidence alone.
+- Deployments will see more DEGRADED/UNKNOWN results than a
+  confidence-only system, especially right after a room changes. That increase
+  is the product working: it is the difference between honest RF perception and
+  confidently-wrong output.
+- Every task head that opts into the substrate must route through the gate;
+  heads that bypass it cannot claim a KNOWN state or earn an ADR-318
+  certificate.
+- The gate couples model serving to the presence of a live calibration
+  certificate, making ADR-301 a hard dependency of confident inference — the
+  intended coupling.
+
+## Validation
+
+- `cargo test` on the OOD crate — state-machine transitions on synthetic
+  fixtures: in-envelope drift stays KNOWN; soft-threshold breach → DEGRADED;
+  empty-baseline drift beyond envelope, channel change, geometry change,
+  device mismatch, and invalidated/absent certificate each → UNKNOWN;
+  hysteresis prevents flapping under injected noise; missing certificate
+  defaults to UNKNOWN.
+- Cross-ADR: consumes an ADR-301 certificate and asserts a drifted fingerprint
+  drives the expected transition; asserts the `DomainState` is present on every
+  emitted inference record consumed by ADR-304.
+- No confident classification is emitted in the UNKNOWN state in any test —
+  enforced as an assertion, not a convention.
+- Real-silicon OOD behavior (moving furniture / changing AP channel on a live
+  ESP32 capture and observing the transition) remains a follow-up requiring
+  hardware evidence per CLAUDE.md.
@@ -0,0 +1,125 @@
+# ADR-303: Ground-truth synchronization — reference sensors as a formal validation plane
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 2)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: ground-truth, validation, fusion, evidence, benchmark, honesty, substrate
+
+## Context
+
+This ADR is primitive 3 of the perception-substrate program (ADR-300), authored
+as **Proposed** in phase 2: it is design intent and a validation plan, not
+implemented by the phase-1 swarm. It sits on top of the phase-1 certificate
+spine and feeds the evidence engine (ADR-304) and the real benchmark service
+(ADR-317). It generalizes the vitals ground-truth rig (ADR-293) from a single
+measurand to a modality-agnostic plane.
+
+RuView's evidence discipline (CLAUDE.md; ADR-282 ladder) requires MEASURED
+accuracy claims to be backed by an independent reference. ADR-293 built exactly
+this for vitals: reference-series ingest, time alignment (cross-correlation
+lag + optional clock-drift fit), and agreement statistics (MAE/RMSE/bias/
+Bland–Altman/within-tolerance), with an `EvidenceGrade` that is only
+constructible as `Measured` when a real reference, non-zero paired samples,
+minimum coverage, and a reproducer are present. That machinery is measurand- and
+device-shaped: it knows about heart rate and breathing rate.
+
+The substrate needs the same discipline for *every* phenomenon RuView senses —
+presence, count, localization, pose, posture, activity — and for reference
+sources of many modalities (cameras, mmWave, pressure mats, wearables, pulse
+oximeters, microphones, manual labels). The critical design decision is that
+these reference sensors form a **validation plane**, not additional inference
+inputs.
+
+## Options considered
+
+1. **Fuse reference sensors as extra inference inputs.** Rejected on principle:
+   folding cameras/mmWave into the estimator would make RuView's RF claims
+   unfalsifiable — the reference would be training the thing it is meant to
+   check, and a camera-fed result is no longer a camera-free RF result. It
+   would also violate the ADR-282 layering (RuView is probabilistic
+   exteroception, never ground truth) and the honesty rule against presenting
+   fused-with-camera output as WiFi sensing.
+2. **One-off rigs per measurand (extend ADR-293 ad hoc each time).** Rejected:
+   duplicates alignment/agreement code per phenomenon and never yields a shared
+   validation surface for the benchmark.
+3. **A first-class, modality-agnostic `GroundTruth` API that is strictly a
+   validation plane.** Chosen.
+
+## Decision
+
+Introduce a `GroundTruth` API — a modality-agnostic validation plane that
+compares RF inference against independent observation and never feeds it.
+
+### 1. Modality-agnostic reference ingest
+
+- A `ReferenceObservation` generalizing ADR-293's `ReferenceSeries`: a
+  timestamped, typed observation of a `Phenomenon` (presence, count,
+  localization, pose keypoints, posture, activity, heart rate, breathing rate)
+  from a `ReferenceModality` (camera, mmWave, pressure, wearable, pulse
+  oximeter, microphone, manual label), with device/source metadata and the
+  measurement principle recorded.
+- Untrusted reference files are validated at the boundary (row-numbered
+  rejections, non-monotonic timestamps are errors), reusing ADR-293's ingest
+  discipline. Camera/mmWave references arrive as exported label/keypoint
+  streams, not live model feeds.
+
+### 2. Synchronization
+
+- Generalize ADR-293's time alignment (bounded-lag normalized cross-correlation
+  + optional linear clock-drift fit) to arbitrary measurands on a common
+  resampled grid, with no interpolation across gaps beyond a configurable
+  limit. Alignment parameters are always reported, never silently applied.
+- Spatial synchronization where relevant: reference observations are expressed
+  in the ADR-306 spatial ontology so an RF localization/pose result and a
+  camera/mmWave observation are compared in one coordinate frame.
+
+### 3. Agreement as validation, not fusion
+
+- A modality-appropriate `AgreementReport` per phenomenon: continuous
+  measurands reuse ADR-293's MAE/RMSE/bias/Bland–Altman/within-tolerance;
+  categorical/detection phenomena (presence, activity) report confusion-matrix
+  metrics; spatial phenomena report localization error percentiles and pose
+  PCK **with the mandatory mean-pose baseline and leakage-free split**
+  (CLAUDE.md; ADR-291).
+- Session scope is mandatory metadata (subject count, motion state, LOS/NLOS/
+  through-wall, distance band) — a report without scope cannot be constructed,
+  as in ADR-293.
+
+### 4. Evidence and isolation guarantees
+
+- The plane is one-directional by type: the inference path has no read access
+  to `GroundTruth` at runtime. A build/test-time isolation check (and the type
+  boundary) prevents a reference observation from becoming an estimator input.
+- Reports carry an `EvidenceLevel` (ADR-282) and an `EvidenceGrade`
+  constructible as `Measured` only with a real reference, paired samples,
+  coverage, and a reproducer (ADR-293 rule). Reports feed the ADR-304 evidence
+  engine and are the substrate ADR-317 scores against.
+
+## Consequences
+
+- Every phenomenon RuView senses gets the same MEASURED-vs-independent-observer
+  discipline vitals already has, in one shared surface.
+- Keeping references strictly as validation preserves the falsifiability and
+  the camera-free identity of RF results; it costs the (tempting) accuracy a
+  camera-fused estimator would show, which is the correct trade.
+- Reference capture is an operational burden (a camera/mmWave rig per validated
+  session); acceptable because it is a validation activity, not a runtime
+  requirement, and it is what turns CLAIMED into MEASURED.
+- Because this is Proposed (phase 2), the API shape may be revised once the
+  phase-1 spine (ADR-301/299/301/303) lands and the benchmark (ADR-317)
+  exercises it.
+
+## Validation
+
+- Unit tests (planned): modality-agnostic ingest rejection cases; alignment
+  recovery of known synthetic offsets/drifts across measurands; agreement math
+  per phenomenon against hand-computed fixtures; pose PCK path requires a
+  mean-pose baseline and rejects leaky splits; evidence-grade constructibility;
+  the isolation check fails a build that wires a reference into the inference
+  path.
+- Cross-ADR: an ADR-317 benchmark scenario consumes `GroundTruth` reports as
+  its scored reference; ADR-304 ingests the agreement reports as evidence
+  records.
+- Real-session validation (RF capture synchronized with a real camera/mmWave/
+  pressure/wearable reference) is the phase-2 exit and requires hardware
+  evidence per CLAUDE.md; a synthetic run is not hardware evidence.
@@ -0,0 +1,117 @@
+# ADR-304: Evidence engine — MLflow for physical sensing
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: evidence, provenance, ledger, accuracy, drift, benchmark, honesty, substrate
+
+## Context
+
+This ADR is primitive 4 of the perception-substrate program (ADR-300) and a
+central pillar of the phase-1 certificate spine. It consumes the domain state
+from out-of-distribution detection (ADR-302) and the calibration age from the
+calibration certificate (ADR-301), it is the store that capability certificates
+(ADR-318) are minted from, and it is the accuracy source the real benchmark
+service (ADR-317) reads. In phase 2 it ingests agreement reports from the
+ground-truth plane (ADR-303).
+
+The strategic assessment (ADR-300) judged this primitive **more commercially
+important than another pose architecture**: what unblocks OEM and integrator
+conversations is not a higher headline number but a defensible, auditable record
+of how a model actually performs, per room, per device, per subject, over time.
+MLflow made ML experiments trackable; physical sensing needs the equivalent for
+deployed accuracy, drift, and evidence level — an append-only ledger, not a
+dashboard that overwrites yesterday's number.
+
+RuView already has the constituent evidence types; what is missing is the ledger
+that unifies them per deployment context:
+
+- RuField provenance/signature types (ADR-260/262/277/279) — the signed,
+  provenance-bearing record types to reuse rather than reinvent.
+- The AetherArena witness-ledger pattern (ADR-149) — an append-only,
+  witness-anchored ledger of scored results, the structural template here.
+- `frame::EvidenceLevel` L0–L5 (ADR-282) — the mandatory evidence tag every
+  record carries.
+- ADR-302 `DomainState`, ADR-137 `QualityScore`, ADR-301 certificate version
+  and age — the per-inference signals to accumulate.
+
+## Options considered
+
+1. **Log accuracy to flat files / metrics dashboards.** Rejected: mutable,
+   un-signed, un-scoped, and not comparable over time — the exact gap.
+2. **Reuse a general experiment tracker (MLflow itself).** Rejected: it is
+   experiment-time, not deployment-time; it has no notion of room/device/
+   subject context, calibration age, evidence level, or signed provenance, and
+   it would add an external service dependency contrary to the substrate's
+   edge-first, dependency-light direction.
+3. **A native append-only evidence ledger reusing RuField record types and the
+   AetherArena ledger pattern.** Chosen.
+
+## Decision
+
+Build an **evidence engine**: a per-`(room, device, subject)` append-only
+accuracy ledger that every model automatically writes to.
+
+### 1. The evidence record
+
+- An `EvidenceRecord` keyed by context — space id (ADR-306), signed device id
+  (ADR-305), and subject id where consented and available — carrying: model
+  version; calibration certificate version and **age** (ADR-301); the ADR-302
+  `DomainState` (KNOWN/DEGRADED/UNKNOWN) and its four inputs; the ADR-137
+  quality signals; predictive uncertainty; and, when a reference is present
+  (ADR-303), the agreement result (accuracy, false-positive rate). Each record
+  carries exactly one `EvidenceLevel` (L0–L5, ADR-282).
+- Records are **append-only** and signed with RuField signature types
+  (ADR-260/262/277/279); the ledger is anchored in the witness chain (ADR-319),
+  following the AetherArena witness-ledger pattern (ADR-149). No record is ever
+  mutated in place — a correction is a new record.
+
+### 2. Per-context accuracy accounting
+
+- The engine maintains, per `(room, device, subject)` context: measured
+  accuracy (only where an ADR-303 reference backs it — otherwise the record is
+  CLAIMED/SYNTHETIC, never MEASURED), false-positive rate, drift trajectory
+  (fingerprint distance over time from ADR-301), the fraction of inferences in
+  each domain state, calibration age distribution, and model-version history.
+- Aggregation is a pure function over the append-only log at a queried time —
+  the ledger is the source of truth; summaries are derived, never authoritative
+  (mirroring CLAUDE.md's "source over summaries" rule).
+
+### 3. Honesty enforced in the record
+
+- The engine cannot upgrade an evidence level; a level is set by the record's
+  provenance at write time (synthetic input → L0/`Synthetic`; no reference →
+  CLAIMED; reference + reproducer → MEASURED), reusing the ADR-282/ADR-291/
+  ADR-293 constructor discipline. A benchmark or certificate reading the ledger
+  gets the honest level, not an optimistic rollup.
+- No benchmark numbers are invented by this ADR; it delivers the ledger and the
+  accounting. Empty contexts report "no evidence," which downstream (ADR-318)
+  must treat as no capability.
+
+## Consequences
+
+- RuView gains a single auditable answer to "how well does this model actually
+  work, here, on this device, for this subject, and how fresh is the
+  calibration?" — the artifact OEM/integrator diligence actually asks for.
+- ADR-318 capability certificates become derivable (a certificate is a signed
+  attestation over a slice of the ledger) and ADR-317 gains a real accuracy
+  source per PR instead of self-reported numbers.
+- The append-only, signed design has storage and key-management cost; bounded
+  by per-context retention policy and by reusing the existing RuField/witness
+  infrastructure rather than a new store.
+- Some contexts will show sparse or unflattering evidence. Surfacing that is the
+  point; the engine must never paper over a thin context with a global average.
+
+## Validation
+
+- `cargo test` on the evidence-engine crate — append-only invariant (no
+  in-place mutation; corrections are new records); per-context aggregation math
+  against fixtures; evidence-level is set by provenance and cannot be upgraded;
+  signature round-trip and tamper rejection; witness anchoring; empty-context
+  queries return "no evidence" not a fabricated number.
+- Cross-ADR: ingests ADR-302 `DomainState` and (phase 2) ADR-303 agreement
+  reports; an ADR-318 test mints a certificate from a ledger slice and an
+  ADR-317 test reads accuracy from the ledger.
+- Real-deployment evidence (a populated ledger from live ESP32 captures with
+  ADR-303 references) is the maturity milestone and requires hardware evidence
+  per CLAUDE.md; a synthetic ledger is L0 by construction.
@@ -0,0 +1,147 @@
+# ADR-305: Authenticated sensor identity — RF chain of custody
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: security, identity, provenance, sensor-ingest, attestation, phase-1
+
+## Context
+
+This ADR is a child of **ADR-300** (perception substrate program) and owns
+primitive #5, *authenticated sensor identity*. In the ADR-300 dependency DAG it
+is a spine root that, together with **ADR-306** (canonical spatial ontology),
+feeds **ADR-301** (calibration certificate) and **ADR-319** (witness chain).
+
+RuView's inference outputs are only as trustworthy as the measurements that
+produced them, yet today a measurement's origin is essentially assertional. The
+UDP data plane accepts frames from any reachable host: **ADR-296** shipped step
+one — a loopback-default bind (`--udp-bind`) and an optional source
+IP/CIDR allowlist — and explicitly deferred to a follow-up ADR "per-device
+provisioned keys, MAC/AEAD, device identifiers, monotonic sequence numbers,
+freshness window, and replay rejection." **This ADR is that step two.** ADR-296
+correctly documented that an IP allowlist does not stop LAN spoofing; a
+cryptographic device identity is what closes that gap.
+
+Foundations already exist in the tree and must be reused rather than rebuilt:
+
+- `wifi-densepose-rufield` provides `DeviceId`, `Signature`, `SignatureBlock`,
+  `FrameProvenance`, `ProvenanceClass`, and `SignatureVerifyError` — the type
+  vocabulary for a signed frame.
+- `wifi-densepose-bfld` provides `CapabilityAttestation` and
+  `PrivacyAttestationProof` (BFLD attestation, ADR-141) — the device-side
+  attestation surface.
+- **ADR-295** defines the source-provenance state machine and freshness
+  (`SpatialStateFreshness`); a monotonic sequence and freshness window slot
+  into that machine rather than duplicating it.
+
+The gap is not new primitives but an **end-to-end chain of custody**: a frame
+must be traceable as `device → signed measurement → sequence → timestamp →
+calibration → inference → signed event`, with every link verified at the
+ingest boundary per CLAUDE.md ("validate untrusted input at every network,
+hardware, and FFI boundary; default to least authority").
+
+## Options considered
+
+1. **Stop at ADR-296 (bind + IP allowlist).** Rejected: ADR-296 itself names
+   this insufficient on a trusted LAN; any on-subnet host can still spoof a
+   device.
+2. **TLS/DTLS transport authentication only.** Rejected: authenticates the
+   *channel*, not the *measurement*. It does not survive store-and-forward,
+   does not bind a sequence number into the signed object, and gives the
+   downstream evidence/witness layers nothing to re-verify offline.
+3. **Per-device signing keys with a signed measurement envelope, monotonic
+   sequence, and freshness window, reusing the RuField/BFLD types.** Chosen.
+
+## Decision
+
+Introduce an **authenticated frame envelope** carried through the sensing
+server, built from existing RuField/BFLD types.
+
+### 1. Per-device provisioned identity
+
+- Each radio (ESP32-S3/C6 node or adapter) is provisioned with a keypair; the
+  device holds the private key, the server holds the enrolled public key bound
+  to a `DeviceId`. Provisioning is an explicit, authorized enrollment step — a
+  device is untrusted until an operator enrolls its public key. Private keys are
+  never logged or committed (CLAUDE.md credential rule); the ESP32 side follows
+  `firmware/esp32-csi-node` key-handling notes.
+- The enrollment record binds `DeviceId → public key → capabilities`
+  (via `CapabilityAttestation`, ADR-141), so a device can only assert
+  measurements for phenomena it is attested to sense. This is what **ADR-318**
+  (capability certificate) later consumes.
+
+### 2. Signed measurement envelope
+
+- A frame on the wire becomes a `SignatureBlock` over the canonical
+  serialization of `{DeviceId, sequence, timestamp, measurement-hash}`. The
+  measurement itself (CSI/CIR payload) is covered by the hash so tampering is
+  detectable without embedding the whole payload twice.
+- Verification uses `Signature`/`SignatureVerifyError` from
+  `wifi-densepose-rufield`. A frame that fails signature verification is
+  dropped and counted, exactly as ADR-296 drops disallowed sources — an `Err`
+  at the boundary, never a warning that proceeds.
+
+### 3. Monotonic sequence + freshness (replay defense)
+
+- Each device maintains a strictly monotonic per-device sequence number. The
+  server tracks the last accepted sequence per `DeviceId`; a non-increasing
+  sequence is rejected as a replay.
+- A freshness window bounds `timestamp` against the server clock skew budget;
+  stale frames are rejected. This reuses ADR-295's `SpatialStateFreshness`
+  rather than inventing a parallel notion of staleness, and composes with
+  ADR-297's stale-node handling.
+
+### 4. Chain of custody into the event
+
+- On successful verification the frame's `FrameProvenance` records the verified
+  `DeviceId`, sequence, and timestamp. Calibration (ADR-301) and inference
+  annotate their transforms, and the emitted spatial event (ADR-306 ontology)
+  carries a signed provenance lineage. `ProvenanceClass` still enforces the
+  synthetic/measured invariant from ADR-282/ADR-279 (invariant 6): a measured
+  chain of custody can never be aliased to synthetic and vice-versa.
+- This end-to-end signed lineage is the substrate the **ADR-319** witness chain
+  serializes and the **ADR-318** capability certificate points at as evidence.
+
+### Compatibility
+
+- The envelope is **opt-in per deployment** and negotiated at enrollment. An
+  un-enrolled single-node desktop deployment keeps working unauthenticated
+  behind ADR-296's loopback default; a routable, multi-node, or fleet
+  deployment (ADR-316) requires enrolled identities. The startup security log
+  (ADR-296) is extended to state whether frame authentication is active.
+
+## Consequences
+
+- LAN spoofing and replay — the residual risks ADR-296 named plainly — are
+  closed for enrolled deployments. The measurement, not merely the channel, is
+  authenticated, so the guarantee survives store-and-forward into the witness
+  chain.
+- Enrollment/key-management is now an operational responsibility (provisioning,
+  rotation, revocation). This is documented as a deployment step; key rotation
+  and revocation lists are specified here but their fleet distribution is
+  owned by ADR-316.
+- Signature verification adds per-frame CPU cost at ingest; bounded and
+  measured in validation below. It is a deliberate cost for a verifiable chain
+  of custody.
+- A schema addition to the frame contract; un-enrolled deployments are
+  unaffected, and the migration accessor mirrors ADR-297's approach.
+- **No spoof-resistance claim is MEASURED until validated on real silicon**
+  (CLAUDE.md hardware rule): a passing unit/integration suite demonstrates the
+  logic, not the fielded device path.
+
+## Validation
+
+- Unit tests (`cargo test -p wifi-densepose-sensing-server`,
+  `-p wifi-densepose-rufield`): valid envelope accepted; bad signature
+  rejected and counted; non-monotonic sequence rejected as replay; out-of-
+  window timestamp rejected; un-enrolled `DeviceId` rejected; measured/synthetic
+  provenance aliasing rejected (ADR-279 invariant 6).
+- Integration test: a captured/synthesized multi-frame stream produces a
+  verifiable `device → … → signed event` lineage that ADR-319 can serialize and
+  re-verify offline.
+- Benchmark (`cargo bench`): per-frame verification cost, to bound ingest
+  overhead.
+- **Real-silicon evidence required** before any deployment-grade
+  authentication claim: a captured boot/runtime log from an enrolled ESP32 node
+  signing frames end-to-end. A successful build or simulator run is not
+  hardware evidence.
@@ -0,0 +1,142 @@
+# ADR-306: Canonical spatial ontology — one Site→…→Event model for every surface
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: ontology, worldgraph, schema, mqtt, matter, rufield, phase-1
+
+## Context
+
+This ADR is a child of **ADR-300** and owns primitive #6, *canonical spatial
+ontology*. In the ADR-300 DAG it is a spine root alongside **ADR-305**
+(authenticated identity) and feeds every downstream primitive that must speak
+about *where* and *what*: **ADR-301** (calibration), **ADR-307** (tracking,
+consumes `Track`/`Person`), **ADR-319** (witness chain), and every external
+surface named in the ADR-300 consequences (MQTT, REST, WebSocket, RuField,
+Matter, agents).
+
+RuView currently expresses "where something is" in several overlapping,
+per-surface schemas: the MQTT/Home-Assistant mapper has its own node/room
+shapes (**ADR-297** just introduced `NodeInference`/`RoomInference` to
+disambiguate node vs. room state); the `worldgraph` crate models a spatial
+graph; RuField carries `SemanticProvenance`; Matter/HomeKit has its own area
+model. The same physical fact — "a person is in the kitchen" — is re-encoded
+differently on each surface, and the review called for "one canonical
+`NodeInference`/`RoomInference` contract" (ADR-297 consequences). Without a
+single semantic model, every new surface multiplies the translation matrix and
+each translation is a place where provenance and evidence level (ADR-282) can
+be silently dropped.
+
+Substantial scaffolding already exists and must be **reused/extended, not
+rebuilt**. `v2/crates/worldgraph/wifi-densepose-worldgraph` already defines:
+
+- `WorldNode` variants including `Room { area_id, name, bounds_enu, floor }`,
+  `Zone { parent_room, … }`, `Wall { rf_attenuation_db }`, and `Doorway`.
+- `WorldEdge` variants including `Observes { quality, last_seen_unix_ms }`,
+  `LocatedIn { since_unix_ms }`, `AdjacentTo { via_doorway }`, and `Supports`.
+- `WorldGraph`, `WorldGraphSnapshot`, `WorldId`, `SemanticProvenance`,
+  `PersonPosition`, and a HomeCore `area_id` linkage join key (ADR-127).
+
+The `worldgraph` crate is therefore the natural home for the canonical model.
+What is missing is (a) the full `Site → Building → Floor → Space → Zone`
+containment spine above `Room`, (b) first-class `Sensor`, `Object`,
+`Observation`, `Track`, and `Event` node types, (c) one canonical serialization
+that every surface consumes, and (d) a documented migration path from the
+existing per-surface schemas.
+
+## Options considered
+
+1. **Leave each surface with its own schema; add adapters pairwise.** Rejected:
+   O(surfaces²) translations, and provenance/evidence loss at each hop.
+2. **Invent a new top-level ontology crate.** Rejected: `worldgraph` already
+   models rooms, zones, walls, doorways, observation edges, and HomeCore
+   linkage; a parallel crate would fork the world model.
+3. **Extend `worldgraph` into the canonical ontology and make every surface a
+   projection of it.** Chosen.
+
+## Decision
+
+Adopt **one canonical spatial ontology**, hosted in the `worldgraph` crate,
+that every RuView surface reads from and writes to.
+
+### 1. The containment spine and entity types
+
+Define the full node taxonomy as an extension of the existing `WorldNode`:
+
+```
+Site ▸ Building ▸ Floor ▸ Space ▸ Zone
+                                   └─▸ { Sensor, Person, Object,
+                                         Observation, Track, Event }
+```
+
+- `Site`, `Building`, `Floor`, `Space` are new containment `WorldNode`
+  variants above the existing `Room` (mapped to `Space`, keeping its `area_id`
+  and `bounds_enu`) and `Zone`. `Wall`/`Doorway` remain as topological
+  elements. Containment reuses the existing `LocatedIn`/`AdjacentTo` edge
+  vocabulary; a new `PartOf` edge expresses the pure hierarchy
+  (Zone `PartOf` Space `PartOf` Floor …).
+- `Sensor` is the entity **ADR-305** authenticates (`DeviceId` as its stable
+  identity) and **ADR-320** (HAL, phase 2) describes the hardware of. `Person`,
+  `Object`, `Observation`, `Track`, and `Event` are first-class nodes.
+  `Observes`/`LocatedIn` edges already carry quality and dwell timestamps.
+- `Track` and `Person` are defined **here** as the ontology contract that
+  **ADR-307** (persistent tracking) produces and updates. `Observation` is what
+  an authenticated frame (ADR-305) becomes after calibration (ADR-301), and
+  `Event` is the governed output that ADR-318 certifies and ADR-319 witnesses.
+
+### 2. Canonical serialization
+
+- A single, versioned serialization (serde-based, stable field names) is the
+  one wire/at-rest representation. Every surface — MQTT/Home-Assistant, REST,
+  WebSocket, RuField observations, Matter/HomeKit, agent queries — is a
+  **projection** of this model, not an independent schema. `NodeInference` and
+  `RoomInference` (ADR-297) become projections of `Sensor→Observes` and the
+  `Space`-level fused inference respectively, so ADR-297's node/room separation
+  is preserved by construction rather than re-encoded per surface.
+- Every node and edge carries `SemanticProvenance` and exactly one
+  `EvidenceLevel` (L0–L5, ADR-282 policy): the evidence ladder travels *with*
+  the fact across every projection, so no surface can silently upgrade or drop
+  it.
+
+### 3. Migration path
+
+- Each existing per-surface schema gets a documented, tested bidirectional
+  mapping to/from the canonical model, plus a migration accessor for consumers
+  reading the old shape (mirroring ADR-297's migration accessor). Surfaces are
+  cut over one at a time; a surface is "canonical" once its projection is the
+  only encoder it uses. Until cutover, the mapping layer is authoritative and
+  round-trip-tested so no fact is lost in translation.
+- The `worldgraph` HomeCore `area_id` linkage (ADR-127) remains the join key
+  between the ontology's `Space` and external area registries.
+
+## Consequences
+
+- The translation matrix collapses from O(surfaces²) to O(surfaces): each
+  surface implements one projection. New surfaces (ROS 2, OpenUSD, OPC UA per
+  ADR-282's roadmap) plug in as additional projections.
+- Provenance and evidence level are carried uniformly; a fact cannot cross a
+  surface boundary and lose its lineage or its L-level.
+- A schema change reaching every surface; managed by the versioned
+  serialization and per-surface migration accessors. Single-node deployments
+  keep working (one `Sensor`, one `Space`).
+- The ontology is a *representation*, not an inference engine: it says nothing
+  about *how* a `Track` or `Event` is produced — that is owned by ADR-307,
+  ADR-301, ADR-302, and the model layer. This ADR does not itself make any
+  accuracy claim to grade.
+- Extending `worldgraph` grows one crate's surface rather than forking a second
+  world model; the geo/worldmodel sub-crates continue to build on the same node
+  vocabulary.
+
+## Validation
+
+- Unit tests (`cargo test -p wifi-densepose-worldgraph`): containment-spine
+  construction and invariants (a `Zone` is `PartOf` exactly one `Space`, a
+  `Space` on exactly one `Floor`, etc.); round-trip serialization of every node
+  and edge type; every node/edge carries exactly one `EvidenceLevel`.
+- Migration tests: each per-surface schema maps to the canonical model and back
+  with no loss of provenance or evidence level; `NodeInference`/`RoomInference`
+  (ADR-297) project and re-project identically.
+- Contract test: a single canonical `Event` renders correctly through the MQTT,
+  REST, and WebSocket projections from one source of truth.
+- No accuracy numbers are claimed; this ADR delivers the shared representation
+  the rest of the phase-1 spine writes into.
@@ -0,0 +1,135 @@
+# ADR-307: Persistent identity & tracking — privacy-preserving probabilistic tracks
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 2)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: tracking, identity, privacy, fusion, worldgraph, phase-2
+
+## Context
+
+This ADR is a child of **ADR-300** and owns primitive #7, *persistent identity
+& tracking*. In the ADR-300 DAG it is a phase-2 primitive sitting on the
+phase-1 spine: it **consumes the ADR-306 ontology** (producing and updating the
+`Track` and `Person` node types defined there), it relies on **ADR-305**
+authenticated identity so that the observations it associates have a verified
+origin, and its outputs are governed `Event`s that ADR-318/ADR-319 can certify
+and witness.
+
+The product need is to reason about *persistent entities* — "person_7 entered
+the kitchen, then the hallway, then the bedroom" — across radios, modalities,
+rooms, and time. The hard constraint is that this must happen **without
+establishing civil identity**. RuView is camera-free (ADR-282), and a
+persistent pseudonymous track must never become, or be joinable to, a real-
+world named individual. This is a privacy property to be enforced *by
+construction*, not a policy footnote.
+
+Substantial scaffolding already exists in
+`v2/crates/wifi-densepose-mat/src/tracking` and must be **reused/extended, not
+rebuilt**:
+
+- `SurvivorTracker`, `TrackedSurvivor`, `TrackId`, `TrackerConfig`,
+  `TrackLifecycle`, and `TrackState` — a multi-target tracker with lifecycle
+  (tentative/active/lost/terminal) and a `TrackId` backed by a UUID
+  (`as_uuid`).
+- `KalmanState` with `predict`/`update`, `position`, `velocity`,
+  `position_uncertainty`, and `mahalanobis_distance_sq` — the motion model and
+  gating distance.
+- `CsiFingerprint`, `DetectionObservation`, `AssociationResult`, and the
+  `can_reidentify`/`matches`/`mark_rescued`/`rescue` re-identification surface —
+  the appearance/fingerprint channel for track continuity.
+
+What is missing is (a) continuity **across radios, modalities, and rooms** (the
+tracker today reasons within a node/room context), (b) a **persistent** entity
+that survives track loss and hand-off between spaces, and (c) an explicit
+**privacy boundary** that guarantees no civil-identity binding.
+
+## Options considered
+
+1. **Per-room independent trackers, no cross-room identity.** Rejected: cannot
+   express "person_7 moved kitchen → hallway → bedroom"; loses the entity at
+   every room boundary.
+2. **Global identity keyed on a strong biometric fingerprint.** Rejected: a
+   fingerprint strong enough to re-identify across long gaps trends toward a
+   civil-identity-grade biometric — exactly what the privacy constraint
+   forbids.
+3. **Probabilistic persistent tracks with bounded, decaying pseudonymous
+   association, built on the existing MAT tracker.** Chosen.
+
+## Decision
+
+Extend `wifi-densepose-mat/tracking` into a **cross-domain persistent track
+layer** that produces ADR-306 `Track`/`Person` nodes.
+
+### 1. Persistent probabilistic entity
+
+- A persistent entity is a pseudonymous `Person` node (ADR-306) with a stable
+  synthetic id (e.g. `person_7`) backed by the existing `TrackId`/UUID. It
+  aggregates one or more `SurvivorTracker` tracks over time and space and holds
+  a **probabilistic** continuity belief — association is never asserted as
+  certain, and every hand-off carries a confidence.
+- Continuity across a track-loss gap reuses the existing re-identification
+  surface (`can_reidentify`, `CsiFingerprint`, `AssociationResult`), extended
+  with a **time- and distance-decayed** association prior so that confidence in
+  "same entity" falls with the size of the gap. Beyond a bounded horizon the
+  association is dropped and a new pseudonym is minted rather than forcing a
+  join — under-linking is the privacy-safe failure mode.
+
+### 2. Cross-radio / cross-modality / cross-room continuity
+
+- Association operates over the ADR-306 ontology graph: `Observes` edges from
+  multiple `Sensor`s and `AdjacentTo`/`Doorway` topology constrain plausible
+  hand-offs (a person can only move between adjacent spaces). The existing
+  `mahalanobis_distance_sq` gating extends to a fused observation across
+  modalities rather than a single node's detections.
+- Fusion here is track-level association; the underlying multi-modality fusion
+  (radar/mmWave per ADR-063, multistatic per ADR-029, and real sensor fusion
+  per ADR-311) supplies the observations. This ADR depends on those for the raw
+  cross-modality evidence and does not re-implement sensor fusion.
+
+### 3. Privacy boundary (by construction)
+
+- **No civil-identity binding.** The persistent id is a synthetic pseudonym
+  with no field, edge, or join key to any name, account, phone, MAC, or other
+  civil identifier. The type carries no such field, so binding is impossible in
+  the schema, not merely discouraged.
+- The `CsiFingerprint` used for re-identification is **bounded and decaying**:
+  it is scoped to short-horizon continuity, is not persisted as a long-term
+  biometric template, and expires. This keeps re-identification useful for
+  "same person across the hallway" while structurally unable to serve "this is
+  the same person who visited last month."
+- Every `Track`/`Person`/`Event` produced carries `SemanticProvenance` and an
+  `EvidenceLevel` (ADR-282), and honors the ADR-277/ADR-280 edge governance and
+  ADR-141 attestation — a pseudonymous track is still governed P-class data.
+  Tracking accuracy is a per-domain claim to be tagged MEASURED/CLAIMED/
+  SYNTHETIC with a reproducer; **this ADR claims no accuracy number.**
+
+## Consequences
+
+- RuView can express persistent, cross-room trajectories for automation and
+  analytics while remaining camera-free and civil-identity-free.
+- The privacy-safe failure mode is **under-linking** (mint a fresh pseudonym
+  when unsure), which will fragment a trajectory across long gaps or sparse
+  coverage. This is a deliberate trade: a fragmented pseudonym is safe, a
+  wrong civil-identity join is not.
+- Extends an existing tracker rather than forking one; single-room single-radio
+  deployments keep the current behavior (one entity = one track).
+- Cross-modality quality depends on ADR-311/ADR-063/ADR-029 landing; until then
+  continuity is WiFi-primary and its limits are stated, not hidden.
+- Being phase 2, this ADR is design intent; it will be revised as the ADR-306
+  ontology and ADR-305 identity spine finalize.
+
+## Validation
+
+- Unit tests (`cargo test -p wifi-densepose-mat`): decayed association prior
+  (confidence falls with gap; drops beyond horizon → new pseudonym);
+  topology-constrained hand-off (no association across non-adjacent spaces);
+  schema check that a `Person`/`Track` carries no civil-identifier field.
+- Integration test against a synthetic multi-room, multi-radio scenario:
+  a scripted walk kitchen → hallway → bedroom yields one persistent pseudonym
+  with per-hand-off confidence, and a deliberately ambiguous crossing produces
+  two pseudonyms rather than a false join.
+- Evidence discipline: any tracking-continuity accuracy is reported only with
+  the ADR-291 leakage-free protocol and an evidence tag; no number is asserted
+  here.
+- Privacy review: confirm no persisted long-term biometric template and no
+  civil-identity join path, as an explicit checklist item before any pilot.
@@ -0,0 +1,138 @@
+# ADR-308: Sensor placement optimizer — floorplan + inventory → recommended positions
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 3)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: placement, planning, rf-twin, coverage, worldgraph, phase-3
+
+## Context
+
+This ADR is a child of **ADR-300** and owns primitive #8, *sensor placement
+optimizer*. In the ADR-300 DAG it is a phase-3, research-forward primitive that
+sits on top of the fused world state and is tightly coupled to **ADR-315**
+(digital RF twin): the twin provides the propagation simulation this optimizer
+plans against. It reads the **ADR-306** canonical ontology for the physical
+scene and, after install, compares its predictions against ADR-302 observability
+and the ADR-318 capability certificate.
+
+The problem it solves is the single most common cause of a bad RuView
+deployment: sensors placed by guesswork. Whether a room can be reliably sensed
+depends on AP/sensor geometry relative to walls, Fresnel-zone clearance,
+multipath structure, and where people actually move. Today an installer has no
+principled way to answer "where do I put the two nodes I have so the kitchen is
+observable?" — and no way, after install, to know whether reality matched the
+plan. This is a genuine **differentiator**: it turns RuView from "sense
+whatever the given placement happens to allow" into "recommend the placement
+that makes the requested sensing feasible."
+
+Relevant existing assets to build on rather than duplicate:
+
+- The `worldgraph` crate models the physical scene the optimizer plans over:
+  `Room`/`Space` with `bounds_enu`, `Wall { rf_attenuation_db }` (drywall ≈ 3
+  dB, brick ≈ 12 dB), `Doorway`, and `Zone` — enough geometry and coarse RF
+  attenuation to seed a coverage model, plus `Sensor` nodes (ADR-306) for
+  candidate positions.
+- **ADR-315** (RF twin, phase 3) is the propagation/multipath simulator; this
+  optimizer is a *consumer* of the twin, not a second simulator.
+- **ADR-302** (OOD/observability) and **ADR-318** (capability certificate)
+  define what "reliably sense the requested phenomenon" means, so the optimizer
+  can optimize against the same observability metric the runtime later gates on.
+- **ADR-029** (multistatic) and **ADR-063** (mmWave fusion) inform which link
+  geometries are useful for which phenomena.
+
+## Options considered
+
+1. **Static placement guidelines in docs (e.g. "one node per room, opposite
+   the door").** Rejected: ignores the specific floorplan, wall materials, and
+   the actual hardware inventory; gives no uncertainty and no post-install
+   feedback.
+2. **Full electromagnetic solver per site.** Rejected for the default path:
+   too heavy for an installer workflow and overkill relative to the coarse
+   `rf_attenuation_db` scene RuView actually has; reserved as an optional
+   high-fidelity backend inside ADR-315.
+3. **A coverage optimizer that consumes the ADR-315 RF twin over the ADR-306
+   scene, then validates predicted vs. measured observability after install.**
+   Chosen.
+
+## Decision
+
+Define a **placement optimizer** that takes a floor plan (ADR-306 scene) and a
+hardware inventory and recommends sensor positions, then closes the loop after
+install.
+
+### 1. Inputs
+
+- The ADR-306 canonical scene: `Space`/`Zone` bounds, `Wall` segments with
+  `rf_attenuation_db`, `Doorway` topology, and any already-placed `Sensor`
+  nodes.
+- A hardware inventory: the count and type of available radios (ESP32-S3/C6
+  nodes, mmWave, adapters) with their capability envelopes (what each can
+  sense, per ADR-318 / ADR-320 HAL descriptors).
+- A sensing objective: which phenomenon must be observable in which
+  `Space`/`Zone` (presence, vitals, pose), expressed against the ADR-302
+  observability metric.
+
+### 2. Prediction
+
+- For a candidate placement, query the **ADR-315 RF twin** for simulated RF
+  coverage: path loss through `Wall` attenuation, **Fresnel-zone clearance**
+  between link endpoints, and coarse **multipath** structure. From that derive
+  an **expected observability** and an **uncertainty** for each objective in
+  each space — reusing the same observability definition ADR-302 gates on so the
+  plan and the runtime speak one language.
+- Search over candidate positions (the inventory bounds the count; the scene
+  bounds the geometry) to recommend the placement that maximizes objective
+  observability, reporting expected observability **and its uncertainty** per
+  space — never a single confident number for a simulated result.
+
+### 3. Post-install loop
+
+- After install, compare **predicted vs. measured** observability using the
+  ADR-302 runtime observability signal from the freshly enrolled (ADR-305),
+  calibrated (ADR-301) sensors. Where measurement disagrees with prediction,
+  recommend adjustments (move, re-aim, add a node) and feed the residual back
+  to improve the ADR-315 twin's scene parameters (e.g. a wall's effective
+  attenuation).
+
+### Evidence discipline
+
+- Predicted coverage is a **simulation** (evidence level L0 per ADR-282) and is
+  labelled `SYNTHETIC`; it is a *recommendation*, never a sensing claim.
+- The predicted-vs-measured comparison is the only place a `MEASURED` statement
+  appears, and only with a reproducer and real-silicon observability data
+  (CLAUDE.md hardware rule). The optimizer never presents a simulated coverage
+  map as evidence that a room *is* being sensed.
+
+## Consequences
+
+- Installers get a principled, floorplan-specific placement plan and, crucially,
+  a post-install check that says whether reality matched the plan — a
+  differentiating capability over guess-and-check deployment.
+- Quality is bounded by the fidelity of the ADR-315 RF twin and the coarseness
+  of the `worldgraph` scene (2D walls, coarse attenuation). The optimizer
+  reports uncertainty rather than overstating a coarse model; higher fidelity
+  is an ADR-315 concern.
+- Hard dependency on ADR-315 (twin), ADR-302 (observability metric), and
+  ADR-306 (scene); this ADR does not build a simulator or an observability
+  metric of its own.
+- Being phase 3, this is design intent sitting on the fused world state; it is
+  expected to be revised as ADR-315 and the phase-1 spine land.
+- No claim that recommended placement *guarantees* sensing — it maximizes
+  modelled observability subject to inventory and geometry, with explicit
+  uncertainty.
+
+## Validation
+
+- Unit tests: coverage/observability prediction is a deterministic function of
+  scene + placement + twin parameters; Fresnel-zone and wall-attenuation math
+  against known analytic cases; search returns the modelled-optimal placement on
+  small synthetic scenes.
+- Integration test: on a synthetic floorplan with a known-good and a
+  known-bad placement, the optimizer ranks them correctly and reports higher
+  uncertainty for the marginal case.
+- Post-install loop test: injected predicted-vs-measured disagreement produces a
+  sensible adjustment recommendation and a twin-parameter residual.
+- Field validation (deferred, real-silicon): predicted vs. measured
+  observability on an instrumented real site, reported as `MEASURED` with a
+  reproducer. Until then all coverage output is `SYNTHETIC`/L0. No coverage or
+  accuracy number is asserted by this ADR.
@@ -0,0 +1,152 @@
+# ADR-309: Active sensing — closed-loop RF experiment control
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 3)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: active-sensing, control-plane, closed-loop, information-gain, actuation, phase-3
+
+## Context
+
+This ADR is a child of **ADR-300** and owns primitive #9, *active sensing*. In
+the ADR-300 phasing it is a phase-3 primitive that sits on top of the fused
+world state produced by **ADR-311** (real sensor fusion) and is driven by the
+information budget of **ADR-314** (information-gain scheduler). It is authored
+as **Proposed**: design intent and validation plan, not a phase-1 build.
+
+The default posture of every current RuView path is **passive**: RF traffic
+happens for its own reasons (a device transmits, a beacon fires), RuView
+observes whatever CSI/CIR arrives, and the pipeline extracts what it can from
+that incidental signal. The strategic assessment behind ADR-300 named the next
+step: move from *RF-happens → observe* to **RuView-controls-RF → observe the
+response → optimize the next measurement**. That turns sensing into a
+closed-loop experiment — the system chooses what to measure to resolve the
+uncertainty it currently has, rather than accepting the measurements the
+environment happens to offer.
+
+Substantial control-plane scaffolding already exists and must be
+**reused/extended, not rebuilt**:
+
+- **ADR-280** (active sensing / programmable perception, *implemented* in
+  `ruview-unified/src/control.rs`) already defines the governed control surface
+  this ADR closes the loop over: `SensingTask` (evidence-aware, fail-closed
+  admission), `SensingAction` + `InformationGoal` (a deliberate act of
+  evidence-gathering against a stated hypothesis, bounded by a `PrivacyClass`
+  P0–P5 ceiling), `ActiveSensingPlanner` (age-of-information scheduler),
+  `CoherentSensorGroup` (coherent fusion fails closed), and `request_actuation`
+  → `ActuationReceipt` for governed RIS/movable/fluid-antenna actuation.
+- ADR-280 explicitly recorded that **information-gain *estimation* is not
+  implemented** — "the planner uses staleness heuristics, not mutual
+  information; RIS drivers, actual multi-AP coherence measurement, and OTFS
+  waveform control are hardware-dependent roadmap items." ADR-309 is the ADR
+  that closes exactly those gaps, in coordination with ADR-314.
+
+The missing piece is not the actuation surface — ADR-280 built that and made it
+fail closed — but the **loop**: a controller that reads the current fused-state
+uncertainty, selects a *controllable measurement configuration* expected to
+reduce it most, requests it through the ADR-280 governed surface, observes the
+response, and updates its belief before choosing the next measurement.
+
+## Options considered
+
+1. **Stay passive; only schedule which incidental observations to keep.** This
+   is roughly today's `ActiveSensingPlanner` (staleness-priority over regions).
+   Rejected as the endpoint: it optimizes *attention* over uncontrolled RF, not
+   the *measurement* itself. It remains the fallback when nothing is
+   controllable.
+2. **Open-loop measurement scripting** (a fixed sweep of channels/bandwidths).
+   Rejected: a fixed sweep spends the RF/energy/privacy budget the same way
+   regardless of what is already known; it cannot concentrate measurement where
+   uncertainty actually is.
+3. **Closed-loop experiment control** — read uncertainty, pick the controllable
+   configuration with highest expected information gain per unit cost/privacy,
+   actuate through the ADR-280 governed surface, observe, update, repeat.
+   Chosen.
+
+## Decision
+
+Adopt **closed-loop RF experiment control** as a phase-3 controller layered on
+the ADR-280 surface. RuView selects and drives the controllable degrees of
+freedom of the RF measurement, then optimizes the next measurement from the
+observed response.
+
+### 1. Controllable degrees of freedom
+
+Define an `ExperimentControl` vocabulary over the configuration axes RuView can
+influence on hardware that exposes them (each axis is optional and
+capability-gated by ADR-320's HAL, so an ESP32-only deployment simply has an
+empty controllable set and degrades to the passive planner):
+
+- **Channel / band** and **bandwidth** (which spectrum to probe; reuses the
+  ADR-292 wideband subcarrier-agnostic metadata).
+- **Packet timing / cadence** (when to solicit a sounding, and at what rate).
+- **Antenna / chain selection** (which subset of a distributed aperture to
+  activate — bounded by the ADR-280 `CoherentSensorGroup` compatibility proof).
+- **Beam / RIS configuration** (which rooms and people become observable —
+  governed exactly as ADR-280 §6 requires, via `request_actuation` and an
+  `ActuationReceipt`).
+- **802.11bf measurement parameters** (TB/non-TB, reporting config) once
+  ADR-310 exposes standardized sensing as a native measurement type.
+
+### 2. The loop
+
+```
+fused-state uncertainty (ADR-311)
+        │
+        ▼
+info-gain ranking of ExperimentControl options (ADR-314)
+        │  select argmax  E[ΔI] / (cost, energy, privacy ceiling)
+        ▼
+governed request  (ADR-280 admit_task / request_actuation, fail-closed)
+        │
+        ▼
+observe response → update belief (ADR-311) → repeat
+```
+
+The controller never bypasses the ADR-280 admission and actuation gates: every
+solicited measurement is a `SensingTask`/`SensingAction`, every environment
+change is an `ActuationReceipt`, and every step composes with the ADR-277
+policy engine. Information gain is what **ADR-314** supplies (the mutual-
+information estimate ADR-280 deferred); ADR-309 owns the *control loop* that
+consumes that estimate and drives the hardware.
+
+### 3. Governance and honesty boundary
+
+- Actuation and solicitation stay fail-closed and privacy-ceilinged: a
+  closed-loop experiment cannot widen the P0–P5 ceiling of the task it serves,
+  and cannot steer a beam into a zone that does not grant the purpose (ADR-280
+  `actuation_requires_policy_authorization`).
+- Any accuracy or "traffic-reduction" claim from the closed loop is tagged
+  **MEASURED** only with a named reproducer over a stated scenario, **SYNTHETIC**
+  for simulated apertures, and **CLAIMED** otherwise. Real multi-AP coherent
+  measurement and RIS actuation remain **hardware-dependent** and require
+  real-silicon evidence (a captured runtime log) before any hardware claim, per
+  CLAUDE.md. No number is invented here.
+
+## Consequences
+
+- Sensing becomes an experiment: RuView spends its RF/energy/privacy budget on
+  the measurements that most reduce current uncertainty, instead of processing
+  whatever incidental traffic arrives.
+- The loop is only as strong as its two dependencies: ADR-311 must expose a
+  usable uncertainty surface and ADR-314 must produce trustworthy information-
+  gain estimates. Where either is absent, the controller degrades to the
+  ADR-280 staleness planner rather than acting on a fabricated gain estimate.
+- Controllability is hardware-bounded. On commodity ESP32 sensors the
+  controllable set may be limited to cadence; the full loop (bandwidth, antenna,
+  beam) needs NICs/RIS that expose those axes, surfaced through ADR-320.
+- This ADR adds a controller; it does not re-open ADR-280's raw-export or
+  actuation-governance decisions, which remain authoritative and fail-closed.
+
+## Validation
+
+- Design-level acceptance (phase 3): a simulated closed loop over a synthetic
+  scene reduces terminal fused-state uncertainty faster than (a) the passive
+  ADR-280 staleness planner and (b) an open-loop fixed sweep, at equal
+  measurement budget — reported **SYNTHETIC**, with the scenario and seed named.
+- Governance tests: every solicited measurement and actuation in the loop is
+  admitted through the ADR-280 fail-closed path; a loop step that would exceed
+  the task's privacy ceiling or steer into an ungranted zone is denied.
+- Degradation test: with an empty controllable set (ESP32-only), the controller
+  falls back to the staleness planner with no error and no fabricated gain.
+- Hardware validation of bandwidth/antenna/beam actuation is explicitly out of
+  scope until real silicon exposes those axes and produces a captured log.
@@ -0,0 +1,147 @@
+# ADR-310: 802.11bf-native architecture — standardized WLAN sensing as native measurement types
+
+- **Status**: Proposed (ADR-300 phase 2)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: 80211bf, wlan-sensing, standards, measurement-types, hal, phase-2
+
+## Context
+
+This ADR is a child of **ADR-300** and owns primitive #10, *802.11bf-native
+architecture*. In the ADR-300 phasing it is a phase-2 integration primitive: it
+sits on the phase-1 spine (authenticated identity ADR-305, spatial ontology
+ADR-306, evidence engine ADR-304) and **feeds ADR-320** (the RuView sensor HAL),
+which is the clause of the acceptance test that "identifies the hardware." It is
+authored as **Proposed**.
+
+**IEEE 802.11bf-2025 ("WLAN Sensing") was published 2025-09-26** — verified
+against the IEEE SA record in `wifi-densepose-hardware` (`ieee80211bf/mod.rs`
+header, "evidence grade MEASURED", ADR-152 §1.1). Standardization is complete
+for sub-7 GHz and >45 GHz (DMG) bands: formal sensing measurement setup,
+measurement instances, feedback/reporting, and sensing-by-proxy (SBP). This
+changes RuView's strategic frame: rather than treating every WiFi measurement as
+an *opportunistic* extraction from incidental traffic, RuView can be the **open
+reference sensing stack around the standard** — the day commodity silicon
+exposes it.
+
+Substantial scaffolding already exists and must be **reused/extended, not
+rebuilt**. `v2/crates/wifi-densepose-hardware/src/ieee80211bf/` already models
+the standardized procedure surface as forward-compatible types (ADR-152/153):
+
+- `types` — `SpecProfile` version gates, `SensingRole`/`TransceiverRole`,
+  `MeasurementSetupParams`, `SensingCapabilities` negotiation, and required
+  `ConsentMode` governance metadata on every setup.
+- `messages` — `SensingMeasurementSetupRequest/Response`,
+  `SensingMeasurementInstance`, `SensingMeasurementReport`, `CsiReportPayload`,
+  `SbpRequest/Response`, `SensingSessionTermination`.
+- `session` — a deterministic FSM (`Idle → SetupNegotiating → Active →
+  Terminating → Idle`) with rejection paths, single-role enforcement, and SBP
+  proxy mode; `table` (responder-side setup registry); `transport` (the
+  `SensingTransport` seam, a `SimTransport` test double, and an
+  `OpportunisticCsiBridge` that maps today's opportunistic CSI onto the
+  standardized report path).
+
+The module's own honesty note is authoritative and carried forward here: it is
+**not a certified 802.11bf implementation**, and **no commodity silicon — ESP32
+included — implements the standard yet**; the OTA frame binding lands when a
+chipset exposes it. Wideband ingest plumbing is already in place too: **ADR-292**
+(FeitCSI/AX210) carries native subcarrier dimensionality end-to-end and records
+the native→pipeline mapping, and noted that "truncated CIR is a natural
+extension of the same plumbing."
+
+What is missing is architectural, not protocol scaffolding: normalized CSI is
+still treated as *the* WiFi input. The standardized sensing measurements
+(TB/non-TB soundings, truncated CIR / PDP reports) are modeled as protocol
+messages but are **not yet first-class native measurement types** that flow
+through calibration (ADR-301), fusion (ADR-311), and the ontology (ADR-306) on
+equal footing with normalized CSI.
+
+## Options considered
+
+1. **Keep 802.11bf as a protocol model only; always down-convert its reports to
+   normalized CSI at ingest.** Rejected: truncated CIR/PDP carry range-resolved
+   multipath structure that flattening to a CSI matrix discards; it also wastes
+   the standard's native report semantics.
+2. **Fork a parallel "bf pipeline" alongside the CSI pipeline.** Rejected:
+   duplicates calibration, fusion, ontology, and evidence plumbing, and re-opens
+   the O(surfaces²) translation problem ADR-306 exists to close.
+3. **Promote standardized sensing measurements to native measurement types
+   inside the existing pipeline**, with normalized CSI as one measurement type
+   among several. Chosen.
+
+## Decision
+
+Adopt an **802.11bf-native architecture**: standardized WLAN sensing
+measurements become **additional native measurement types**, alongside — not
+replacing — normalized CSI.
+
+### 1. Native measurement types
+
+- Define the standardized reports the `ieee80211bf` module already models
+  (TB and non-TB soundings; truncated CIR; PDP) as first-class
+  `MeasurementType` variants that the pipeline carries end-to-end, each tagged
+  with its `SpecProfile` and band. Normalized CSI remains one such type; the
+  `OpportunisticCsiBridge` remains the path for silicon that only offers
+  incidental CSI.
+- Truncated CIR/PDP reuse the **ADR-292** subcarrier-agnostic / native-
+  dimensionality plumbing (truncated CIR is the stated natural extension); the
+  native→pipeline mapping is recorded in frame metadata so downstream stages
+  know the true range/spectral resolution of a bf report vs. an interpolated CSI
+  frame.
+
+### 2. Ontology and governance binding
+
+- Each standardized measurement becomes an ADR-306 `Observation` node from an
+  ADR-305-authenticated `Sensor`, carrying `SemanticProvenance` and exactly one
+  `EvidenceLevel` (L0–L5, ADR-282). The `ieee80211bf` `ConsentMode` metadata —
+  required on every setup — composes with the ADR-277 policy engine, so a
+  standardized session is admitted under the same governance as any other
+  sensing task (ADR-280).
+- SBP (sensing-by-proxy) sessions attribute the report to the proxying and the
+  sensing entities distinctly, so provenance is not laundered through the proxy.
+
+### 3. HAL feed (ADR-320)
+
+- The capability set a device advertises — which `MeasurementType`s, bands,
+  bandwidths, roles, and `SpecProfile` it supports — is exactly the descriptor
+  **ADR-320** (HAL) needs to "identify the hardware." ADR-310 defines that
+  capability descriptor as the projection of `SensingCapabilities`; ADR-320
+  consumes it. A device that implements no bf profile advertises only the
+  opportunistic-CSI capability.
+
+## Consequences
+
+- RuView is positioned as the open reference stack *around* the standard: when a
+  chipset exposes 802.11bf, its native reports flow through calibration, fusion,
+  ontology, and evidence with no bespoke pipeline — the plumbing is already
+  tested against `SimTransport` and synthetic fixtures.
+- Normalized CSI is demoted from "the WiFi input" to "one measurement type,"
+  which is the correct framing for a multi-measurement future and prevents the
+  bf path from being a second-class citizen.
+- **No hardware claim is made or implied.** No commodity silicon implements
+  802.11bf yet; this ADR wires the *types and flow*, tested in simulation. Any
+  OTA/native-report accuracy claim requires real silicon evidence (a captured
+  log) per CLAUDE.md, and any wideband number must be tagged with the capture
+  hardware (ADR-292). No benchmark number is invented here.
+- This ADR does not re-open ADR-152/153's decision to avoid OTA frame binding
+  until silicon exists; it consumes that surface and adds the pipeline
+  integration.
+
+## Validation
+
+- `cargo test -p wifi-densepose-hardware` — existing `ieee80211bf` FSM,
+  table, and transport tests continue to pass; new tests assert that a
+  `SensingMeasurementReport` (TB and non-TB) and a truncated-CIR/PDP report
+  round-trip through the pipeline as native `MeasurementType`s.
+- `cargo test -p wifi-densepose-mat` — truncated CIR ingest reuses the ADR-292
+  subcarrier-agnostic path and records the native→pipeline mapping; dimension/
+  version validation on standardized reports mirrors the FeitCSI parser gates.
+- Ontology/governance tests: each standardized measurement becomes an ADR-306
+  `Observation` from an ADR-305-authenticated `Sensor` with one `EvidenceLevel`;
+  `ConsentMode` composes with ADR-277 admission; SBP attributes proxy vs. sensor
+  provenance distinctly.
+- HAL contract test: the ADR-320 capability descriptor is derivable from
+  `SensingCapabilities`; a bf-less device advertises only opportunistic CSI.
+- All measurement-type flows are simulation-tested (`SimTransport`, synthetic
+  fixtures); OTA binding and any hardware accuracy claim remain out of scope
+  until real silicon exposes the standard.
@@ -0,0 +1,140 @@
+# ADR-311: Real sensor fusion — uncertainty-aware, multiple observations → one world state
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 2)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: fusion, uncertainty, multimodal, world-state, ontology, phase-2
+
+## Context
+
+This ADR is a child of **ADR-300** and owns primitive #11, *real sensor fusion*.
+In the ADR-300 DAG it is a phase-2 integration primitive: it **consumes ADR-306**
+(canonical spatial ontology) and **produces the single fused world state** that
+the phase-3 primitives build on — **ADR-312** (long-term spatial memory),
+**ADR-313** (counterfactual inference), and **ADR-315** (digital RF twin). It is
+authored as **Proposed**.
+
+The defining invariant is not "support more modalities" but the *shape of the
+output*: **multiple observations must resolve to one probabilistic world state,
+not many feeds into a visualization.** A dashboard that shows a WiFi layer, a
+mmWave layer, and a BLE layer side by side is not fusion; it pushes the
+reconciliation onto the human. Real fusion produces one uncertainty-aware state
+that every downstream consumer reads, with each contributing observation's
+provenance and confidence still recoverable.
+
+Substantial scaffolding already exists and must be **reused/extended, not
+rebuilt**:
+
+- **ADR-063** (60 GHz mmWave ↔ WiFi CSI fusion, *Proposed*) established the
+  first cross-modal fusion case: pairing noisy CSI-derived vitals with clinical-
+  grade mmWave FMCW radar (Seeed MR60BHA2 over UART, with a **live hardware
+  capture** logged on 2026-03-15). ADR-311 generalizes that pairwise case into
+  an N-modality, uncertainty-aware fusion.
+- **ADR-137** (fusion-engine quality scoring, *Accepted — partial*) already
+  built the auditable-quality building block: it identified that the multistatic
+  fusers (`wifi-densepose-signal/src/ruvsense/multistatic.rs`,
+  `wifi-densepose-ruvector/src/viewpoint/fusion.rs`) discarded the evidence they
+  used, and specified a single auditable record — "this fused output is
+  trustworthy because X, Y, Z, but be aware of contradiction C" — with evidence
+  references and contradiction flags. ADR-311 reuses that record as the
+  provenance/quality carrier of the fused state.
+- **ADR-280** `CoherentSensorGroup` (fail-closed coherent fusion) and
+  **ADR-306** `Observation`/`Track`/`Event` node types are the input and output
+  vocabulary respectively.
+
+What is missing is the **uncertainty-aware combiner across heterogeneous
+modalities**: a fusion stage that takes authenticated observations from WiFi,
+BLE, UWB, mmWave, acoustic, IMU, lidar, and cameras (only where policy permits),
+each with its own uncertainty, and emits one probabilistic `WorldState` — with
+per-observation contradiction flags, not a stack of independent feeds.
+
+## Options considered
+
+1. **Per-modality feeds rendered together** (today's implicit model on some
+   surfaces). Rejected: it is visualization, not fusion; contradictions are
+   never reconciled and there is no single state to reason over.
+2. **Hard-switch "best modality wins"** (e.g., always prefer mmWave vitals over
+   CSI vitals). Rejected: throws away corroborating evidence and cannot express
+   *disagreement* — the very thing ADR-137's contradiction flags exist to
+   surface — and degrades badly when the preferred modality is absent or OOD.
+3. **Uncertainty-weighted probabilistic fusion into one world state**, reusing
+   ADR-137's auditable quality record and ADR-280's fail-closed coherence gate.
+   Chosen.
+
+## Decision
+
+Adopt **uncertainty-aware multimodal fusion** whose invariant output is one
+probabilistic world state.
+
+### 1. Inputs: authenticated, ontology-typed observations
+
+- Inputs are ADR-306 `Observation` nodes from **ADR-305-authenticated** sensors.
+  Supported modalities: WiFi (CSI / 802.11bf native reports via ADR-310), BLE,
+  UWB, mmWave (ADR-063), acoustic, IMU, lidar, and cameras. Cameras and any
+  higher privacy-class modality enter fusion **only where the ADR-277 policy
+  engine permits** — camera-free coverage is a RuView invariant (ADR-282), so
+  cameras are an opt-in, policy-gated input, never assumed present.
+- Each observation carries its own uncertainty and exactly one `EvidenceLevel`
+  (ADR-282). An observation flagged out-of-distribution by **ADR-302** is
+  down-weighted or excluded per its OOD verdict rather than silently averaged in.
+
+### 2. Combiner: uncertainty-weighted, contradiction-aware
+
+- Observations are combined by their uncertainty into one probabilistic
+  `WorldState` over the ADR-306 entities (`Person`, `Object`, `Track`, and the
+  per-`Space` inference). The combiner does **not** collapse disagreement: when
+  modalities conflict beyond their stated uncertainty, the fused output carries
+  ADR-137 **contradiction flags** and the evidence references that produced
+  them, so a consumer can see *that* WiFi and mmWave disagree and *why*.
+- Coherent multi-node fusion inherits ADR-280's fail-closed
+  `CoherentSensorGroup` gate: no coherent combination unless sync, phase, and
+  geometry compatibility are proven; otherwise the group degrades to incoherent
+  combination rather than producing confident nonsense.
+
+### 3. Output: one world state, provenance preserved
+
+- The output is a single `WorldState` written into the ADR-306 ontology, with
+  every fused value retaining recoverable per-observation provenance and the
+  ADR-137 quality record. This is the state ADR-312/310/312 consume; they read
+  one probabilistic world, not a modality stack.
+- The fused state carries an aggregate uncertainty and an evidence level derived
+  from its inputs (never upgraded above the weakest contributing L-level for a
+  given claim).
+
+## Consequences
+
+- Downstream primitives (spatial memory, counterfactual, RF twin) build on one
+  probabilistic world state with uniform uncertainty and provenance, instead of
+  re-implementing reconciliation per consumer.
+- Contradictions become first-class signal, not noise: ADR-137's record means a
+  disagreement between mmWave and CSI is surfaced and auditable, which is also
+  what lets ADR-302 and the evidence engine (ADR-304) reason about reliability.
+- Fusion is uncertainty-honest: an OOD or low-evidence observation is
+  down-weighted, not averaged in as if trustworthy; a fused claim never presents
+  a stronger evidence level than its weakest necessary input.
+- **No accuracy or "camera-grade" claim is made.** ADR-063's mmWave path has a
+  real-silicon capture; the multimodal combiner's accuracy is not asserted here.
+  Any fused-accuracy number requires a named reproducer tagged MEASURED /
+  SYNTHETIC / CLAIMED, and WiFi sensing is never presented as camera-grade
+  (CLAUDE.md, ADR-282). No number is invented.
+- Cameras remain a governed, opt-in input; enabling them does not weaken the
+  camera-free coverage guarantee for deployments that exclude them.
+
+## Validation
+
+- `cargo test -p wifi-densepose-ruvector` / `-p wifi-densepose-signal` — the
+  ADR-137 quality record and contradiction flags travel with the fused output;
+  the ADR-280 `CoherentSensorGroup` gate still fails closed under
+  clock/phase/geometry violation.
+- Fusion invariant test: N modality observations over one scene resolve to a
+  single `WorldState` node in the ADR-306 ontology (not N feeds), with
+  per-observation provenance recoverable and one aggregate evidence level.
+- Uncertainty tests: a high-uncertainty or ADR-302-flagged-OOD observation is
+  down-weighted/excluded; conflicting modalities produce a contradiction flag
+  rather than a silently averaged value; the fused evidence level never exceeds
+  the weakest necessary input.
+- Governance test: a camera or higher-privacy modality is admitted into fusion
+  only when the ADR-277 policy engine permits; otherwise it is excluded and the
+  fused state notes the exclusion.
+- Any accuracy comparison (e.g., fused vitals vs. mmWave-only) is reported with
+  its evidence tag and reproducer; none is asserted in this ADR.
@@ -0,0 +1,146 @@
+# ADR-312: Long-term spatial memory — learn the normal physics of a location
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 3)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: spatial-memory, ruvector, anomaly-detection, temporal, world-state, phase-3
+
+## Context
+
+This ADR is a child of **ADR-300** and owns primitive #12, *long-term spatial
+memory*. In the ADR-300 phasing it is a phase-3 primitive that sits on the fused
+world state produced by **ADR-311** (real sensor fusion) and **ties to ADR-315**
+(digital RF twin): spatial memory is the *learned normal* that a twin can
+simulate against and that anomaly detection compares against. It is authored as
+**Proposed**.
+
+The capability is to **learn the normal physics of a location** so anomalies
+surface *without training a detector for every anomaly*. Concretely, the system
+should learn statements like: "a chair is normally here"; "this bedroom is
+usually occupied between these hours"; "the RF propagation of this space
+changed"; "this machine's vibration signature changed"; "a new reflector
+appeared." None of these is a labeled anomaly class — they are *deviations from
+a learned baseline of normality*. This is the difference between supervised
+anomaly detection (which needs examples of every failure) and **baseline-relative
+anomaly detection** (which needs only a well-characterized normal).
+
+Substantial substrate already exists and must be **reused/extended, not
+rebuilt**:
+
+- **RuVector** (`v2/crates/wifi-densepose-ruvector`) is the designated substrate
+  in the ADR-282 layer stack ("persistent objects, Gaussian fields, scene
+  graphs, temporal memory"). It already provides the vector/temporal machinery
+  this ADR needs — HNSW indexing (`hnsw.rs`, `hnsw_quantized.rs`), an event log
+  (`event_log.rs`), coverage and estimator surfaces, and the `crv`/`mat`
+  temporal sub-modules — so long-term spatial memory is a *consumer and
+  organizer* of RuVector primitives, not a new store.
+- **ADR-306** supplies the entity vocabulary the memory is indexed by (`Space`,
+  `Object`, `Sensor`, `Track`, `Event`); **ADR-311** supplies the fused,
+  uncertainty-carrying `WorldState` snapshots that memory accumulates over time.
+- **ADR-135** (empty-room baseline calibration) and **ADR-301** (automatic
+  domain calibration) already establish a *calibration-time* baseline of a
+  space; ADR-312 extends that from a one-shot baseline to a **continuously
+  learned, time-of-day-aware** model of normal.
+
+What is missing is the **temporal normality model**: a per-`Space` learned
+distribution of fused world states over time (including periodicity — hour of
+day, day of week), plus RF-propagation and modality-signature baselines, against
+which a live fused state is scored for deviation.
+
+## Options considered
+
+1. **Supervised anomaly classifiers per anomaly type.** Rejected: it needs
+   labeled examples of every anomaly (fall, intrusion, machine fault, moved
+   furniture), which do not exist for most spaces and do not transfer between
+   rooms; it also cannot catch a *novel* anomaly it was never trained on.
+2. **Single static baseline** (the ADR-135 empty-room snapshot, used forever).
+   Rejected as the endpoint: it cannot express *when* a space is normally
+   occupied, cannot track slow legitimate drift (furniture rearranged on
+   purpose), and flags every diurnal change as anomalous.
+3. **Continuously learned, time-aware normality model on the RuVector
+   substrate**, scoring live fused state against learned normal. Chosen.
+
+## Decision
+
+Adopt a **long-term spatial memory** that learns each location's normal physics
+on the RuVector substrate and scores live fused state against it.
+
+### 1. What "normal" is learned over
+
+Per ADR-306 `Space` (and the entities within it), accumulate the ADR-311 fused
+`WorldState` over time into a learned normality model covering:
+
+- **Occupancy / activity periodicity** — the distribution of presence and
+  activity by hour-of-day and day-of-week (the "bedroom usually occupied certain
+  hours" case).
+- **Static scene layout** — persistent `Object` positions and the expected
+  reflector set (the "chair normally here" / "new reflector appeared" cases),
+  building on the ADR-135/298 baseline.
+- **RF-propagation baseline** — the space's normal multipath/propagation
+  signature (the "RF propagation changed" case).
+- **Per-modality signatures** — e.g., a machine's normal vibration/acoustic/IMU
+  signature (the "vibration signature changed" case).
+
+Each learned baseline carries its own uncertainty and an `EvidenceLevel`
+(ADR-282); a baseline learned from replay is L1, from a field pilot L4, and is
+never presented above the evidence of the observations it was learned from.
+
+### 2. Substrate: RuVector, temporally compressed
+
+- The memory is stored and indexed on RuVector (HNSW for nearest-normal recall,
+  the event log for the temporal stream, the temporal sub-modules for
+  compression). Long-horizon history is temporally compressed — recent detail
+  retained, older history summarized — so memory cost is bounded rather than
+  growing linearly forever.
+- The memory is *keyed by* the ADR-306 ontology, so "normal for this `Space` at
+  this hour" is a first-class query, and slow legitimate drift updates the
+  baseline (with provenance) instead of accumulating as permanent anomaly.
+
+### 3. Anomaly = deviation from learned normal
+
+- A live fused `WorldState` is scored against the applicable learned baseline
+  (matched by space and time context). A deviation beyond the baseline's
+  uncertainty is surfaced as an ADR-306 `Event` — *without* a per-anomaly
+  detector — carrying the baseline it deviated from, the deviation magnitude,
+  and its evidence level. Whether that event is actionable is a policy/consumer
+  decision (ADR-277), not this layer's.
+- The learned normal is exactly what **ADR-315** (RF twin) can simulate against:
+  the twin proposes an expected state, spatial memory supplies the learned
+  actual-normal, and their divergence is a physically grounded anomaly signal.
+
+## Consequences
+
+- Anomaly detection generalizes: a space gets deviation detection from its own
+  learned normal, so a novel anomaly (never labeled anywhere) still registers as
+  a deviation, and the model transfers to a new room by *learning that room's*
+  normal rather than importing a foreign detector.
+- Bounded memory: temporal compression keeps long-horizon memory finite; the
+  trade-off is that fine detail of old history is summarized, which is acceptable
+  for a normality baseline.
+- Legitimate change is not a permanent false positive: slow drift updates the
+  baseline with provenance, distinguishing "furniture deliberately rearranged"
+  (baseline shifts) from "reflector appeared unexpectedly" (deviation event).
+- **No accuracy claim is made.** Deviation-detection quality is not asserted
+  here; any detection-rate or false-positive number requires a named reproducer
+  tagged MEASURED / SYNTHETIC / CLAIMED, and a health/safety framing stays within
+  the ADR-282 bounded-claims discipline (decision support, not diagnosis). No
+  number is invented.
+- The memory is governed: learned baselines are observations of a space, subject
+  to the same ADR-277 retention/privacy policy as the fused state they summarize;
+  no raw P0 RF is retained to build a baseline.
+
+## Validation
+
+- `cargo test -p wifi-densepose-ruvector` — the normality model builds on the
+  existing HNSW/event-log/temporal primitives; nearest-normal recall and
+  temporal-compression bounds are exercised on synthetic streams.
+- Baseline/deviation tests: a synthetic scene with a known injected change (moved
+  `Object`, altered propagation, altered modality signature) produces a deviation
+  `Event` against the learned normal *without* a per-anomaly detector; an
+  unchanged diurnal cycle produces none (no false positive on normal periodicity).
+- Drift test: a slow legitimate change updates the baseline (with provenance)
+  rather than emitting a persistent anomaly; an abrupt change does emit one.
+- Evidence test: a learned baseline carries the evidence level of its source
+  observations and is never presented above it; retention honors ADR-277.
+- Twin-linkage design check (with ADR-315): divergence between a twin-simulated
+  expected state and the learned normal is expressible as a deviation signal.
@@ -0,0 +1,142 @@
+# ADR-313: Counterfactual inference — generative spatial reasoning
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 3)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: inference, generative, counterfactual, rf-twin, fusion, uncertainty, phase-3
+
+## Context
+
+This ADR is a child of **ADR-300** (perception substrate program) and owns
+primitive #13, *counterfactual inference*. In the ADR-300 DAG it is a phase-3,
+research-forward primitive that sits on top of the fused world state: it
+**consumes ADR-311** (real sensor fusion) for the current fused estimate and
+**ADR-315** (digital RF twin) for the twin's expected measurement
+distributions. It is design intent, authored as Proposed, and is expected to be
+revised as the phase-1 spine and the phase-2 fusion layer land.
+
+RuView today reasons discriminatively: a task head maps measurements to a label
+or a pose. That answers "what does the classifier say?" but not the questions an
+operator actually asks — *would these RF measurements still make sense if nobody
+were present? Does one person explain the observation better than two?* Those
+are counterfactual questions, and a classifier cannot answer them because it has
+no model of what a measurement *should* look like under a hypothesized world
+state. A discriminative head asked about an empty room simply emits its
+best-effort label; it cannot say "the observation is better explained by
+absence."
+
+The step this ADR proposes is toward a **generative spatial model**: given a
+hypothesized scene state (occupancy, count, coarse positions) and the ADR-315
+twin's propagation model for the deployment, predict the *expected* measurement
+distribution, then score how well each hypothesis explains the observed
+measurement. The best-explaining hypothesis — including the *nobody-present*
+null hypothesis — is the answer, and the margin between hypotheses is a
+first-class uncertainty signal.
+
+Relevant existing assets to build on rather than duplicate:
+
+- **ADR-311** (fusion) already produces the fused world estimate and its
+  covariance; the counterfactual layer scores hypotheses *relative to* that
+  estimate rather than re-fusing raw measurements.
+- **ADR-315** (RF twin) is the generative forward model — per-deployment
+  geometry, radio locations, and expected measurement distributions. This ADR
+  is a *consumer* of the twin's forward simulator, not a second simulator.
+- **ADR-302** (OOD/observability) already owns the `UNKNOWN` verdict; the
+  null-hypothesis ("nobody present better explains this than any occupancy
+  hypothesis") and the "no hypothesis explains this" case route through ADR-302,
+  not a parallel gate.
+- `frame::EvidenceLevel` L0–L5 (ADR-282) and the ADR-304 evidence engine
+  account for the resulting confidence.
+
+## Options considered
+
+1. **Keep only discriminative heads.** Rejected: cannot express absence,
+   cannot compare "one person vs. two" as competing explanations, and gives a
+   confident label even when no world state explains the data.
+2. **A second, independently trained generative network with its own forward
+   model.** Rejected for the default path: duplicates the ADR-315 twin's
+   propagation model, invites the two models to disagree, and multiplies the
+   surface that must be validated. Reserved only if the twin's analytic forward
+   model proves insufficient for a phenomenon.
+3. **A hypothesis-scoring layer that uses the ADR-315 twin as the forward model
+   and the ADR-311 fused state as the hypothesis prior, routing low-margin and
+   null-dominant cases to the ADR-302 UNKNOWN verdict.** Chosen.
+
+## Decision
+
+Define a **counterfactual inference layer** that scores a small set of scene
+hypotheses against observed measurements using the digital RF twin as the
+generative forward model.
+
+### 1. Hypothesis set
+
+- Hypotheses are drawn from the ADR-311 fused state and its neighbourhood: the
+  current estimate, the **null hypothesis** (nobody present), and a bounded set
+  of nearby alternatives (±1 occupant, shifted position). The fused estimate
+  supplies the prior so the search stays small and grounded rather than
+  enumerating an open world.
+- The hypothesis space is expressed over the **ADR-306** canonical ontology
+  (`Space`/`Zone`, occupant count, coarse position), so a counterfactual result
+  is a governed spatial statement, not an opaque score.
+
+### 2. Forward model and scoring
+
+- For each hypothesis, query the **ADR-315 twin** for the expected measurement
+  distribution given that scene state and the deployment's propagation model.
+  Score the observed measurement's likelihood under each hypothesis's expected
+  distribution.
+- The answer is the maximum-likelihood hypothesis; the **margin** between the
+  top hypotheses (and between the top hypothesis and the null) is the
+  confidence signal, carried into the ADR-304 evidence engine.
+
+### 3. Routing to UNKNOWN
+
+- When the null hypothesis dominates, the layer reports *absence*, not a
+  low-confidence occupancy label.
+- When **no** hypothesis explains the observation well (all likelihoods low, or
+  the winning margin below threshold), the result routes to the **ADR-302**
+  `UNKNOWN` verdict — the observation is outside what the twin can explain, and
+  the honest output is "I cannot account for this," never a forced label.
+
+### Evidence discipline
+
+- Twin-predicted distributions are a **simulation** (evidence level L0 per
+  ADR-282) labelled `SYNTHETIC`; a counterfactual verdict inherits the evidence
+  level of its weakest input and is never presented as camera-grade ground
+  truth (CLAUDE.md honesty rule).
+- Any accuracy statement about counterfactual discrimination (e.g. "distinguishes
+  one occupant from two") requires the mean-pose-style baseline discipline of
+  CLAUDE.md, a leakage-free held-out split, and a reproducer before it may be
+  tagged `MEASURED`. This ADR asserts **no** such number.
+
+## Consequences
+
+- RuView gains the ability to answer absence and "which explanation is better"
+  questions that discriminative heads structurally cannot — a step toward
+  generative spatial reasoning and a differentiator for security and
+  facility-monitoring applications where *absence* is the valuable signal.
+- Quality is bounded by the fidelity of the ADR-315 twin's forward model and the
+  ADR-311 fused prior; the layer reports margins and defers to ADR-302 UNKNOWN
+  rather than overstating a coarse model.
+- Hard dependency on ADR-311 (fused state and covariance) and ADR-315 (forward
+  model); this ADR builds neither a fusion engine nor a propagation simulator of
+  its own.
+- Being phase 3, this is design intent sitting on the fused world state; it is
+  expected to be revised as ADR-311 and ADR-315 land, and it is not implemented
+  by the phase-1 swarm.
+
+## Validation
+
+- Unit tests: hypothesis likelihood scoring is a deterministic function of
+  observed measurement + hypothesis + twin parameters; the null hypothesis wins
+  on a synthesized empty-room measurement; a two-occupant measurement scores the
+  two-occupant hypothesis above the one-occupant hypothesis on a controlled
+  synthetic case.
+- Integration test: measurements the twin cannot explain (out-of-model
+  scattering) drive the layer to the ADR-302 UNKNOWN verdict rather than a
+  forced occupancy label; margins propagate into the ADR-304 evidence engine.
+- Held-out discrimination (deferred, real-silicon): one-vs-two and
+  presence-vs-absence discrimination on a leakage-free held-out split with a
+  mean-pose baseline, reported as `MEASURED` with a reproducer. Until then all
+  counterfactual output is `SYNTHETIC`/L0. No discrimination accuracy number is
+  asserted by this ADR.
@@ -0,0 +1,138 @@
+# ADR-314: Information-gain scheduler — sample the most informative radios
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 3)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: scheduling, active-sensing, information-gain, edge, energy, fusion, phase-3
+
+## Context
+
+This ADR is a child of **ADR-300** (perception substrate program) and owns
+primitive #14, *information-gain scheduler*. In the ADR-300 DAG it is a phase-3,
+research-forward primitive that sits on top of the fused world state and
+**pairs with ADR-309** (active sensing): ADR-309 decides *what to probe*
+(waveform, sensing task); this ADR decides *which radios/modalities to spend
+budget on next*. It is authored as Proposed and is not implemented by the
+phase-1 swarm.
+
+With multiple sensors, processing every stream at full rate is wasteful: many
+radios are, at any moment, contributing little to the current estimate while
+consuming compute, energy, and bandwidth — the three scarce resources on the
+edge nodes RuView targets (ESP32-S3/C6 and small gateways). Treating all sensors
+equally is precisely the design that does not survive a real deployment of
+"hundreds of sensors."
+
+The scheduler assigns each candidate sensor/modality a value
+
+```
+Value(sensor) ≈ expected uncertainty reduction / (compute + energy + bandwidth)
+```
+
+and spends the next sampling/processing budget on the highest-value sensors.
+Expected uncertainty reduction is estimated *before* paying for the measurement,
+which is why the scheduler needs a model of what each sensor is likely to tell
+it — supplied by the fused state's covariance and the RF twin's forward model,
+not by actually sampling.
+
+Relevant existing assets to build on rather than duplicate:
+
+- **ADR-311** (fusion) maintains the fused state and its covariance — the
+  current uncertainty the scheduler is trying to reduce. Expected uncertainty
+  reduction is computed against that covariance, not a private one.
+- **ADR-315** (RF twin) provides the per-sensor forward model used to predict a
+  candidate measurement's expected informativeness before sampling.
+- **ADR-320** (RuView sensor HAL, phase 2) exposes each radio's real
+  compute/energy/bandwidth cost descriptors; the denominator is read from the
+  HAL, not guessed per platform.
+- **ADR-309** (active sensing) is the paired actuator: the scheduler ranks
+  sensors, ADR-309 chooses the probe on the chosen sensor.
+- **ADR-302** (observability) defines the phenomenon the estimate is *for*, so
+  the scheduler prioritizes uncertainty reduction on the objective that matters,
+  not on nuisance dimensions.
+
+## Options considered
+
+1. **Round-robin / process-everything scheduling.** Rejected: burns edge
+   compute and energy on redundant streams and does not scale to large fleets;
+   the strategic and external reviews named exactly this as an edge-deployment
+   blocker.
+2. **Static priority per sensor type (e.g. always prefer mmWave).** Rejected:
+   ignores that a sensor's *current* informativeness depends on the scene and
+   the present uncertainty — a well-placed WiFi link can dominate an occluded
+   mmWave node in a given moment.
+3. **A value-of-information scheduler that ranks sensors by expected uncertainty
+   reduction per unit cost, using the ADR-311 covariance and ADR-315 forward
+   model, with costs from the ADR-320 HAL.** Chosen.
+
+## Decision
+
+Define an **information-gain scheduler** that allocates the next
+sampling/processing budget across available radios by value of information.
+
+### 1. Value function
+
+- For each candidate sensor/modality, estimate **expected uncertainty
+  reduction** on the ADR-302 objective by evaluating how much a predicted
+  measurement (via the **ADR-315** forward model) would shrink the **ADR-311**
+  fused-state covariance — a value-of-information estimate made *before* paying
+  for the measurement.
+- Divide by the sensor's **cost** — compute + energy + bandwidth — read from the
+  **ADR-320** HAL descriptors. The exact weighting of the three cost terms is a
+  deployment policy (a battery node weights energy heavily; a wired gateway
+  weights bandwidth), configured, not hardcoded.
+
+### 2. Allocation
+
+- Rank candidates by value and spend the budget on the top set, subject to a
+  configurable floor that guarantees each sensor is sampled at least
+  occasionally (so a sensor whose value is currently low is not starved into
+  permanent blindness and can be re-evaluated as the scene changes).
+- The scheduler emits an allocation, not a measurement; **ADR-309** active
+  sensing chooses the probe/waveform on each selected sensor, and the fusion
+  layer (ADR-311) incorporates the result.
+
+### 3. Governance and honesty
+
+- Skipping a sensor for a cycle is a *deliberate* reduction in coverage; the
+  scheduler records which sensors were sampled so downstream evidence (ADR-304)
+  reflects the actual sensing that occurred, and observability (ADR-302) can
+  raise `UNKNOWN` for a zone that went under-sampled rather than reporting a
+  stale estimate as current.
+
+### Evidence discipline
+
+- Expected-uncertainty-reduction estimates are model predictions from the
+  ADR-315 twin (simulation, L0 per ADR-282, `SYNTHETIC`); a scheduling decision
+  is a resource choice, never a sensing claim.
+- Any energy/latency/throughput improvement figure requires real-silicon
+  measurement with a reproducer before it is tagged `MEASURED` (CLAUDE.md
+  hardware rule). This ADR asserts **no** efficiency number.
+
+## Consequences
+
+- Edge deployments spend scarce compute, energy, and bandwidth where they buy
+  the most certainty, making "hundreds of sensors" operationally tractable — a
+  capability the reviews flagged as critical for edge deployment.
+- Quality is bounded by the accuracy of the ADR-315 forward model (informativeness
+  prediction) and ADR-320 cost descriptors; a poor forward model degrades to
+  near-round-robin, which is safe but not optimal. The sampling floor bounds the
+  worst case.
+- Hard dependency on ADR-311 (covariance), ADR-315 (forward model), and ADR-320
+  (cost descriptors), and paired with ADR-309; this ADR builds none of those.
+- Being phase 3, this is design intent sitting on the fused world state and is
+  expected to be revised as ADR-309, ADR-311, ADR-315, and the ADR-320 HAL land.
+
+## Validation
+
+- Unit tests: the value function is a deterministic function of covariance +
+  forward model + cost descriptors; a sensor predicted to reduce objective
+  uncertainty more per unit cost ranks above one that reduces it less; the
+  sampling floor guarantees eventual re-evaluation of a low-value sensor.
+- Integration test: on a synthetic multi-sensor scene, the scheduler reduces
+  objective uncertainty faster per unit modelled cost than round-robin, and
+  raises ADR-302 UNKNOWN for a deliberately starved zone rather than reporting a
+  stale estimate.
+- Field validation (deferred, real-silicon): energy/latency/throughput on an
+  instrumented multi-node deployment, reported as `MEASURED` with a reproducer.
+  Until then all informativeness and cost figures are `SYNTHETIC`/L0. No
+  efficiency number is asserted by this ADR.
@@ -0,0 +1,159 @@
+# ADR-315: Digital RF twin — persistent per-deployment RF model
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 3)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: rf-twin, digital-twin, propagation, calibration, spatial-memory, worldgraph, phase-3
+
+## Context
+
+This ADR is a child of **ADR-300** (perception substrate program) and owns
+primitive #15, *digital RF twin*. In the ADR-300 DAG it is a phase-3,
+research-forward primitive that underpins several other phase-3 primitives:
+**ADR-308** (placement optimizer) plans against the twin's propagation model,
+**ADR-313** (counterfactual inference) uses it as the generative forward model,
+and **ADR-314** (information-gain scheduler) uses it to predict per-sensor
+informativeness. It ties directly to **ADR-301** (calibration), **ADR-308**
+(placement), and **ADR-312** (long-term spatial memory). It is authored as
+Proposed and is not implemented by the phase-1 swarm.
+
+RuView today has no persistent, per-deployment model of the RF environment.
+Calibration state, observed multipath, and radio geometry exist transiently
+inside a running session; when the process restarts or a change happens
+overnight, there is nothing that says "this is what this room's RF looked like
+yesterday." Without a persistent baseline, a physical change — furniture moved,
+a wall opened, a machine relocated, an intruder present — has nothing to be a
+*delta against*. It is just a different measurement, indistinguishable from
+noise or drift.
+
+The **digital RF twin** is that persistent baseline: a per-deployment model
+holding
+
+- **geometry and radio locations** (from the ADR-306 scene / worldgraph),
+- **propagation history** and **observed multipath** structure,
+- **calibration state** (from ADR-301),
+- **expected measurement distributions** for each link and phenomenon.
+
+Once the twin exists, a physical change becomes a **measurable delta against the
+twin** rather than an unexplained measurement. This is what connects RuView to
+facility management (what changed in this space?), security (is there an
+unexplained presence?), robotics (has the map drifted?), and industrial
+monitoring (did the plant layout change?) — the applications the strategic
+assessment named as the value beyond a single detector.
+
+Relevant existing assets to build on rather than duplicate:
+
+- The `worldgraph` crate already models the physical scene — `Room`/`Space`
+  with `bounds_enu`, `Wall { rf_attenuation_db }`, `Doorway`, `Zone`, and
+  `Sensor` nodes (ADR-306). The twin *annotates and persists* this scene with RF
+  state; it does not invent a second geometry.
+- `wifi-densepose-calibration` (enrollment, bank, anchor, runtime, specialist)
+  holds the calibration state the twin persists; the twin references and
+  versions calibration records, it does not reimplement calibration.
+- **ADR-312** (long-term spatial memory, phase 3) is the persistence and
+  temporal-history substrate; the twin is a *structured occupant* of that
+  memory, not a separate database.
+- **ADR-305** (authenticated identity) and **ADR-295** (provenance) mean the
+  measurements that update the twin carry verified lineage, so a delta is
+  attributable rather than anonymous.
+
+## Options considered
+
+1. **No persistent RF model (status quo).** Rejected: every change looks like
+   noise; nothing supports "what changed since yesterday?", which is the
+   question the facility/security/industrial applications actually ask.
+2. **A full electromagnetic digital twin (per-site ray-tracing / FDTD kept in
+   sync in real time).** Rejected for the default path: far heavier than the
+   coarse `rf_attenuation_db` scene RuView actually has and impractical on edge
+   hardware. A high-fidelity solver is retained as an *optional backend* the
+   twin can call, not the baseline.
+3. **A persistent, per-deployment RF model layered over the ADR-306 scene and
+   ADR-312 memory: geometry + radio locations + calibration state + observed
+   multipath + expected measurement distributions, updated by verified
+   measurements, exposing changes as deltas.** Chosen.
+
+## Decision
+
+Define the **digital RF twin** as a persistent, versioned, per-deployment model
+of the RF environment, layered over existing scene, calibration, and memory
+assets.
+
+### 1. State the twin holds
+
+- **Geometry and radio locations** referenced from the ADR-306 / worldgraph
+  scene (not copied).
+- **Calibration state** referenced and versioned from
+  `wifi-densepose-calibration` (ADR-301), so the twin knows *which* calibration
+  a stored distribution was captured under.
+- **Observed multipath and propagation history** — a bounded temporal summary
+  of per-link channel structure, stored in ADR-312 spatial memory.
+- **Expected measurement distributions** per link and phenomenon — the forward
+  model ADR-308, ADR-313, and ADR-314 consume.
+
+### 2. Update and delta
+
+- Verified measurements (ADR-305 identity, ADR-295 provenance) update the twin's
+  distributions online, bounded by ADR-301 calibration validity. A new
+  observation is compared to the twin's expected distribution; the **delta** —
+  and its statistical significance against the twin's own variance — is the
+  primary output. A change large relative to the twin's modelled variance is a
+  *detected physical change*, not noise.
+- The twin is **versioned**: a calibration event, a deliberate geometry edit, or
+  an accepted physical change advances the twin version, so history is
+  auditable and a delta is always relative to a named baseline.
+
+### 3. Consumers
+
+- **ADR-308** queries the twin's propagation model to plan placements.
+- **ADR-313** uses the twin's expected distributions as the generative forward
+  model for hypothesis scoring.
+- **ADR-314** uses per-sensor expected informativeness from the twin.
+- Facility/security/robotics/industrial integrations read the twin's change
+  deltas as governed ADR-306 spatial events.
+
+### Evidence discipline
+
+- The twin's expected distributions and any propagation simulation are
+  **simulation** (evidence level L0 per ADR-282), labelled `SYNTHETIC`. A delta
+  computed against them is a model-relative statement.
+- A change/anomaly detection *claim* (e.g. "detects furniture-scale changes")
+  requires real-silicon measurement against a leakage-free protocol with a
+  reproducer before it is tagged `MEASURED` (CLAUDE.md hardware rule). The twin
+  never presents a modelled expected distribution as evidence that a physical
+  state *is* the case; it presents a *delta and its significance*. This ADR
+  asserts **no** detection-accuracy number.
+
+## Consequences
+
+- RuView gains a persistent per-deployment baseline, turning "a different
+  measurement" into "a measurable, attributable, versioned change" — the bridge
+  from a sensing runtime to facility management, security, robotics, and
+  industrial monitoring.
+- The twin is the shared forward model for ADR-308/310/311, so those primitives
+  speak one propagation model rather than three inconsistent ones — a
+  deliberate reason to build the twin before its consumers mature.
+- Quality is bounded by the coarseness of the worldgraph scene and the fidelity
+  of the forward model; the twin reports deltas *with significance against its
+  own variance* rather than asserting confident change detection on a coarse
+  model. The optional high-fidelity backend is where higher accuracy lives.
+- Hard dependency on ADR-306 (scene), ADR-301 (calibration state), and ADR-312
+  (persistence); it reuses `worldgraph` and `wifi-densepose-calibration` rather
+  than rebuilding geometry or calibration.
+- Being phase 3, this is design intent; it is expected to be revised as the
+  phase-1 spine, ADR-311 fusion, and ADR-312 memory land.
+
+## Validation
+
+- Unit tests: the twin's expected distribution is a deterministic function of
+  scene + calibration + propagation history; delta computation and its
+  significance against stored variance are correct on synthetic distributions;
+  versioning advances on calibration/geometry/accepted-change events and history
+  is retained.
+- Integration test: on a synthetic deployment, an injected physical change (a
+  wall attenuation shift) produces a significant delta against the twin while
+  ordinary noise does not; the delta surfaces as a governed ADR-306 event with
+  provenance (ADR-305/292).
+- Field validation (deferred, real-silicon): change detection on an instrumented
+  real deployment with a controlled physical-change protocol, reported as
+  `MEASURED` with a reproducer. Until then all twin distributions and deltas are
+  `SYNTHETIC`/L0. No detection-accuracy number is asserted by this ADR.
@@ -0,0 +1,156 @@
+# ADR-316: Fleet control plane — provisioning to audit trails
+
+- **Status**: Proposed (ADR-300 phase 2)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: fleet, operations, provisioning, firmware, updates, audit, identity, phase-2
+
+## Context
+
+This ADR is a child of **ADR-300** (perception substrate program) and owns
+primitive #16, *fleet control plane*. In the ADR-300 DAG it is a phase-2
+integration-and-operations primitive that sits on the phase-1 spine: it
+**consumes ADR-305** (authenticated sensor identity) for per-device identity and
+enrollment, and **ADR-318** (capability certificate) for the signed models,
+calibration validity, and capability envelopes a device is allowed to run. It is
+authored as Proposed and is not implemented by the phase-1 swarm.
+
+The external and internal reviews both named the same operational gap: RuView
+has strong per-device primitives but no **release identity** and no **bill of
+materials** binding a fielded sensor to the exact firmware, model, and
+calibration it is running — and no plane to manage that across many devices.
+Without this, a handful of nodes is fine but *hundreds* of sensors become an
+operational nightmare: no coherent way to provision, roll certificates, verify
+firmware compatibility, distribute signed models, track calibration lifecycle,
+watch health, stage updates, roll back, diagnose remotely, enforce data
+retention, or produce an audit trail. This ADR addresses that release-identity /
+BOM gap directly.
+
+The scope is deliberately the **control plane**, not the data plane. The
+authenticated measurement path is **ADR-296** (bind + allowlist) plus **ADR-305**
+(signed envelope); this ADR governs the *devices and artifacts*, not the
+per-frame stream.
+
+Relevant existing assets to build on rather than duplicate:
+
+- **ADR-305** already defines per-device keypairs, the `DeviceId → public key →
+  capabilities` enrollment record, key rotation and revocation *semantics* — and
+  explicitly deferred their **fleet distribution** to this ADR. The control
+  plane is the distribution and lifecycle layer over ADR-305 identity, not a new
+  identity scheme.
+- **ADR-318** (capability certificate) defines the signed, expiring artifact a
+  device is authorized to run; the fleet plane is what *distributes, stages, and
+  revokes* those certificates and the signed models they point at.
+- **ADR-301** (calibration) owns calibration validity/expiry; the fleet plane
+  tracks calibration *lifecycle* across the fleet (which nodes are due, which are
+  stale) rather than redefining calibration.
+- **ADR-319** (witness chain) provides the append-only, re-verifiable record;
+  fleet audit trails are witness-chain entries, not a parallel log format.
+- **ADR-320** (RuView sensor HAL, phase 2) provides hardware/firmware capability
+  descriptors used for firmware-compatibility checks before staging an update.
+- `wifi-densepose-bfld` `CapabilityAttestation` (ADR-141) is the device-side
+  attestation the plane checks against declared cohort capabilities.
+
+## Options considered
+
+1. **Manual per-device operations (SSH/flash by hand).** Rejected: does not
+   scale past a handful of nodes, produces no release identity, no audit trail,
+   and no safe rollback — exactly the operational nightmare the reviews named.
+2. **Adopt a generic third-party IoT device-management platform wholesale.**
+   Rejected as the core: generic platforms do not understand RuView's signed
+   capability certificate, calibration validity, or witness chain, and would
+   fork trust away from the phase-1 spine. A generic transport/agent *may* be a
+   backend, but identity, certificates, and audit remain RuView's.
+3. **A RuView-native control plane layered on ADR-305 identity, ADR-318
+   certificates, ADR-301 calibration lifecycle, and ADR-319 audit — covering
+   provisioning through rollback and retention.** Chosen.
+
+## Decision
+
+Define a **fleet control plane** that manages RuView sensors and their signed
+artifacts across their lifecycle, built on the phase-1 identity/certificate
+spine.
+
+### 1. Release identity and bill of materials
+
+- Each fielded device has a **BOM record** binding `DeviceId` (ADR-305) → exact
+  firmware version → signed model set → active capability certificate (ADR-318)
+  → current calibration record (ADR-301) → HAL/hardware descriptor (ADR-320).
+  This *is* the release identity the reviews found missing: given a device you
+  can state precisely what it is running and prove it is signed.
+
+### 2. Provisioning, certificates, firmware compatibility
+
+- **Provisioning** is the authorized ADR-305 enrollment step at fleet scale:
+  minting a keypair, registering the public key and capabilities, and issuing
+  the initial ADR-318 certificate. A device is untrusted until provisioned.
+- **Certificate lifecycle**: issue, rotate, expire, and **revoke** ADR-318
+  certificates and the ADR-305 keys behind them; revocation lists are
+  distributed here (the distribution ADR-305 deferred).
+- **Firmware compatibility**: before staging a firmware or model, check the
+  target's ADR-320 HAL descriptor and ADR-141 capability attestation so an
+  incompatible or under-capable device is never sent an artifact it cannot
+  honestly run.
+
+### 3. Cohorts, staged updates, rollback
+
+- Devices group into **cohorts** (by site, hardware, capability). Updates —
+  signed models and firmware — roll out **staged** (canary → cohort → fleet)
+  with health gates between stages, and **roll back** to the previously recorded
+  BOM on a failed health check. Only signed artifacts are ever staged.
+
+### 4. Health telemetry, remote diagnostics, retention, audit
+
+- **Health telemetry** and **remote diagnostics** report device liveness,
+  calibration staleness (ADR-301), certificate expiry (ADR-318), and error
+  state — read-only diagnostics by default, mutations authorized explicitly.
+- **Data retention** policy is enforced per cohort, and P0/CSI/person data never
+  leaves the edge except under the ADR-277/280 governance already in force
+  (CLAUDE.md: never commit or exfiltrate CSI/person data).
+- Every lifecycle action — provision, rotate, revoke, stage, roll back — is
+  written as an **ADR-319 witness-chain** entry, giving a re-verifiable **audit
+  trail** rather than a mutable log.
+
+### Authority and least privilege
+
+- The control plane is default-deny (CLAUDE.md: default to least authority).
+  Provisioning, key rotation, revocation, staging, and rollback are each
+  separately authorized operations; no fleet action is implied by another.
+  Credentials and private keys are never logged or committed.
+
+## Consequences
+
+- Hundreds of sensors become operable: coherent release identity, signed-artifact
+  distribution, staged updates with rollback, and a re-verifiable audit trail —
+  closing the release-identity / BOM gap the reviews raised.
+- The plane concentrates operational authority; that is mitigated by
+  default-deny, per-action authorization, signed-only artifacts, and
+  witness-chained audit. A compromised plane must still forge signatures the
+  phase-1 spine verifies.
+- Hard dependency on ADR-305 (identity), ADR-318 (certificate), ADR-301
+  (calibration lifecycle), ADR-319 (audit), and ADR-320 (firmware/HAL
+  compatibility). This ADR distributes and sequences those artifacts; it does
+  not redefine identity, certificates, calibration, or the witness format.
+- Being phase 2, this is design intent depending on the spine; it is expected to
+  be revised as ADR-318, ADR-319, and ADR-320 land.
+- **No fielded fleet-operation claim is MEASURED without real-silicon evidence**
+  (CLAUDE.md hardware rule): staged update and rollback on real nodes require a
+  captured runtime log. A passing simulation is not fleet evidence.
+
+## Validation
+
+- Unit tests: BOM records bind identity/firmware/model/certificate/calibration
+  consistently and reject inconsistent bindings; certificate issue/rotate/revoke
+  transitions are correct; a firmware-incompatible target is refused staging;
+  every lifecycle action emits a well-formed ADR-319 witness entry.
+- Integration test: a synthetic cohort undergoes a canary→cohort→fleet staged
+  update; an injected health failure triggers rollback to the prior BOM; the
+  full sequence is re-verifiable from the witness chain offline; a revoked
+  certificate is rejected fleet-wide.
+- Security test (`npm run test:security` analogue for the plane): default-deny
+  is enforced; unauthorized provision/rotate/revoke/stage is rejected and
+  counted; no credential or P0 data appears in telemetry or audit output.
+- Field validation (deferred, real-silicon): a real multi-node staged update and
+  rollback with a captured boot/runtime log, reported as `MEASURED` with a
+  reproducer. Until then all fleet-operation results are simulator-level. No
+  fielded reliability number is asserted by this ADR.
@@ -0,0 +1,140 @@
+# ADR-317: Multi-domain benchmark scorecard — regressions cannot hide behind pooled accuracy
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: benchmark, aetherarena, ci-gate, evidence, honesty, domain-generalization, substrate
+
+## Context
+
+This ADR is primitive 17 of the perception-substrate program (ADR-300) and the
+per-PR enforcement edge of the phase-1 certificate spine. In the ADR-300
+dependency DAG it reads accuracy from the evidence engine (ADR-304), consumes
+the domain state produced by out-of-distribution detection (ADR-302), scores
+against calibration certificates (ADR-301), and is anchored in the witness chain
+(ADR-319). It is the surface that makes the rest of the spine testable on every
+change to sensing code.
+
+A single pooled accuracy number is the classic way a domain-generalization
+regression hides. A model can raise mean PCK or mean presence accuracy while
+quietly collapsing on unseen rooms, unseen devices, or stationary subjects —
+exactly the conditions WiFi sensing fails in and exactly the conditions a
+pooled average washes out. The strategic assessment (ADR-300) named this: what
+distinguishes infrastructure from a demo is that a regression on *any* operating
+domain is caught before merge, not discovered in the field.
+
+RuView does not need a new benchmark to do this. AetherArena is already
+**v0-complete infrastructure** (ADR-149): a deterministic scoring engine
+reusing `wifi-densepose-train` (`src/ruview_metrics.rs`, `src/ablation.rs`,
+`src/eval.rs`, `src/proof.rs`), a `PROOF_SEED=42` determinism substrate that
+SHA-256-hashes outputs against an expected hash, an append-only witness ledger,
+and a live Hugging Face Space. ADR-145's ablation harness already computes
+presence accuracy, localization error, FP/FN, latency percentiles, a
+privacy-leakage score, and **cross-room degradation**. The board is
+intentionally empty (benchmark-first). What is missing is not a scorer but a
+**scorecard format** that reports per-domain rather than pooled, and a
+**sensing-crate CI gate** that runs it on every PR.
+
+## Options considered
+
+1. **Keep the single pooled score / `RuViewTier`.** Rejected: it is exactly the
+   surface a per-domain regression hides behind; a Gold tier can coexist with a
+   broken unseen-room slice.
+2. **Add a new benchmark repo/harness for domains.** Rejected: AetherArena's
+   scorer, determinism binding, and witness ledger already exist and are the
+   right engine; a parallel harness would fork the scoring substrate and its
+   anti-gaming/leakage discipline.
+3. **Extend the AetherArena scorer with a per-domain scorecard and wire it as a
+   per-PR sensing-crate gate.** Chosen.
+
+## Decision
+
+Reuse the AetherArena scorer and witness ledger (ADR-149) and add two things: a
+**multi-domain scorecard** format and a **sensing-crate PR gate** that produces
+it.
+
+### 1. The multi-domain scorecard
+
+The scorecard reports each capability broken out by operating domain, never
+pooled into one figure. The v0 domain axes:
+
+- **Presence**: `room-known`, `room-unseen`, `device-unseen`, `stationary-10m`
+  (a stationary subject at range — the canonical WiFi failure case).
+- **Pose**: `matched`, `subject-unseen`, `room-unseen`.
+- **OOD rejection**: the rate at which genuinely out-of-distribution input is
+  correctly returned as UNKNOWN by ADR-302 (a capability, not a failure) and
+  the false-UNKNOWN rate on in-distribution input.
+- **Calibration drift**: fingerprint-distance trajectory against the ADR-301
+  certificate over the scored window, and the fraction of inferences in each
+  ADR-302 `DomainState` (KNOWN / DEGRADED / UNKNOWN).
+
+Each cell carries exactly one `EvidenceLevel` (L0–L5, ADR-282). A slice scored
+on synthetic input is L0/`Synthetic` by construction; a slice on a leakage-free
+held-out real split is graded higher and only then may a per-domain number be
+labelled MEASURED. Pose PCK cells additionally require the mean-pose baseline
+and a leakage-free held-out split (CLAUDE.md) or they are not reported as pose
+accuracy at all.
+
+### 2. Per-domain regression gate
+
+- The gate compares each scorecard cell against the merged-baseline scorecard
+  stored in the AetherArena witness ledger. A regression **in any single
+  domain** beyond its configured threshold fails the PR, even if the pooled
+  average improved. Improvement on `room-known` cannot buy a regression on
+  `room-unseen`.
+- Thresholds are per-domain and per-capability; the unseen/stationary/OOD
+  domains carry the strictest budgets because they are the ones a pooled score
+  hides. The baseline is append-only and witness-anchored — a new baseline is a
+  new signed ledger entry, never an in-place overwrite (ADR-149 ledger pattern,
+  ADR-319 anchoring).
+
+### 3. Sensing-crate CI wiring
+
+- Every PR that touches a sensing crate runs the scorecard across all domains
+  under the ADR-011/ADR-149 determinism binding (`PROOF_SEED=42`), so the run
+  is reproducible and tamper-evident. The gate is added to
+  `.github/workflows/` as an authoritative check.
+- The held-out real split remains private and is never accessible to synthetic
+  generation, augmentation, or calibration (ADR-149 leakage constraint, ADR-282
+  rule d). Submitters/PRs provide a model, not predictions on data they hold.
+
+### Provenance and honesty discipline
+
+- No benchmark numbers are invented by this ADR. It delivers the scorecard
+  format, the per-domain gate, and the CI wiring; the numbers come from the
+  ADR-304 evidence ledger and the AetherArena scorer on real data, labelled at
+  the honest evidence level. Empty domains report "no evidence," which the gate
+  treats as no coverage — never as a pass.
+
+## Consequences
+
+- A domain-generalization regression can no longer merge behind a flattering
+  pooled average; the failure mode that most distinguishes fielded sensing from
+  a demo is caught at PR time.
+- Every PR touching sensing pays a per-domain scoring cost. Bounded by reusing
+  the existing deterministic scorer and by tiered compute (CPU smoke vs full
+  score, ADR-149), but it is a deliberate cost for per-domain safety.
+- The empty AetherArena board fills with honest, per-domain, evidence-labelled
+  results rather than a single headline tier — consistent with the
+  benchmark-first posture and with ADR-282's ecosystem positioning.
+- Some domains will show weak or absent coverage. Surfacing that per-domain is
+  the point; the scorecard must never paper over a thin domain with a pooled
+  number.
+- The program-level acceptance test (ADR-300) is encoded here as an AetherArena
+  scenario, closing the loop once the phase-1 spine lands.
+
+## Validation
+
+- `cargo test` on the AetherArena scorer extension — per-domain slicing math
+  against fixtures; per-domain regression gate fails on a single-domain
+  regression while pooled improves, and passes when all domains hold; empty
+  domains report "no evidence," not a pass; every cell carries exactly one
+  `EvidenceLevel`; synthetic slices are L0 by construction.
+- Determinism: a scored run reproduces its SHA-256 hash under `PROOF_SEED=42`
+  (ADR-011/ADR-149 binding); the baseline scorecard is append-only and
+  witness-anchored (ADR-319), never mutated in place.
+- CI: the sensing-crate gate runs on a PR touching a sensing crate and blocks a
+  planted single-domain regression.
+- Real-data scorecards (a leakage-free held-out split with ADR-303 references)
+  are the maturity milestone; a synthetic scorecard is L0 and no per-domain
+  number is MEASURED without a reproducer per CLAUDE.md.
@@ -0,0 +1,138 @@
+# ADR-318: Capability certificates — validated-for-this-environment claims
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: capability, certificate, evidence, provenance, signature, honesty, substrate
+
+## Context
+
+This ADR is primitive 18 of the perception-substrate program (ADR-300) and,
+per the strategic assessment, among the strongest ideas in the program: it is
+where the whole certificate spine becomes a consumable contract. In the ADR-300
+dependency DAG it **consumes the evidence engine (ADR-304)** — a capability
+certificate is a signed attestation minted over a slice of that ledger — the
+**calibration certificate (ADR-301)** for the environment it is validated
+against, and the **RuField signature types (ADR-305 / ADR-260/262/277/279)** to
+sign it. It reports domain state via ADR-302 and is anchored in the witness
+chain (ADR-319).
+
+RuView must stop making unconditional capability claims. "Supports presence" is
+not a true statement — presence detection works in some rooms, on some hardware,
+for some subject dynamics, and fails on a stationary subject at range in an
+uncalibrated room. A capability is only ever *validated for a specific
+environment*, and the honest unit of that claim is a signed, expiring
+certificate, not a feature flag in a README.
+
+The ingredients now exist across the phase-1 spine: ADR-304 accumulates
+per-`(room, device, subject)` accuracy, false-positive rate, drift, and domain
+state; ADR-301 produces the signed room fingerprint the environment is keyed to;
+ADR-305 provides the authenticated device identity and `CapabilityAttestation`
+(BFLD, ADR-141) that bounds *what a device is even attested to sense*; ADR-282
+provides the mandatory `EvidenceLevel`. What is missing is the artifact that
+binds them into a single, verifiable "validated here, until then" claim and the
+consumer-side rule that refuses capabilities lacking one.
+
+## Options considered
+
+1. **Static capability flags / a `supports_presence` boolean.** Rejected: it is
+   the exact dishonest claim — environment-independent, unsigned, non-expiring,
+   and false the moment the room, device, or subject dynamics differ.
+2. **Report raw ledger accuracy to consumers directly.** Rejected: the ledger
+   (ADR-304) is the source of truth but not a portable, signed, bounded contract;
+   handing consumers raw records pushes evidence-weighting and expiry logic into
+   every consumer and drops the single verifiable object.
+3. **Mint a signed, expiring `CapabilityCertificate` over an ADR-304 ledger
+   slice, and make consumers refuse capabilities without a valid one.** Chosen.
+
+## Decision
+
+Introduce a signed **`CapabilityCertificate`**: a bounded attestation that a
+specific capability has been validated for a specific environment, for a bounded
+time.
+
+### 1. The certificate
+
+A serializable `CapabilityCertificate` binding:
+
+- `capability` — the phenomenon (e.g. `presence`, `pose`), which must be within
+  the device's ADR-305/ADR-141 `CapabilityAttestation` (a device cannot be
+  certified for something it is not even attested to sense).
+- `room` — the ADR-306 space identifier, tied to the ADR-301 calibration
+  certificate version the validation was performed against.
+- `hardware` — the ADR-305 authenticated `DeviceId` (and, in phase 2, the
+  ADR-320 HAL descriptor of the sensor).
+- `model` — the model version scored.
+- `calibrated_date` — the calibration certificate age at validation time.
+- `moving_recall`, `stationary_recall`, `false_presence_per_24h` — the measured
+  operating metrics, sliced from the ADR-304 ledger for this exact context (not
+  a global average), each honestly labelled. These are per-capability; a pose
+  certificate carries pose metrics with the mean-pose baseline and a
+  leakage-free split (CLAUDE.md) or it is not issued.
+- `valid_until` — an explicit expiry; a certificate is never open-ended.
+- `evidence_level` — exactly one L0–L5 (ADR-282). A certificate minted from a
+  synthetic ledger slice is L0/`Synthetic`; a MEASURED metric requires an
+  ADR-303 reference and a reproducer. The certificate cannot upgrade the level
+  of the ledger it is minted from (ADR-304 honesty rule).
+- `signature` — a RuField `SignatureBlock` (ADR-305 / ADR-260/262/277/279) over
+  the canonical serialization; an unsigned certificate is not a valid
+  certificate. The certificate is anchored in the witness chain (ADR-319).
+
+### 2. Minting
+
+- A certificate is minted from a slice of the ADR-304 evidence ledger for one
+  `(room, device, subject-class, model)` context. If the ledger reports "no
+  evidence" for that context, **no certificate is issued** — absence of evidence
+  is never a capability. Minting is a pure function over the append-only ledger
+  at mint time; the metrics are frozen into the signed object.
+- Expiry (`valid_until`) is derived from calibration validity (ADR-301) and an
+  evidence-freshness policy: a certificate cannot outlive the calibration it was
+  validated against, and drift beyond the ADR-301 envelope invalidates both.
+
+### 3. Consumer refusal rule
+
+- Applications and surfaces **refuse to consume a capability that lacks a valid
+  certificate for the current environment**. "Valid" means: signature verifies,
+  `room`/`hardware`/`model` match the running context, `valid_until` is in the
+  future, and the referenced calibration certificate is itself still valid
+  (ADR-301 not invalidated). A failed check yields UNKNOWN via ADR-302, not a
+  best-effort guess.
+- This makes the ADR-300 acceptance clause "quantify whether it can reliably
+  sense the requested phenomenon → generate a signed capability certificate"
+  a hard gate rather than a hope.
+
+## Consequences
+
+- RuView can no longer claim a capability it has not validated for the caller's
+  environment; the honest failure — "not certified here" → UNKNOWN — is
+  surfaced by construction rather than by discipline.
+- OEM/integrator diligence gets a single verifiable artifact ("presence,
+  validated in *this* room, on *this* device, with *these* recall/false-alarm
+  numbers, until *this* date, at *this* evidence level, signed") — the strongest
+  commercial output of the spine.
+- Certificates expire and get refused; some environments will have no
+  certificate and therefore no capability until validated. That refusal is the
+  intended honest behavior, not a regression.
+- Key management and expiry policy are operational responsibilities, reusing the
+  ADR-305 enrollment/rotation and ADR-301 validity machinery rather than new
+  infrastructure; fleet distribution of certificates is owned by ADR-316.
+- No capability number is invented here; every metric on a certificate is sliced
+  from the ADR-304 ledger at its honest evidence level.
+
+## Validation
+
+- `cargo test` on the certificate crate — mint from a ledger slice produces the
+  frozen metrics; "no evidence" context yields no certificate; signature
+  round-trip and tamper rejection; `valid_until` and calibration-linked expiry
+  enforced; consumer refusal on room/hardware/model mismatch, expiry, or
+  invalidated calibration resolves to UNKNOWN (ADR-302), not a guess; evidence
+  level is inherited from the ledger and cannot be upgraded; a certificate
+  cannot be issued for a capability outside the device's ADR-305/ADR-141
+  attestation.
+- Cross-ADR: an ADR-304 ledger fixture mints a certificate; an ADR-302 test
+  asserts an expired/mismatched certificate gates to UNKNOWN; the ADR-300
+  acceptance test consumes a minted certificate end-to-end.
+- Real-deployment certificates (minted from a populated ledger with ADR-303
+  references on live ESP32 captures) are the maturity milestone and require
+  hardware evidence per CLAUDE.md; a certificate minted from a synthetic ledger
+  is L0 by construction.
@@ -0,0 +1,146 @@
+# ADR-319: Witness chain — epistemic infrastructure for physical AI
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: provenance, witness, evidence, signature, epistemics, ontology, substrate
+
+## Context
+
+This ADR is primitive 19 of the perception-substrate program (ADR-300) and a
+spine root of its phase-1 certificate stack. In the ADR-300 dependency DAG it
+**extends the source-provenance state machine (ADR-295)** and the RuField
+provenance types, **ties to the signature machinery (ADR-305 /
+ADR-260/262/277/279)**, and anchors the artifacts produced by ADR-301
+(calibration certificates), ADR-304 (evidence records), ADR-317 (benchmark
+scorecards), and ADR-318 (capability certificates). In phase 2 it carries the
+independent-corroboration link from ADR-303.
+
+The strategic assessment (ADR-300) framed RuView's real product as **epistemic
+infrastructure for physical AI**: the value is not the claim "a person is
+present" but the *auditable reasoning* behind it. A bare boolean output discards
+everything a downstream system needs to trust or contest it — which radio
+observed it, what DSP evidence supported it, which model inferred it, whether an
+independent sensor agreed, what spatial state it updated, and what policy acted
+on it. Once the answer is a boolean, "why do you believe that?" has no answer.
+
+RuView already has the pieces of a chain but not the chain itself. ADR-295
+defines a canonical `SourceState` (`Synthetic` / `LiveVerified` /
+`LiveUnverified` / `Stale` / `Disconnected`) with `Unknown` structurally
+forbidden from collapsing to live. ADR-305 defines the signed
+`device → measurement → sequence → timestamp → … → signed event` chain of
+custody. RuField carries `FrameProvenance`, `SemanticProvenance`, and signature
+types; the AetherArena witness ledger (ADR-149) demonstrates an append-only,
+witness-anchored ledger. What is missing is a single **staged, signed envelope**
+that travels the whole pipeline and records, at each stage, the confidence and
+provenance of that stage.
+
+## Options considered
+
+1. **Keep provenance as scattered per-stage fields (status quo).** Rejected:
+   `FrameProvenance`, `SourceState`, calibration state, and model uncertainty
+   live in different structures and are re-encoded per surface; there is no
+   single object a consumer can re-verify offline to answer "why."
+2. **Log a free-form audit trail alongside the output.** Rejected: mutable,
+   unsigned, and not structurally tied to the output — the classic
+   dashboard-that-overwrites-yesterday failure the evidence engine (ADR-304)
+   already rejects.
+3. **A staged, signed witness envelope carried through the pipeline, each stage
+   appended and signed, anchored in an append-only ledger.** Chosen.
+
+## Decision
+
+Define the **witness chain**: a staged, append-only, signed envelope that
+accompanies an observation from radio to policy decision. Instead of emitting
+"person present," RuView emits a chain whose stages are:
+
+```
+RF observation ▸ DSP evidence ▸ model inference ▸ independent corroboration
+              ▸ spatial state ▸ policy decision
+```
+
+### 1. The staged envelope
+
+- Each stage is a signed record carrying its **confidence** and its
+  **provenance**:
+  - **RF observation** — the ADR-305 authenticated frame envelope
+    (`DeviceId`, sequence, timestamp, measurement hash) and its ADR-295
+    `SourceState`. This is the root link; a `Synthetic` root can never present
+    as a `LiveVerified` one (ADR-295 invariant).
+  - **DSP evidence** — the deterministic signal features and the ADR-137
+    quality signals that support (or fail to support) an inference.
+  - **model inference** — the model version, its raw output, and its predictive
+    uncertainty; the ADR-302 `DomainState` (KNOWN / DEGRADED / UNKNOWN) gate
+    result, so a low-confidence or out-of-distribution inference is recorded as
+    such, not silently promoted.
+  - **independent corroboration** — the phase-2 ADR-303 agreement link
+    (a reference/second modality that agreed or disagreed); absent in phase 1,
+    the stage records "no corroboration," never a fabricated one.
+  - **spatial state** — the ADR-306 ontology `Observation`/`Track`/`Event` the
+    inference updated, carrying `SemanticProvenance` and its `EvidenceLevel`.
+  - **policy decision** — the governed action taken (or withheld), with the
+    certificate (ADR-318) it relied on.
+- Each stage carries exactly one `EvidenceLevel` (L0–L5, ADR-282); the envelope's
+  effective level is the **minimum** across its stages — a synthetic root or an
+  unreferenced inference caps the whole chain, so the chain cannot claim more
+  than its weakest link.
+
+### 2. Signing and anchoring
+
+- Each stage is signed with RuField signature types (ADR-305 /
+  ADR-260/262/277/279) over the canonical serialization of that stage plus the
+  hash of the prior stage, so the chain is tamper-evident end to end and any
+  broken link is detectable. The completed chain is anchored in an append-only,
+  witness-anchored ledger following the AetherArena pattern (ADR-149); it is the
+  same anchoring ADR-301/ADR-304/ADR-317/ADR-318 write into.
+- The chain is **append-only**: a correction is a new chain referencing the
+  prior one, never an in-place edit (mirroring ADR-304 and CLAUDE.md's "source
+  over summaries").
+
+### 3. Offline re-verification
+
+- A consumer with the enrolled public keys (ADR-305) can re-verify a chain
+  offline: check each stage signature, check each prior-stage hash, and read the
+  per-stage confidence and evidence level — answering "why do you believe this?"
+  without trusting the emitting host. This is the property store-and-forward
+  channel authentication (rejected in ADR-305) cannot provide.
+
+### Provenance and honesty discipline
+
+- The witness chain never manufactures confidence: a stage that lacks evidence
+  records the absence. A `Synthetic` root, a missing corroboration, or an
+  UNKNOWN gate is carried faithfully and caps the chain's evidence level. No
+  accuracy number is invented here; the chain records the numbers the other
+  primitives produce at their honest level.
+
+## Consequences
+
+- Every RuView output becomes contestable and auditable: a downstream physical-AI
+  system can inspect the reasoning, weight it by per-stage confidence, and reject
+  a chain whose weakest link is too weak — the defining property of epistemic
+  infrastructure the strategic assessment asked for.
+- The certificate spine (ADR-301/301/314/315) gains a single anchoring substrate;
+  each of those artifacts is a specialization of a witness record rather than a
+  bespoke signed blob.
+- Carrying and signing a staged envelope adds per-observation size and CPU cost;
+  bounded by reusing RuField signatures and the existing ledger, and by the
+  minimum-level rule keeping the object honest rather than exhaustive.
+- The chain will frequently reveal weak links (synthetic root, no corroboration,
+  DEGRADED gate). Surfacing that is the point; the envelope must never smooth a
+  weak stage into a confident summary.
+
+## Validation
+
+- `cargo test` on the witness-chain crate — stage-by-stage signature round-trip
+  and tamper rejection (a mutated stage or a broken prior-stage hash fails
+  verification); effective evidence level equals the minimum across stages; a
+  `Synthetic` root caps the chain and cannot present as `LiveVerified`
+  (ADR-295 invariant); an UNKNOWN gate (ADR-302) and a "no corroboration" stage
+  are recorded faithfully; append-only correction produces a new chain
+  referencing the prior one.
+- Cross-ADR: an ADR-305 signed frame lineage serializes into a chain that
+  re-verifies offline with only the enrolled public keys; ADR-301/301/314/315
+  artifacts anchor into the same ledger.
+- Real-deployment chains (from live ESP32 captures with ADR-303 corroboration)
+  are the maturity milestone and require hardware evidence per CLAUDE.md; a
+  chain rooted in synthetic input is L0 by construction.
@@ -0,0 +1,150 @@
+# ADR-320: RuView sensor HAL — abstract all sensing hardware to one Observation type
+
+- **Status**: Accepted — initial implementation (ADR-300 phase 2)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: hal, sensor-abstraction, ontology, fusion, adapters, category, phase-2
+
+## Context
+
+This ADR is primitive 20 of the perception-substrate program (ADR-300) and a
+phase-2 integration primitive; it is authored as **Proposed**. In the ADR-300
+DAG it **consumes the canonical spatial ontology (ADR-306)** — its output is an
+ontology `Observation` bound to a `Sensor` entity — and **feeds real sensor
+fusion (ADR-311)**, which resolves many observations into one world state. It
+closes the "identify the hardware" clause of the ADR-300 acceptance test that
+phase 1 leaves open.
+
+RuView's strategic ceiling is set by how tightly it is coupled to WiFi CSI.
+Every new modality today lands as a bespoke ingest path with its own frame
+shape, its own provenance handling, and its own place in the pipeline. That is
+the difference between "a WiFi-DensePose project" and "an open
+spatial-intelligence operating layer": the category changes the moment *any*
+sensing hardware — {CSI, 802.11bf, BLE, UWB, mmWave, acoustic, camera, lidar,
+IMU, custom} — enters through one abstraction and becomes one `Observation`
+feeding one world model.
+
+Crucially this is a *unification*, not a green field. Adapters already exist and
+must be reused, not rebuilt:
+
+- ADR-279's native RF frame contract (`RfFrameV2`) already unifies ESP32,
+  Intel, Atheros, PicoScenes, Realtek radar, and 320 MHz 802.11bk producers as
+  `RfFrameV2` producers into a shared latent — "lightweight per-device adapters
+  into a shared latent, not a shared tensor." The HAL generalizes that lesson
+  beyond RF.
+- Existing CSI adapters (ESP32/Nexmon/FeitCSI paths), the mmWave fusion path
+  (ADR-063), and the multistatic WiFi path (ADR-029) are concrete producers to
+  bring under one trait.
+- ADR-305 already authenticates a `Sensor`/`DeviceId`; ADR-306 already defines
+  `Sensor`, `Observation`, `Track`, and `Event` as first-class node types. The
+  HAL is the trait that turns a heterogeneous device into that authenticated
+  `Sensor` emitting those `Observation`s.
+
+The gap is a single **`SensorHal` trait and one `Observation` type** that every
+modality implements, so the world model never sees a modality-specific frame —
+only a provenance-bearing, evidence-labelled `Observation`.
+
+## Options considered
+
+1. **Continue adding per-modality ingest paths.** Rejected: O(modalities) bespoke
+   pipelines, each re-encoding provenance and evidence, each a place the ladder
+   can be dropped — and it keeps RuView categorically a WiFi project.
+2. **Force every modality into the ADR-274/279 RF tensor/frame.** Rejected: the
+   ADR-279 lesson is precisely that premature canonicalization discards
+   information (bandwidth, antenna structure, phase). A camera, lidar, or IMU
+   has no meaningful `RfFrameV2` projection; forcing one is the same mistake at a
+   larger scale.
+3. **Define a `SensorHal` trait producing one `Observation` type, with existing
+   adapters as implementations feeding a shared latent and the ADR-306
+   ontology.** Chosen.
+
+## Decision
+
+Introduce a **`SensorHal` trait** and a single **`Observation`** type. Every
+sensing modality is an implementation of the trait; the world model consumes
+only `Observation`s.
+
+### 1. The `SensorHal` trait
+
+- A `SensorHal` describes a device's **capabilities** (which phenomena it can
+  sense — reusing the ADR-305/ADR-141 `CapabilityAttestation`), its **native
+  frame** (kept native, not canonicalized, per the ADR-279 shared-latent
+  lesson), and a method that lifts a native frame into an `Observation`.
+- Implementations wrap the existing producers: CSI (ESP32/Nexmon/FeitCSI via the
+  ADR-279 `RfFrameV2` path), 802.11bf (ADR-310, phase 2), BLE, UWB, mmWave
+  (ADR-063), acoustic, camera, lidar, IMU, and `custom`. RF modalities reuse the
+  ADR-279 per-device latent adapters wholesale; the HAL adds the non-RF and
+  ranging modalities under the same trait.
+- The trait is the boundary where untrusted hardware input is validated
+  (CLAUDE.md: validate at every hardware/FFI boundary; default to least
+  authority). A device is authenticated as an ADR-305 `Sensor` before its
+  observations are trusted.
+
+### 2. The `Observation` type
+
+- One provenance-bearing `Observation`: a measurement plus its `SensorHal`
+  source descriptor, its ADR-305 authenticated `DeviceId`, its ADR-295
+  `SourceState`, its native-frame reference (not a lossy projection), and
+  exactly one `EvidenceLevel` (L0–L5, ADR-282). A camera-derived `Observation`
+  and a CSI-derived `Observation` are the same type with different provenance —
+  and a camera observation never lifts WiFi output to camera-grade; each carries
+  its own honest evidence level (CLAUDE.md: never present WiFi sensing as
+  camera-grade).
+- The `Observation` maps directly onto the ADR-306 ontology `Observation` node
+  attached to its `Sensor`, so the ontology is the one representation and the
+  HAL is its ingest funnel.
+
+### 3. Feeding fusion
+
+- Observations from any set of modalities flow into ADR-311 fusion, which
+  resolves them into one probabilistic world state. The HAL guarantees fusion
+  never sees a modality-specific frame — only `Observation`s with uniform
+  provenance and evidence — which is what makes ADR-311's "many observations →
+  one world state" invariant implementable across heterogeneous hardware.
+
+### Category and honesty discipline
+
+- This ADR changes RuView's category from a WiFi-DensePose pipeline to an open
+  spatial-intelligence operating layer, but it makes **no accuracy claim**: the
+  HAL delivers a uniform ingest boundary, not a detector. Any capability of a
+  newly-connected sensor is still gated by ADR-302 and certified by ADR-318 for
+  its specific environment — connecting a camera does not grant a validated
+  capability by itself.
+- Hardware support for a given modality is CLAIMED until demonstrated on real
+  silicon with captured evidence per CLAUDE.md; a passing trait test proves the
+  abstraction, not a fielded device.
+
+## Consequences
+
+- New sensing hardware lands as one `SensorHal` implementation instead of a
+  bespoke pipeline; the translation matrix stays O(modalities), mirroring how
+  ADR-306 collapsed the surface matrix.
+- The ADR-300 acceptance clause "identify the hardware" becomes implementable:
+  a new sensor type is described by its HAL, authenticated as an ADR-305
+  `Sensor`, calibrated (ADR-301), gated (ADR-302), and certified (ADR-318)
+  through the same phase-1 spine, closing the last open clause.
+- A trait boundary and an `Observation` type are added; existing RF adapters
+  are re-expressed as implementations rather than rewritten, preserving the
+  ADR-279 native-frame/shared-latent design.
+- Non-RF modalities (camera, lidar, acoustic) enter the governed plane with the
+  same provenance and privacy discipline as RF; a camera is not a privacy-free
+  shortcut — it inherits the ADR-277 governance and its own evidence level.
+- As a phase-2 Proposed ADR, the trait shape may be revised as ADR-311 fusion
+  and ADR-310 802.11bf land; that revision is expected for a phased program.
+
+## Validation
+
+- `cargo test` on the HAL crate (design-time, Proposed) — a fixture `SensorHal`
+  for each of at least two modalities (CSI via ADR-279, plus one non-RF)
+  produces uniform `Observation`s; every `Observation` carries a `DeviceId`,
+  `SourceState`, native-frame reference, and exactly one `EvidenceLevel`; a
+  synthetic source yields L0/`Synthetic` and cannot alias to measured
+  (ADR-279 invariant 6); an unauthenticated device's observations are rejected
+  at the trait boundary (ADR-305).
+- Cross-ADR: an `Observation` maps round-trip to an ADR-306 ontology
+  `Observation` node with no provenance loss, and a set of `Observation`s from
+  distinct modalities is accepted by an ADR-311 fusion fixture.
+- Real-silicon evidence is required before any modality's hardware support is
+  claimed beyond CLAIMED: a captured boot/runtime log from the real device
+  emitting `Observation`s. A successful build or simulator run is not hardware
+  evidence (CLAUDE.md).
@@ -0,0 +1,101 @@
+# ADR-321: Decision policy — action authorization conditioned on certificate class, freshness, uncertainty, and evidence
+
+- **Status**: Accepted — initial implementation planned (ADR-300 phase 1)
+- **Date**: 2026-08-11
+- **Deciders**: ruv
+- **Tags**: policy, authorization, safety, certificates, governed-action, phase-1
+
+## Context
+
+The perception substrate (ADR-300) makes RuView state *what it knows* and
+*how well* — the capability certificate (ADR-318) binds hardware, environment,
+model, calibration, metrics, expiry, and evidence level. But a certificate is a
+statement of knowledge, not a grant of action. The same certificate that is
+adequate to dim a light is wholly inadequate to release a door lock or clear an
+industrial stop condition.
+
+Without an explicit authorization layer, every consumer re-implements its own
+(inconsistent, usually optimistic) rule for "is this good enough to act on,"
+and a confident-but-out-of-domain inference can reach an actuator. That is the
+exact failure the substrate exists to prevent. Decision policy therefore
+belongs in **phase 1**, alongside the certificate it gates, not later.
+
+This ADR realizes program invariant #1 (UNKNOWN is a first-class output, never
+an error) and the action-side of the refined acceptance test: a drift-
+invalidated capability must be *denied at the actuator* before a false
+confident inference is acted upon.
+
+## Decision
+
+Introduce a `ruview-policy` crate providing an **action authorization gate**
+that sits between governed spatial state and any actuator.
+
+### 1. Assurance requirements per action
+
+An `ActionClass` declares the assurance an action demands:
+
+- `min_certificate_class` — the required `CapabilityCertificate` class (ADR-318).
+- `max_certificate_age` / `min_domain_freshness` — the certificate must be
+  currently valid **and** the live domain signature (ADR-302) must not be in a
+  DEGRADED/UNKNOWN state (this is the staleness guard, program invariant on
+  certificate conditionality — see ADR-300).
+- `max_uncertainty` — inference uncertainty ceiling.
+- `min_evidence_level` — the L0–L5 floor (ADR-282/ADR-304); e.g. a safety
+  action may require ≥ L3 (held-out room+subject validation).
+
+Reference action classes (illustrative, configurable):
+
+| Class | Example | Typical floor |
+|---|---|---|
+| `Convenience` | lighting, scenes | tolerant: L1+, higher uncertainty ok |
+| `Security` | alerts, arming | stricter: valid cert, L2+, bounded uncertainty |
+| `SafetyCritical` | door lock, machine stop | strict: fresh cert, L3+, low uncertainty, KNOWN domain only |
+
+### 2. The authorization decision
+
+`authorize(action, capability_certificate, live_state) -> Authorization` where
+`live_state` carries the current `SourceState` (ADR-295), OOD/domain state
+(ADR-302), and inference uncertainty. Rules:
+
+- **Fail-closed.** Any unmet condition → `Deny { failed_condition }`. The denial
+  names the *specific* condition (expired cert, domain DEGRADED, uncertainty
+  over ceiling, evidence below floor, certificate class too low).
+- **UNKNOWN denies high-assurance actions.** A domain in UNKNOWN (ADR-302)
+  cannot authorize `Security`/`SafetyCritical` actions; it may still authorize
+  `Convenience` if that class's policy permits, but the authorization records
+  that it proceeded under UNKNOWN.
+- The decision is a **pure function** of (action class, certificate, live
+  state) — deterministic and unit-testable without a clock or actuator.
+- Every authorization (allow or deny) is emitted as the terminal stage of the
+  witness chain (ADR-319), so "why was this actuator allowed/denied" is
+  auditable end-to-end.
+
+### 3. No silent optimism
+
+A missing certificate, an expired certificate, or an unrecognized action class
+all deny by default. Absence of a policy is not permission.
+
+## Consequences
+
+- Action authorization becomes uniform and centrally reasoned instead of
+  per-consumer and optimistic; this is the "RuView Certify → constrains action"
+  boundary that is hard to commoditize.
+- A behavior change for existing automations that acted directly on presence:
+  they now pass through the gate. Convenience-class defaults keep low-stakes
+  automations working; high-stakes actions must opt into stricter classes.
+- Depends on ADR-318 (certificate), ADR-302 (domain/OOD state), ADR-295
+  (source state), ADR-304 (evidence). Built in the phase-1 dependent wave after
+  those types land.
+
+## Validation
+
+- Unit tests: each action class authorizes/denies correctly across the matrix
+  of (valid/expired/degraded cert × KNOWN/DEGRADED/UNKNOWN domain × uncertainty
+  above/below ceiling × evidence above/below floor); UNKNOWN denies
+  safety-critical; every deny names its failed condition; absence-of-policy
+  denies; determinism.
+- Integration: the acceptance-test scenario (ADR-300) — post-certification room
+  change drives domain to DEGRADED→UNKNOWN, and a `SafetyCritical` authorization
+  is denied with `failed_condition = domain_not_known` *before* the inference
+  reaches the actuator, witness chain preserved.
+- `cargo test -p ruview-policy`.
@@ -0,0 +1,364 @@
+# ADR-323: Native Rust physics-constrained pose refinement
+
+- **Status**: Proposed
+- **Date**: 2026-08-15
+- **Deciders**: ruv
+- **Owners**: RuView perception and edge runtime maintainers
+- **Tags**: pose, physics, rust, uncertainty, provenance, abstention, edge
+- **Numbering note**: ADR-323 is the next free number in the authoring checkout. Re-run the ADR index/collision check immediately before merge and rename if needed.
+- **Extends**: ADR-020, ADR-027, ADR-079, ADR-101, ADR-135, ADR-145, ADR-150, ADR-273, ADR-279, ADR-282, ADR-295, ADR-296, ADR-297, ADR-298, ADR-302, ADR-303, ADR-304, ADR-305, ADR-306
+- **Supersedes**: None
+
+## Executive decision
+
+RuView will add a clean-room native Rust boundary between RF pose inference and
+semantic publication. It will preserve the immutable RF observation, publish a
+physics assessment, optionally produce a bounded corrected candidate, and
+abstain when required evidence is absent. It must never increase observational
+confidence merely because a pose is physically plausible.
+
+Three independently gated layers are adopted:
+
+1. A deterministic kinematic auditor and bounded covariance-weighted projector
+   using Rust and `nalgebra`.
+2. An optional articulated-body dynamics auditor using `rapier3d`.
+3. A later optional supervised residual model using Burn.
+
+The first production milestone is deterministic audit. It is not a GRIP port,
+not PPO, and not evidence that the current pose observer is production-ready.
+
+## Context
+
+ADR-101's committed Cog emits 17 COCO keypoints as normalized 2D coordinates.
+Its model has no per-joint uncertainty head and publishes a constant confidence.
+The sensing server also contains renderer-oriented EMA and bone clamping. These
+surfaces cannot establish metric 3D physics and can make weak evidence look
+more convincing.
+
+Pose output can violate bone length, floor, velocity, acceleration, and temporal
+continuity constraints. Downstream consumers also cannot reliably distinguish
+observed coordinates from derived correction. The rejected premise is:
+"physically plausible means more likely correct." Plausibility is only a prior;
+many incorrect poses are plausible.
+
+GRIP is architectural inspiration for an observer/controller split, but it
+observes four wearable IMUs and pressure insoles and drives a simulator. RuView
+observes RF, so GRIP weights are not input-compatible. External code, weights,
+simulators, and datasets require independent license review and never enter the
+runtime dependency graph by implication.
+
+## Outcome and actors
+
+For every accepted person track/timestamp, the engine returns exactly one
+`PoseRefinementV1`, including off, timeout, rejection, and abstention paths:
+
+- immutable `PoseObservationV2` content hash;
+- constraint residuals and quality disposition;
+- an optional bounded candidate and an explicit `selected` bit;
+- a typed reason when correction is unavailable;
+- model, calibration, configuration, and optional learned-artifact provenance.
+
+The RF observer owns observations and calibrated uncertainty; tracking owns
+identity stability; physics owns assessment/correction only; the sensing server
+owns deadlines, modes, publication, and rollback; the evidence engine owns
+release evaluation; clients choose raw/both/refined without silent fallback.
+
+## Input and coordinate contract
+
+Metric correction requires a monotonic nanosecond timestamp, session-scoped
+track ID, sequence and sensor epoch, 17 ordered COCO joints in metric X/Y/Z,
+per-joint positive-semidefinite covariance calibrated on held-out data, a
+versioned right-handed Z-up room frame, a normalized upward floor plane, model
+and calibration hashes, ADR-302 trust state, and authenticated/replay-protected
+source provenance.
+
+`Image2d` observations may be audited for image-plane ratios and continuity but
+must never enter 3D projection/dynamics or be called physically corrected.
+Unknown trust, missing calibration, missing uncertainty, stale/non-monotonic
+input, non-finite values, invalid covariance, excessive tracks, and room-bound
+violations fail to raw output with a typed reason.
+
+## Public contracts
+
+`wifi-densepose-core` owns `PoseObservationV2` and `PoseRefinementV1`; no
+duplicate server/Cog contract is permitted. Public output remains COCO17. The
+engine derives pelvis and thorax virtually and never labels them observed.
+
+The raw content hash is deterministic and excludes its own hash field. The
+idempotency key is `(sensor_epoch, sequence, track_id, raw_hash, config_hash)`.
+An exact duplicate returns the cached result; same sequence with different
+content is a replay rejection.
+
+Contact is `hypothesis` unless a measured sensor and its provenance say
+otherwise. Raw, derived, hypothesis, and unknown labels must survive every
+projection.
+
+## Confidence invariant
+
+For upstream calibrated confidence `c_obs`, normalized residual `r`, and
+normalized intervention `i`:
+
+```text
+c_physics = exp(-(beta_r * r + beta_i * i))
+c_effective = min(c_obs, c_obs * c_physics)
+0 <= c_effective <= c_obs <= 1
+```
+
+Only a separately witnessed multimodal fusion contract may increase fused
+confidence.
+
+## Deterministic projector
+
+The default `kinematic` feature has no Rapier, Burn, ONNX, libtorch, Python,
+CUDA, or network dependency. Per bounded iteration it:
+
+1. projects observed parent/child distances toward anonymous track-scoped
+   bone-length posteriors;
+2. applies broad joint/trunk validity checks without an upright prior;
+3. bounds temporal motion and resets derivatives after gaps;
+4. resolves floor penetration only, allowing seated, kneeling, prone, child-
+   scale, mobility-aid, and genuine-fall poses;
+5. recomputes residuals and stops below epsilon.
+
+Initial operator-owned caps are four iterations (hard maximum eight), 0.20 m
+single-joint correction, 0.10 m root correction, 250 ms derivative gap, 500 ms
+track reset, ten known joints, a 100 m metric room bound, a separate 16,384
+image-coordinate audit bound, and a 5 ms one-track Pi 5 p95 gate. Keeping image
+and metric bounds separate prevents legitimate pixel observations from
+weakening the physical room bound. A candidate over either correction cap is
+discarded in full.
+
+Bone posteriors are initialized only from high-confidence frames, anonymous,
+memory-only, track-scoped, and deleted on expiry. Persistent personalization is
+outside this ADR and requires consent/retention/deletion governance.
+
+## Optional dynamics and learned layers
+
+`dynamics` adds a process-owned Rapier humanoid and begins audit-only. Network
+input may never provide Rapier snapshots, bodies, constraints, solver limits,
+or arbitrary geometry. Dynamics approval is independent of kinematic approval.
+
+`learned` uses first-party Burn 0.21 core/NN components without `burn-tch`
+because this workspace already has a different native libtorch link.
+`learned-cpu` adds the ndarray backend. The implemented two-layer GRU uses a
+20-frame history and width 128 to predict bounded residuals, uncertainty,
+foot-contact hypotheses, and abstention. Verified model records can be loaded
+from bytes and executed natively; no trained artifact is shipped or approved.
+The resolved Burn/CubeCL graph declares Rust 1.92, while the workspace file
+pins Rust 1.89 and the authoring host provides Rust 1.91.1.
+`--ignore-rust-version` is diagnostic evidence only: learned activation remains
+blocked until an approved Rust 1.92 release-toolchain change builds it without
+that override. Residuals are hard-clipped to deterministic caps and cannot
+bypass validation or confidence monotonicity. PPO is deferred until measured
+evidence identifies a failure supervised residual learning cannot address.
+
+## Feature boundary
+
+```text
+default = kinematic
+dynamics = rapier3d
+learned = burn-core + burn-nn
+learned-cpu = learned + burn-ndarray
+learned-train = learned + burn-train
+learned-wgpu = learned-train + burn-wgpu
+learned-cuda = learned-train + burn-cuda
+deterministic = rapier3d?/enhanced-determinism
+```
+
+The lockfile is release authority. The learned feature currently requires the
+toolchain supported by Burn/CubeCL's resolved graph; this does not change the
+default edge build.
+
+## Runtime modes and API
+
+Rollout is `OFF -> AUDIT -> SHADOW_CORRECT -> OPT_IN_CORRECT -> DEFAULT_CORRECT`.
+Evidence permits forward transitions; any regression returns immediately to
+audit/off. Correct selection additionally requires authenticated sensor
+identity and replay protection from ADR-305. High model confidence cannot
+override missing source authentication.
+
+Existing pose fields stay unchanged and raw remains the migration default:
+
+```text
+GET /api/v1/pose/current?view=raw
+GET /api/v1/pose/current?view=both
+GET /api/v1/pose/current?view=refined
+```
+
+Refined-only returns HTTP 409 with `pose_refined_unavailable` when no selected
+candidate exists. It never silently returns raw labeled refined.
+
+## Security, privacy, and availability
+
+All frames, model output, geometry, and pre-verification artifacts are
+untrusted. Calibration/config/model artifacts become trusted only after signed,
+hash-addressed verification and atomic activation. Runtime inference performs
+no model retrieval or other network access.
+
+Fixed arrays/caps, bounded iterations, a maximum track count, room geometry
+limits, deadlines, and track expiry constrain denial of service. Timeout drops
+partial refinement, never raw publication. Backpressure retains the newest raw
+frame per track, drops intermediate refinement work, resets derivatives after
+250 ms, and never extrapolates beyond 500 ms.
+
+Metrics contain only allowlisted aggregate scalars: mode/disposition/reason,
+stage latency, iterations, maximum correction, residuals, confidence delta,
+track resets, invalid input, timeout, and raw/refined divergence. They exclude
+joint arrays, body dimensions, room coordinates, CSI, and persistent person
+identifiers. Bone/gait state is memory-only and excluded from logs.
+
+Refined output is not a sole medical, emergency, industrial-safety, or
+autonomous-control source. A real fall is valid state and must never be made
+upright to stabilize a simulator.
+
+## Threat model summary
+
+| Threat | Primary control | Residual risk |
+|---|---|---|
+| Spoofed/replayed sensor | ADR-305 identity, MAC, sequence and replay window; correction gate | Compromised legitimate sensor |
+| Altered model/floor/config | Signed hashes, authenticated configuration, atomic activation | Authorized unsafe configuration |
+| Poisoned data/splits | Immutable manifests, strict split validator, witnessed benchmarks | Subtle label poisoning |
+| Operator repudiation | Append-only witnessed transition with actor/old/new hash/reason | Compromised signer |
+| Biometric/log leakage | Track-local retention and fixed metric allowlist | Aggregate inference |
+| Track/geometry CPU flood | Authentication, cardinality/geometry/allocation/deadline caps | Valid dense-scene overload |
+| Remote mode escalation | Capability-scoped local control plane, deny by default | Compromised operator capability |
+| Derived output relabeled observed | Required schema/provenance and signed event envelope | Malicious downstream stripping |
+
+The implementation review records commit, lockfile hash, Rust toolchain,
+scanner versions, and advisory-feed timestamp.
+
+## Evidence protocol
+
+Evidence levels are L0 deterministic synthetic, L1 public measured replay, L2
+controlled RuView RF plus optical truth, L3 subject/room/hardware/session-
+disjoint RuView, L4 privacy-safe shadow fleet aggregates, and L5 independent
+vertical validation outside this ADR.
+
+No sequence, contiguous take, subject, room, or calibration session may cross
+train/test for the generalization gate. Preprocessing, body priors, and
+uncertainty calibration fit training data only. Reports include raw observer,
+renderer smoothing, audit, deterministic correction, dynamics audit, and
+learned residual on identical observations, plus empty-room, prone/fall,
+missing-joint, and OOD subsets.
+
+Primary metrics are 3D MPJPE, declared-threshold PCK, per-joint error, foot
+slide, floor penetration, jerk, uncertainty calibration, abstention coverage,
+and selective risk. Learned runs use at least five fixed seeds and report mean,
+median, standard deviation, and 95% bootstrap intervals. All frames count;
+selective metrics report risk and coverage.
+
+## Acceptance gates
+
+- **G0 contract**: real metric 3D/covariance output, round-trip raw hash,
+  versioned frame/floor, 2D compatibility, non-stub observer, ADR-298 artifact
+  sanity, and the ADR-079 PCK@20 >=35% gate or adopted successor. The current
+  committed Cog does not pass G0, so correction remains unavailable.
+- **G1 deterministic audit**: property/fuzz tests, deterministic hashes per
+  platform class, 24-hour accelerated replay without panic/growth, Pi 5 p95
+  <=5 ms, and universal confidence monotonicity.
+- **G2 shadow correction**: strict-disjoint measured median MPJPE improvement
+  >=10% with positive 95% CI lower bound; foot slide >=30% and jerk >=25%
+  better; no joint median >5 mm worse; fall/prone sensitivity change <=2 pp;
+  >=95% corrections below 0.10 m; every correction above 0.20 m abstains.
+- **G3 opt-in**: >=30 subjects, 10 rooms, 3 hardware configurations, and 3
+  independent sessions/room; UNKNOWN never selected; confidence monotonic;
+  live disable; REST/WebSocket/MQTT/Home Assistant/replay compatibility.
+- **G4 default visualization only**: 30 shadow days under 0.1% timeout/internal
+  error, no open severity 1/2 incidents, and gates still valid for current
+  model/calibration.
+
+Dynamics and learned engines each repeat G2-G4; approval is not inherited.
+
+## Testing and completion evidence
+
+Unit/property/fuzz/integration/security coverage maps to requirements R1-R13:
+raw hash, confidence, modes, malformed/stale/frame/covariance input, caps and
+deadlines, provenance, dependency graph, pose diversity/fall preservation,
+strict splits, fail-to-raw faults, no network capability, and authenticated
+source/replay selection.
+
+Release commands include focused core/physics tests, default/dynamics/learned
+feature checks, format/clippy, benches, `cargo deny`, `cargo audit`, strict split
+verification, and golden replay verification. Completion also requires JSON
+schemas, measured Pi 5/x86 rows, strict manifest hashes, raw/refined metrics,
+SBOM/license report, rollback drill, and residual-risk owners. Missing measured
+or operational evidence leaves status Proposed and runtime in audit.
+
+## Rollback
+
+Rollback is an authenticated mode transition to audit/off, not a binary
+downgrade. Stop selection immediately, keep raw publication and disposition
+records, discard track state, and retain only aggregate incident metrics plus
+signed configuration history. Failed artifact activation leaves the previous
+engine atomically active. Additive schemas remain; refined-only callers receive
+the typed unavailable response.
+
+## Consequences
+
+### Positive
+
+- Explicit anti-hallucination and provenance boundary after RF inference.
+- Reusable native Rust consistency primitive with measurable abstention.
+- Python/CUDA remain absent from the production default.
+- Cross-modal teacher data remains possible without wearable runtime inputs.
+
+### Negative
+
+- Full value requires a real metric 3D observer and calibrated uncertainty.
+- Stateful tracks add latency/memory; optional backends add supply-chain surface.
+- A constrained but wrong pose can look more credible.
+- Strict data collection costs more than the software implementation.
+
+### Neutral
+
+- This ADR does not improve RF observability or current weight evidence.
+- Existing 2D consumers continue to function.
+
+## Implementation phases
+
+P0 contracts/schemas; P1 deterministic audit; P2 bounded shadow correction; P3
+server/Cog publication and evidence ledger; P4 Rapier audit; P5 Burn residual
+training/inference. Code may land ahead of evidence, but runtime authority
+advances only through the gates above.
+
+## Implementation status at proposal
+
+- P0-P3 are implemented on this branch: canonical contracts, strict schemas,
+  deterministic audit/projection, authenticated correction receipts,
+  idempotency, bounded track state, latest-frame backpressure, additive HTTP
+  and WebSocket publication, live legacy-2D audit, privacy-safe metrics, golden
+  replay, and strict-split checks.
+- P4 is implemented as an optional persistent per-track Rapier dynamics auditor
+  and remains audit-only pending independent G2-G4 evidence.
+- P5 inference architecture, artifact verification, serialization, and native
+  CPU execution are implemented. Training data, a signed trained artifact, and
+  G2-G4 accuracy/calibration evidence do not exist, so the layer has no runtime
+  selection authority. Its resolved Rust 1.92 requirement is also an explicit
+  activation blocker on the current Rust 1.91.1 release host.
+- The live Cog honestly emits `Image2d`, degraded trust, and uncalibrated
+  uncertainty. It can be audited but cannot be selected for 3D correction.
+  G0 therefore remains open until an independently released metric-3D observer
+  with calibrated covariance is integrated.
+- Local x86 latency and synthetic contract checks are recorded in the append-
+  only evidence ledger. Pi 5 measurements, 24-hour replay, 100-million-case
+  fuzzing, held-out RF/optical accuracy, fleet shadowing, and vertical safety
+  validation remain release evidence gates rather than software claims.
+
+## References
+
+- [GRIP project](https://ryosukehori.github.io/grip-project/)
+- [GRIP paper (arXiv:2603.16233)](https://arxiv.org/abs/2603.16233)
+- [Rapier documentation](https://docs.rs/rapier3d/)
+- [Burn documentation](https://docs.rs/burn/0.21.0/burn/)
+- [ADR-020](./ADR-020-rust-ruvector-ai-model-migration.md)
+- [ADR-079](./ADR-079-camera-ground-truth-training.md)
+- [ADR-101](./ADR-101-pose-estimation-cog.md)
+- [ADR-150](./ADR-150-rf-foundation-encoder.md)
+- [ADR-273](./ADR-273-unified-rf-spatial-world-model.md)
+- [ADR-279](./ADR-279-native-rf-frame-contract.md)
+- [ADR-298](./ADR-298-model-release-sanity-gates.md)
+- [ADR-302](./ADR-302-out-of-distribution-detection.md)
+- [ADR-303](./ADR-303-ground-truth-synchronization.md)
+- [ADR-304](./ADR-304-evidence-engine.md)
+- [ADR-305](./ADR-305-authenticated-sensor-identity.md)
+- [ADR-306](./ADR-306-canonical-spatial-ontology.md)
@@ -0,0 +1,218 @@
+# ADR-323: RTL8721Dx (Realtek AmebaDplus) CSI Wire Protocol
+
+- **Status**: accepted
+- **Date**: 2026-09-15
+- **Deciders**: RuView maintainers
+- **Tags**: realtek, ameba, amebadplus, rtl8721dx, csi, protocol, rust, udp
+
+## Context
+
+Unlike the MediaTek/Qualcomm CSI paths (ADR-266..269), which are simulator-first
+because no supported public vendor interface exports complex CSI, Realtek's
+official Ameba RTOS SDK (`Ameba-AIoT/ameba-rtos`, Apache-2.0) documents and
+exposes a real, callback-driven CSI API for the RTL8721Dx ("AmebaDplus")
+family: `wifi_csi_config()` plus the `RTW_EVENT_CSI_DONE` event delivering a
+`struct rtw_event_csi_report_info` (per-tone signed I/Q, 8-bit or 16-bit
+precision, selectable tone decimation, passive or active/triggered capture).
+This has been confirmed directly against SDK source
+(`component/wifi/api/wifi_api_event.h`) and against the official
+`example/wifi/wifi_csi` example, and validated on real PKM8721DAF-C13-F10
+hardware (build+flash+boot confirmed on branch `feat/rtl8721dx-csi-bringup`).
+
+The RTL8721Dx is a 1x1 WiFi 4 part — single TX/RX chain, not MIMO — so the
+MediaTek/Qualcomm wire format (Tx/Rx dimensioned matrices, chipset chain
+counts) does not fit. The vendor SDK's raw struct is also not a safe host
+wire format as-is: it has no CRC, a C flexible-array-member payload, and
+fields sized for firmware convenience (e.g. a wrapping `u32` microsecond
+timestamp) rather than network robustness.
+
+Per the existing repo convention (ESP32/ADR-018, MediaTek/ADR-266-267,
+Qualcomm/ADR-268-269, RTL8720F radar/ADR-263-264), each vendor CSI/radar
+source gets its own self-delimiting envelope and its own Rust module pair
+(`wifi-densepose-hardware` for framing+codec+simulator,
+`wifi-densepose-sensing-server` for the bounded JSON-safe snapshot), never a
+shared "generic vendor CSI" struct that would either lose vendor-specific
+fields or invite magic-space collisions. `SourceKind::Realtek` (value 2) is
+already assigned to the RTL8720F FMCW radar path (ADR-263/264) and must not
+be reused for CSI.
+
+## Decision
+
+Define `RAC1` ("Realtek Ameba CSI", version 1) as a little-endian,
+self-delimiting envelope, magic `0x3143_4152` (distinct from `MTC1`
+`0x3143544d`, `QCS1` 0x31535143, `RTR1` 0x31525452, and all ADR-018
+`0xC511000x` siblings):
+
+Fixed 49-byte header (explicit field-by-field serialization, no `#[repr(C)]`
+padding, matching the MediaTek/Qualcomm modules' style):
+
+| Field | Type | Notes |
+|---|---|---|
+| magic | u32 LE | `0x3143_4152` |
+| version | u8 | 1 |
+| header_len | u16 LE | 49 |
+| frame_len | u32 LE | header + payload + 4-byte CRC |
+| node_id | u8 | disambiguates multi-board illuminator/receiver deployments; 0 = unset |
+| csi_mode | u8 | 0=passive, 1=active, 2=board-to-board (`CsiMode`) |
+| sequence | u32 LE | from firmware `csi_sequence` |
+| timestamp_us | u32 LE | from firmware `hw_assigned_timestamp` (hardware-clock microseconds, wraps ~71 min — consumers must not assume monotonic across a capture longer than that) |
+| peer_mac | [u8; 6] | firmware `mac_addr` |
+| trig_mac | [u8; 6] | firmware `trig_addr` |
+| channel | u8 | operating channel |
+| bandwidth | u8 | 0=20MHz, 1=40MHz |
+| rx_rate | u8 | firmware `rx_rate` |
+| protocol_mode | u8 | 0=OFDM,1=HT,2=VHT,3=HE (`ProtocolMode`) |
+| num_sub_carrier | u16 LE | tone count in payload |
+| num_bit_per_tone | u8 | 16 (8-bit I + 8-bit Q) or 32 (16-bit I + 16-bit Q) |
+| decimation | u8 | tone group (1/2/4/8 — every Nth tone) |
+| rssi_dbm | i8 | single RF chain (1x1 hardware) |
+| rxsc | u8 | sub-20 MHz channel used |
+| csi_valid | u8 | 0/1 from firmware |
+| flags | u8 | bit 0 = SYNTHETIC (simulator provenance, never clearable downstream) |
+| payload_len | u32 LE | bytes, == `num_sub_carrier * (num_bit_per_tone / 8)` |
+
+Payload: `num_sub_carrier` consecutive (I, Q) tone pairs, each
+`num_bit_per_tone / 16` bytes per component (1 byte/component when
+`num_bit_per_tone == 16`, 2 bytes/component little-endian signed when `== 32`)
+— i.e. exactly the byte layout the firmware already produces in
+`csi_data[]`, just framed. CRC-32/IEEE over header+payload, final 4
+little-endian bytes. One envelope per UDP datagram.
+
+Parsers reject: unknown version, wrong `header_len`, `frame_len` exceeding
+the IPv4 UDP payload cap (65,507 bytes), `num_bit_per_tone` outside
+`{16, 32}`, `payload_len` inconsistent with `num_sub_carrier *
+(num_bit_per_tone/8)`, trailing bytes, and bad CRC — mirroring the
+MediaTek/Qualcomm parser contract exactly.
+
+Host side: add `realtek_csi.rs` to both
+`wifi-densepose-hardware` (frame + codec + simulator, mirroring
+`mediatek_csi.rs`/`qualcomm_csi.rs`) and `wifi-densepose-sensing-server`
+(bounded `RealtekCsiSnapshot`, mirroring `QualcommCsiSnapshot`), wired into
+the same UDP listener loop and `/api/v1/csi/realtek/latest` route as the
+existing vendor sources. The initial Mac compatibility port keeps Realtek CSI
+as a separate bounded diagnostic stream. Fresh ESP32 frames remain the primary
+sensing source. This change does not add `SourceKind::RealtekCsi` to a signed
+ingest contract; that requires a separate reviewed identity-bound hardware
+proof. RAC1 CRC checks corruption, not origin.
+
+Firmware side (`example/wifi/wifi_csi` derivative, built against the
+official Ameba RTOS SDK, tracked outside this repository per the existing
+`CLAUDE.local.md` convention — the vendor SDK itself is never vendored into
+this repo): join the board to the deployment's WiFi AP in STA mode
+(passive CSI against the real AP as peer, since only one physical board is
+available in this bring-up), read the AP's BSSID at runtime after
+association (never hardcode a MAC into firmware source), pack each
+`RTW_EVENT_CSI_DONE` report into one `RAC1` datagram, and `sendto()` it over
+UDP to the host sensing-server's existing CSI port.
+
+## Consequences
+
+### Positive
+
+- CSI is real, MEASURED hardware output from day one — no simulator-first
+  bridge phase is needed the way MediaTek/Qualcomm required, because the
+  vendor SDK genuinely exposes the capability and we have the board in hand.
+- One board is sufficient for a first useful signal (passive CSI against the
+  home AP); active and board-to-board modes are additive later without a
+  wire-format break (`csi_mode` already reserves the values).
+- Reuses the bounded UDP parser and status-route pattern without changing
+  existing ESP32 sensing. Unsigned RAC1 diagnostics are not authorized as
+  calibrated presence, person count, pose, or vital evidence.
+
+### Negative
+
+- 1x1 hardware means no spatial (multi-antenna) diversity from a single
+  board; multi-board deployment is required for the differential/localization
+  use cases described in the original RTL8721Dx capability analysis.
+- The 71-minute microsecond timestamp wraparound (inherited from the
+  firmware's `u32` field) means long unattended captures need host-side
+  sequence-based reordering, not raw timestamp arithmetic, across a wrap.
+
+### Neutral
+
+- The RAC1 envelope intentionally does not carry the SDK's raw
+  `csi_signature` (0xABCD) marker — our own `magic`/CRC supersede it as the
+  framing integrity check.
+
+## Hardware gates
+
+- [x] Confirm SDK source exposes `RTW_EVENT_CSI_DONE` / `rtw_event_csi_report_info` (done — `component/wifi/api/wifi_api_event.h`).
+- [x] Build and flash a baseline image on real PKM8721DAF-C13-F10 hardware, confirm boot over serial (done — `feat/rtl8721dx-csi-bringup`).
+- [x] Flash the CSI-streaming firmware and confirm `RAC1` datagrams parse on the host from the real board (done, 2026-09-15 — see below).
+- [x] Record MEASURED throughput/latency/jitter from the real running firmware (done, 2026-09-15 — see below).
+- [ ] A human walk-test across the link (amplitude perturbation vs. static baseline) is deferred — requires the operator physically present; not claimed until performed.
+
+### MEASURED: real RAC1 capture and sustained throughput (2026-09-15)
+
+Passive CSI (`RTW_CSI_MODE_NORMAL`, `RTW_CSI_TRIG_BEACON | RTW_CSI_TRIG_DATA | RTW_CSI_TRIG_QOS_DATA`)
+against the deployment AP. A single `RAC1` datagram was first
+cross-checked field-by-field against the firmware's own serial log of the
+same report — every byte matched: magic `0x31434152`, RSSI byte exact match,
+channel/bandwidth/protocol/subcarrier-count exact match, 157-byte total frame
+(49-byte header + 104-byte payload + 4-byte CRC, exactly as specified above).
+
+`RTW_CSI_MODE_RX_RESP` (estimate CSI from ACKs to the STA's own transmissions)
+never fired `RTW_EVENT_CSI_DONE` across two full test runs with confirmed
+real traffic (not a hang) — this mode does not work for this hardware/AP
+combination and `RTW_CSI_MODE_NORMAL` with beacon+data triggers is the
+working configuration.
+
+**An earlier note here claimed `NORMAL` mode fires only once per CSI enable
+— that was wrong**, caused by a debug log line gated to print only every
+50th frame (`frame_count % 50 == 1`), which was misread as "only one report
+total." A follow-up capture with a UDP listener running concurrently with a
+board reset measured **277 real RAC1 datagrams in 40 seconds (43,489 bytes)**,
+with `csi_sequence` climbing continuously and monotonically in the firmware's
+own serial log across six separate 50-frame log checkpoints in one 45s
+session — CSI reporting is continuous, roughly 7-12 fps, not sparse.
+
+### MEASURED: throughput optimization pass (2026-09-15)
+
+Formalized as a repeatable tool: `scripts/benchmark-rtl8721dx-csi.py` (listens
+on the sensing-server's CSI UDP port, reports fps/throughput/RSSI/inter-frame
+interval/sequence-gap stats from real received `RAC1` datagrams).
+
+**Baseline** (`trig_period=200` [64ms], `trig_frame_ctrl=0`,
+`CSI_REPORT_BUF_NUM=1`), 30s capture:
+
+| Metric | Value |
+|---|---|
+| RAC1 fps | 14.67 |
+| Throughput | 2,302.7 bytes/s |
+| Mean inter-frame interval | 68.3 ms |
+| RSSI | mean -34.4 dBm |
+
+`trig_period` (units of 320µs) was hypothesized as the rate-limiting
+throttle — the observed 68.3ms mean interval tracks the 64ms configured
+period almost exactly. Confirmed by tuning:
+
+1. `trig_period`: 200 → 15 (the SDK doc's stated minimum recommended value,
+   ~4.8ms)
+2. `trig_frame_ctrl`: 0 → `RTW_CSI_TRIG_ACK` (second trigger source: every
+   link-layer ACK the AP sends for the heartbeat's own outgoing traffic, on
+   top of the existing beacon trigger)
+3. `CSI_REPORT_BUF_NUM`: 1 → 4 (a "lack of csi buf!" drop was observed even
+   at the slower baseline rate; more headroom needed at a higher rate)
+
+**Tuned**, 30s capture:
+
+| Metric | Value | vs. baseline |
+|---|---|---|
+| RAC1 fps | 66.40 | **4.5x** |
+| Throughput | 10,424.8 bytes/s | **4.5x** |
+| Mean inter-frame interval | 14.9 ms | 4.6x lower |
+| Sequence gaps | 78 / ~2036 (~3.8%) | new (0 observed at the slower baseline rate) |
+| RSSI | mean -31.1 dBm | (different session/position, not a controlled variable here) |
+
+The `trig_period` hypothesis is confirmed as the primary lever. The ~3.8%
+frame-loss rate at 66 fps is a reasonable place to stop for now — it is
+UDP-over-WiFi loss, not a firmware defect, and is small enough not to block
+downstream sensing use; revisit only if a use case needs stronger delivery
+guarantees (sequence-gap-triggered re-request, TCP fallback, etc.).
+
+## Links
+
+- [ADR-266](ADR-266-mediatek-filogic-csi-platform.md) / [ADR-267](ADR-267-mediatek-mimo-csi-wire-protocol.md) — sibling vendor CSI ADR pair (simulator-first precedent)
+- [ADR-268](ADR-268-qualcomm-atheros-csi-platform.md) / [ADR-269](ADR-269-qualcomm-csi-wire-protocol.md) — sibling vendor CSI ADR pair
+- [ADR-263](ADR-263-rtl8720f-2-4ghz-fmcw-radar-platform.md) / [ADR-264](ADR-264-rtl8720f-radar-wire-protocol.md) — existing Realtek (RTL8720F radar) path; `SourceKind::Realtek` owner
+- `CLAUDE.local.md` — RTL8721Dx toolchain setup, board/COM port, first bring-up log
@@ -0,0 +1,276 @@
+# ADR-324: off-axis-mode — RF-assisted head-coupled perspective for the three.js realtime demo
+
+| Field | Value |
+|-------|-------|
+| **Status** | Proposed (core implemented — see §2.5) |
+| **Date** | 2026-08-16 |
+| **Deciders** | ruv |
+| **Codename** | **off-axis-mode** |
+| **Scope** | New `examples/three.js/demos/07-off-axis-window.html` (client-side only); no server changes |
+| **Relates to** | ADR-019 (sensing-only UI), ADR-035 (live sensing UI accuracy), ADR-169 (adam-mode), ADR-170 (yoga-mode), ADR-282 (L0–L5 evidence ladder), ADR-295 (source provenance), ADR-306 (spatial ontology), ADR-307 (persistent tracking), ADR-323 (pose refinement) |
+| **Prior art** | [`icurtis1/off-axis-sneaker`](https://github.com/icurtis1/off-axis-sneaker) (reference only — see §2.1 licensing) |
+| **Numbering note** | ADR-324 is the next free number in the authoring checkout (322 is unused, 323 is the latest on disk). Re-run the ADR index/collision check immediately before merge and rename if needed. |
+| **Tracking issue** | none yet |
+
+---
+
+## 1. Context
+
+### 1.1 The question this ADR answers
+
+"Can we use [`icurtis1/off-axis-sneaker`](https://github.com/icurtis1/off-axis-sneaker)
+with RuView?" The answer is: **yes for the technique, no for the code, and
+only honestly for the RF part.** This ADR records the research behind each of
+those three clauses and defines the integration that is actually defensible.
+
+### 1.2 What off-axis-sneaker is
+
+`off-axis-sneaker` is a React + TypeScript + Vite web app that renders a GLB
+model (a sneaker) in three.js and creates a *head-coupled perspective*
+("fish-tank VR" / "window into the screen") illusion:
+
+- **Tracking input**: MediaPipe Face Mesh (468 facial landmarks) from a
+  webcam. Head (x, y) comes from the eye midpoint; depth (z) is proxied by
+  inter-ocular distance. An exponential moving average (default factor 0.3)
+  smooths jitter; sensitivity multipliers are `strengthX: 4`, `strengthY: 3`,
+  `strengthZ: 2`.
+- **Projection**: `src/utils/offAxisCamera.ts` builds a **true asymmetric
+  (off-axis) frustum** — `makePerspective(left, right, top, bottom, near, far)`
+  with `left/right/top/bottom = (screenBound − eyePosition) · (near /
+  viewerToScreenDistance)` — i.e. Kooima's generalized perspective projection,
+  plus a matching camera translation. Constants: `nearPlane 0.05`,
+  `farPlane 1000`, `worldScale 0.01` (cm → world units), `movementScale 1.5`.
+- **Calibration**: a wizard captures physical screen width/height (cm),
+  typical viewing distance, and pixel density, stored locally, so eye position
+  is computed relative to the *physical* display.
+
+The technique descends from Johnny Chung Lee's 2007 Wii-remote desktop VR
+demo and the fish-tank VR literature (Ware, Arthur & Booth, CHI '93). The
+projection math is Robert Kooima's "Generalized Perspective Projection"
+(2008). Both are public, well-documented techniques independent of any one
+implementation.
+
+### 1.3 What the illusion physically requires
+
+The head-coupled illusion is only convincing when the tracked eye position is
+**accurate to roughly centimeters** and **low-latency**. The VR literature
+puts comfortable motion-to-photon latency below ~20 ms for head-mounted
+displays; desktop fish-tank VR tolerates more, but visible lag between head
+motion and parallax response is exactly what breaks the "window" illusion.
+`CLAIMED` (literature values; no RuView measurement exists for this demo yet).
+
+### 1.4 What RuView RF sensing can actually supply today
+
+This is where honesty is mandatory (repo rule: never present WiFi sensing as
+camera-grade).
+
+- **Field-peak position, not metric localization.**
+  `wifi-densepose-sensing-server/src/field_localize.rs` derives a position
+  from the strongest peak of the 20×20 `signal_field` carried on
+  `/ws/sensing` `sensing_update` frames. Its own module doc states the
+  caveat: the subcarrier→angle mapping is a *representation*; "a single ESP32
+  link cannot resolve a true (x, z) room position." The emitted position is
+  "strongest field peak in the room model," mapped with `X_SCALE 0.6`,
+  `Z_SCALE 0.5`, gated by `PEAK_THRESHOLD 0.35` — real, live, motion-tracking,
+  but **not a calibrated person fix** and nowhere near eye-position precision.
+- **RF pose is 2-D, normalized, constant-confidence.** The committed Cog
+  (ADR-101, restated by ADR-323) emits 17 COCO keypoints as normalized 2-D
+  coordinates with a constant confidence and no per-joint uncertainty. A
+  "nose" keypoint exists (COCO index 0), but it is not a metric 3-D head fix.
+- **Tracks are coarse and pseudonymous by design.** `ruview-track` (ADR-307)
+  maintains `person_N` tracks with container-level ("kitchen → hallway")
+  continuity, coarse non-reversible features, and asserts **no accuracy
+  number** — outputs default to evidence level `L1`.
+- **Update cadence and latency are unmeasured for this purpose.** The demo
+  pipeline runs at ~30 Hz on the MediaPipe side (ADR-170), but no end-to-end
+  RF motion-to-photon latency has been measured. Any figure quoted for the RF
+  path must be tagged `MEASURED` with a reproducer before it appears in docs
+  or UI.
+
+Conclusion of the capability match: **RF cannot drive a convincing fish-tank
+illusion by itself today**, and this ADR does not claim it can. RF *can*
+supply things a webcam cannot: camera-free presence, zone-level position,
+person count, approach direction, and pseudonymous continuity — including
+when the camera is off.
+
+### 1.5 What this ADR is *not*
+
+- Not a vendoring of `off-axis-sneaker` (see §2.1 — the repo has no license).
+- Not a claim of camera-grade RF head tracking, at any tier.
+- Not a backend change: no new server endpoints, no new auth surface, no
+  schema changes. Purely additive client-side HTML/JS, like ADR-169/170.
+- Not a React/Vite/Tailwind adoption. The `examples/three.js/demos/*` are
+  dependency-light single-file HTML demos and stay that way.
+
+## 2. Decision
+
+### 2.1 Licensing: adopt the technique, not the code
+
+`off-axis-sneaker` publishes **no license**. Under default copyright, its
+source cannot be copied, vendored, or translated into this repository.
+Decision:
+
+1. **No code, assets, or models from `off-axis-sneaker` enter this repo.**
+   The GLB sneaker model is likewise unlicensed for reuse; demos use assets
+   already present in `examples/`.
+2. The off-axis projection is implemented **clean-room from the public
+   sources**: Kooima's "Generalized Perspective Projection" (2008) — the
+   `pa/pb/pc` screen-corner formulation — and three.js's documented
+   `PerspectiveCamera.projectionMatrix` override path. The repository is cited
+   as prior art in this ADR only.
+3. If upstream later adds a permissive license, revisiting reuse requires a
+   new ADR note, not silent copying.
+
+### 2.2 Tiered integration — each tier labeled by what it really is
+
+**Tier A (ships first): webcam-fine + RF-context hybrid.**
+`07-off-axis-window.html` uses MediaPipe Face Landmarker (already the pattern
+in demo 05) for fine head tracking and the Kooima frustum for rendering —
+functionally what off-axis-sneaker does, reimplemented. RuView RF adds the
+camera-free layer around it:
+
+- **Presence-gated camera**: the webcam pipeline starts only when the RF
+  presence signal (`/ws/sensing` `sensing_update`) says someone is in the
+  zone, and stops after a configurable RF-vacancy timeout. The privacy
+  posture improves: the camera is *off* until physics says there is someone
+  to track.
+- **Multi-person arbitration**: when RF reports more than one person, the HUD
+  says so and the demo holds the last stable perspective instead of jumping
+  between faces.
+- **Pre-warm**: RF approach direction (field-peak trajectory) warms up
+  MediaPipe and the scene before the person sits down.
+
+**Tier B (demo mode, prominently labeled): RF-only coarse parallax.**
+A toggle drives the off-axis eye position from RF alone — field peak (x, z)
+plus the pose nose keypoint when present — through a one-euro filter, a
+deadband, and a hard gain clamp. The HUD labels it **"RF coarse body
+parallax — not head tracking"** and shows the live evidence level (`L1`
+heuristic unless a certificate says otherwise, per ADR-282/ADR-318). The
+expected experience is a slow, body-scale parallax sway — a demonstrative
+"the room model moves because *you* moved, with no camera" — not a stable
+fish-tank illusion. The demo must never present Tier B as equivalent to
+Tier A.
+
+**Tier C (future, explicitly gated, not promised): metric RF head position.**
+Only a calibrated multistatic deployment (ADR-297 multi-node semantics,
+ADR-311 fusion, ADR-303 ground-truth sync) with an evidence-engine ledger
+entry (ADR-304) and a capability certificate (ADR-318) could justify feeding
+RF positions into the fine path. No current data supports this; Tier C exists
+in this ADR solely so nobody ships it informally without those gates.
+
+### 2.3 Implementation surface
+
+- New file `examples/three.js/demos/07-off-axis-window.html` (07, not 06 —
+  ADR-170 reserves `06-yoga-mode.html`). Single-file demo following the 01–05
+  conventions: same CSS custom properties, same HUD/helper-panel pattern,
+  served from the existing static demo server
+  (`http://127.0.0.1:8765/examples/three.js/demos/…`).
+- A small clean-room module (inline `<script type="module">` or
+  `examples/three.js/lib/off-axis-camera.js` if shared later) that, given
+  screen corners `pa, pb, pc` (from calibration) and eye point `pe`, sets
+  `camera.projectionMatrix` via the Kooima formulation each frame.
+- Data inputs are the **existing** streams only: `/ws/sensing`
+  (`sensing_update` → `signal_field` → field peak, using the same
+  `X_SCALE`/`Z_SCALE`/`PEAK_THRESHOLD` mapping as `field_localize.rs`) and,
+  when available, `/api/v1/stream/pose` for the nose keypoint. WebSocket
+  access uses the existing ticket flow (`ws_ticket.rs` / `bearer_auth.rs`);
+  no endpoint is exempted or added.
+- Calibration mirrors the sneaker app's concept without its code: screen
+  width/height in cm, viewing distance, persisted in `localStorage` under a
+  demo-scoped key. No calibration data leaves the browser.
+- Provenance discipline: if the demo is pointed at a synthetic or replayed
+  source, the ADR-295 provenance state must surface in the HUD exactly as the
+  Observatory does — synthetic can never present as live.
+
+### 2.4 Honesty and evidence rules binding this feature
+
+1. Every user-visible latency, accuracy, or precision statement in the demo,
+   README, or docs carries a `MEASURED` (with reproducer), `CLAIMED`, or
+   `SYNTHETIC` tag. This ADR itself contains no `MEASURED` claims.
+2. Tier B is labeled coarse body parallax in the HUD at all times; there is
+   no configuration that hides the label while RF drives the camera.
+3. No PCK or pose-accuracy number may be quoted for the RF path without the
+   mean-pose baseline and a leakage-free held-out split (repo rule).
+4. The webcam feed never leaves the browser; no frames, landmarks, or
+   embeddings are sent to the server. RF data continues to obey ADR-307's
+   privacy invariants (pseudonymous, coarse, rotatable).
+
+### 2.5 Implementation status (2026-08-16 amendment)
+
+The projection core shipped as a **Rust crate compiled to WASM** rather than
+the inline JS module §2.3 anticipated — a strict upgrade with the same
+surface: `v2/crates/ruview-offaxis` (dependency-free native core; wasm-bindgen
+only on wasm32) implements the Kooima projection, the one-euro filter, the
+field-peak mapping (constants mirroring `field_localize.rs`), and the Tier B
+coarse-parallax stage with its deadband/gain/clamp bounds enforced in Rust.
+`examples/three.js/demos/07-off-axis-window.html` consumes the wasm-bindgen
+output (built locally per the crate README; generated artifacts are not
+committed). Validation and `MEASURED` benchmarks live in the crate README.
+The demo ships with a `SYNTHETIC`-labeled mouse simulator and the labeled
+Tier B RF mode; a Tier A fine tracker connects through
+`OffAxisCamera.update_normalized` and remains host-provided.
+
+## 3. Options considered
+
+| Option | Verdict | Why |
+|---|---|---|
+| Vendor `off-axis-sneaker` (or fork + point at RuView) | **Rejected** | No license ⇒ no redistribution rights. Also React/Vite stack conflicts with the repo's single-file demo convention. |
+| Clean-room Kooima off-axis demo, webcam-fine + RF-context (Tier A/B) | **Chosen** | Legally clean, matches demo conventions, uses RF for what it is actually good at, and demonstrates camera-free presence value honestly. |
+| RF-only head-coupled perspective as the headline | **Rejected** | Over-claim. Single-link field peaks are a representation, not metric localization (`field_localize.rs` caveat); shipping this as "head tracking" violates the camera-grade rule. Survives only as the labeled Tier B toggle. |
+| Wait for multistatic metric localization (Tier C) before any demo | **Rejected** | Blocks a useful, honest demo on a phase-2/3 program (ADR-303/311/318) with no delivery date. The gates are recorded instead. |
+| Add a dedicated server endpoint for head position | **Rejected** | Unnecessary — existing `/ws/sensing` + `/api/v1/stream/pose` suffice; a new endpoint would expand the auth surface for no capability gain. |
+
+## 4. Consequences
+
+**Improves**
+
+- A publicly legible demo of RF sensing's actual differentiator: the scene
+  knows you are there, where you roughly are, and how many of you there are —
+  before and without any camera.
+- Privacy posture of the head-tracking demo class: camera duty-cycle is
+  bounded by RF presence instead of always-on.
+- Canonical, licensed off-axis projection code the Observatory or future UI
+  can reuse.
+
+**Costs / risks**
+
+- Tier B can underwhelm viewers primed by webcam demos; the mitigation is the
+  labeling and the side-by-side toggle, not inflated gain.
+- MediaPipe CDN dependency (same as demo 05) remains a network-availability
+  risk for Tier A; the demo must degrade to Tier B with a visible notice.
+- Screen-calibration friction (cm measurements) may deter casual users; a
+  "skip calibration (approximate)" path with degraded-accuracy labeling is
+  acceptable.
+- Upstream `off-axis-sneaker` may change or add a license; tracking that is
+  manual.
+
+**Follow-ups (not in this ADR's scope)**
+
+- Measure end-to-end RF motion-to-parallax latency with a reproducer and
+  publish it `MEASURED`.
+- If/when ADR-303/311 land, evaluate Tier C against the ADR-318 certificate
+  gate.
+- Consider promoting the off-axis camera module into the Observatory 3D view.
+
+## 5. Validation
+
+- Demo checklist (manual, per ADR-169/170 practice): loads from the static
+  server; Tier A activates only on RF presence; Tier B label visible whenever
+  RF drives the camera; provenance badge correct against a synthetic source;
+  no network requests carrying webcam-derived data (verified in devtools).
+- `rg` gate before merge: no file under `examples/` contains code originating
+  from `icurtis1/off-axis-sneaker`.
+- No workspace, harness, or firmware validation rows are triggered — the
+  change is a static HTML demo plus this document.
+
+## 6. References
+
+- [`icurtis1/off-axis-sneaker`](https://github.com/icurtis1/off-axis-sneaker) — prior-art reference (unlicensed; technique only)
+- Robert Kooima, *Generalized Perspective Projection*, 2008 — off-axis frustum math
+- Johnny Chung Lee, *Head Tracking for Desktop VR Displays using the Wii Remote*, 2007
+- Ware, Arthur & Booth, *Fish Tank Virtual Reality*, CHI '93 — head coupling vs. stereo
+- `v2/crates/wifi-densepose-sensing-server/src/field_localize.rs` — field-peak honesty caveat and coordinate mapping
+- `v2/crates/wifi-densepose-sensing-server/src/ws_ticket.rs`, `bearer_auth.rs` — WebSocket auth pattern
+- `v2/crates/ruview-track/src/lib.rs` — ADR-307 privacy invariants and evidence discipline
+- ADR-169, ADR-170 — demo-scoped ADR pattern for `examples/three.js/demos/`
+- ADR-282 — L0–L5 evidence ladder; ADR-295 — provenance state machine
@@ -0,0 +1,543 @@
+# ADR-325: Cognitum Spaces activation and governed spatial exchange
+
+- **Status**: Accepted — legacy and versioned reads, OAuth activation, local spatial memory, governed-action policy, metaharness support, and npm distribution are implemented; HTTPS production evidence is complete
+- **Date**: 2026-08-17
+- **Deciders**: ruv
+- **Tags**: cognitum-spaces, oauth, spatial-state, privacy, ruvector, policy, autogenous
+- **Relates to**: ADR-271, ADR-277, ADR-304, ADR-306, ADR-312, ADR-318, ADR-319, ADR-321; Cognitum API ADR-094; Autogenous ADR-402
+
+## Context
+
+RuView produces camera-free RF perception locally. Cognitum Spaces provides a
+tenant-scoped cloud projection of physical places. Autogenous ADR-402 proposes
+using that projection as a spatial-intelligence input for agent coordination.
+The useful product is not another sensor dashboard: it is a governed chain from
+local perception to spatial state, persistent memory, explanation, and action.
+
+Four product pillars define the requested integration:
+
+1. **Spatial state** — sites, buildings, floors, rooms/spaces, zones, entities,
+   semantic events, and alerts.
+2. **RuView perception** — camera-free sensing is normalized locally before any
+   permitted P2/P3 semantic event synchronizes.
+3. **Persistent memory** — RuVector grounds anomaly explanations in
+   tenant-scoped spatial history.
+4. **Governed action** — agents observe or recommend by default; consequential
+   execution requires explicit policy authorization.
+
+The live API audit on 2026-08-17 established the current production boundary:
+
+- `GET https://api.cognitum.one/v1/spaces` exists and returns a bounded list;
+- an unauthenticated request is rejected;
+- the current account has no paired sites, so the authenticated result is an
+  empty list rather than fabricated sample state;
+- the projection declares HomeCore Edge authoritative and excludes raw CSI,
+  CIR, RF tensors, recordings, pose frames, vital waveforms, and identity
+  observations;
+- the first deployed Function revision accepted only legacy `cog_` API keys;
+- the gateway was configured to authenticate private Function hops, but the
+  direct Function endpoint was still publicly invokable; that bypass has now
+  been closed and the exact gateway runtime service account is the only
+  invoker;
+- OAuth protected-resource metadata and a RuView-scoped OAuth accept path were
+  absent.
+
+The Autogenous review at commit
+`f7fa308b261bac89a8909edae8a3fdbbfb8ce66c` found additional integration risks:
+
+- its Spaces client only listed spaces; no governed ingest contract existed;
+- it trusted a loose TypeScript cast, with no response-size, timeout, redirect,
+  or strict semantic-boundary validation;
+- its observation conversion dropped tenant/message/sequence identity;
+- missing confidence became zero but could still enter fusion;
+- provenance could be substituted for calibration identity;
+- a Spaces-derived belief could be converted back into an observation and
+  counted as independent corroboration, laundering one source into two;
+- its API-key exchange returns a `cognitum-cli` OAuth token, but the live Spaces
+  endpoint accepted only a `cog_` key. Calling this “OAuth Spaces access” was a
+  contract mismatch.
+
+## Decision
+
+Adopt a one-way-by-default, typed spatial exchange with separate activation,
+data, memory, and action authorities.
+
+```text
+RuView RF capture (P0/P1, local)
+  -> calibrated/OOD-gated semantic observation
+  -> ontology + evidence + witness envelope (P2/P3)
+  -> HomeCore authoritative edge state
+  -> Cognitum Spaces tenant/workspace projection
+  -> RuView bounded read client / Autogenous spatial context
+  -> RuVector tenant-scoped memory and explanation
+  -> recommendation
+  -> ruvview-policy authorization + approval + receipt
+  -> optional consequential action
+```
+
+Cloud state is a projection of edge state, not a second sensor and not an
+independent corroborating modality.
+
+### 1. Activation and data-plane credentials are distinct
+
+RuView uses Cognitum's existing Authorization Code + PKCE flow with the public
+`ruview` client. A user explicitly requests `spaces:read` with
+`wifi-densepose login --spaces`. The authorization-server registration is a
+ceiling; ordinary sensing login does not silently gain cloud access.
+
+The Spaces resource server accepts either:
+
+- a legacy API key carrying `spaces:read` (or the migration-compatible
+  predecessor `devices:manage`); or
+- a Cognitum OAuth access token that passes every condition below.
+
+OAuth acceptance is conjunctive:
+
+| Check | Required value |
+|---|---|
+| Signature | ES256 against `https://auth.cognitum.one/.well-known/jwks.json` |
+| Issuer | exact `https://auth.cognitum.one` |
+| Audience | exact `ruview` |
+| Client claim | exact `ruview` |
+| Token type | ordinary `access`; setup/workload tokens denied |
+| Lifetime | current `exp`/`nbf`, five-second clock tolerance only |
+| Scope | exact token `spaces:read` member |
+| Tenant binding | valid non-empty UUID `org_id` and `workspace_id` |
+
+An API key is not called OAuth. An OAuth token is not stored in
+`COGNITUM_SPACES_API`. The compatibility environment variable contains an API
+key only and is never printed, logged, or committed.
+
+OAuth consent grants identity-bound read access. It does **not** grant device
+pairing, data publication, deployment, billing, spending, leases, learning
+promotion, automation installation, commands, or actuator authority.
+
+The contributor metaharness exposes this as CLI verb `spaces` and MCP tool
+`ruview_spaces_list`. It delegates to the same Rust client rather than parsing
+or refreshing OAuth independently. The tool never accepts a bearer token or API
+key. MCP use requires an operator-provided `credential-use` grant, and MCP calls
+cannot select the credential path or API origin. The adapter requires an
+installed `wifi-densepose` binary rather than executing Cargo build scripts
+from an auto-detected checkout while holding credential authority. Because
+refresh tokens rotate, a read may atomically update the local OAuth credential
+before contacting Spaces; this authentication side effect is disclosed and
+does not add cloud write authority.
+
+### 2. The gateway owns the private credential relay
+
+The public gateway strips inbound `X-Cognitum-User-Authorization` and
+`X-Serverless-Authorization`. For a locked Function upstream it then:
+
+1. retains a legacy `cog_` credential in `X-API-Key`, or, for the exact Spaces
+   route only, retains a non-key bearer in a gateway-owned internal header;
+2. replaces `Authorization` with the gateway's Google invoker ID token;
+3. fails closed with `503` if it cannot mint that hop identity;
+4. forwards only to the configured Function origin.
+
+The Function's Cloud Run invoker check is enabled. `allUsers` has no invoker
+binding; only the exact `apigateway-sa` service account may invoke it. This is
+required because otherwise a caller could bypass Cloud Armor and spoof an
+internal relay header.
+
+The API publishes RFC 9728 protected-resource metadata naming the authorization
+server and `spaces:read` scope. Discovery describes capability; it does not
+grant it.
+
+### 3. Tenant isolation is part of authentication
+
+Legacy API-key documents are queried by their existing owner-bound `tenantId`.
+OAuth requests are conjunctively queried by both signed `org_id` and
+`workspace_id` using stored `tenantId` and `workspaceId` fields. The public
+tenant identifier is projected from signed `org_id`. A request cannot supply
+either selector in a query string.
+
+No cross-tenant aggregation exists on this path. Pagination, search, memory,
+and event endpoints added later must carry the same authoritative principal;
+client-provided tenant filters may only narrow within it, never replace it.
+
+### 4. Spatial model and ownership
+
+The canonical RuView vocabulary remains ADR-306:
+
+```text
+Site -> Building -> Floor -> Space -> Zone
+                                  -> Sensor / Person / Object / Track
+                                  -> Observation -> Event -> Alert
+```
+
+Cognitum may call a bounded room a “space”; RuView does not create a second
+room type. Stable external IDs are namespaced and validated before entering the
+ontology. HomeCore remains authoritative for local registry state and local
+automation. Cognitum owns tenant/workspace projection and activation. RuVector
+owns indexed spatial history, not tenancy or authorization.
+
+The current live endpoint exposes the first `Space` slice only. Sites, floors,
+zones, entities, events, and alerts are contract milestones, not inferred from
+missing fields. A client must represent absence as unknown/unavailable and must
+not fabricate parents, coordinates, people, alerts, or provenance.
+
+### 5. Privacy boundary and synchronization eligibility
+
+Only allow-listed P2/P3 semantic projections may cross the cloud boundary.
+
+| Class | Examples | Cloud default |
+|---|---|---|
+| P0 | raw CSI, CIR, RF tensors, packet captures | prohibited |
+| P1 | pose frames, vital waveforms, identity observations, recordings | prohibited |
+| P2 | occupancy count, bounded activity/fall possibility, anomaly score | permitted when policy allows |
+| P3 | versions, connection health, signed capability metadata | permitted |
+
+The client independently rejects forbidden raw-field names anywhere in the
+response. This is defense in depth, not a substitute for server-side
+projection. It also enforces HTTPS except for loopback tests, refuses redirects,
+uses bounded connect/total timeouts, caps responses at 1 MiB, caps the list at
+100 spaces, bounds nesting/arrays/strings, validates confidence, and rejects
+non-P2/P3 space records.
+
+Cloud-bound envelopes must preserve, when available:
+
+- tenant/workspace/site/space/device identity;
+- `messageId` and monotonic `eventSequence`;
+- `observedAt`, `expiresAt`, freshness, and connection state;
+- privacy class and semantic schema version;
+- calibrated confidence and explicit uncertainty/abstention;
+- model, HomeCore, hardware-manifest, calibration, evidence, and witness
+  provenance.
+
+Provenance is never used as a calibration identifier. Missing confidence,
+calibration, timestamp, or tenant identity stays missing and cannot satisfy an
+admission rule.
+
+### 6. No feedback laundering or false corroboration
+
+A Spaces record derived from RuView evidence carries derivation lineage. If it
+returns to RuView or Autogenous, it is a **projection/recollection** of that
+lineage, not a new observation. It cannot:
+
+- increment corroborating-sensor count;
+- raise evidence level;
+- be fused as an independent modality;
+- reset freshness to retrieval time;
+- erase abstention, contradiction, or uncertainty;
+- generate a second belief that cites the first as support.
+
+Deduplication keys include tenant, source/witness identity, message ID, and
+sequence. Cycles are detected and rejected. Independent corroboration requires
+a distinct authenticated source and evidence chain.
+
+### 7. Persistent memory is tenant-scoped and explanation-oriented
+
+RuVector indexes accepted semantic state under at least:
+
+```text
+(tenant_id, workspace_id, site_id, space_id, schema_version, time_bucket)
+```
+
+It stores bounded semantic features, uncertainty, evidence references, and
+witness digests. It does not store OAuth/API credentials or prohibited raw
+payloads. Retrieval always applies the authenticated tenant/workspace filter
+before similarity ranking.
+
+An anomaly explanation names:
+
+- the current semantic state and its uncertainty;
+- the relevant learned baseline/window from ADR-312;
+- comparable tenant-local history;
+- the measured deviation and contradictory evidence;
+- the provenance/witness chain;
+- the evidence label (`MEASURED`, `SYNTHETIC`, or `CLAIMED`).
+
+Memory supplies context, not permission. A historically common action is not
+automatically authorized.
+
+### 8. Agents observe and recommend; policy authorizes action
+
+Autogenous and other agents receive read-only spatial context by default. Their
+normal outputs are observations, explanations, proposals, and recommendations.
+
+Any consequential action must cross the ADR-321 `ruview-policy` gate with:
+
+- an exact action class and target;
+- a fresh capability certificate;
+- KNOWN/DEGRADED/UNKNOWN domain state;
+- bounded uncertainty and sufficient evidence;
+- tenant/workspace authorization;
+- expiry, nonce, idempotency key, and replay protection;
+- required human/policy approval;
+- a terminal witness receipt for allow or deny.
+
+Missing policy, unknown action class, stale state, incomplete provenance, or an
+unavailable approval service denies. OAuth `spaces:read` can never authorize an
+action. This ADR adds no actuator method to the Spaces client.
+
+## Implementation
+
+### RuView
+
+- `ruview-cognitum-spaces` is a reusable, read-only client with typed/redacted
+  credentials and a bounded response decoder.
+- `wifi-densepose login --spaces` explicitly requests `spaces:read` through the
+  existing PKCE flow and credential store.
+- `wifi-densepose spaces` refreshes OAuth through the existing single-flight,
+  persist-before-return mechanism, verifies that the stored grant contains
+  `spaces:read`, and lists validated state. `COGNITUM_SPACES_API` remains an
+  explicit compatibility path.
+- the dependency-free contributor metaharness adds `spaces` /
+  `ruview_spaces_list`, invokes only the OAuth branch, bounds and revalidates
+  child output, fixes the production API origin, strips the API-key compatibility
+  environment, requires an installed binary, and default-denies MCP access
+  without `credential-use`.
+
+### Cognitum Identity
+
+- the `ruview` public client allow-list includes `spaces:read`;
+- RFC 8414 metadata advertises it;
+- refresh preserves the originally granted scope;
+- no new client secret or password grant is introduced.
+
+### Cognitum API
+
+- the gateway preserves caller OAuth through an internal, spoof-resistant
+  relay while authenticating the private Function hop;
+- Spaces verifies the signed OAuth principal and queries by tenant + workspace;
+- legacy API-key behavior remains available;
+- bounded semantic-state `PUT` is available only to an explicitly scoped API-key
+  publisher and is not exposed by the RuView OAuth client;
+- OpenAPI documents both alternatives and RFC 9728 metadata supports discovery;
+- the Function remains gateway-only at Cloud Run IAM.
+
+### Autogenous
+
+Autogenous must consume an explicitly typed credential. It must not imply that
+`/v1/cli/session/exchange` produces a RuView-audience token: that exchange
+currently produces `client_id=cognitum-cli` and cannot pass the Spaces policy.
+An external RuView PKCE token may be supplied after activation, or a scoped API
+key may be used as the compatibility path. Response validation and lineage
+rules in this ADR apply before agent belief formation.
+
+## Threat model
+
+| Threat | Required control |
+|---|---|
+| Direct Function bypass | invoker IAM check; gateway SA only; no `allUsers` |
+| Forged internal OAuth header | strip inbound relay headers; gateway writes after route classification |
+| Token substitution | ES256/JWKS plus exact issuer, audience, client, type, scope, and tenant claims |
+| Cross-tenant enumeration | principal-derived Firestore selector; bounded non-enumerating errors |
+| Redirect/token exfiltration | redirects disabled; HTTPS required; fixed path |
+| Oversized/malformed response | byte/depth/count/string bounds before use |
+| Raw-data regression | server allow-list plus client forbidden-field rejection |
+| Secret disclosure | redacting types; no token logs/URLs; `.env` untracked |
+| Feedback amplification | lineage preservation, dedupe, cycle rejection, no independent corroboration |
+| Memory leakage | tenant filter before vector search; no global nearest-neighbor pass |
+| Agent overreach | observe/recommend default; ADR-321 fail-closed action gate |
+| Stale/replayed state | expiry, sequence, message ID, freshness, witness receipt |
+| JWKS outage/rotation | bounded cache; fail closed; refresh after unknown `kid`; no algorithm fallback |
+
+## Deployment and rollback
+
+Rollout order is dependency-safe:
+
+1. merge and deploy Identity scope/metadata;
+2. deploy the Spaces Function with OAuth verification while API-key behavior
+   remains unchanged;
+3. deploy the gateway relay and protected-resource metadata;
+4. verify gateway API-key access, OAuth denial matrices, direct-origin platform
+   denial (`401` or `403` before application code), and tenant isolation;
+5. merge/release the RuView client and CLI activation;
+6. enable Autogenous consumption only after its strict validation/lineage gates
+   pass.
+
+Rollback disables OAuth advertisement/relay and returns clients to scoped API
+keys. It must not restore public Function invocation. Revoking an OAuth session
+or API key must not alter paired-site state.
+
+## Validation and acceptance
+
+Required automated gates:
+
+- Identity: metadata test, migration application, PKCE authorize/token/refresh
+  scope preservation, cross-client scope denial;
+- API Function: valid claim matrix and rejection for wrong issuer/audience/
+  client/type/scope/tenant, API-key regression, tenant query assertion, bounded
+  projection tests, build and dependency audit;
+- gateway: spoofed relay stripped, caller OAuth preserved, Google hop identity
+  substituted, OpenAPI security alternatives, RFC 9728 metadata, build and
+  dependency audit;
+- RuView: semantic decoder bounds/privacy tests, redaction tests, login scope
+  tests, CLI compile, and live empty/non-empty response tests without fixtures
+  masquerading as production;
+- policy: no Spaces read can invoke an actuator; denial receipts are witnessed.
+
+Production readback must prove:
+
+- unauthenticated gateway request returns `401`;
+- legacy scoped API key returns the authenticated tenant list;
+- valid RuView OAuth returns only its workspace;
+- wrong client, missing `spaces:read`, setup/workload token, and second-tenant
+  token are denied;
+- the direct Function origin is rejected by the Google platform with `401` or
+  `403` before application code, even with a valid application credential;
+- response remains `no-store` and excludes P0/P1;
+- no secret appears in logs, diffs, artifacts, or issue/PR text.
+
+Performance, detection quality, and action-safety numbers are not claimed by
+this decision. Any such number requires a named reproducer and the repository's
+evidence labels. An empty production tenant is a successful isolation/read-path
+test, not sensing-quality evidence.
+
+## Production evidence (2026-08-18)
+
+The bounded Spaces read slice and RuView activation path are deployed. The exact
+production release chain is:
+
+- Spaces run `32148530629`, revision `spacesapi-00003-xij`, source
+  `fc333e634cd918b9d6fdde4eecbe7beac1043ab8`, Node 22, runtime service account
+  `spacesapi-runtime@cognitum-20260110.iam.gserviceaccount.com`, with
+  `apigateway-sa@cognitum-20260110.iam.gserviceaccount.com` as sole invoker;
+- gateway run `32151485401`, revision `apigateway-00180-peh`, source
+  `c4e99ebb4ce0d4e1407f435f905621476c1f0166`, image digest
+  `sha256:bacb81281a54256ff6fdaac253175e76ce6fc225f399163ca0a807a2839bd6a3`;
+- Identity run `32163542502`, revision `identity-00052-fid`, source
+  `fb6320827b879e481cad6caf184d3cbccd8279c4`, image digest
+  `sha256:0cd5896518bd8ecf042d2f3e9aea58a32e65a68dbddaab1e54f8ae6da2bfab06`,
+  and runtime service account
+  `identity-runtime-prod@cognitum-20260110.iam.gserviceaccount.com`.
+
+The live API-key matrix returned `200` with an empty bounded list,
+`Cache-Control: private, no-store`, and no prohibited P0/P1 projection fields.
+No credential returned `401`. A direct-origin request received a Google
+Frontend Bearer challenge (`401`) before application code.
+
+Two independent RuView Authorization Code + PKCE principals also passed the
+live matrix. Each token used ES256, exact issuer/audience/client checks,
+`sensing:read spaces:read`, signed UUID organization/workspace claims, refresh
+rotation, and revocation. Each gateway read returned `200`, an empty bounded
+list, and `private, no-store`; a corrupted signature returned `401`; and the
+principals had distinct pseudonymous tenant/workspace fingerprints. This proves
+the production empty-tenant behavior and independent claim binding. Non-empty
+cross-tenant isolation remains emulator/staging evidence because production was
+not mutated to manufacture a fixture.
+
+Identity metadata deliberately advertises `spaces:read` for RuView but not
+`spaces:write`. The deployed semantic-state `PUT` remains an API-key-only
+publisher surface. RuView therefore has no OAuth write, command, policy-approval,
+or actuator capability.
+
+That receipt was for the initial flat Space slice. The following production
+expansion supersedes only its hierarchy/event/alert deferral. MQTT, commands,
+actuators, real-hardware accuracy, and the long-duration operational trial
+remain outside the completed claim.
+
+## Completed implementation and production expansion (2026-08-19)
+
+- Cognitum API PRs #211 and #212 shipped the eight `/v1/spatial` collections,
+  transactional hierarchy integrity, stable pagination, event/alert retention,
+  strict P2/P3 admission, API-key-only writes, OAuth/API-key reads, and the
+  additive-only Firestore release authority. Function run `32279092861`
+  promoted active Node 22 revision `spacesapi-00005-kaf`.
+- Edge PRs #214, #215, and #216 preserved canonical UUID routing, kept SQLi
+  denial, and removed secret-valued API-key rate selection. Gateway run
+  `32284410107` promoted the reviewed immutable digest to 100% production
+  traffic. Every versioned collection returned HTTP 200 through the public
+  edge; the hierarchy composite index is `READY` and both retention TTL fields
+  are `ACTIVE`.
+- The dedicated RuView service credential was rotated to exactly
+  `spaces:read` and `spaces:write`; its predecessor returns 401. A non-mutating
+  invalid-body probe reached write validation without persisting customer data.
+  Other potentially affected owner keys and residual log retention remain
+  tracked in Cognitum API #217.
+- A live RuView Authorization Code + S256 PKCE consent requested exactly
+  `sensing:read spaces:read`. Its in-memory token read versioned `sites` with
+  HTTP 200 and schema `1.0`; the verifier then revoked the temporary refresh
+  credential and persisted no token.
+- RuView PR #1650 merged `ruview-cognitum-spaces`,
+  `ruview-spatial-memory`, the ADR-327 policy extension, CLI paging, and the
+  guarded `ruview_spaces_list` metaharness surface. PR #1651 removed stale
+  feature-branch guidance and refreshed the signed package manifest.
+- The contributor metaharness fixes the API origin, accepts bounded resource,
+  limit, and opaque-cursor inputs, strips API-key compatibility authority over
+  MCP, invokes only the hardened OAuth CLI, and rejects raw sensing or malformed
+  hierarchy/event/alert output. Its test, security, reviewed-brain, flywheel,
+  manifest, audit, exact-tarball, and claim-check gates pass.
+- Release run `32286297277` rebuilt and smoke-tested the exact package and
+  provenance-published `@ruvnet/ruview` 0.5.0. The public npm registry resolves
+  0.5.0 as `latest`; no workstation publish was used.
+- `ruview-spatial-memory` keeps one RuVector HNSW index per authenticated
+  tenant/workspace with replay, derivation, retention, cascading-erasure,
+  bounded-explanation, encrypted-snapshot, and reload-verified rotation gates.
+  This is local `SYNTHETIC` evidence, not a production sensing claim.
+- `ruview-policy` keeps observe/recommend/execute intents distinct, requires
+  exact host grants plus signed approval for consequence, rejects nonce replay,
+  and emits signed hash-chained receipts. `spaces:read` is explicitly denied as
+  execution authority.
+- Focused Rust gates and the Linux workspace/CLI/security lanes pass. Earlier
+  Windows whole-workspace attempts ended in host compiler failure or timeout;
+  those attempts are not reclassified as green evidence.
+- No OAuth write/action scope, actuator callback, MQTT deployment claim, sensing
+  accuracy claim, or real-hardware claim is introduced.
+
+## Consequences
+
+### Positive
+
+- One Cognitum identity can explicitly activate RuView's cloud spatial read
+  capability without sharing a long-lived static bearer.
+- Tenant and workspace become cryptographically bound inputs to the data query.
+- RuView and Autogenous gain useful spatial context without importing raw RF or
+  inventing independent evidence.
+- The design keeps a path for RuVector-grounded explanations and separately
+  governed action without treating either as part of the deployed read slice.
+- The direct-origin bypass is closed permanently, independent of OAuth rollout.
+
+### Costs and limitations
+
+- Two credential types coexist during migration and must stay visibly distinct.
+- OAuth depends on Identity JWKS availability and correct key rotation.
+- Production exposes both the legacy Space twins and the versioned hierarchy,
+  anonymous entities, semantic events, and alerts over HTTPS. MQTT remains a
+  design contract without deployment evidence.
+- OAuth workspace IDs will return only documents populated with `workspaceId`;
+  legacy owner-only documents require an explicit migration, never a broad query.
+- The RuView client exposes no write, command, or agent execution surface. The
+  separate API-key semantic-state ingress is neither OAuth activation nor
+  actuator authority.
+
+## Alternatives considered
+
+**Keep API keys only.** Rejected as the target: keys are useful for service
+compatibility but do not provide user activation, consent, short lifetime, or
+refresh/revocation semantics.
+
+**Treat the CLI API-key exchange token as a Spaces OAuth token.** Rejected: it
+is minted for `cognitum-cli`, not `ruview`, and accepting it would remove the
+audience/client boundary.
+
+**Trust the gateway without verifying OAuth in Spaces.** Rejected: hop identity
+and user authorization are distinct, and authorization must remain valid if the
+route topology changes.
+
+**Make Spaces state independent corroboration.** Rejected: it is derived from
+the same RuView/HomeCore lineage and would double-count evidence.
+
+**Allow agents to execute from `spaces:read`.** Rejected: read consent is not
+action authority, and perception confidence alone cannot authorize consequence.
+
+**Synchronize raw RF for better cloud models.** Rejected by default: it violates
+the edge privacy boundary and is unnecessary for the semantic product.
+
+## References
+
+- Autogenous ADR-402, `docs/adr/ADR-402-ruview-cognitum-spaces-spatial-intelligence.md`
+- Cognitum API ADR-094, `docs/adr/ADR-094-cognitum-spaces-homecore-edge-boundary.md`
+- Cognitum API hierarchy/events/alerts follow-up,
+  `https://github.com/cognitum-one/api/issues/206`
+- RuView metaharness OAuth surface,
+  `https://github.com/ruvnet/RuView/issues/1643`
+- RuVector spatial-history follow-up,
+  `https://github.com/ruvnet/RuView/issues/1640`
+- governed-action and witness-receipt follow-up,
+  `https://github.com/ruvnet/RuView/issues/1641`
+- RFC 7636, Proof Key for Code Exchange
+- RFC 8414, OAuth 2.0 Authorization Server Metadata
+- RFC 9700, OAuth 2.0 Security Best Current Practice
+- RFC 9728, OAuth 2.0 Protected Resource Metadata
@@ -0,0 +1,137 @@
+# ADR-326: Tenant-scoped RuVector spatial memory and anomaly explanations
+
+- **Status**: Accepted — implementation complete; repository-wide and deployment gates pending
+- **Date**: 2026-08-19
+- **Decision owners**: RuView maintainers
+- **Extends**: ADR-312, ADR-319, ADR-325
+- **Implements**: ruvnet/RuView#1640
+- **Tags**: cognitum-spaces, ruvector, memory, tenant-isolation, explanation, privacy
+
+## Context
+
+ADR-325 requires anomaly explanations grounded in tenant-local spatial history,
+but the deployed client only returns a current list. A global vector index would
+be unsafe: filtering nearest-neighbor results after the search can reveal that a
+different tenant has a close match, even when identifiers are removed. A memory
+record can also launder returned RuView-derived state into a second independent
+observation, reset freshness, or form circular evidence.
+
+Spatial memory must be useful without storing OAuth/API credentials, raw CSI/CIR,
+RF tensors, pose frames, vital waveforms, recordings, identity observations, or
+unbounded agent transcripts. Persistence also needs explicit retention,
+deletion, provenance, and key-rotation behavior.
+
+## Decision
+
+### 1. Partition before similarity
+
+`ruview-spatial-memory` owns a `SpatialMemory` map keyed by the exact authenticated
+`(tenant_id, workspace_id)` pair. Each partition owns its own RuVector HNSW index.
+Ingest and search resolve the partition first; no global ANN query exists. Site,
+space, schema version, and time-window constraints narrow within the selected
+partition before results are returned.
+
+### 2. Bounded semantic records
+
+An accepted record contains:
+
+- tenant/workspace/site/space and stable record identity;
+- source ID, message ID, record ID, monotonic event sequence, schema version;
+- original `observed_at`/`expires_at` and a retention deadline;
+- a bounded finite semantic feature vector, uncertainty, and evidence label;
+- provenance and witness digests, plus bounded derivation references;
+- explicit observation/inference classification.
+
+Credentials and P0/P1 fields have no representation in the type. Strings,
+features, references, record counts, and query `k` are bounded. Non-finite
+features and uncertainty fail closed.
+
+### 3. Lineage and replay
+
+The partition rejects:
+
+- changed reuse of `(source_id, message_id)`;
+- a non-increasing sequence for the same source;
+- duplicate derivation references;
+- self-reference, missing/forward parents, and therefore every cycle;
+- expired input or a provenance/witness substitution.
+
+A recollection keeps its original lineage, timestamp, uncertainty, and evidence
+label. It cannot increment corroborating-source count or become independent
+support for its own ancestor.
+
+### 4. Persistent encrypted storage
+
+Snapshots are encrypted with XChaCha20-Poly1305 under a caller-supplied 256-bit
+key and a non-secret key ID. The authenticated associated data binds the storage
+format and key ID. The envelope is bounded and versioned; plaintext spatial
+records are never written to disk. Loading requires a keyring containing the
+named key. Rotation decrypts with the old key, atomically creates a new
+generation under the new key ID, reload-verifies that generation, and leaves
+the source intact. Snapshots never overwrite an existing path implicitly.
+
+Deletion supports a tenant/workspace partition, a record, and retention cutoff.
+Every deletion rebuilds that partition's HNSW index so removed records cannot be
+returned from stale graph nodes.
+
+### 5. Explanations
+
+`explain` compares a bounded query vector with nearest tenant-local history and
+returns the exact authenticated partition, generation time, ordered record IDs,
+RuVector distances, original uncertainty/evidence labels, and provenance/witness
+digests. Its basis explicitly says that similarity is not causation. The API
+does not expose the vectors or invent a causal explanation.
+
+History provides context, not authority. An explanation cannot authorize an
+action, increase certificate class, or replace a policy decision.
+
+## Consequences
+
+### Positive
+
+- Cross-tenant ANN leakage is structurally unavailable.
+- Explanations cite the exact tenant-local records used.
+- Replay/cycle/provenance substitution are rejected before indexing.
+- Encrypted persistence has explicit key IDs and rotation behavior.
+
+### Costs and limitations
+
+- Partition-local HNSW uses more indexes than a global graph.
+- Deletes and key rotation rebuild indexes.
+- No detection-quality or latency claim is made; tests are `SYNTHETIC` unless a
+  reproducer explicitly marks a measurement.
+- Cloud Cognitum does not receive the local encrypted memory file.
+
+## Validation
+
+- cross-tenant and cross-workspace nearest-neighbor denial;
+- duplicate record/message, stale-sequence, self/duplicate/missing-parent, and
+  provenance-substitution tests;
+- expiry, retention deletion, whole-partition deletion, sealed round-trip,
+  tamper rejection, wrong-key rejection, and key-rotation tests;
+- explanation citations and retained evidence/provenance labels;
+- no forbidden raw-field or credential representation;
+- the focused `ruview-spatial-memory` crate suite passes with `SYNTHETIC`
+  evidence on 2026-08-19;
+- the whole-workspace Windows gate was non-terminal (compiler crash in parallel,
+  timeout when serialized), so Linux CI, a RustSec advisory scan, and package
+  review remain release gates.
+
+## Alternatives considered
+
+**One global HNSW followed by filtering.** Rejected: ranking itself crosses the
+tenant boundary.
+
+**Cloud vector memory.** Rejected as the default: it expands the privacy and
+credential boundary without being needed for local explanations.
+
+**Plain JSONL persistence.** Rejected because tenant spatial history is sensitive
+even when raw sensing is excluded.
+
+## References
+
+- ADR-312: Long-term spatial memory
+- ADR-319: Witness chain
+- ADR-325: Cognitum Spaces activation and governed exchange
+- Cognitum API ADR-101
+- ruvnet/RuView#1640
@@ -0,0 +1,133 @@
+# ADR-327: Governed action intents, approvals, replay protection, and witness receipts
+
+- **Status**: Accepted — implementation complete; repository-wide and deployment gates pending
+- **Date**: 2026-08-19
+- **Decision owners**: RuView maintainers
+- **Extends**: ADR-318, ADR-319, ADR-321, ADR-325
+- **Implements**: ruvnet/RuView#1641
+- **Tags**: policy, governed-action, approval, idempotency, witness, cognitum-spaces
+
+## Context
+
+The current `ruview-policy` crate evaluates assurance for an action class, but it
+does not define a complete action intent, tenant/workspace binding, policy
+version, approval, nonce/idempotency replay behavior, or signed terminal receipt.
+An agent recommendation can therefore be mistaken for execution authority, and
+`spaces:read` could be accidentally treated as a general capability.
+
+The system needs a framework that can prove why an action was allowed or denied
+without adding any actuator. Real actuation remains a separate integration and
+requires its own threat model and device evidence.
+
+## Decision
+
+### 1. Typed intent and registered policy
+
+A governed `ActionIntent` binds:
+
+- intent ID, tenant, workspace, action name/class, and exact target;
+- requested policy version and parameter/evidence digests;
+- creation/expiry, replay nonce, and requesting principal;
+- the recommendation/explanation that motivated review, never a hidden command.
+
+The gate accepts only a registered action policy. Unknown action, action-class
+mismatch, policy-version mismatch, target mismatch, invalid timestamps, and
+missing exact host authority deny before assurance is evaluated. Tenant and
+workspace are part of the signed intent/receipt and nonce key. `spaces:read` is
+explicitly tested as insufficient for an `alerts:execute` rule.
+
+### 2. Assurance and approval
+
+The existing ADR-321 certificate/domain/uncertainty/evidence gate remains the
+assurance authority. The registered policy declares a bounded minimum of
+distinct enrolled approvers. An absent, rejected, duplicated, expired,
+wrong-intent, wrong-policy-version, or unverifiable approval denies. Approval
+resolution fails closed.
+
+Agents observe, explain, or recommend by default. `evaluate` returns a decision
+receipt; it does not call an actuator. An executor may consume an `allow` receipt
+only if a separate adapter verifies the receipt, target, expiry, and its own
+device-specific authority.
+
+### 3. Replay and idempotency
+
+The bounded in-memory gate stores terminal receipts by intent ID and tracks
+nonces by `(tenant, workspace, nonce)`.
+
+- exact intent replay returns the original terminal receipt;
+- changed reuse of an intent ID returns a fail-closed idempotency error;
+- reuse of a nonce by another intent returns a fail-closed replay error;
+- expired intents and approvals deny;
+- failed or denied attempts are terminal and auditable.
+
+The current state store is bounded and in-memory, intended for local/runtime use
+rather than cross-process replay protection. A production executor must place
+the same intent/nonce/receipt invariants behind a transactional durable store;
+this ADR does not claim that adapter exists.
+
+### 4. Witnessed terminal receipt
+
+Every evaluated observe/recommend/execute request produces a canonical receipt
+containing the intent digest, decision/reason, policy version, tenant/workspace,
+decision/expiry time, intent ID and nonce, approval count, and previous receipt
+digest. The receipt is signed through the `ruview-attest` signer interface and
+can be independently verified. Hash chaining makes removal/reordering visible.
+Malformed input, ID conflict, nonce replay, capacity exhaustion, and sequence
+exhaustion are errors before receipt creation and must be audited by the host.
+
+The reference keyed-BLAKE3 signer remains `SYNTHETIC` evidence only, as documented
+by ADR-319. Production asymmetric signing and key custody must be supplied by the
+deployment adapter; no symmetric test MAC is represented as hardware identity.
+
+## Consequences
+
+### Positive
+
+- Recommendation, authorization, and execution are distinct typed stages.
+- Default-deny covers missing policy, stale evidence, unavailable approval, and replay.
+- Every decision has a terminal, verifiable explanation.
+- `spaces:read` cannot silently expand into consequence.
+
+### Costs and limitations
+
+- Executors must implement a separate receipt-verifying adapter.
+- Distributed replay protection needs a transactional durable store.
+- This ADR implements no actuator, command transport, pairing mutation, or device control.
+- Simulator tests are not hardware validation.
+
+## Validation
+
+- unknown/missing policy, stale intent, policy-version/target mismatch,
+  insufficient authority, and `spaces:read`-only denial;
+- certificate/domain/uncertainty/evidence denial matrix from ADR-321;
+- missing/rejected/expired/duplicate/wrong-intent approval tests;
+- exact idempotent replay, changed reuse, nonce replay, and bounded-store tests;
+- receipt signature, canonical digest, chain linkage, and tamper rejection;
+- tests proving evaluation exposes no actuator callback or network/file side effect.
+
+The focused `ruview-policy` suite passes on 2026-08-19. The reference signer
+tests are `SYNTHETIC`; they are not hardware-identity evidence. The non-terminal
+whole-workspace Windows gate still requires authoritative Linux CI evidence.
+
+Any future actuator adds a separate ADR, credential boundary, failure/rollback
+plan, allow/deny integration tests, and captured target-device evidence.
+
+## Alternatives considered
+
+**Let agents call actuators after a recommendation.** Rejected: recommendation
+quality is not authorization.
+
+**Treat OAuth scopes as action policy.** Rejected: `spaces:read` expresses read
+consent only and carries no target-specific assurance or approval.
+
+**Emit receipts only for successful actions.** Rejected: denial and unavailable
+approval are security-relevant terminal facts.
+
+## References
+
+- ADR-318: Capability certificates
+- ADR-319: Witness chain
+- ADR-321: Decision policy action authorization
+- ADR-325: Cognitum Spaces activation and governed exchange
+- ADR-326: Tenant-scoped RuVector spatial memory
+- ruvnet/RuView#1641
@@ -0,0 +1,59 @@
+# ADR 340: iPhone LiDAR Sensor Bridge
+
+Status: Proposed
+
+## Context
+
+RuView needs a low cost mobile geometry sensor that can contribute calibrated spatial observations without coupling the perception substrate to Apple frameworks.
+
+ARKit exposes rear LiDAR scene depth through `ARFrame.sceneDepth` and `smoothedSceneDepth` on supported devices. Ordinary mobile web pages do not receive this ARKit depth surface directly, so native capture and web visualization must be separated.
+
+## Decision
+
+Use a two layer architecture.
+
+1. Native Swift and ARKit perform acquisition.
+2. A modality neutral wire frame transports geometry into browser tools and, next, the RuView HAL.
+
+The native client will capture depth, confidence, camera intrinsics, and world tracking pose. RGB imagery is excluded from the default transport.
+
+The protocol identifier is `ruview.lidar.depth.v1`.
+
+Depth samples are quantized to UInt16 millimeters for transport. Confidence remains UInt8. The default sender downsamples by two spatially and caps transmission at 15 FPS. Full fidelity depth remains available locally for future on device inference.
+
+## RuView integration boundary
+
+The transport must not become a second world model. The production receiver converts each packet into the canonical `ruview-hal::Observation`, then passes it through authenticated sensor identity, provenance, OOD gating, uncertainty aware fusion, spatial memory, and WorldGraph adapters.
+
+Rules:
+
+1. `source=live` is valid only for frames produced by an active ARKit session.
+2. Sequence numbers are monotonic per sensor session.
+3. Wall clock timestamp is separate from ARKit monotonic frame timing.
+4. RGB is off by default and requires an explicit higher privacy capability.
+5. Browser clients consume geometry but are not treated as authoritative sensors.
+6. Unsupported devices fail closed rather than substituting simulated depth.
+
+## Performance target
+
+`[SYNTHETIC]` A 256 x 192 Float32 depth map is about 196 KB before confidence and metadata. Downsampling to 128 x 96 and encoding each sample as two byte depth plus one byte confidence yields about 36.9 KB raw. At 15 FPS the raw sensor payload is about 553 KB/s. Base64 raises this to roughly 737 KB/s before JSON metadata. These values are arithmetic sizing estimates, not device measurements.
+
+The `[CLAIMED target]` for local network latency is below 150 ms p95. A later binary WebSocket or QUIC transport can remove base64 overhead; the exact end-to-end reduction must be measured before it is claimed.
+
+## Security
+
+The development relay is LAN-facing, requires a random per-run bearer token, bounds message size, and restricts the files it serves. Its default `ws://` transport is not encrypted, so it is not a production trust boundary.
+
+Production requires WSS, authenticated sensor identity, replay protection, message size limits, per tenant authorization, provenance receipts, and explicit retention policy before persistence.
+
+## Consequences
+
+Benefits include commodity hardware, metric depth, tracked camera pose, rapid room scanning, calibration support for RF sensing, and a practical ground truth source for RuView experiments.
+
+The main limitation is that Apple provides processed scene depth rather than the underlying raw transient LiDAR waveform. Therefore this implementation supports direct geometry and sensor fusion now, but does not reproduce research systems that require raw multipath time of flight transients for non line of sight reconstruction.
+
+## Acceptance criteria
+
+A physical LiDAR capable iPhone must stream live geometry to the browser viewer with monotonically increasing sequence numbers, no RGB payload, valid confidence maps, and below 150 ms p95 local network latency over a 60 second run.
+
+CI type-checking and simulator runs do not satisfy this criterion. Until a captured physical-device run records the environment and results, the hardware behavior and latency remain unverified.
@@ -0,0 +1,93 @@
+# ADR-344: Adaptive local installation discovery
+
+## Status
+
+Accepted — local advertisement and mobile discovery implemented; physical
+peer-link and hosted-relay qualification pending.
+
+## Context
+
+RuView installations previously depended on a manually stored IP address.
+DHCP changes, access-point changes, and client isolation could therefore leave
+a healthy sensing installation unreachable from the mobile app. Repeated
+authentication-policy log entries did not prove that the selected endpoint was
+reachable.
+
+Discovery must make commissioning recoverable without turning a service name
+into authentication, leaking sensor data, scanning arbitrary subnets, or
+silently moving private spatial data to a hosted service.
+
+## Decision
+
+The sensing server advertises one bounded `_ruview._tcp.local.` service when it
+is bound to a routable interface. Loopback-only instances do not advertise,
+and operators can disable advertisement with `--no-mdns`.
+
+The TXT contract is deliberately small:
+
+| Key | Required | Meaning |
+|---|---:|---|
+| `schema=ruview.installation.v1` | yes | Fail-closed protocol discriminator |
+| `tls=0|1` | yes | HTTP or HTTPS origin construction |
+| `installation=<opaque id>` | no | Bounded routing hint, never authentication |
+
+The advertisement contains no node inventory, room identifier, SSID,
+credentials, CSI, vital estimates, pose, identity, or learning data. The
+hostname is bounded and sanitized before registration. Advertisement failure
+is recoverable and does not stop sensing.
+
+RuView Mobile resolves only the matching service and schema, validates the
+resulting origin under its private-LAN/HTTPS policy, and requires an application
+health probe before selection. Its adaptive broker retains the configured
+origin preference and requires two failed configured probes plus two healthy
+fallback probes before switching. Credentials remain scoped to their saved
+origin.
+
+The recovery ladder is:
+
+1. configured private-LAN or HTTPS origin;
+2. verified Bonjour local origin;
+3. physically qualified Apple peer-to-peer local path;
+4. explicit, authenticated HTTPS relay for bounded derived frames only;
+5. optional administrator-managed WireGuard/Tailscale access.
+
+Only levels 1 and 2 are implemented and software-validated by this decision.
+Peer-to-peer browsing is enabled on Apple platforms, but it is not a qualified
+peer-link data plane. This repository does not provide a hosted relay and must
+fail closed when no local endpoint is healthy.
+
+## Security and privacy consequences
+
+- Service discovery is routing evidence, not installation authentication.
+- Public HTTP origins, credentials in URLs, malformed records, and records with
+  the wrong schema are rejected before use.
+- Raw CSI, RSSI streams, camera/LiDAR frames, room geometry, pose labels,
+  identity data, and training examples remain local.
+- Future relay work requires a separate consent, authentication, revocation,
+  minimization, and physical evidence review.
+- ESP32-S3/C6 nodes remain provisioned to the sensing installation. This ADR
+  does not claim direct phone-to-node discovery or invent a firmware protocol.
+
+## Validation
+
+Software acceptance requires:
+
+- unit tests for bounded advertisement construction and hostname sanitation;
+- mobile parser rejection, route scoring, anti-flapping, and Settings UI tests;
+- Rust, TypeScript, lint, security, metaharness, Expo, and native compile gates;
+- a real Bonjour resolve of the TXT contract followed by a successful
+  `/api/v1/status` probe.
+
+Physical qualification additionally requires installation discovery on an
+iPhone, live frame and node-inventory receipt, DHCP-change recovery without
+flapping, and a five-to-ten-minute zero-fusion-error burn-in. Simulator and
+host-only results remain `MEASURED_SOFTWARE`; peer-link, relay, and physical
+reconnection claims remain `NOT_MEASURED` until those captures exist.
+
+## Implementation references
+
+- `v2/crates/wifi-densepose-sensing-server/src/discovery.rs`
+- `v2/crates/wifi-densepose-sensing-server/src/main.rs`
+- Mobile companion decision: `cognitum-one/ruview-mobile`,
+  `docs/adr/ADR-026-adaptive-local-installation-discovery-and-transport-recovery.md`
+- Related decisions: ADR-034, ADR-054, ADR-296
@@ -0,0 +1,193 @@
+# ADR-345: Per-link CSI attribution and node-to-node ranging
+
+- **Status**: Proposed — measurement layer implemented and validated on hardware; localization not built
+- **Date**: 2026-08-28
+- **Deciders**: Joe
+- **Tags**: csi, wire-format, esp32-c6, localization, adr-018, adr-060, adr-110
+
+## Context
+
+Every attempt at device-free position estimation in this repository has failed
+against the same wall, and the wall has now been measured twice from different
+directions.
+
+**Phase is unusable.** The bistatic tier needed a signed per-link radial
+velocity, which requires the common-mode component of CSI phase. Measured
+2026-08-28 across all three ESP32-C6 nodes over ~40,000 frames, the
+frame-to-frame change in common-mode phase is statistically indistinguishable
+from uniform random — resultant length `R` = 0.011–0.032 against a 0.000
+reference, standard deviation 1.78–1.81 against `pi/sqrt(3)` = 1.814, and no
+lag-1 autocorrelation. A second, unwrap-free estimator agreed. The mechanism is
+packet-detection timing quantization: common-mode phase is `-2*pi*f_c*tau`, and
+one ADC sample of jitter at 20 MHz is `2*pi * 2.412e9 * 50e-9` ~= 758 rad, about
+120 full wraps, re-randomized every packet. Not calibratable. The bistatic tier
+is default-off as a result (`bistatic_tier_enabled`).
+
+**Amplitude works but had no parallax.** The three AP -> node links leave a
+single distant transmitter within a 36.5 degree fan and converge on the node
+cluster. Bearings computed from `room_config.json`: 198.5, 221.2, 235.0 degrees.
+Scalar per-node energy weighting was closed with a clean negative result on
+2026-08-27 — magnitude responds to proximity, direction does not.
+
+**The receivers were hearing far more than we recorded.** A node in promiscuous
+MGMT+DATA mode with no `filter_mac` produces CSI for every transmitter on the
+channel. Measured on node 2: the AP accounted for only **34%** of frames; the
+two peer nodes supplied 39% and 27%. Those peer frames are valid measurements
+of *node-to-node* channels — but ADR-018's wire format carries no transmitter
+address, so the sink could not attribute them. They interleaved into one
+`frame_history` with mixed geometry, and the only available remedy
+(`filter_mac`, ADR-060) fixes the mixing by discarding ~75% of the data.
+
+The node-to-node links between the same three boards cross the room from three
+sides at **108.7 degrees** of angular spread (bearings 0.0, 73.2, 108.7) versus
+36.5 for the AP links — roughly 3x the parallax, with both endpoints known,
+fixed, and under our control rather than wherever the router happens to live.
+Link count also grows as `N*(N-1)/2`: 3 nodes give 3 links, 6 give 15, 13 give
+78.
+
+## Decision
+
+Carry the transmitter MAC on the CSI wire and model CSI per **link**
+(receiver, transmitter) rather than per **node**, as a layer alongside the
+existing per-node model.
+
+### 1. Wire format v2
+
+`CSI_MAGIC_V2 = 0xC5110008`, header 26 bytes: the v1 header unchanged through
+byte 19, then the transmitter address (`info->mac`, 802.11 addr2) at bytes
+20..25, with I/Q from byte 26.
+
+`0xC5110002`..`0xC5110007` were already claimed by the vitals, feature and other
+edge packets, so v2 takes the next free value rather than an adjacent one — see
+`issue_928_magic_collision_tests` for why that matters. The parser accepts both
+magics, so a mixed fleet keeps working and v1 nodes simply report no
+transmitter.
+
+### 2. Per-link state (`links.rs`)
+
+`LinkTable` keyed by `LinkId { rx_node, tx_mac }`, each link holding its own
+amplitude history, RSSI EMA, learned resting baseline and motion metric.
+
+The metric is the mean over subcarriers of the temporal standard deviation of
+**AGC-normalized** amplitude. Removing each frame's own mean across subcarriers
+is essential rather than cosmetic: the ESP32 applies automatic gain control per
+packet, so absolute amplitude jumps between packets for reasons unrelated to the
+channel, and any statistic built on the raw level measures the radio's gain
+control instead of the room.
+
+Amplitude only, deliberately — nothing here can depend on phase coherence.
+
+### 3. Beacon rate
+
+`BEACON_PERIOD_MS` 100 -> 20. At 10 Hz a peer samples a node-to-node link with a
+5 Hz Nyquist while motion Doppler lives at 1–20 Hz; it aliases before it starts.
+20 ms matches both the receiver's own `CSI_MIN_PROCESS_INTERVAL_US` ceiling and
+the gateway self-ping already used for the AP link.
+
+### 4. `GET /api/v1/links` and a live UI panel
+
+The link table was initially reachable only through a 30-second log line, which
+is the wrong medium for a quantity whose value is watching it respond while you
+walk across the room. `GET /api/v1/links` returns one row per link — `motion`,
+`raw_motion`, `rssi_dbm`, `frames`, `kind` — and `LinkMeshPanel` renders them in
+the Sensing tab at 1 Hz. `raw_motion` is shown beside `motion` deliberately: a
+link whose baseline has not settled reports a healthy raw value and a near-zero
+motion, and with only the one number that is indistinguishable from a dead link.
+
+Node identity is **inferred, not measured**. Nothing in the system records a
+node's own MAC — a node reports the addresses it hears, never its own. But a
+radio does not receive its own transmissions, so given the set of receivers
+currently reporting, a transmitter heard by all of them except exactly one is
+that one receiver's own board; a transmitter heard by every receiver is external
+infrastructure. `links::infer_transmitting_node` declines (returns `None`) with
+fewer than three receivers, where "heard by all but one" and "heard by exactly
+one" are the same observation, and whenever more than one receiver is missing,
+which a peer out of range produces indistinguishably. The field is named
+`tx_node_inferred` and the UI draws the peer id with a trailing `?`.
+
+Checked against the known MAC map on 2026-08-28 the inference labelled all four
+transmitters correctly — nodes 0, 1 and 2 by address, and the AP as external —
+with no access to that map. A wrong answer here mislabels a display row; it
+never reaches a metric.
+
+## Consequences
+
+### Validated on hardware, 2026-08-28
+
+All three nodes on wire v2 at 20 ms produced the full mesh: **9 links** (3 AP +
+6 directional node-to-node).
+
+Reciprocity — each physical channel measured independently from both ends:
+
+| channel | direction A | direction B | ratio |
+|---|---|---|---|
+| 0 <-> 1 | 2.229 | 1.930 | 1.15 |
+| 0 <-> 2 | 1.353 | 1.000 | 1.35 |
+| 1 <-> 2 | 1.398 | 1.486 | 1.06 |
+
+Nothing in the implementation enforces this. Three independent radio pairs
+agreeing within 6–35% is the strongest available evidence that the per-link
+separation is real rather than an artifact of frame bucketing.
+
+Link quality is also far more uniform than the AP links: node-to-node raw motion
+spans 1.0–2.2 across all six, versus 3.8–17.8 for the three AP links (which
+track RSSI: -67, -72, -80). Uniform link quality is desirable for tomographic
+localization — no single link dominates the solution.
+
+### Known limitations
+
+- **Peer links are ~10x weaker.** A 16-byte ESP-NOW beacon offers far less
+  energy to estimate a channel response from than a full data frame. Whether
+  1.0–2.2 perturbation is sufficient to localize with is **unknown and untested**.
+- **Three links is below threshold.** Tomographic localization needs many
+  crossing links; 3 will not localize regardless of quality. This ADR delivers
+  the measurement layer, not localization.
+- **Localization is not implemented.** No position tier consumes `LinkTable`.
+  The live position estimate remains `doppler_centroid`.
+- **Per-node path regression.** Removing `filter_mac` to admit peer frames
+  returned the *per-node* `frame_history` to a mixed-transmitter stream, since
+  it still consumes every frame regardless of source. Node 2's classification
+  signal is noisier as a result. The fix is to select a link to feed the
+  per-node path — software filtering that keeps the other links — and it is not
+  yet done.
+
+### Scaling limits to settle before more nodes
+
+- **Airtime.** Every node broadcasts, so N nodes put N/period frames per second
+  on the channel being sensed. 3 nodes at 20 ms is 150 pps; 13 would be 650 pps.
+  `BEACON_PERIOD_MS` should become an NVS setting scaled to fleet size.
+- **`MAX_LINKS` is 64.** 13 nodes give 78 receiver-transmitter pairs plus the AP
+  plus neighbours, which overflows. Raise deliberately, with the memory implied.
+- **Placement.** Links must *cross* the target area. Nodes spread through a
+  house give roughly one link per room, each attenuated by walls and perturbed
+  by anyone anywhere along it — whole-house coarse presence, not position.
+  Perimeter placement around a single room is the geometry that works.
+
+## Related bugs found and fixed while implementing
+
+- **ADR-060 MAC filtering cost ~75% of capture rate.** The 50 Hz rate gate ran
+  *before* the MAC filter and stamped `s_last_process_us` before the check, so a
+  frame from any other transmitter consumed the slot and was then discarded.
+  Enabling `filter_mac` dropped yield from ~42 pps to 6–13. Filtering first
+  restores it (measured 31–37 pps). A 6-byte `memcmp` is negligible ISR work next
+  to the CSI processing the gate guards.
+- **The entire edge pipeline was dead on ESP32-C6.** `EDGE_MAX_SUBCARRIERS` was
+  128, an S3-era assumption; a C6 on an HE-capable AP delivers HE20 frames with
+  256 bins, and `process_frame` rejected every one. ADR-110 onboarded the C6 to
+  the capture path but not this one. Vitals, presence, fall detection and
+  per-slot counting had never run on these boards. Now target-conditional on
+  `CONFIG_SOC_WIFI_HE_SUPPORT`, with the four subcarrier-sized arrays hoisted to
+  static so peak stack is *lower* than it was at 128.
+- **A target-conditional constant that failed silently.** `edge_processing.h`
+  had no `#include` at all, so `CONFIG_SOC_WIFI_HE_SUPPORT` was undefined and
+  `#if` evaluated it as 0 — selecting the wrong size with no warning. An
+  undefined identifier in `#if` is 0 in C. This is the same failure mode as the
+  bug it was fixing, one layer up.
+
+## References
+
+- `v2/crates/wifi-densepose-sensing-server/src/links.rs` — per-link state, 8 tests
+- `v2/crates/wifi-densepose-sensing-server/src/phase_diag.rs` — the phase measurement
+- `firmware/esp32-csi-node/main/csi_collector.c` — wire v2 serialization, filter ordering
+- `firmware/esp32-csi-node/main/edge_processing.h` — `EDGE_MAX_SUBCARRIERS`
+- ADR-018 (wire format), ADR-060 (MAC filtering), ADR-110 (C6 onboarding)
@@ -0,0 +1,52 @@
+# ADR 346: Fail closed ESP32 occupancy evidence
+
+## Status
+
+Accepted and implemented. Physical qualification is required after each firmware build.
+
+## Date
+
+2026 08 31
+
+## Context
+
+The ESP32 Tier 2 pipeline produces two different signals. Presence is a debounced room level decision. Person count is a bounded subcarrier diversity heuristic. A live four node installation emitted packets with `presence=false` and `n_persons=3` or `4`. The server eventually gated the aggregate room count, but raw WebSocket consumers and diagnostics could still treat the contradictory count as occupancy evidence.
+
+That contradiction is more dangerous than a missed optional count. It can contaminate empty room calibration, train a room model on false labels, and encourage a product claim that the firmware cannot support. The count is not identity, pose, or a validated multi person estimator.
+
+## Decision
+
+1. Firmware person slots are subordinate to the debounced presence gate.
+2. When presence is false, the firmware clears slot activity, slot history, candidate count, persistence streak, and stable count.
+3. The serialized person count is always zero when presence is false and is clamped to `EDGE_MAX_PERSONS` when presence is true.
+4. The sensing server repeats the invariant for older firmware. A contradictory or out of range count becomes zero and carries `person_count_valid=false`.
+5. Fused CSI plus mmWave packets use either CSI presence or mmWave presence as the supporting presence condition.
+6. The node inventory and WebSocket diagnostics expose person count validity. Consumers must not infer a person from an invalid count.
+7. No count accuracy claim is created by this change. The firmware output remains a heuristic until a leakage free, held out physical dataset demonstrates otherwise.
+8. OTA admission uses the selected update partition size rather than a stale fixed 900 KB ceiling. The status endpoint reports that same hardware bound, while image validation and authenticated OTA remain mandatory.
+
+## Security and privacy
+
+The change retains no raw CSI or personal data. It reduces authority by preventing a secondary heuristic from asserting occupancy after the primary gate has closed. The host validates packet length, magic, range, and logical consistency before using count evidence.
+
+## Consequences
+
+Older firmware remains wire compatible. Invalid count evidence becomes visibly unavailable instead of silently affecting calibration. A true multi person event can still be undercounted when the presence gate is false, which is the intended fail closed behavior. Current C6 images larger than 900 KB can use the installed 1,900,544 byte OTA slots after one serial upgrade, without weakening the OTA authentication gate.
+
+The largest uncertainty is whether the current presence gate itself generalizes across the installed rooms. The fix path is a room bound empty baseline plus the fixed room selective held out protocol, not a global threshold reduction.
+
+## Evidence and acceptance
+
+MEASURED before implementation on 2026 08 31: four live nodes streamed for 86 seconds with zero transport errors, while edge packets repeatedly contradicted `presence=false` with counts of three or four.
+
+Software acceptance requires:
+
+1. Host firmware tests prove absent plus four active slots serializes zero.
+2. Rust parser tests prove contradictory and out of range counts fail closed.
+3. The node API exposes count validity without breaking older firmware.
+
+Physical acceptance requires the updated firmware on a confirmed board, a captured boot log, five minutes of live packets, zero logical count contradictions, and no increase in transport errors. Accuracy remains unmeasured until labelled held out sequences are recorded.
+
+Physical occupancy qualification completed for ESP32 C6 node 4 on 2026 08 31. The five minute run observed 242 edge packets, including 61 absent packets, with zero logical count contradictions and zero parse errors. See `docs/validation/2026-08-31-esp32-c6-occupancy-integrity.md`.
+
+ESP32 C6 node 7 was subsequently identified, upgraded to firmware 0.8.8, and transport qualified for five minutes with zero fused presence count contradictions and zero steady state transport errors. Its controlled empty room sequence remains required before occupancy qualification. See `docs/validation/2026-08-31-esp32-c6-node7-rate-aware-sensing.md`. Other nodes remain unqualified until separately identified and upgraded.
@@ -0,0 +1,85 @@
+# ADR 347: Rate aware ESP32 temporal sensing
+
+## Status
+
+Accepted. Implemented in firmware 0.8.8. The timing and transport path is
+physically qualified on ESP32 C6. The independent raw transport path is also
+physically qualified on an ESP32 S3 running Tier 0. Held out inference accuracy
+remains required.
+
+## Context
+
+The ESP32 firmware creates CSI opportunities by sending one byte ICMP probes to
+the connected access point. The traffic source is configured for 50 Hz, but the
+delivered CSI cadence varies with channel contention and callback safety gates.
+A physical ESP32 C6 produced 28 to 37 callbacks per second during the baseline
+capture. Firmware 0.8.5 then exposed that the old per-interval estimator saw
+only 12 to 16 Hz because WiFi replies arrived in short bursts separated by
+longer gaps. The filters still consumed those burst frames, so excluding them
+from the clock estimate was incorrect.
+
+The edge DSP estimates its sample rate from timestamps so that breathing,
+heartbeat, motion, and future Doppler features stay in physical Hertz. That
+estimator was capped at 30 Hz. Once the actual cadence exceeded the cap, every
+temporal feature was scaled against the wrong clock.
+
+Physical firmware 0.8.5 validation corrected that initial diagnosis. Although
+the callback path received 26 to 40 frames per second, Tier 2 on the unicore C6
+processed an irregular subset that converged toward the 8 Hz estimator floor.
+The right design is not to force the edge DSP to match raw capture. The paths
+need independent, explicit cadence contracts.
+
+The device free gesture preprint at
+`https://www.preprints.org/manuscript/202602.0018` reinforces the importance of
+timestamp correct Doppler features, but its 100 Hz controlled link is not a
+safe firmware default for RuView. Existing S3 and C6 evidence records WiFi ISR
+and packet buffer failures under sustained callback pressure above 50 Hz.
+
+## Decision
+
+1. Make the connected STA probe rate a build time setting from 10 through 50
+   Hz, with a default and hard ceiling of 50 Hz.
+
+2. Track the delivered DSP cadence by counting every processed frame interval
+   over one second timestamp windows, then smooth successive windows in an 8
+   through 60 Hz estimator range. The 60 Hz estimator ceiling accommodates
+   timestamp jitter; it does not authorize more than 50 Hz callback processing.
+
+3. Reject incomplete windows below one second and stalled windows above three
+   seconds. Do not discard valid burst frames from the estimated clock.
+
+4. Surface the DSP rate in the one second controller diagnostic so hardware
+   validation can compare callback yield with the clock used by temporal
+   filters.
+
+5. Keep raw CSI on the wire at the independent network cadence. Rate-limit the
+   C6 on-device Tier 1 and Tier 2 DSP input to a uniform 8 Hz. Physical 0.8.7
+   evidence showed that a requested 10 Hz input still converged to 8.0 through
+   8.4 Hz under Tier 2 load, while raw delivery remained 30 through 40 pps.
+   Eight hertz retains a 4 Hz Nyquist limit for the 0.1 through 2.0 Hz vital
+   bands without creating a backlog. The S3 default remains 20 Hz.
+
+6. STFT, spectrogram gating, and learned temporal
+   classification remain host or iPhone responsibilities where memory,
+   rollback, and held out evaluation are stronger.
+
+## Consequences
+
+Heartbeat, respiration, and motion features receive a stable timestamped clock
+instead of an accidental subset determined by C6 backlog. Operators can lower
+the probe or DSP load for constrained networks without editing source. The host
+still receives the higher-rate raw stream for richer Doppler processing.
+
+This does not prove vital sign accuracy or gesture recognition. Higher temporal
+fidelity only improves the representation available to a separately validated
+model. The 50 Hz ceiling also means the paper's 100 Hz results are not directly
+transferable.
+
+## Acceptance test
+
+On a physical C6, run at least five minutes after flashing. Pass when the boot
+log reports the configured probe and DSP rates, the controller converges within
+one hertz of the configured DSP cadence, raw callback yield remains at least 20
+pps, no steady-state ENOMEM, watchdog, panic, or reboot occurs, and the fail
+closed occupancy invariant remains zero contradictions for at least 30 absent
+packets.
@@ -0,0 +1,336 @@
+# ADR-348: Independent Rust multivariate forecasting for RuView
+
+- **Status**: Proposed
+- **Date**: 2026-09-01
+- **Deciders**: ruv
+- **Owners**: RuView perception, model, security, and data-governance maintainers
+- **Tags**: forecasting, rust, ruvector, temporal, uncertainty, clean-room, provenance
+- **Extends**: ADR-016, ADR-020, ADR-145, ADR-273, ADR-282, ADR-295,
+  ADR-298, ADR-302, ADR-304, ADR-317, ADR-318, ADR-319
+- **Supersedes**: None
+
+## Executive decision
+
+RuView will develop an independently specified and independently trained Rust
+multivariate forecasting subsystem. It will forecast bounded, versioned
+temporal feature streams, publish calibrated quantiles and an explicit
+abstention state, optionally use a split-safe RuVector analogue index, and
+remain advisory until all release gates in this ADR pass.
+
+This is not a port, compatibility layer, distillation, or behavioural clone of
+Google TimesFM. The implementation API is derived from RuView requirements.
+Its weights must descend from an approved random initialization and approved
+training data only.
+
+**Evidence status at proposal:** the forecasting accuracy, false-alert
+reduction, calibration, CPU latency, memory use, cross-building generalization,
+and operational value described below are all **UNMEASURED targets**. This ADR
+authorizes implementation and evaluation; it makes no `MEASURED` capability
+claim and approves no production model.
+
+## Context
+
+RuView currently observes present and recent RF state. Forecasting could add a
+separate answer to questions such as whether a feature trajectory is consistent
+with real occupancy, whether motion is likely to transition between zones, or
+whether a radio link is degrading. A forecast is not a sensor observation. It
+is derived evidence with uncertainty and must never overwrite the immutable
+observation that produced it.
+
+TimesFM 3 is useful research context because its public description discusses
+multivariate targets, past covariates, known-future covariates, probabilistic
+outputs, temporal patching, and cross-series attention. Its licensing creates
+two distinct surfaces:
+
+- the Google TimesFM source repository states that source code is Apache-2.0;
+- the TimesFM 3 pretrained weights are distributed under a separate
+  non-commercial, non-production license that also restricts commercial
+  training, fine-tuning, and distillation from the model.
+
+An Apache-compliant Rust port would be a permissible but attributed derivative
+source path, subject to its exact license obligations. It would not support the
+strongest independent-development claim. Using the restricted TimesFM 3 model
+or its outputs to create a RuView commercial model is outside this ADR. The
+project therefore chooses the stricter clean-room protocol in
+[`../security/ruview-forecast-clean-room.md`](../security/ruview-forecast-clean-room.md).
+
+Clean-room controls reduce copyright, contract, and provenance risk. They do
+not establish freedom to operate against patents, clear trademarks, approve a
+dataset, or replace legal review in a launch jurisdiction.
+
+## Options considered
+
+1. **Use the TimesFM 3 checkpoint in RuView.** Rejected for commercial and
+   production use under the current checkpoint license.
+2. **Translate the Apache-licensed implementation into Rust.** Not selected.
+   This can be evaluated under a separate ADR, with attribution and license
+   compliance, but must not be mixed with the independent-development path.
+3. **Build an independent Rust forecasting specialist for RuView.** Chosen.
+   This narrows model scope, keeps inference native, controls provenance, and
+   makes RF-specific evaluation the source of authority.
+4. **Do not add forecasting.** Retained as the deployment baseline. Forecasting
+   must beat simpler deterministic and statistical baselines before acquiring
+   runtime authority.
+
+## Requirements
+
+| ID | Requirement | Verification authority |
+|---|---|---|
+| RF-001 | No TimesFM 3 code, configuration, weights, parameters, outputs, activations, or derivatives enter specification, implementation, training, evaluation feedback, or release artifacts. | Clean-room manifest, contributor attestations, repository and artifact scans |
+| RF-002 | Every contributor, reference, dependency, dataset, transform, training job, and checkpoint has immutable provenance. | Signed provenance manifests and review receipts |
+| RF-003 | Every training byte has documented rights for commercial machine-learning use and applicable privacy approval. | Dataset licensing gate and data-steward approval |
+| RF-004 | The default runtime is native Rust, bounded, offline, deterministic for a fixed artifact/input within the declared platform class, and free of runtime model download. | Unit, property, fuzz, replay, and dependency tests |
+| RF-005 | Inputs and outputs are versioned, finite, bounded, timestamped, mask-aware, and provenance-labelled. Invalid, stale, insufficient, or OOD inputs abstain. | Contract tests and malformed-input corpus |
+| RF-006 | Forecasts remain derived evidence. They cannot rewrite observations, silently increase observation confidence, or be relabelled `MEASURED`. | Schema invariants and evidence-engine tests |
+| RF-007 | Quantile ordering, interval calibration, missing-data behaviour, and abstention are evaluated on leakage-free site/session/device holdouts. | Frozen evaluation manifest and reproducible report |
+| RF-008 | RuVector retrieval is optional, split-scoped, provenance-recorded, and evaluated against the same model without retrieval. | Retrieval isolation tests and paired ablation |
+| RF-009 | RuVLLM may explain or summarize a signed forecast but cannot alter numeric forecasts, bypass policy, spend money, or trigger medical, emergency, access-control, or life-safety action. | Capability tests and downstream policy review |
+| RF-010 | Training on local Linux or a hosted accelerator uses identical signed code, container, data, and configuration identities; the provider is an untrusted processor. | Training receipts and digest comparison |
+| RF-011 | Accuracy, latency, memory, power, and operational claims remain `UNMEASURED` or `CLAIMED` until a named reproducer satisfies the repository evidence contract. | Documentation and release review |
+| RF-012 | Rollout is reversible and cannot advance from offline evaluation to shadow or advisory operation without the mapped gates below. | Signed mode transition and rollback drill |
+
+## Architecture boundary
+
+The initial implementation is split across three crates:
+
+| Crate | Owned responsibility | Dependency/runtime rule |
+|---|---|---|
+| `ruview-forecast-core` | Backend-neutral schemas, invariants, metrics, forecast receipts, and the `Forecaster` trait | No Burn, CUDA, WGPU, provider SDK, sensing-server, or network dependency |
+| `ruview-forecast-model` | Independent Burn 0.21 patch-mixer architecture and artifact execution | CPU, CUDA, and WGPU are explicit optional features; every backend feature is off by default |
+| `ruview-forecast-train` | Dataset manifests/splits, trainer, evaluator, the `ruforecast` CLI, and Linux/fal.ai training assets | Training-only authority; no production activation or sensing-server mutation |
+
+This PR does not connect the forecaster to the sensing server. A shadow bridge
+requires a follow-up change after the core contract and evidence receipt have
+stabilized. Landing crates or passing synthetic tests therefore creates no
+live RuView forecasting capability.
+
+Version one activates only the exact reviewed `tiny_ci` and `large_linux`
+architecture profiles. The model and training boundaries enforce checked
+dimension, parameter, activation-cell, input-cell, and forward multiply-add
+limits per batch. Adding or changing a profile is therefore a reviewed code and
+artifact-schema decision, not untrusted request configuration.
+
+The proposed logical pipeline is:
+
+```text
+authenticated RF observations
+        |
+        v
+versioned one-second feature windows
+        |
+        +----> split-scoped RuVector analogue retrieval (optional)
+        |
+        v
+independent Rust temporal model
+        |
+        v
+point forecast + ordered quantiles + validity mask + abstention
+        |
+        v
+signed derived-evidence record
+        |
+        +----> RuView policy/evidence engine
+        +----> RuVLLM explanation with no numeric mutation authority
+```
+
+The initial feature contract should favour compact one-second summaries rather
+than feeding an unbounded raw CSI stream. Candidate fields include motion
+energy, Doppler summary, amplitude/phase dispersion, coherence, RSSI, packet
+loss, channel utilization, current detector confidence, device temperature,
+and source-validity masks. Each field needs a schema version, physical unit,
+aggregation rule, validity semantics, and provenance. Adding a field is a
+schema change, not an implicit positional extension.
+
+The model may independently combine normalization, temporal patch encoding,
+temporal mixing, cross-stream fusion, and quantile heads. This is a functional
+design space, not permission to reproduce protected source expression,
+checkpoint dimensions, constants, tests, diagrams, or API choices. Exact
+architecture and parameter count remain implementation decisions recorded in
+the model card and training receipt.
+
+## Forecast contract
+
+For each request the runtime returns one typed result, including abstention and
+error paths. The result must identify:
+
+- input schema, feature-window, model, configuration, and calibration digests;
+- source time range, requested horizon, cadence, target streams, and masks;
+- point estimate and declared quantiles for each target/horizon cell;
+- whether quantiles were corrected for crossing and which method was used;
+- OOD, insufficient-context, stale-input, and non-finite dispositions;
+- optional RuVector index version, neighbour identifiers, distances, and
+  leakage-scope receipt;
+- runtime platform class, duration, and peak-memory measurement when enabled;
+- evidence label `DERIVED_FORECAST`, never `MEASURED_OBSERVATION`;
+- deterministic content hash and optional RVF signature.
+
+The runtime rejects non-finite values, duplicate or non-monotonic timestamps,
+unsupported schema versions, unbounded dimensions, invalid quantile requests,
+future covariates without an allowed source, and payloads above configured
+limits. It abstains rather than imputing an authoritative state when history or
+validity coverage is below the model-card threshold.
+
+## RuVector integration
+
+RuVector supplies temporal memory, not ground truth. During training and
+evaluation, each split has a separate index built only from records permitted
+for that split. A test query may retrieve training analogues, but it may never
+retrieve a window from the same subject/session/site holdout, an overlapping
+target horizon, or any test record. Fitted normalizers and retrieval thresholds
+come from training data only.
+
+Every release reports three comparable rows on identical examples:
+
+1. deterministic/statistical baseline;
+2. forecasting model without retrieval;
+3. forecasting model with RuVector retrieval.
+
+This prevents retrieval from hiding a weak model or leaking future state.
+
+## RuVLLM and action authority
+
+RuVLLM consumes an immutable, signed forecast record and may produce an
+explanation referencing its uncertainty and provenance. Its prose is not the
+forecast and receives no higher evidence grade. Numeric values exposed to APIs
+come from the forecasting record, not regenerated text.
+
+No forecast or LLM explanation independently triggers a health alert, emergency
+response, access decision, actuator, firmware change, model promotion, or
+commercial spend. Such actions require a separate governed policy, explicit
+capability, and appropriate observed evidence.
+
+## Training and artifact boundary
+
+Training jobs run from a pinned container or reproducible local environment.
+The receipt binds the source commit, lockfile, compiler, container, datasets,
+transforms, architecture, hyperparameters, seeds, hardware, provider job ID,
+start/end time, and every emitted checkpoint. Hosted workers receive only the
+least data and credentials necessary. Provider caches, logs, retention, and
+reuse rights must pass security and data review before customer-derived data is
+uploaded.
+
+A release artifact is immutable and hash addressed. It is loaded locally after
+signature, schema, size, and compatibility verification. The inference process
+does not fetch models, execute embedded code, accept arbitrary operators, or
+contact the training provider.
+
+## Leakage and evaluation protocol
+
+- Split by deployment/site first, then subject, session, device, and contiguous
+  time block as applicable. No overlapping raw sequence or derived window may
+  cross a split.
+- Freeze test manifests before tuning. A failed test result does not become a
+  new training target; material architecture changes require a new untouched
+  holdout.
+- Fit normalization, calibration, feature selection, thresholds, and RuVector
+  index parameters on training/validation data only.
+- Report missingness, abstention coverage, selective risk, per-horizon errors,
+  interval coverage, quantile loss, and results by site/device/interference
+  regime. Pooled performance cannot hide a failed domain.
+- Compare against last value, seasonal naive, and at least one small classical
+  or recurrent baseline. TimesFM 3 output is not an acceptance oracle.
+- Forecast evaluation does not prove presence, pose, fall, respiration, or
+  medical accuracy. Any downstream claim requires its own labelled protocol.
+
+## Acceptance gates and requirement mapping
+
+Targets below are release criteria, not current results.
+
+| Gate | Requirements | Pass condition | Current state |
+|---|---|---|---|
+| G0 independent-authoring boundary | RF-001, RF-002 | Approved source allowlist; 100% current contributor attestations; zero restricted artifacts or outputs; all similarity findings adjudicated by the clean-room custodian. | **OPEN / UNMEASURED** |
+| G1 data and lineage | RF-002, RF-003, RF-010 | 100% of training/evaluation bytes resolve to approved manifests; zero unknown, noncommercial, research-only, no-ML, or no-derivatives sources; checkpoint lineage reaches approved random initialization; local/hosted receipts bind identical governed inputs. | **OPEN / UNMEASURED** |
+| G2 bounded Rust contract | RF-004, RF-005, RF-006 | Unit/property/fuzz tests cover dimensions, non-finite values, timestamp order, masks, quantile order, stale/OOD/insufficient context, deterministic hashes, offline loading, evidence labels, and resource caps; 24-hour accelerated replay has no panic or unbounded growth. | **OPEN / UNMEASURED** |
+| G3 leakage-free model evidence | RF-007, RF-008, RF-011 | Frozen site/session/device-disjoint report; all baseline and ablation rows present; nominal 80% interval coverage target is 75%-85%; weighted quantile loss target is at least 10% better than seasonal naive; every metric has a reproducer. | **OPEN / TARGETS UNMEASURED** |
+| G4 RuView shadow value | RF-006, RF-007, RF-008, RF-009 | At least 14 days shadow-only; empty-room false-alert target is at least 50% relative reduction without more than 2 percentage points occupied-room recall loss; no safety-critical action authority; drift and abstention reported by deployment. | **OPEN / TARGETS UNMEASURED** |
+| G5 deployment fitness | RF-004, RF-009, RF-010, RF-011, RF-012 | CPU p95 target is at most 1 second for 32 declared streams with peak process memory at most 4 GiB; signed model card/SBOM/provenance; privacy, security, trademark, dataset, and patent reviews; rollback drill; no open severity 1/2 issue. | **OPEN / TARGETS UNMEASURED** |
+
+Failure at any gate keeps the model offline or shadow-only. Passing a software
+gate is not real-hardware evidence and does not convert an accuracy target into
+a measurement.
+
+## Rollout and rollback
+
+The only permitted progression is:
+
+```text
+OFF -> OFFLINE_EVAL -> SHADOW -> ADVISORY
+```
+
+This ADR does not authorize autonomous action. Each transition records actor,
+old/new mode, artifact and configuration digests, evidence report, and reason.
+Regression, provenance failure, calibration drift, security incident, or
+licensing uncertainty returns immediately to `OFF` or `SHADOW` while observed
+RuView sensing continues unchanged.
+
+Rollback deactivates the forecast artifact atomically, clears ephemeral model
+and retrieval state, preserves signed aggregate evidence and incident records,
+and never downgrades or rewrites the raw observation stream.
+
+## Security and privacy
+
+Forecasting can infer routines from occupancy and movement even without raw
+CSI. Feature windows, neighbour identifiers, forecasts, and explanations are
+therefore deployment data subject to purpose limitation, tenant isolation,
+retention, deletion, access control, and audit.
+
+Model artifacts, feature schemas, calibration, indexes, and manifests are
+untrusted until their signature and digest verify. Cardinality, dimensions,
+horizon, context, allocations, execution time, and concurrent requests are
+bounded. Metrics use allowlisted aggregate values and exclude raw CSI, precise
+room coordinates, persistent person identifiers, and unrestricted feature
+payloads.
+
+The detailed authoring, data, AI-tool, incident, trademark, and patent controls
+are normative in
+[`../security/ruview-forecast-clean-room.md`](../security/ruview-forecast-clean-room.md).
+
+## Consequences
+
+### Positive
+
+- RuView gains a provider-neutral predictive evidence primitive with explicit
+  uncertainty and abstention.
+- Rust-native inference can be evaluated on CPU without requiring a Python or
+  cloud runtime in production.
+- RuVector retrieval becomes a measurable ablation rather than an implicit
+  memory claim.
+- Signed provenance supports reproducible Linux and hosted training.
+
+### Negative
+
+- Independent training needs substantial diverse, correctly licensed temporal
+  data and untouched deployment holdouts.
+- Strict source separation and manifests increase contributor and review cost.
+- A plausible forecast can make weak sensing look more authoritative unless
+  downstream evidence labels remain intact.
+- Clean-room development does not remove patent, trademark, privacy, or dataset
+  risk.
+
+### Neutral
+
+- This ADR does not repair an inaccurate upstream presence or pose estimator.
+- It does not approve TimesFM 3 for RuView use.
+- It does not select a final model size, training budget, or hosted provider.
+- No production checkpoint or measured benchmark is created by this decision.
+
+## References
+
+- [TimesFM 3 public research article](https://research.google/blog/timesfm-3-a-zero-shot-foundation-model-for-multivariate-forecasting/)
+- [Google TimesFM repository and source-license notice](https://github.com/google-research/timesfm)
+- [TimesFM 3 checkpoint license](https://huggingface.co/google/timesfm-3.0-pytorch/blob/main/LICENSE)
+- [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+- [17 U.S.C. section 102](https://www.copyright.gov/title17/92chap1.html)
+- [USPTO Patent Public Search](https://www.uspto.gov/patents/search/patent-public-search)
+- [USPTO comprehensive trademark clearance](https://www.uspto.gov/trademarks/search/comprehensive-clearance-search-similar-trademarks)
+- [RuView Forecast clean-room protocol](../security/ruview-forecast-clean-room.md)
+- [RuView Forecast model-card template](../huggingface/RUVIEW_FORECAST_MODEL_CARD_TEMPLATE.md)
+- [ADR-145](./ADR-145-ablation-eval-harness-privacy-leakage.md)
+- [ADR-282](./ADR-282-ruview-ecosystem-positioning.md)
+- [ADR-295](./ADR-295-source-provenance-state-machine.md)
+- [ADR-298](./ADR-298-model-release-sanity-gates.md)
+- [ADR-302](./ADR-302-out-of-distribution-detection.md)
+- [ADR-304](./ADR-304-evidence-engine.md)
+- [ADR-317](./ADR-317-benchmark-multi-domain-scorecard.md)
+- [ADR-318](./ADR-318-capability-certificates.md)
+- [ADR-319](./ADR-319-witness-chain.md)
@@ -0,0 +1,231 @@
+# ADR-349: Governed local and fal.ai forecast training
+
+- **Status**: Proposed
+- **Date**: 2026-09-01
+- **Deciders**: ruv
+- **Owners**: RuView forecast training, security, and release maintainers
+- **Tags**: forecasting, training, fal, rust, receipts, idempotency, cost-control
+- **Parent**: ADR-348
+- **Extends**: ADR-010, ADR-145, ADR-298, ADR-319, ADR-348
+- **Supersedes**: None
+
+## Decision
+
+RuView Forecast will use one Rust training engine behind two deliberately
+different request boundaries. The local Linux request may bind a governed,
+hash-addressed RuView JSONL shard. Hosted v1 accepts only a bounded,
+deterministic synthetic generator recipe. It cannot serialize a local
+`TrainSpec`, `DataPolicy`, path, dataset bytes, tenant/account/workspace/site/
+device/session identity, split receipt, or RuVector namespace.
+
+The fal.ai path is a bounded execution adapter, not a remote shell. It may
+train the fixed synthetic profile and export fixed artifact kinds, but it may
+not choose an arbitrary command, executable, container, URL, environment
+variable, output path, or release action. A later real-data hosted path needs a
+new accepted ADR, provider/privacy review, and an operator-signed export grant;
+it is intentionally not implemented here.
+
+Every hosted result is untrusted and quarantined until it is exported with a
+complete receipt, downloaded through the authenticated provider channel,
+re-hashed locally, scanned, and bound to the original request. Only the local
+release boundary may sign or activate it. Signing keys never enter fal.ai.
+
+This ADR delegates dataset rights, clean-room evidence, model-card, patent,
+trademark, and production gates to [ADR-348](./ADR-348-independent-rust-multivariate-forecasting.md)
+and the [clean-room protocol](../security/ruview-forecast-clean-room.md).
+
+**Evidence status:** typed local and hosted configuration, root-confined file
+verification, atomic fixed-kind artifact publication, and cooperative
+cancellation source surfaces exist. End-to-end local training and mock hosted
+transport are software-testable in this change. Real fal.ai execution,
+provider cancellation, cost reconciliation, quarantine promotion, and local
+signature verification remain **UNMEASURED and unapproved** until their named
+acceptance evidence exists.
+
+## Context
+
+The same training engine needs to run on a 128 GiB Linux workstation and on an
+optional hosted accelerator without creating two architecture lineages. A
+generic remote-command interface would allow request data to become executable
+authority, make cost difficult to bound, and weaken cancellation. Sending a
+general local request to fal would also expose governance and customer
+identifiers that the hosted smoke path does not need.
+
+The initial `ruview-forecast-train` crate already separates three relevant
+modules:
+
+| Module | Current contract |
+|---|---|
+| [`config.rs`](../../v2/crates/ruview-forecast-train/src/config.rs) | `TrainingRequest`, `ValidatedTrainingRequest`, bounded `JobId`, root-relative dataset path, exact size/SHA-256, named model profiles, typed CPU/CUDA choice, and bounded optimizer values; unknown fields are denied |
+| [`artifact.rs`](../../v2/crates/ruview-forecast-train/src/artifact.rs) | verified open dataset handle, root confinement, fixed `Model`/`Manifest`/`Receipt`/`Checkpoint` kinds, atomic writes, content descriptors, and conflict-on-different-bytes idempotency |
+| [`cancel.rs`](../../v2/crates/ruview-forecast-train/src/cancel.rs) | `Cancellation`, `CancelToken`, and cooperative cancellation checks for batch/checkpoint boundaries |
+
+The training crate features keep `cli`, `server`, `fal-client`, `cpu`, and
+`cuda` explicit, with default features empty. WGPU remains a model-crate
+inference backend and is not advertised as a training runner. The `ruforecast`
+binary requires the `cli` feature. Source presence is not execution evidence.
+
+## Typed execution contracts
+
+The non-serializable trusted `TrainingRequest` is built locally from a
+size-bounded `LocalTrainingRequestWire`. It contains:
+
+- stable job identity;
+- a constructor-validated local split/horizon/normalization `TrainSpec`;
+- either a root-relative dataset identity with exact byte count and SHA-256,
+  or a deterministic synthetic recipe;
+- one allowlisted model capacity profile and compiled-in local backend;
+- bounded optimizer, checkpoint cadence, seed, memory, step, time, checkpoint,
+  and artifact budgets.
+
+Local JSON and TOML deny unknown fields. Dataset paths resolve below an
+operator-configured root, and the exact regular file remains open after
+size/hash verification to avoid replacement between validation and use. JSONL
+windows are decoded incrementally with per-line and per-window caps rather
+than loading the full shard into memory.
+
+The distinct `HostedSyntheticRequestV1` contains only a schema version,
+idempotency/request digests, a fixed model profile, deterministic generator
+parameters and seed, bounded optimizer/resource caps, and public build
+identities. Its constructor needs a non-serializable core governance authority
+proving that the synthetic recipe is the approved hosted source. Hosted v1 has
+no external dataset field.
+
+Neither request contains a shell string, argument vector, executable path,
+container/image selector, package installer, arbitrary URL, callback URL,
+environment map, secret, source fragment, or unrestricted output name.
+
+The local client maps `HostedSyntheticRequestV1` to one allowlisted,
+process-configured fal app and pre-deployed content-addressed worker image. The
+caller cannot override the app, machine, worker entry point, or artifact
+destination. The endpoint returns typed status or artifact descriptors only.
+Provider paths are derived from validated job identity and fixed artifact
+kinds, then downloaded through the authenticated fal Platform Files API; they
+are not accepted as remote URLs or local paths.
+
+The deploy wrapper builds from an allowlisted `git archive`, selects the exact
+`fal_app.py::run_server` symbol, and passes `--auth private` for both `fal run`
+and `fal deploy`; ephemeral Fal runs otherwise default to public. Hosted v1
+retains only bounded synthetic request/result metadata so its typed queue result
+can be reconciled. It sets `X-Fal-No-Retry: 1` and a bounded timeout rather than
+claiming that `X-Fal-Store-IO: 0` or an unverified lifecycle header protects
+the result. A live unauthenticated 401/403 probe and provider retention/deletion
+reconciliation remain blocking operational evidence.
+
+## Idempotency and cost authority
+
+The local effective idempotency identity is:
+
+```text
+job_id + canonical request digest + source commit + lockfile digest
+ container digest + dataset/split digest + initial-weight digest
+```
+
+Hosted v1 replaces `dataset/split digest` with the canonical synthetic-recipe
+digest. No local governance identifier is part of, or derivable from, the
+hosted payload.
+
+Repeating an identical completed request returns the existing verified receipt
+and descriptors. Reusing `job_id` with any different governed input fails as a
+conflict. A retry after an ambiguous network failure must first query the same
+provider job; it must not silently create a second billable run.
+
+Before hosted submission, the caller sets explicit maximum steps, wall-clock
+time, memory, checkpoint count, export bytes, and billable units. Submission
+also requires an explicit local spend-approval record bound to the request
+digest and maximum units. The adapter rejects a request when its configured
+cap exceeds that approval. The final receipt records estimated and actual
+provider units/cost when the provider supplies them, the price source/time,
+and whether the amount is final or provider-reported. A provider estimate is
+`CLAIMED`, never `MEASURED`, until reconciled against a bill.
+
+No automatic retry may increase the approved budget. Budget changes create a
+new signed authorization record. The initial wire carries operator ceilings
+for wall time, billable seconds, and micro-USD, but it does not yet bind a
+provider price quote or reconcile a final provider ledger. Monetary enforcement
+therefore remains an operator/Fal-account control and the production hosted
+spend gate stays open.
+
+## Cancellation and checkpoints
+
+Cancellation is cooperative and idempotent:
+
+1. Local signal or authenticated hosted cancel marks one `job_id` cancelled.
+2. Training checks `Cancellation` at every batch boundary and before/after each
+   checkpoint/export boundary.
+3. A cancellation checkpoint is committed atomically when safe and within the
+   artifact budget; a partial file never becomes a valid artifact.
+4. The terminal receipt records `cancelled`, the last completed epoch/step,
+   checkpoint digest, provider state, elapsed resource units, and final known
+   cost.
+5. Repeating cancel returns the same terminal state.
+
+Cancellation does not promise immediate GPU termination. Cancellation latency,
+checkpoint durability, and residual provider billing are **UNMEASURED** until a
+real fal.ai run supplies a receipt. A timeout or lost cancellation response
+keeps the job and any output quarantined.
+
+## Export, quarantine, and local signing
+
+The worker may emit only the fixed artifact set from `ArtifactKind`:
+
+| Kind | Required purpose |
+|---|---|
+| `Model` | Burn model record bytes |
+| `Manifest` | architecture, data/split, seed, build, and clean-room identity |
+| `Receipt` | request, environment, metrics, cost, status, and export lineage |
+| `Checkpoint` | final or cancellation-time model weights; v1 does not claim optimizer/cursor resume |
+
+Every descriptor includes kind, size, and SHA-256. Export acceptance requires
+all mandatory descriptors, bounded lengths, exact hashes, the expected job and
+request digest, no duplicate kind, and a terminal status consistent with the
+artifact set.
+
+Downloaded files enter a non-executable quarantine outside the model search
+path. Local verification repeats envelope/schema/size/hash checks, SBOM and
+malware/policy scans, clean-room declarations, dataset/split lineage, metric
+labels, and parent-checkpoint validation. No provider output may update a
+symlink, current-model pointer, RuVector index, sensing server, or release tag.
+
+After quarantine passes, an authorized local signer binds the exact export
+receipt and artifact digests to an `ArtifactReceipt` and release manifest. The
+signature records algorithm, public key ID, signer capability, and time. Fal.ai
+receives no private signing material and cannot promote its own output. The
+current core supplies canonical digests and receipts, not a complete release
+signature implementation; signature-backed activation remains open.
+
+## Requirements and acceptance
+
+| ID | Requirement | ADR-348 gate | Acceptance evidence | Current state |
+|---|---|---|---|---|
+| FT-001 | Local and hosted adapters invoke the same model/trainer implementation while using intentionally separate local-data and hosted-synthetic request schemas. | G1 | Shared-engine tests plus hosted DTO exclusion and recipe-digest binding tests | **OPEN / UNMEASURED** |
+| FT-002 | No request field or endpoint can select arbitrary code, command, image, URL, environment, or output path. | G2 | Schema negatives, endpoint capability test, dependency review | **OPEN / UNMEASURED** |
+| FT-003 | Job/request idempotency prevents duplicate execution and conflicts on changed governed input. | G1, G5 | Concurrent/retry/lost-response tests with provider job query | **OPEN / UNMEASURED** |
+| FT-004 | Hosted execution has explicit non-escalating resource and monetary caps with estimated/actual cost receipts. | G5 | Over-budget rejection and reconciled provider-bill fixture plus real-run receipt | **OPEN / UNMEASURED** |
+| FT-005 | Cancellation is authenticated, cooperative, idempotent, checkpoint-safe, and terminally receipted. | G2, G5 | Local property tests and a real hosted cancellation drill | **OPEN / UNMEASURED** |
+| FT-006 | Export is fixed-kind, bounded, complete, hash-verified, and bound to request/job/environment. | G1, G2 | Missing/duplicate/truncated/tampered export tests | **OPEN / UNMEASURED** |
+| FT-007 | Hosted outputs remain quarantined until local verification and local-only signing succeed. | G1, G5 | Promotion-denial tests, signing-key absence check, rollback drill | **OPEN / UNMEASURED** |
+| FT-008 | Hosted v1 receives synthetic inputs only; provider credentials, logs, retention, region, output reuse, and deletion satisfy ADR-348 privacy/security approval before any real run. | G1, G5 | Hosted DTO exclusion tests, provider review, and deletion/export receipts | **OPEN / UNMEASURED** |
+
+No successful unit test closes a hosted gate. G5 requires one bounded real
+fal.ai run, one cancellation drill, one ambiguous-retry/idempotency drill, cost
+reconciliation, quarantine rejection of a tampered export, and local signature
+verification over the accepted artifact. Until then fal.ai support is a typed
+software surface, not an operational capability claim.
+
+## Consequences
+
+The design gives local and hosted training one auditable lineage and keeps
+provider output below local release authority. It adds receipt, budget,
+quarantine, and signing work, and cooperative cancellation may still incur
+provider cost. If a hosted provider cannot support bounded idempotent status,
+export, cancellation, and deletion, the Linux path remains the only approved
+training environment.
+
+## References
+
+- [ADR-348](./ADR-348-independent-rust-multivariate-forecasting.md)
+- [RuView Forecast clean-room protocol](../security/ruview-forecast-clean-room.md)
+- [`ruview-forecast-train` manifest](../../v2/crates/ruview-forecast-train/Cargo.toml)
+- [`ruview-forecast-core` receipts](../../v2/crates/ruview-forecast-core/src/receipt.rs)
+- [`ruview-forecast-model` public artifact boundary](../../v2/crates/ruview-forecast-model/src/lib.rs)
@@ -0,0 +1,217 @@
+# ADR-350: RuVector predictive memory and RuVLLM authority boundary
+
+- **Status**: Proposed
+- **Date**: 2026-09-01
+- **Deciders**: ruv
+- **Owners**: RuView forecast, RuVector, evidence, and RuVLLM integration maintainers
+- **Tags**: forecasting, ruvector, ruvllm, retrieval, memory, receipts, authority
+- **Parent**: ADR-348
+- **Extends**: ADR-004, ADR-010, ADR-016, ADR-145, ADR-261, ADR-295,
+  ADR-304, ADR-319, ADR-348
+- **Supersedes**: None
+
+## Decision
+
+RuVector may augment RuView Forecast by retrieving analogous historical
+feature/forecast states from a tenant- and split-scoped predictive-memory
+index. Retrieval is optional context, never ground truth. Every release must
+report the same frozen examples with retrieval disabled and enabled so its
+incremental value and leakage risk remain visible.
+
+Each forecast is published in an immutable, locally signed envelope binding the
+model artifact, request, output, source evidence, and retrieval receipt. RuVLLM
+may read that envelope to explain uncertainty and analogous history. It may not
+rewrite numeric forecasts, create a stronger evidence class, select a model,
+promote an artifact, spend money, invoke an actuator, or make medical,
+emergency, access-control, or life-safety decisions.
+
+This child ADR delegates forecasting, clean-room, data, and general production
+gates to [ADR-348](./ADR-348-independent-rust-multivariate-forecasting.md). It
+does not authorize a sensing-server bridge.
+
+**Evidence status:** canonical forecast/receipt types and an indexable latent
+state exist in source. A RuVector adapter, retrieval receipt, signature wrapper,
+outcome reconciler, RuVLLM explanation adapter, paired retrieval evaluation,
+latency, storage cost, accuracy lift, and operational value are all
+**UNMEASURED and unapproved**.
+
+## Existing implementation boundary
+
+The current crates establish only the preconditions:
+
+| Module | Implemented surface used by this ADR |
+|---|---|
+| [`ruview-forecast-core/src/forecast.rs`](../../v2/crates/ruview-forecast-core/src/forecast.rs) | validated `ForecastRequest`, backend-neutral `Forecaster`, ordered finite `Forecast`, canonical output digest, and receipt verification |
+| [`ruview-forecast-core/src/receipt.rs`](../../v2/crates/ruview-forecast-core/src/receipt.rs) | `SourceState`, `ArtifactReceipt`, and `ForecastReceipt`; derived forecasts cannot retain `MEASURED` merely because measured input existed |
+| [`ruview-forecast-core/src/series.rs`](../../v2/crates/ruview-forecast-core/src/series.rs) | bounded feature schema, masked time series, canonical series digest, and training-only scaler fit |
+| [`ruview-forecast-model/src/network.rs`](../../v2/crates/ruview-forecast-model/src/network.rs) | `ForecastModelOutput.state` with shape `[batch, variates, d_model]`, intended as a bounded representation candidate for indexing |
+
+`ForecastReceipt` is content-addressed but not itself a digital signature.
+`ForecastModelOutput.state` is indexable but not automatically safe, private,
+stable across model versions, or useful. Those distinctions remain release
+gates.
+
+## Predictive-memory record
+
+RuVector stores a versioned `PredictiveMemoryRecord` containing:
+
+- tenant and index namespace;
+- model/artifact/config/feature-schema digests;
+- source series and forecast-request digests;
+- split, site, subject-class, session, device, calibration, and bounded time
+  scope using pseudonymous identifiers;
+- bounded latent-state or engineered-feature digest plus the approved vector;
+- forecast envelope digest and horizon;
+- observed validity mask and evidence class;
+- optional reconciled outcome digest added only after the forecast horizon;
+- retention/deletion class and creation/expiry time.
+
+Raw CSI, unrestricted feature windows, precise room coordinates, persistent
+person identity, RuVLLM prompts, and explanation prose are excluded by default.
+The vector is still potentially sensitive because it can encode routines or
+location. Tenant isolation, encryption, access control, retention, deletion,
+and membership-inference review apply.
+
+An outcome is appended through a new immutable record linked to the original;
+the historical forecast is never rewritten. Outcome reconciliation can measure
+forecast quality but cannot retroactively turn the forecast into a measured
+observation.
+
+## Split-scoped analogue retrieval
+
+Every index is bound to an immutable corpus manifest, model version, feature
+schema, preprocessing configuration, and split policy. These rules are
+mandatory:
+
+1. Tenants never share an index or query result without a separately authorized
+   privacy-preserving federation protocol.
+2. Training, validation, calibration, and test records have distinct
+   namespaces. A test query may retrieve approved training analogues only; it
+   may not retrieve test examples or validation/calibration records used to set
+   thresholds.
+3. The same site, subject, session, device, calibration episode, overlapping
+   context, or overlapping target horizon is excluded when that dimension is a
+   holdout.
+4. Index construction, distance metric, normalization, filter policy, `k`, and
+   score threshold are fitted on training data and frozen before test.
+5. Missing, stale, mismatched, unauthorized, or unverifiable indexes disable
+   retrieval and return the no-retrieval forecast or abstention according to
+   the model card. They never trigger an implicit global-index fallback.
+6. Every query returns a bounded `RetrievalReceipt` even when zero neighbours
+   qualify.
+
+The retrieval receipt binds query digest, index/corpus/policy digests,
+namespace, exclusion filter, neighbour record IDs and distances, `k`, latency,
+and disposition. It excludes raw neighbour payloads from ordinary logs.
+
+## Paired ablation
+
+Retrieval has no deployment authority without a paired evaluation on identical
+frozen requests:
+
+| Row | Model and examples | Retrieval |
+|---|---|---|
+| A | exact candidate artifact and frozen examples | disabled |
+| B | exact candidate artifact and frozen examples | enabled with frozen index/policy |
+
+The report includes weighted quantile loss, interval coverage/width,
+abstention, per-horizon error, per-site/device/interference slices, retrieval
+hit/filtered/empty rates, latency, and memory/storage overhead. It reports both
+aggregate and paired deltas with uncertainty. A gain on pooled error cannot
+hide a failed deployment domain, calibration regression, or neighbour leakage.
+
+The no-retrieval row remains a supported fallback. Retrieval is removed when
+its lower confidence bound does not show useful improvement, when it weakens
+calibration beyond the ADR-348 gate, or when its privacy/latency/storage cost
+exceeds its measured value. No uplift is claimed today.
+
+## Immutable signed forecast envelope
+
+The signed envelope covers:
+
+```text
+envelope schema/version
+ ArtifactReceipt canonical digest
+ ForecastRequest canonical digest
+ Forecast payload/output digest
+ ForecastReceipt canonical digest
+ RetrievalReceipt digest or explicit retrieval-disabled marker
+ policy/calibration/index digests
+ creation/expiry time and tenant namespace
+```
+
+Signing occurs at the trusted local boundary after artifact and retrieval
+verification. The wrapper records algorithm, public key ID, signer capability,
+and signature. Private keys never enter model artifacts, RuVector, RuVLLM, or a
+hosted training worker.
+
+Consumers verify signature, expiry, tenant, schemas, every nested digest, and
+the `Forecast::verify_receipt` invariant before using numeric values. Any
+failure yields unavailable/abstain. Unsigned content-addressed receipts remain
+useful for local tests but are not described as signed and cannot cross the
+production trust boundary.
+
+## RuVLLM explanation boundary
+
+RuVLLM receives a read-only projection of the verified envelope:
+
+- exact point and quantile values as structured fields;
+- units, horizons, calibration/OOD/abstention state;
+- bounded analogue summaries and retrieval receipt references;
+- evidence labels, model/version, and envelope digest;
+- approved explanation policy and audience.
+
+Explanation prose is stored separately and linked to the envelope digest. It
+is `CLAIMED_EXPLANATION`, not a replacement forecast. Numeric API fields are
+copied from the verified envelope after generation, never parsed back from LLM
+text. If prose contradicts a structured number, evidence state, unit, or
+disposition, the response fails validation and the numeric envelope remains
+authoritative.
+
+The explanation capability exposes no tools for artifact activation, model
+promotion, retraining, spending, messaging, emergency dispatch, access control,
+or actuation. A separate downstream policy may consume a forecast only under
+its own ADR, capabilities, approvals, and observed-evidence requirements. The
+LLM cannot grant itself that authority or lower an approval threshold.
+
+## Requirements and acceptance
+
+| ID | Requirement | ADR-348 gate | Acceptance evidence | Current state |
+|---|---|---|---|---|
+| PM-001 | Every predictive-memory query is tenant-, model-, schema-, corpus-, split-, and time-scope bound. | G3, G5 | Cross-tenant/split/version negative tests and signed index manifest | **OPEN / UNMEASURED** |
+| PM-002 | Holdout identities, overlapping contexts, and target horizons cannot appear as neighbours. | G3 | Property tests plus frozen leakage report | **OPEN / UNMEASURED** |
+| PM-003 | Every query, including disabled/empty/error, produces a bounded retrieval receipt. | G2, G3 | Receipt round-trip, tamper, bound, and zero-result tests | **OPEN / UNMEASURED** |
+| PM-004 | Retrieval-disabled and retrieval-enabled rows use identical artifact/examples and report paired metrics and overhead. | G3 | Frozen paired ablation with reproducer | **OPEN / UNMEASURED** |
+| PM-005 | Forecast envelope signatures bind all nested forecast/retrieval identities and fail closed on mutation, expiry, tenant, or key error. | G2, G5 | Signature/tamper/replay/cross-tenant tests and local signing receipt | **OPEN / UNMEASURED** |
+| PM-006 | Derived forecast and explanation can never become `MEASURED_OBSERVATION` or exceed source evidence. | G2, G4 | Evidence-monotonicity schema/property tests | **OPEN / UNMEASURED** |
+| PM-007 | RuVLLM cannot mutate structured numbers; contradictions fail validation and explanations remain separately labelled. | G4 | Numeric/unit/evidence mutation corpus and fail-closed integration tests | **OPEN / UNMEASURED** |
+| PM-008 | RuVLLM explanation has no spending, promotion, messaging, safety, access-control, or actuator capability. | G4, G5 | Default-deny capability and attempted-escalation tests | **OPEN / UNMEASURED** |
+| PM-009 | Vector/explanation privacy, retention, deletion, extraction, and membership risks are approved and operationally tested. | G5 | Privacy review, tenant deletion drill, and access audit | **OPEN / UNMEASURED** |
+
+G3 additionally requires the paired retrieval ablation to satisfy ADR-348's
+forecast and calibration gates. G4 requires shadow evidence that retrieval and
+explanation improve operator comprehension or forecast value without changing
+numeric/action authority. G5 requires signed-envelope verification, rollback,
+tenant deletion, and key-rotation drills. None has passed.
+
+## Consequences
+
+RuVector can evolve from retrospective search into outcome-linked predictive
+memory while preserving a measurable no-retrieval baseline. RuVLLM can make
+forecasts understandable without becoming the numeric or action authority. The
+cost is additional index isolation, storage, signature, deletion, evaluation,
+and policy complexity. If paired evidence does not justify that cost, the
+correct release keeps retrieval and explanation disabled.
+
+## References
+
+- [ADR-348](./ADR-348-independent-rust-multivariate-forecasting.md)
+- [ADR-349](./ADR-349-governed-local-and-fal-forecast-training.md)
+- [RuView Forecast clean-room protocol](../security/ruview-forecast-clean-room.md)
+- [RuView Forecast model-card template](../huggingface/RUVIEW_FORECAST_MODEL_CARD_TEMPLATE.md)
+- [RuForecast benchmark protocol](../benchmarks/ruforecast.md)
+- [ADR-016](./ADR-016-ruvector-integration.md)
+- [ADR-145](./ADR-145-ablation-eval-harness-privacy-leakage.md)
+- [ADR-261](./ADR-261-ruvector-graph-ann-index.md)
+- [ADR-304](./ADR-304-evidence-engine.md)
+- [ADR-319](./ADR-319-witness-chain.md)
@@ -0,0 +1,162 @@
+# ADR-353: fal.ai synthetic visual teacher LoRA
+
+- **Status**: Accepted
+- **Date**: 2026-09-02
+- **Deciders**: ruv
+- **Owners**: RuView visualization / neural-styling maintainers
+- **Tags**: fal, lora, synthetic-visualization, display-only, cost-control
+- **Parent**: None
+- **Extends**: None
+- **Supersedes**: None
+
+## Decision
+
+RuView will use one real, fal.ai-trained LoRA fine-tune (a "synthetic visual
+teacher") to steer fal.ai image/video generation toward a consistent
+"RuView-style" room visualization — glowing pose overlays, WiFi signal arcs,
+vitals readout panels, dark tech aesthetic — instead of relying on ad hoc
+prompt engineering against a stock model.
+
+**The architecture boundary is non-negotiable:**
+
+> The implementation boundary is now clear: fal.ai will train an optional
+> synthetic visual teacher, while RuView's measured RF, pose, vitals,
+> identity, and confidence remain local and authoritative.
+
+Concretely:
+
+- The trained model produced here is ONLY ever allowed to generate
+  supplementary synthetic visual/pixel output for display or broadcast.
+- It must NEVER be a source of, or influence, any measured/derived value: RF/
+  CSI measurements, pose estimates, vitals (heart rate/breathing rate),
+  identity, or confidence/quality scores. Those stay local, deterministic,
+  and authoritative — the existing `wifi-densepose-engine` /
+  `ruview-twin` / `ruview-witness` stack — completely untouched by this work.
+- Any output this model produces must be clearly framed as SYNTHETIC per this
+  repo's rule: "Never present WiFi sensing as camera-grade."
+- This model has no read or write path into the RF/pose/vitals/identity
+  pipeline. It consumes only a text prompt (and optionally a reference
+  image) and returns pixels for display.
+
+**Evidence status:** the training data extraction, training submission
+script, and validation script are real and committed. The training run
+completed and validation succeeded — trained model id, actual spend, and the
+validation sample are recorded in "Result" below. Actual-vs-billed cost
+reconciliation against the fal.ai account dashboard remains UNMEASURED (the
+figure below is a documented-pricing estimate).
+
+## Context
+
+A concurrent workstream (`ruview-fal-room-viz` / `ruview-room-viz-h3-upgrade`)
+generated real fal.ai room-visualization videos across several style presets
+(architectural, abstract, branded, and an "h3" refresh: architectural,
+cinematic, minimal, abstract) using stock fal.ai video models driven by
+prompt engineering alone. A separate concurrently-running agent
+("realtime-dual-renderer") is building a neural-styling layer that needs a
+*specific* trained model id to call, rather than continuing to rely on prompt
+engineering against a generic model.
+
+This ADR's job is narrow: turn the real captured style presets into a real
+trained fal.ai LoRA, verify it actually works, and hand off the model id. It
+does not implement the renderer integration — that is
+`realtime-dual-renderer`'s scope — and it does not touch the measured
+RF/pose/vitals/identity/confidence pipeline in any way.
+
+## Training data
+
+Source: the real fal.ai-generated room-visualization MP4s already captured
+this session (read from `/tmp/room-viz-*/room-viz.mp4` on `ruvultra`, one per
+style preset — not committed to the repo; the repo has no camera or person
+data in these clips, they are synthetic renders). `scripts/fal-visual-teacher/extract_frames.py`
+extracts one JPEG frame every 1.5 seconds from each of the 7 real style-preset
+videos (architectural, abstract, branded, h3-architectural, h3-cinematic,
+h3-minimal, h3-abstract), producing 27 frames total, each paired with a
+caption `.txt` describing the shared RuView visual motifs. Frames and the
+training zip are gitignored (`scripts/fal-visual-teacher/training-data/`,
+`training-data.zip`) — they are regenerable from the source MP4s and are not
+committed, consistent with the repo's no-generated-artifacts rule.
+
+## Training endpoint and pricing (verified 2026-09-02)
+
+- **Endpoint**: `fal-ai/flux-lora-fast-training` — a real, currently-listed
+  fal.ai LoRA training endpoint for FLUX.1, verified against
+  `https://fal.ai/models/fal-ai/flux-lora-fast-training/api`.
+- **Pricing**: $2 per training run at the default 1000 steps, scaling
+  linearly with steps (verified against fal.ai's own pricing text on the
+  model page).
+- **Mode**: submitted with `is_style: true` (style LoRA, not
+  subject/character LoRA) and explicit per-frame caption files, so fal.ai's
+  auto-captioning/segmentation is skipped in favor of our own captions.
+- **Inference endpoint** (validation only): `fal-ai/flux-lora`, $0.035 per
+  megapixel, accepting `loras: [{ path, scale }]` pointing at the trained
+  `diffusers_lora_file` URL.
+
+## Budget
+
+- **Original cap**: $15 total (this task's cap only; not shared with other
+  concurrent tasks' budgets this session).
+- **Raised cap**: the user explicitly raised this task's cap to **$100** on
+  2026-09-02, mid-run, as real headroom for a larger/better run or retries —
+  not an instruction to spend all of it.
+- **Planned spend**: ~$2 for the training run (1000 steps, default) + ~$0.04
+  per validation inference image.
+- **Actual spend**: ~$2.04 (one 1000-step training run at $2/run + one
+  landscape_16_9 validation image at $0.035/megapixel, rounded up to 1
+  megapixel). This is a documented-pricing estimate (`CLAIMED`), not yet
+  reconciled against the fal.ai account billing dashboard (`MEASURED`).
+  Comfortably under both the original $15 cap and the raised $100 cap.
+- **Why no larger follow-up run**: the first validation image already showed
+  a clean, on-style result (glowing pose overlay, WiFi arcs, vitals panels,
+  dark aesthetic, all present and legible) on the first attempt. Spending
+  further into the raised budget for marginal improvement was judged not
+  worth it against a result that already meets the bar; the fallback path in
+  "Consequences" was not needed.
+
+## Result
+
+- **Trained model id / LoRA weights URL**:
+  `https://v3b.fal.media/files/b/0aa8c60d/OjaBs6Gi8pMhZqMo79iym_pytorch_lora_weights.safetensors`
+  (131 MB `diffusers_lora_file`, paired `config.json` at
+  `https://v3b.fal.media/files/b/0aa8c60d/-GU6dd_2ZFqq18I0CuPOB_config.json`).
+  Use with `fal-ai/flux-lora` (or any fal.ai FLUX.1 endpoint accepting a
+  `loras: [{ path, scale }]` array) — trigger word `ruviewstyle`. Full
+  training record: `scripts/fal-visual-teacher/output/training-result.json`
+  (gitignored — regenerate by re-running `train_lora.py`, or copy the URL
+  above).
+- **Training request id**: `01a060b2-c940-7972-abf9-ea48847eb2ae` (fal.ai
+  `fal-ai/flux-lora-fast-training`, 1000 steps, `is_style: true`, 27 training
+  images, completed in 376s on an H100/H200 worker).
+- **Actual spend**: ~$2.04 (see Budget above).
+- **Validation sample**: `assets/fal-visual-teacher-sample.png` (+ sibling
+  `assets/fal-visual-teacher-sample.json` with the exact prompt, LoRA scale
+  1.0, and source fal.ai URL) — a real `fal-ai/flux-lora` inference call
+  using the trained LoRA, generated 2026-09-02. The image shows a glowing
+  cyan pose skeleton, WiFi signal arcs, vitals-style readout panels, and a
+  HUD-style TV overlay in a dark living room — confirming the LoRA learned
+  and reproduces the intended RuView visual motifs.
+- **Consumer**: `realtime-dual-renderer` (separate worktree
+  `~/projects/ruview-worktrees/realtime-render`) — notified directly with the
+  model id above.
+
+## Consequences
+
+A real trained LoRA gives the display layer a specific, repeatable style
+target instead of prompt engineering against a stock model, at a bounded and
+small real cost ($2 training + cents per generated image). Because the model
+only ever produces pixels for a prompt, and has no schema path into any
+measured/derived RuView value, it cannot silently become a second source of
+truth for pose, vitals, identity, or confidence — that boundary is structural
+(no shared types, no shared data path), not just documented convention.
+
+If the trained LoRA does not meaningfully improve style consistency over the
+stock model (a genuine risk with 27 training images and default steps), the
+fallback is to keep using prompt engineering against the stock model and note
+that outcome honestly here rather than claim a training win that isn't real.
+
+## References
+
+- `scripts/fal-visual-teacher/extract_frames.py` — real frame extraction
+- `scripts/fal-visual-teacher/train_lora.py` — real training submission
+- `scripts/fal-visual-teacher/validate.py` — real validation inference
+- [fal.ai Flux LoRA Fast Training](https://fal.ai/models/fal-ai/flux-lora-fast-training)
+- [fal.ai FLUX.1 with LoRAs (inference)](https://fal.ai/models/fal-ai/flux-lora)
@@ -0,0 +1,89 @@
+# ADR-354: fal.ai forecast governance and spend enforcement now real, in the vendored RuForecast submodule
+
+- **Status**: Accepted
+- **Date**: 2026-09-02
+- **Deciders**: ruv
+- **Owners**: RuView forecast training, security, and release maintainers
+- **Tags**: forecasting, training, fal, governance, submodule, cost-control
+- **Parent**: ADR-349
+- **Extends**: ADR-348, ADR-349
+- **Supersedes**: None
+
+## Decision
+
+ADR-349 specified two governance controls for RuView Forecast's fal.ai
+hosted path: operator-verified dataset/schema/policy/recipe authorization,
+and an explicit local spend-approval record bound to the request digest and
+maximum units. A 9-agent code review of the training stack merged as PR
+#1766 found that neither control was actually wired into the code path that
+builds a submittable, fal-destined training contract — `FalGovernanceVerifier`
+existed with zero callers outside its own tests, and no spend-approval type
+existed anywhere in the codebase.
+
+That code no longer lives directly in this repository. Between the review
+and this fix, `v2/crates/ruview-forecast-{core,model,train}` was extracted
+into its own repository, `github.com/ruvnet/RuForecast`, and is now vendored
+back into `v2/crates/ruforecast` as a git submodule (crates renamed to
+`ruforecast-{core,model,train}`). This ADR records two things at the RuView
+level:
+
+1. **The governance and spend-approval gaps are fixed**, in
+   `ruvnet/RuForecast` PR #2 (branch `fix/governance-and-spend-enforcement`).
+   The full technical decision record — what changed, why, and the
+   requirements/acceptance table — lives in that repository's own
+   [ADR-350](https://github.com/ruvnet/RuForecast/blob/main/docs/adr/ADR-350-fal-governance-and-spend-enforcement.md),
+   which this ADR defers to rather than duplicating. In summary: a
+   fal-destined `TrainSpec` can no longer be constructed without a real,
+   operator-signed, single-use-verified governance receipt; a hosted
+   reservation can no longer be built without a real, operator-signed spend
+   approval bound to the exact request digest and cost ceiling; and several
+   related correctness/resilience gaps on the same trust boundary
+   (unauthenticated Direct Server webhook, no execution timeout, mismatched
+   local/hosted artifact budgets, cancellation permanently wedging a job)
+   were fixed in the same pass.
+2. **The submodule pointer in this repository is bumped** to the commit
+   containing that fix, once `ruvnet/RuForecast`'s own CI is green on that
+   PR and it merges. This RuView-side change is deliberately small: a
+   pointer bump plus this ADR, not a re-implementation or re-review of code
+   that now lives, is tested, and is reviewed in its own repository.
+
+## Context
+
+RuView's own copies of ADR-348 and ADR-349 predate the extraction and still
+describe the crates as if they lived directly under `v2/crates/`. They are
+left as-is here (not corrected path-by-path) since the canonical, actively
+maintained copies of the forecast-specific ADRs now live in
+`ruvnet/RuForecast`'s own `docs/adr/`, which was seeded with copies of
+ADR-348/349 at extraction time and now also carries ADR-350. Consult that
+repository for the forecast subsystem's own decision history going forward;
+this repository's ADR series should record RuView-level integration
+decisions about the vendored submodule (like this one), not attempt to
+re-host the submodule's internal history.
+
+This repo's CLAUDE.md requires an ADR for load-bearing upstream changes.
+The governance-enforcement fix is load-bearing for RuView even though none
+of its source lines are: it changes what RuView's vendored forecast
+subsystem actually requires before it will reach real, billable fal.ai
+infrastructure on behalf of a RuView deployment.
+
+## Consequences
+
+Once the submodule pointer here is bumped, any RuView-side code, CLI
+wrapper, or documentation that assumes the old, unenforced fal.ai
+submission path (a bare `SourceState::synthetic` claim with no verified
+governance receipt or spend approval) will no longer compile or run against
+the vendored crate — `TrainSpec::new_fal_synthetic` and
+`ReservedSyntheticSubmission::reserve` both gained new required parameters.
+A repository-wide search found no such RuView-side caller today; this ADR
+records the change in case one is added later without checking the
+submodule's current API first.
+
+This pointer bump must not merge before `ruvnet/RuForecast` PR #2 merges and
+its CI is green — see that PR for status.
+
+## References
+
+- [ADR-349](./ADR-349-governed-local-and-fal-forecast-training.md) (this repository's copy; canonical copy is in `ruvnet/RuForecast`)
+- [ruvnet/RuForecast PR #2](https://github.com/ruvnet/RuForecast/pull/2)
+- [ruvnet/RuForecast ADR-350](https://github.com/ruvnet/RuForecast/blob/main/docs/adr/ADR-350-fal-governance-and-spend-enforcement.md)
+- [`v2/crates/ruforecast`](../../v2/crates/ruforecast) (submodule)
@@ -0,0 +1,134 @@
+# ADR 355: Local empty room bootstrap prior
+
+Status: Accepted
+
+Date: 2026-09-04
+
+## Context
+
+Most installations are occupied when RuView first starts. An uncalibrated
+signal heuristic can interpret HVAC, clock error, neighboring motion, or a
+short covariance window as a person. It can also surface plausible numeric
+vitals before a room model establishes occupant attribution.
+
+One empty home is not representative training data for all homes and contains
+no positive human examples. It is useful only as a recent negative prior for
+the same installation. It cannot define a universal human signal model.
+
+The field model was memory only. The server also used a relative `data/`
+directory, which is unreliable for embedded application hosts.
+
+## Decision
+
+RuView may persist a completed empty room field model as a local bootstrap
+prior only after two server controlled stages:
+
+1. Normal calibration reaches both 1,000 accepted frames and 600 seconds.
+   The frame target represents twenty complete fifty frame runtime windows.
+   A caller may select one currently live ESP32 source. The server checks its
+   freshness before replacing an active bootstrap prior, binds collection to
+   that source, and rejects frames from other radios. When no source is
+   selected, the first accepted ESP32 source preserves legacy behavior.
+2. Promotion observes 12 new samples spaced by at least one second. Each
+   sample has a four second bounded acquisition timeout. At least 10 must
+   resolve empty, all ticks must be fresh, and none may publish numeric vital
+   signs.
+
+The stored image contains aggregate means, environmental modes, mode energies,
+noise statistics, sorted scalar residual references, configuration, one source
+node ID, and a server generated model ID. It excludes raw CSI, waveforms,
+device addresses, room names, pose, identity, credentials, and positive human
+labels. Runtime matching compares a fifty frame mean with the learned residual
+distribution. Its score is empirical background conformance, not an absence
+probability.
+
+The image is bound to a SHA 256 digest of the stable installation ID, carries
+an integrity digest over the exact stored payload bytes, is capped at 1 MiB,
+and inherits the field model expiry.
+Files with an invalid schema, dimensions, values, node set, installation
+binding, digest, size, or lifetime fail closed.
+
+Restoring an image creates a field model in `bootstrap_only` mode. It may
+reduce an uncalibrated false person count, but it cannot authorize calibrated
+evidence or numeric heart and breathing rates. Explicit calibration replaces
+it with fresh statistics. Cancelling an unfinished capture restores a valid
+prior. Administrator scoped reset removes it.
+
+A restored image may receive one operator confirmed held out empty refinement.
+The server measures 12 fresh, source bound runtime residuals at one second
+spacing and requires zero stale samples and zero numeric vital samples. It
+persists only the scalar residuals. The new boundary is the larger of the
+existing threshold and 110 percent of the held out 95th percentile, capped at
+125 percent of the prior threshold. The one use marker persists in the model,
+so repeated requests cannot ratchet the threshold upward.
+
+The status endpoint reports the learned runtime window, residual threshold,
+reference count, current background conformance, and the negative only
+authority boundary. A restored model never resumes collection and never
+persists raw calibration frames.
+
+The server accepts `--data-dir` or `RUVIEW_DATA_DIR`, allowing an application
+host to provide a protected state directory.
+
+## Consequences
+
+Startup can use recent measured background structure instead of only generic
+heuristics. No accuracy lift is claimed until occupied and empty held out data
+from multiple installations is recorded.
+
+The largest failure mode is overfitting to a temporarily quiet home and
+suppressing a weak occupant. Controls are low authority, 24 hour expiry,
+installation binding, vital abstention, explicit recalibration, and reset.
+
+A human signal model still requires positive, consented, leakage separated
+occupied sequences. Empty data is never relabeled as human training.
+
+## Implementation
+
+1. `wifi-densepose-signal::ruvsense::field_model` exports and validates
+   `FieldModelSnapshotV1`.
+2. `wifi-densepose-sensing-server::bootstrap_baseline` owns schema, integrity,
+   storage, lifetime, and the held out gate.
+3. `POST /api/v1/calibration/bootstrap/promote` measures the validation window
+   and stores the image only on pass.
+4. `GET /api/v1/calibration/status` reports bootstrap authority and explicitly
+   denies calibrated evidence and numeric vital authority.
+5. Numeric vitals fail closed unless an explicit fresh calibration resolves
+   exactly one occupant at sufficient signal quality and confidence.
+6. The legacy `edge_vitals` WebSocket message applies the same publication
+   gate as `sensing_update`. When the bootstrap background matches, it emits
+   absent state, zero people, null numeric rates, and an explicit abstention
+   reason instead of forwarding raw edge candidates.
+7. `POST /api/v1/calibration/start?source_node_id=N` selects a live source for
+   deterministic single link capture. A missing or stale selection fails
+   without disabling the active bootstrap prior.
+8. `POST /api/v1/calibration/bootstrap/refine?confirmed_empty=true&source_node_id=N`
+   performs the bounded one time held out refinement. It requires administrator
+   authority when transport authentication is enabled.
+
+## Measured installation evidence
+
+One physical empty home run on source Node 5 collected 1,762 accepted frames
+over 655 seconds and produced 35 privacy reduced reference windows. Promotion
+observed 12 of 12 fresh empty samples, zero stale samples, and zero numeric
+vital samples. After process restart, 12 of 12 fresh samples matched the empty
+background and contained no numeric vital signs. Background conformance scores
+ranged from 50.0 to 64.3 percent with a median of 54.3 percent.
+
+This is measured negative evidence for one installation. No occupied positive
+holdout was recorded, so it does not prove person recall, person counting, or
+cross home accuracy improvement.
+
+## Acceptance test
+
+With a physically empty room, complete calibration on stable nodes, promote
+the single source model, and restart the server with the same installation ID
+and data directory. Status must report `binding_mode=bootstrap_only`, zero
+collection frames, and false authority for calibrated evidence and numeric
+vitals. Twelve fresh empty samples must contain no numeric vital signs.
+Starting a new room calibration must replace the prior and begin at frame zero.
+When several radios are live, selecting Node 5 must leave Nodes 3 and 7 out of
+the source set for the entire capture.
+After restart, a confirmed empty holdout may refine the restored boundary once.
+The stored snapshot must reject a second refinement and must continue to deny
+calibrated evidence and numeric vital authority.
@@ -0,0 +1,151 @@
+# ADR 356: Rate truthful CSI and reliability gated room adaptation
+
+Status: Accepted
+
+Date: 2026-09-05
+
+## Context
+
+RuView mixed three different notions of time. ESP32 firmware requested a packet
+rate, the server observed a delivered rate, and several server paths still used
+fixed 2 Hz, 10 Hz, or 20 Hz assumptions. One feature named
+`dominant_freq_hz` was not a temporal frequency at all. It was the index of the
+strongest subcarrier multiplied by 0.05. A second defect compared a newly
+inserted frame with itself, forcing that motion delta to zero.
+
+These errors can move a spectral peak into the breathing or heartbeat band and
+produce plausible but false values. They also make models sensitive to WiFi
+traffic and processor scheduling rather than physical motion.
+
+ESP-IDF documents that `wifi_csi_info_t.first_word_invalid` marks the first four
+CSI bytes invalid because of a hardware limitation. It also documents that the
+CSI receive callback runs in the WiFi task and should hand work to a lower
+priority task rather than perform lengthy processing. RuView serialized the
+invalid bytes unchanged and fed the original buffer to edge processing.
+
+Recent work suggests four useful directions with different maturity:
+
+1. OpenCSI represents each link as a dimensionless residual against its own
+   quiet period temporal standard deviation and exposes baseline maturity. Its
+   reported transfer results are limited to binary presence.
+2. MORIC derives motion centered delay and Doppler views to reduce dependence
+   on static environment specific CSI structure.
+3. Parameter efficient CSI crowd counting combines self supervised pretraining,
+   small room adapters, and a stateful counting machine.
+4. WiFi JEPA masks complete radio links and predicts their latent embeddings,
+   using real and ray traced CSI for pose representation learning.
+
+The papers report promising external results. None is measured RuView evidence,
+and none authorizes deployment without leakage free occupied and empty held out
+evaluation.
+
+## Decision
+
+### Firmware ingestion
+
+1. When ESP-IDF marks the first CSI word invalid, zero the first four serialized
+   CSI bytes while retaining the fixed packet shape.
+2. Set ADR-018 byte 19 bit 5 to record that sanitation occurred.
+3. Feed edge DSP from the sanitized serialized payload, never the original
+   invalid driver buffer.
+4. Keep callback work bounded to sanitation, serialization, and the existing
+   queue handoff. Do not add transforms to the WiFi task.
+
+### Server time model
+
+1. Estimate delivered CSI rate from accepted monotonic frame timestamps after
+   five samples. Use 20 Hz only during startup.
+2. Cap the physical input rate at the firmware contract of 50 Hz so a burst or
+   timestamp artifact cannot retune downstream filters above their supported
+   range.
+3. Reconfigure the vital detector only after a 20 percent rate change. Clear
+   temporal and smoothing state whenever its clock changes. Samples calculated
+   with different clocks must never be blended.
+4. Compute temporal dominant frequency from the recent mean amplitude series
+   with demeaning, a Hann window, and bounded direct Fourier bins from 0.1 Hz to
+   the smaller of 4 Hz or 45 percent of sample rate.
+5. Return zero for short, flat, nonfinite, or spectrally ambiguous windows.
+6. Compare the current frame with the prior frame, not itself, for motion delta.
+7. Export zero sample rate until the estimate is mature. Never present a startup
+   fallback as a measured node property.
+
+### Model compatibility and room reliability
+
+1. Preserve the historical fifth input feature for version 1 adaptive models at
+   the model boundary. Version 2 and later models consume the true temporal
+   frequency. This prevents an existing model from silently receiving a
+   different input distribution after a server update.
+2. A background model is unreliable until it contains at least ten finite,
+   nonnegative residual references. An unreliable model cannot suppress a
+   runtime change and exposes no conformance score.
+3. Expose background maturity, reliability, and a robust residual Z score based
+   on the median and median absolute deviation.
+4. Keep the persisted empty home prior negative only. It cannot authorize
+   calibrated presence, person count, pose, or numeric vitals.
+
+### Model roadmap
+
+The following work remains proposal only:
+
+1. Evaluate an OpenCSI style per link quiet residual normalization for binary
+   presence without replacing absolute magnitude features used for motion.
+2. Evaluate delay and Doppler views after phase sanitation for activity.
+3. Pretrain a frozen multilink encoder and adapt small room specific modules for
+   counting.
+4. Evaluate link masked self supervision for pose only when at least three
+   spatially distinct links and synchronized positive pose labels exist.
+
+Every candidate uses immutable manifests and splits by room, subject,
+recording, and time. It is compared with the frozen baseline under identical
+seeds. Counting includes confusion matrices and mean absolute error. Pose
+includes PCK at 20 centimetres, MPJPE, and the mean pose baseline. A shuffled
+label control must fail.
+
+Promotion requires at least 10 percent held out lift, less than 10 milliseconds
+added p95 inference latency, no more than 20 percent peak memory overhead, zero
+leakage or secret findings, frozen anchor retention, and no regression in empty
+rejection or occupied recall. Promotion remains an explicit maintainer action.
+
+## Consequences
+
+The firmware no longer preserves a known invalid prefix as sensor evidence. The
+server uses an observed physical clock for spectral features and vital filters.
+Existing version 1 adaptive models remain compatible. Sparse background samples
+fail open to observation and fail closed for suppression.
+
+The direct Fourier estimator is intentionally small and bounded to 128 temporal
+samples. It is portable and deterministic, but it is not a replacement for a
+phase sanitized delay and Doppler pipeline.
+
+The largest remaining uncertainty is human recall. Empty home evidence can
+measure false presence but cannot show whether weak occupied signals are being
+suppressed. The fix path is a consented, leakage separated occupied holdout with
+multiple spatial links and synchronized reference labels.
+
+## Research basis
+
+1. Espressif ESP-IDF WiFi CSI programming guide:
+   https://docs.espressif.com/projects/esp-idf/en/v5.5.4/esp32/api-guides/wifi.html
+2. Espressif ESP CSI reference implementation:
+   https://github.com/espressif/esp-csi
+3. OpenCSI:
+   https://arxiv.org/abs/2607.26665
+4. MORIC:
+   https://arxiv.org/abs/2506.12997
+5. Parameter efficient CSI crowd counting:
+   https://arxiv.org/abs/2601.02203
+6. WiFi JEPA:
+   https://arxiv.org/abs/2607.11064
+
+## Acceptance test
+
+Run the firmware serializer host tests and the focused hardware, signal, and
+sensing server Rust suites. The deterministic serializer test must prove the
+first four bytes are zero only when ESP-IDF marks them invalid and bit 5 must
+round trip through the Rust parser. The temporal estimator must recover a
+1.2 Hz synthetic signal within 0.21 Hz, abstain on short and flat inputs, and
+remain below 10 milliseconds p95 on the target Mac. Existing version 1 model
+input must retain the legacy proxy. A background model with nine references
+must never report a match or suppress a runtime change. Physical firmware is
+not qualified until an S3 and C6 boot and stream the sanitized flag without
+watchdog, memory, or transport regressions during a five minute burn in.
@@ -0,0 +1,143 @@
+# ADR 357: Raw CSI calibration sample integrity
+
+Status: Accepted
+
+Date: 2026-09-06
+
+## Context
+
+The empty room field model requires 1,000 accepted observations over at least
+600 seconds. The sensing server previously invoked calibration from both the
+raw CSI path and the one second edge vital path. Edge vital packets did not add
+a CSI observation, so that path repeatedly fed the existing history tail. A
+counter could therefore satisfy the frame gate without representing 1,000
+independent CSI packets.
+
+Node liveness also combined edge vital and CSI traffic. A source emitting only
+edge vital summaries could appear live enough to start calibration even though
+it had no fresh raw CSI. Finally, cloning the complete per node history before
+each feed copied as much as 204,800 bytes for a 100 frame, 256 subcarrier
+window even though calibration consumes only the current observation.
+
+The earlier single installation result recorded in ADR 355 predates this
+admission boundary. Its frame count is not accepted as evidence of independent
+CSI coverage. It remains useful only as diagnosis of the failure mode and must
+not be promoted as a production bootstrap prior.
+
+## Decision
+
+1. Only a packet on the frozen, model specific CSI grid may advance field
+   calibration. Edge vital packets update their own health and presentation
+   state but never feed the field model. The independent live inference grid
+   remains unchanged.
+2. Each calibration session stores the last admitted wrapping sequence for
+   every contributing node. Duplicate sequences are ignored. Normal forward
+   progress and the `u32::MAX` to zero wrap are accepted.
+3. A packet one through sixteen sequence values behind the current high water mark
+   is bounded UDP reordering. It is recorded and dropped without feeding the
+   model or moving the high water mark. A backward depth above sixteen, or an
+   ambiguous half range sequence, latches that node as faulted for the remainder
+   of the session. Status exposes the policy, reorder window, per node reorder
+   count, maximum observed depth, and `sequence_fault_node_ids`. Finalization
+   returns `calibration_sequence_discontinuity` after a fault. The operator must
+   cancel and restart the empty room capture.
+4. A requested source may start calibration only after a header only, bounded
+   observation window identifies one stable grid. The selected grid needs at
+   least ten seconds of evidence, a measured rate of at least 2 Hz, a latest
+   sample newer than five seconds, and no observed gap of five seconds or more.
+   Calibration status reports the immutable grid, selection evidence, current
+   grid age, and `last_sequence_by_node` without exposing CSI values.
+5. Start, cancel, reset, and process initialization clear sequence admission
+   state. A failed feed does not advance the sequence cursor, so the same
+   packet may be retried after a transient model input failure.
+6. The field bridge receives the current amplitude slice rather than a cloned
+   history. A separate bounded runtime history retains only that same frozen
+   grid, so the model is never trained on one symbol layout and evaluated on a
+   different layout. Canonical grid normalization remains unchanged.
+7. The exact source grid is stored inside the digest protected bootstrap v2
+   payload. A restored model rebuilds only its matching runtime history. An
+   unbound legacy image cannot become an active startup prior.
+8. Successful finalization clears the selected grid runtime history. Bootstrap
+   promotion waits up to 35 seconds for a complete fresh runtime window before
+   scoring twelve additional samples. This covers a 50 frame window at the 2 Hz
+   admission floor plus ten seconds of bounded jitter. Calibration observations
+   therefore cannot enter the held out decision window.
+9. Stop and promotion require the frozen grid to remain fresh and reject any
+   latched sequence fault immediately before persistence. Bootstrap v2 accepts
+   exactly one source node because the current runtime supports one grid bound
+   field model.
+10. The legacy `--calibrate` startup switch fails closed before opening ports.
+    Grid evidence does not exist at process start, so operators start the server,
+    wait ten seconds, then call the explicit single source calibration API.
+
+## Consequences
+
+Calibration frame count now means unique, forward raw CSI observations within
+one uninterrupted sequence epoch. A vitals only node cannot produce a
+bootstrap model. Late packets never become calibration evidence.
+
+One physical Node 5 capture observed sequence 4,119,566 followed by 4,119,563,
+4,119,564, and 4,119,565 in one receive batch. A second independent 90 second
+capture observed bounded late packets at depths 9, 10, and 11. The window of
+sixteen covers the measured maximum with five positions of margin. At the
+firmware acceptance ceiling of 50 Hz, the window represents no more than 320
+milliseconds. Late packets are always dropped. Larger regressions remain
+failed closed.
+
+The same 90 second capture measured three interleaved HT grids on Node 5. The
+64 subcarrier stream delivered 436 frames at 4.84 Hz with a 1.56 second maximum
+gap. The 128 stream delivered 100 frames at 1.11 Hz with a 5.05 second maximum
+gap. The 192 stream delivered 49 frames at 0.54 Hz with an 11.53 second maximum
+gap. Only the 64 grid exceeded the 2 Hz admission floor and stayed inside the
+five second freshness boundary, so the final field model binds to that grid.
+
+The current wire format still has no authenticated boot epoch or stable device
+identity. A restart very early in a session or a same endpoint adversary cannot
+be distinguished cryptographically. A future ADR 018 revision must carry an
+authenticated device identifier and a random per boot identifier before the
+server claims exact restart or identity collision detection.
+
+No new raw CSI is persisted. Sequence cursors and fault markers remain bounded
+in memory to active calibration sources. The bootstrap schema advances to v2
+to protect the grid identity while its negative only authority remains
+unchanged.
+
+## Implementation
+
+1. `NodeState` records header only recent grid evidence and a separate bounded
+   field model history.
+2. `AppStateInner::maybe_feed_calibration_frame` owns source binding, sequence
+   ordering, fault latching, model feed, and cursor commit.
+3. `field_bridge::maybe_feed_calibration` accepts exactly one current amplitude
+   slice and rejects an empty observation.
+4. Calibration start, status, stop, cancel, reset, promotion, refinement, and
+   restart enforce the frozen source and grid contract.
+5. `bootstrap_baseline` persists the source grid inside the verified v2 image.
+6. Finalization clears training history, and promotion blocks until the model
+   has a complete fresh scoring window plus twelve separately spaced samples.
+7. Startup calibration without measured grid evidence exits with a typed
+   operator instruction instead of creating a model that can never receive a
+   frame.
+
+## Acceptance test
+
+Unit tests must prove stable grid selection, rate and gap rejection, first
+packet acceptance, forward progress, duplicate rejection, source and grid
+isolation, maximum counter wrap, empty input retry, measured depth eleven
+reordering without a model feed, depth sixteen acceptance, depth seventeen
+latching, half range rejection, session clear, receipt visibility, protected
+grid persistence, and typed stop refusal.
+Tests must also prove startup flag refusal, missing and stale grid refusal,
+complete holdout isolation, and sequence fault rejection during holdout.
+
+On physical hardware, begin a Node 5 empty room capture and observe a fresh
+sixty second interval. Calibration frame growth must match unique 64 subcarrier
+Node 5 sequences while the independent global inference grid remains unchanged.
+Edge vital packets and other grids must produce zero growth. The bound grid
+must remain active, sequence faults must remain empty, and numeric vital output
+must remain absent. Any bounded late packet must appear in the reorder receipts
+while leaving the model count unchanged. Complete both the 1,000 frame and 600
+second gates, then run the twelve sample server controlled bootstrap holdout.
+Restart and prove that only the persisted grid rebuilds the runtime history.
+Do not claim human detection improvement until a separate consented occupied
+holdout demonstrates retained recall.
@@ -0,0 +1,110 @@
+# ADR-361: Point the whole fleet at one transmitter, to remove selection ambiguity
+
+**Status:** Proposed — built, deployed fleet-wide, A-B-A measured. **Hypothesis CONFIRMED, adoption NOT justified.** The pairing *fraction* rises sharply; paired observations per second fall.
+**Date:** 2026-09-09
+**Follows:** ADR-358 (falsified), ADR-359 (mechanism confirmed, not adopted), ADR-360 (falsified).
+
+## The hypothesis, recorded long before it could be tested
+
+From `docs/BACKLOG.md`, "Next: the actual pairing constraint":
+
+> Two nodes can therefore fire in the same aligned window and still pick frames
+> from *different* transmitters, which can never pair under the
+> `(tx_mac, rx_seq)` key. Cheapest test and likely fix: **point the whole fleet
+> at one strong transmitter with the existing ADR-060 MAC filter.**
+
+It had never been run, and the reason was mechanical rather than scientific:
+**`filter_mac` was writable only by `provision.py` over USB.** It is a 6-byte
+blob, absent from the `cfg_key_t` scalar table the config API validates
+against, so the test would have required nine physical visits. Exposing it over
+the network (see the firmware change accompanying this ADR) reduced the whole
+experiment to two config pushes.
+
+## What was measured
+
+The associated AP was chosen on measurement, not assumption. Five transmitters
+reach all nine receivers; only one carries a usable rate:
+
+```
+transmitter            n_rx  total_fps  mean_rssi
+8c:30:66:86:a4:21        9      109.81     -66.6   <- the AP, 26x the next
+96:30:66:86:a4:21        9        4.24     -65.9
+08:36:c9:71:ff:52        9        0.18     -75.9
+64:16:66:cb:17:07        9        0.08     -81.7
+10:a5:62:24:bb:30        9        0.06     -78.2
+```
+
+A-B-A, ten 30 s windows per arm. `/api/v1/fusion` counters are cumulative since
+sink start, so they are **differenced over each window** and never divided as
+lifetime totals — the trap already recorded for `early_drop`/`csi_fps_samples`.
+The filter applied live on all nine nodes with **no restart**, so no reboot
+confounds any arm.
+
+```
+arm            n   paired_fraction        tx/s    paired/s
+A1 control    10   0.5668 +/- 0.0107      73.0     41.4
+B  filtered   10   0.7287 +/- 0.0352      33.9     24.7
+A2 control    10   0.5836 +/- 0.0120      81.5     47.6
+```
+
+**Pairing fraction +0.1535 against the pooled control (+26.7% relative),
+Welch t = 13.26, df = 10.5, p < 0.0001.** Reversible: A2 returned to control,
+0.0168 against A1.
+
+Per-node confirmation that the filter did what it claims, taken on node 3 while
+eight nodes were still unfiltered:
+
+```
+node 3 (filtered)   AP fps 13.56   non-AP fps 0.28   non-AP share  2.0%
+node 8 (control)    AP fps 12.18   non-AP fps 5.66   non-AP share 31.7%
+```
+
+The AP rate is untouched; peer traffic falls to residue.
+
+## The hypothesis is confirmed. The fix is not.
+
+Transmitter ambiguity **was** suppressing pairing, and removing it lifts the
+fraction by a quarter. That settles a question that had been open since
+2026-09-07 and had resisted three other experiments.
+
+But the backlog called this the "likely fix", and that half does not survive.
+It predicted yield would fall to ~13 fps and that "the frames that remain are
+pairable". Both are true, and neither is sufficient:
+
+- **tx/s fell 56%** (77.3 -> 33.9)
+- **paired observations per second fell 44%** (44.4 -> 24.7)
+
+A higher fraction of a much smaller pie. The quantity downstream sensing
+actually consumes is paired observations per second, and that went **down**.
+Fraction was the wrong figure of merit, and choosing it is what made this look
+like a fix rather than a diagnosis.
+
+## Decision
+
+**Do not adopt. Keep the branch unmerged.** Production stays unfiltered,
+`gate_mode=2`, `gate_seq_period=8`.
+
+`filter_mac` **is** kept in the config API. It costs nothing when unset, it is
+now the cheapest available probe for "is this node's pairing transmitter-
+limited?", and the ADR-060 filter had been effectively unreachable for the
+fleet's whole life.
+
+## What this opens
+
+A **partial** filter is the obvious next question and is NOT what was tested
+here. Restricting to a handful of widely-heard transmitters rather than exactly
+one would trade less yield for some of the gain, and there is no reason to think
+the optimum is at either extreme. The five 9-receiver transmitters above are the
+natural candidate set, though four of them carry almost no rate.
+
+That is a new experiment with a different independent variable, not a variant
+of this one. It should be sized on **paired observations per second**, which is
+the lesson this ADR paid for.
+
+## Honest scope
+
+Software-only. One house, one AP, nine nodes, ~15 minutes per arm, at 05:00
+local with the house quiet. The effect is far larger than the within-arm
+scatter and it reversed cleanly, but it has not been repeated across times of
+day, and pairing is known to move with the transmitter population (see
+"Transmitter population instability", 2026-09-02).
@@ -0,0 +1,69 @@
+# ADR-362: Reading the on-node log is on-demand, never streamed
+
+**Status:** Accepted
+**Date:** 2026-09-09
+**Follows:** the on-node log engine (persistent 128 B-record ring + coredump-to-flash)
+
+## Context
+
+The firmware now keeps a persistent log on the node's `storage` volume and can
+write a coredump to flash. Nothing reads either one. The log is a new concept
+in this tree, so there is no existing consumer to extend and the access
+pattern is genuinely open.
+
+Two shapes were considered:
+
+1. **Ingest** — the server polls every node on a schedule, drains new records,
+   and keeps its own copy that the UI reads.
+2. **On-demand** — the server fetches a node's log only when a human asks for
+   it, and keeps nothing.
+
+## Decision
+
+**On-demand only. No streaming, no periodic polling, no server-side copy, no
+alerting.**
+
+The log is pulled after a board hangs or crashes, or while troubleshooting a
+specific node. That is the whole access pattern.
+
+## Why
+
+- **The persistence already lives on the node.** The ring holds ~208 days at
+  128 B per 300 s, and surviving a power cycle is the entire reason the module
+  exists — a power cycle is how a wedged node gets recovered. A second copy on
+  the server duplicates a durability property that is already satisfied.
+- **Airtime is this fleet's binding constraint, and it is the thing being
+  diagnosed.** Two nodes uplinking at 1 Mbps were measured consuming 91% of
+  fleet airtime. A periodic log drain across nine nodes would spend exactly the
+  resource whose exhaustion is the most common thing you would open the log to
+  investigate. An instrument must not perturb what it measures.
+- **Coredumps are 64 KB.** They are only ever worth moving when something has
+  actually crashed.
+- **The use is diagnostic, not observational.** Nobody watches nine logs. You
+  open one node's history when that node misbehaves.
+
+## What this implies gets built
+
+- A server route that proxies to the node on request — `GET
+  /api/v1/nodes/{id}/log`, and the same for `/coredump` — authenticating with
+  the OTA PSK the firmware endpoints already sit behind.
+- A page under the existing Tools menu to view one node's records.
+- **No** scheduler, **no** new storage, **no** retention policy on the server.
+
+## Open question, deliberately not settled here
+
+Whether the server decodes the 128 B records into JSON, or proxies raw bytes
+and lets the decoder at the edge (browser, or `node_log_read.py`) interpret
+them.
+
+Decoding server-side means the record layout is defined in two places — C and
+Rust — and can drift silently. The pilot already paid for a version of this:
+a field whose sentinel the host had to learn to render as `n/a`, where a
+plausible wrong value would have been worse than an obvious gap. That argues
+for the raw proxy and a single definition of the format.
+
+## Non-goals
+
+Real-time monitoring, log streaming, fleet-wide log aggregation, and alerting
+on log contents are all explicitly out of scope. If a future need genuinely
+requires one of them, it should revisit this ADR rather than grow into it.
@@ -0,0 +1,93 @@
+# ADR 363: Native macOS USB node onboarding
+
+## Status
+
+Accepted and physically qualified with one attached ESP32 S3 and one attached
+ESP32 C6 through an unsigned Mac Catalyst development build. Signed
+distribution remains a release gate.
+
+## Context
+
+RuView operators currently provision ESP32 nodes with command line tooling.
+The macOS app can list server accepted node identities, but it cannot establish
+that an attached serial device is RuView firmware, assign a collision free node
+identity, preserve its WiFi configuration, or prove that it joined the sensing
+server. A UI that merely stores a friendly name would create false success.
+
+Generic shell access from the app would also expand authority beyond the task.
+Serial logs can contain operational data, and WiFi credentials must not enter
+application diagnostics or provisioning receipts.
+
+## Decision
+
+1. Firmware 0.8.12 provides a bounded line protocol over the physical USB serial
+   channel. A discovery request carries a random 128 bit nonce. The device
+   response binds that nonce to chip family, firmware version, current node
+   identity, private server target, configuration state, and a pseudonymous
+   64 bit device digest derived from the base MAC under a RuView domain.
+
+2. A configuration request is accepted only for the most recently issued
+   nonce within 60 seconds. The nonce is single use. Node identity is limited
+   to 1 through 255, the target is limited to RFC 1918 IPv4, and the target port
+   is limited to 1 through 65535.
+
+3. Existing WiFi configuration can be preserved. New credentials use strict
+   base64 framing, bounded lengths, and control character rejection. Firmware
+   commits NVS before acknowledging and rebooting. Credentials are never
+   returned, logged, or included in the receipt.
+
+4. The macOS client uses a native serial bridge. It allowlists exact character
+   device prefixes, configures the port directly, and does not invoke a shell,
+   Python, or an external process. It rechecks the device digest immediately
+   before configuration to reduce port substitution risk.
+
+5. The app suggests the lowest unused server node identity and the Mac private
+   LAN address. Success is shown only after the configured node appears in the
+   server inventory as active with evidence no older than three seconds.
+
+6. Old firmware is reported as requiring an update. The app must not claim it
+   provisioned a device based only on generic RuView serial logs.
+
+7. Automatic firmware flashing is outside this decision. Flashing requires an
+   exact chip and port check, a private backup, a matching image, and captured
+   boot evidence. Release publication remains a separate maintainer action.
+
+8. The device digest uses the PSA Crypto SHA 256 interface on ESP IDF 5.4 and
+   6.0. This keeps the stable domain separated identity while avoiding the
+   legacy Mbed TLS hash API removed by ESP IDF 6.
+
+9. ESP32 C6 mmWave UART defaults use GPIO 4 and GPIO 5. Startup rejects any
+   configured mmWave pin pair that overlaps the active console RX or TX pins.
+   This preserves the onboarding input path after a failed mmWave probe.
+
+## Security and privacy consequences
+
+The app gains Mac App Sandbox USB and serial device access, but not general file
+or shell authority. The protocol does not authenticate a device with a hardware
+root of trust; the digest is stable identification, not a cryptographic device
+certificate. Physical USB possession is therefore the trust boundary for this
+version. An authenticated fleet identity remains ADR 305 scope.
+
+The largest failure mode is a successful NVS write followed by failure to join
+the LAN. The user receives an explicit bounded verification failure instead of
+a success screen, while the board retains its committed settings and can be
+rescanned over USB.
+
+## Acceptance test
+
+Connect an ESP32 with firmware 0.8.12 to a Mac that is already receiving RuView
+nodes. Use only the macOS Add Sensor workflow to preserve WiFi, assign the
+lowest unused identity, and set the Mac private address. Pass when the UI
+reports the expected chip and firmware, the reassigned node remains fresh for
+five minutes, the stale collided identity expires, app restart preserves the
+profile, no server health, send, watchdog, panic, or reboot evidence appears,
+and no credential appears in app logs or the provisioning receipt.
+
+The 2026-08-31 physical run passed on an ESP32 S3. The measured witness is in
+`docs/validation/2026-08-31-macos-usb-node-onboarding.md`.
+
+The 2026-09-11 physical run passed on an ESP32 C6 over
+`cu.usbserial-3120`. The Mac app flashed the image, received the nonce bound
+hello receipt, preserved node identity 3, committed the server route, and
+verified fresh server evidence at minus 34 dBm. The run also exposed and fixed
+the GPIO 17 console RX conflict described above.
@@ -0,0 +1,96 @@
+# ADR-364: BFI capture admission and continuity
+
+- **Status**: proposed
+- **Date**: 2026-09-29
+- **Deciders**: RuView maintainers; acceptance pending
+- **Tags**: bfi, capture, evidence, continuity, hardware
+
+## Context
+
+The Archer BE550, associated iPhone and MT7927 capture host have produced
+readable beamforming feedback information (BFI). Monitor-mode support alone
+does not establish this capability, and readable reports do not establish
+continuous sensing. Router channel width also does not guarantee an identical
+feedback grid in every report.
+
+**MEASURED:** two saved trials contain 66 and 96 unique reports. During their
+approximately 30-second sender intervals, rates were 2.2 and 3.2 reports/s,
+with maximum silence of 8.392 and 6.437 seconds. No reports followed in the
+approximately 15-second post-traffic intervals. All 162 reports received an
+independent tshark angle/control/SNR comparison. Reproducer commands, capture
+hashes and limitations are in the [capture results](../../tools/bfi/OPTIMIZATION.md)
+and [continuity report](../../tools/bfi_learning/CAPTURE-CONTINUITY.md).
+
+## Decision
+
+Admit a hardware/driver/profile combination only from its actual packet
+evidence. Apply these boundaries before using its output for sensing:
+
+1. Keep originals and receipts outside Git, with raw own-network captures on
+   the capture host. Record hardware, driver, channel, source hashes, capture
+   interval and restoration outcome. Select the authorized AP/client direction
+   explicitly; missing provenance cannot be inferred from an SSID.
+2. Enforce container, radiotap, MAC, length, fragmentation and supported-format
+   checks in [bfi_decode.py](../../tools/bfi/bfi_decode.py). Validate FCS when
+   present and reject flagged corruption; absent FCS is a recorded limitation.
+   Unsupported tuples remain counted rejections. Compare every admitted angle
+   against an independent dissector before extending a format's support claim.
+3. Deduplicate retries over the whole capture before slicing time intervals.
+   Preserve integer timestamps and separate feedback grids. Sequence numbers
+   and sounding tokens do not measure lost packets. BFI steering matrices are
+   not full CSI; the identity product of a square unitary matrix with its
+   conjugate transpose cannot serve as a changing channel feature.
+4. Preserve full-observation quality metrics and add separate before-traffic,
+   sender-interval and after-traffic metrics. Include leading/trailing silence,
+   report rate, maximum gap and duration-weighted occupied one-second bins.
+   Sender timestamps bound attempted UDP sends, not verified over-air sounding.
+5. Use an initial continuity gate of reports in at least 27 of the first 30
+   complete one-second sender bins and no silence longer than two seconds
+   anywhere in the actual sender interval, repeated in three comparable trials.
+   Report any partial final bin separately; never count it as a complete second.
+   This is a project engineering gate, not a published sensing accuracy result.
+
+The current traffic receipt lacks a PCAP hash and AP/client binding. The
+analyzer checks caller-selected file associations and hashes all inputs in its
+output; this establishes content integrity, not authenticated session binding.
+Stronger binding is required before automated capture admission can treat
+receipt association as independently verified.
+
+## Alternatives
+
+Monitor-mode declarations, average report rate alone and interpolating missing
+reports would each hide a different failure. Retain explicit packet validation
+and interval coverage instead. ESP32/Realtek CSI remains a separate modality;
+multiple unsynchronized boards do not establish a coherent BFI array.
+
+## Consequences
+
+### Positive
+
+Packet validity, capture continuity and sensing accuracy have separate,
+reproducible acceptance criteria. Changes in denominators cannot appear as RF
+performance gains.
+
+### Negative
+
+Strict format and continuity gates can exclude usable but sparse observations.
+New PHY formats and hardware require additional captures and independent checks.
+
+### Neutral
+
+The current trials fail continuity. Further motion modeling requires a new
+capture result; this ADR does not authorize hardware changes or establish
+identity recognition.
+
+## Validation and links
+
+Run `python -B -m unittest discover -s tools/bfi -v` and the focused
+`test_traffic_coverage.py` suite under `tools/bfi_learning`. Synthetic tests
+check parsing and interval rules; acceptance additionally requires retained
+real captures and the three successful trials above.
+
+- Extends proposed [ADR-118](ADR-118-bfld-beamforming-feedback-layer-for-detection.md)
+  and [ADR-123](ADR-123-bfld-capture-path-nexmon-and-esp32.md); neither is superseded.
+- Preserves [ADR-120](ADR-120-bfld-privacy-class-and-hash-rotation.md)'s privacy boundary.
+- Public-data admission has a separate contract in
+  [ADR-365](ADR-365-public-bfi-dataset-and-decoder-contract.md).