feat: add multi-actor PoseCode scene crate

Published 0.3.4 predates HardwareNormalizer::resample_to_canonical and
MultistaticConfig::for_tdm_schedule, which the sensing-server binary
uses — its publish verify fails against the registry 0.3.4. The in-repo
version had not been bumped since those APIs landed.

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

.github/workflows/ci.yml

@@ -9,7 +9,7 @@ on:
 
 env:
   PYTHON_VERSION: '3.11'
-  NODE_VERSION: '18'
+  NODE_VERSION: '20' # ADR-265: all Node packages in this repo declare engines >= 20
   REGISTRY: ghcr.io
   IMAGE_NAME: ${{ github.repository }}
 

.github/workflows/npm-packages.yml

@@ -0,0 +1,148 @@
+# ADR-265 D1 — the npm-package gate.
+#
+# Every Node package in this repo (published or private) gets: install, build,
+# tests, a version-literal gate (D3 — package.json is the only place a version
+# lives), a pack-content gate (no source maps, unpacked-size budget), a
+# tarball-install smoke test (would have caught ADR-264 F1's broken `require`
+# export), and the claim-check honesty lint on the README (D4).
+
+name: npm packages
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'harness/ruview/**'
+      - 'tools/ruview-mcp/**'
+      - 'tools/ruview-cli/**'
+      - '.github/workflows/npm-packages.yml'
+  pull_request:
+    paths:
+      - 'harness/ruview/**'
+      - 'tools/ruview-mcp/**'
+      - 'tools/ruview-cli/**'
+      - '.github/workflows/npm-packages.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  gate:
+    name: ${{ matrix.package.dir }} (node ${{ matrix.node }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node: ['20', '22']
+        package:
+          - dir: harness/ruview
+            build: false
+            publishable: true
+            # ADR-263: dependency-free harness; budget guards against dep creep.
+            unpacked_budget: 65536
+          - dir: tools/ruview-mcp
+            build: true
+            publishable: true
+            # ADR-264 O2: map-free tarball (was 188 kB with maps).
+            unpacked_budget: 140000
+          - dir: tools/ruview-cli
+            build: true
+            publishable: false
+            unpacked_budget: 0
+    defaults:
+      run:
+        working-directory: ${{ matrix.package.dir }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+
+      # Repo policy gitignores lockfiles under harness/ (the harness is
+      # dependency-free anyway); the TS packages commit theirs.
+      - name: Install
+        run: |
+          if [ -f package-lock.json ]; then npm ci; else npm install --no-fund --no-audit; fi
+
+      - name: Build
+        if: ${{ matrix.package.build }}
+        run: npm run build
+
+      - name: Test
+        run: npm test --if-present
+
+      # ADR-265 D3 — package.json is the only place a version string lives.
+      - name: Version-literal gate
+        run: |
+          set -euo pipefail
+          hits=""
+          for d in src bin; do
+            if [ -d "$d" ]; then
+              hits+=$(grep -rEn '\b[0-9]+\.[0-9]+\.[0-9]+\b' "$d" | grep -vE '127\.0\.0\.1|0\.0\.0\.0' || true)
+            fi
+          done
+          if [ -n "$hits" ]; then
+            echo "Hardcoded version-like literals found (read package.json instead — ADR-265 D3):"
+            echo "$hits"
+            exit 1
+          fi
+
+      # ADR-265 D1.3 — pack-content gate: no maps, size budget enforced.
+      - name: Pack gate
+        if: ${{ matrix.package.publishable }}
+        run: |
+          npm pack --dry-run --json 2>/dev/null | node -e "
+            const [info] = JSON.parse(require('fs').readFileSync(0, 'utf8'));
+            const budget = Number(process.env.UNPACKED_BUDGET);
+            const maps = info.files.filter((f) => f.path.endsWith('.map'));
+            if (maps.length > 0) {
+              console.error('Tarball contains source maps (ADR-264 F2):', maps.map((m) => m.path));
+              process.exit(1);
+            }
+            if (info.unpackedSize > budget) {
+              console.error(\`Unpacked size \${info.unpackedSize} B exceeds budget \${budget} B\`);
+              process.exit(1);
+            }
+            console.log(\`pack gate OK: \${info.files.length} files, \${info.unpackedSize} B unpacked (budget \${budget} B), 0 maps\`);
+          "
+        env:
+          UNPACKED_BUDGET: ${{ matrix.package.unpacked_budget }}
+
+      # ADR-265 D1.4 — install the real tarball and drive each bin/export.
+      - name: Tarball smoke test
+        if: ${{ matrix.package.publishable }}
+        run: |
+          set -euo pipefail
+          TGZ="$PWD/$(npm pack --silent 2>/dev/null | tail -1)"
+          SMOKE="$(mktemp -d)"
+          cd "$SMOKE"
+          npm init -y > /dev/null
+          npm i --no-fund --no-audit "$TGZ"
+          case "${{ matrix.package.dir }}" in
+            harness/ruview)
+              ./node_modules/.bin/ruview --version
+              ./node_modules/.bin/ruview doctor
+              # the honesty gate must fail closed on empty input (ADR-263 F1)
+              if ./node_modules/.bin/ruview 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);"
+              ;;
+            tools/ruview-mcp)
+              # initialize over stdio; server must answer and exit 0 on EOF
+              printf '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"ci","version":"0"}}}\n' \
+                | timeout 30 ./node_modules/.bin/rvagent | grep -q '"serverInfo"'
+              # the ESM export must resolve from the installed tarball (ADR-264 F1)
+              timeout 30 node --input-type=module -e "await import('@ruvnet/rvagent');" < /dev/null
+              ;;
+          esac
+
+      # ADR-265 D4 — package READMEs must pass the project's own honesty lint.
+      - name: Claim-check README
+        run: |
+          if [ -f README.md ]; then
+            node "$GITHUB_WORKSPACE/harness/ruview/bin/cli.js" claim-check --file README.md
+          else
+            echo "no README.md — skipping"
+          fi

.github/workflows/ruview-npm-release.yml

@@ -0,0 +1,137 @@
+# ADR-265 D2 — publish only from CI, with provenance.
+#
+# Manual `npm publish` from laptops stops: this workflow re-runs the ADR-265 D1
+# gate for the selected package and then publishes with npm provenance
+# attestations (OIDC), tying every published version to a public commit +
+# workflow run — the npm-side analogue of the ADR-028 witness bundle.
+#
+# Requires: NPM_TOKEN repo secret (an npm automation token), or npm Trusted
+# Publishing configured for the package (in which case the token is unused).
+
+name: ruview npm release
+
+on:
+  workflow_dispatch:
+    inputs:
+      package:
+        description: 'Package directory to publish'
+        required: true
+        type: choice
+        options:
+          - harness/ruview
+          - tools/ruview-mcp
+      dist_tag:
+        description: 'npm dist-tag'
+        required: false
+        default: 'latest'
+        type: string
+
+permissions:
+  contents: read
+  id-token: write # npm --provenance
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ${{ inputs.package }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install
+        run: |
+          if [ -f package-lock.json ]; then npm ci; else npm install --no-fund --no-audit; fi
+
+      - name: Build (if present)
+        run: npm run build --if-present
+
+      - name: Test
+        run: npm test --if-present
+
+      # ADR-265 D3 — package.json is the only place a version string lives.
+      - name: Version-literal gate
+        run: |
+          set -euo pipefail
+          hits=""
+          for d in src bin; do
+            if [ -d "$d" ]; then
+              hits+=$(grep -rEn '\b[0-9]+\.[0-9]+\.[0-9]+\b' "$d" | grep -vE '127\.0\.0\.1|0\.0\.0\.0' || true)
+            fi
+          done
+          if [ -n "$hits" ]; then
+            echo "Hardcoded version-like literals found (read package.json instead — ADR-265 D3):"
+            echo "$hits"
+            exit 1
+          fi
+
+      # ADR-265 D1.3 — pack-content gate: no maps AND the per-package
+      # unpacked-size budget (the budgets that npm-packages.yml enforces).
+      - name: Pack gate (no maps + size budget)
+        run: |
+          set -euo pipefail
+          case "${{ inputs.package }}" in
+            # ADR-263: dependency-free harness; budget guards against dep creep.
+            harness/ruview) export UNPACKED_BUDGET=65536 ;;
+            # ADR-264 O2: map-free tarball (was 188 kB with maps).
+            tools/ruview-mcp) export UNPACKED_BUDGET=140000 ;;
+            *) echo "Unknown package '${{ inputs.package }}' — no budget defined"; exit 1 ;;
+          esac
+          npm pack --dry-run --json 2>/dev/null | node -e "
+            const [info] = JSON.parse(require('fs').readFileSync(0, 'utf8'));
+            const budget = Number(process.env.UNPACKED_BUDGET);
+            const maps = info.files.filter((f) => f.path.endsWith('.map'));
+            if (maps.length > 0) {
+              console.error('Tarball contains source maps (ADR-264 F2):', maps.map((m) => m.path));
+              process.exit(1);
+            }
+            if (info.unpackedSize > budget) {
+              console.error(\`Unpacked size \${info.unpackedSize} B exceeds budget \${budget} B\`);
+              process.exit(1);
+            }
+            console.log(\`pack gate OK: \${info.files.length} files, \${info.unpackedSize} B unpacked (budget \${budget} B), 0 maps\`);
+          "
+
+      # ADR-265 D1.4 — install the real tarball and drive each bin/export.
+      - name: Tarball smoke test
+        run: |
+          set -euo pipefail
+          TGZ="$PWD/$(npm pack --silent 2>/dev/null | tail -1)"
+          SMOKE="$(mktemp -d)"
+          cd "$SMOKE"
+          npm init -y > /dev/null
+          npm i --no-fund --no-audit "$TGZ"
+          case "${{ inputs.package }}" in
+            harness/ruview)
+              ./node_modules/.bin/ruview --version
+              ./node_modules/.bin/ruview doctor
+              # the honesty gate must fail closed on empty input (ADR-263 F1)
+              if ./node_modules/.bin/ruview 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);"
+              ;;
+            tools/ruview-mcp)
+              # initialize over stdio; server must answer and exit 0 on EOF
+              printf '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"ci","version":"0"}}}\n' \
+                | timeout 30 ./node_modules/.bin/rvagent | grep -q '"serverInfo"'
+              # the ESM export must resolve from the installed tarball (ADR-264 F1)
+              timeout 30 node --input-type=module -e "await import('@ruvnet/rvagent');" < /dev/null
+              ;;
+          esac
+
+      - name: Claim-check README
+        run: |
+          if [ -f README.md ]; then
+            node "$GITHUB_WORKSPACE/harness/ruview/bin/cli.js" claim-check --file README.md
+          fi
+
+      - name: Publish (with provenance)
+        run: npm publish --provenance --access public --tag "${{ inputs.dist_tag }}"
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

CHANGELOG.md

@@ -7,7 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- **Multi-actor PoseCode scene crate (`wifi-densepose-posecode`, ADR-266).** Adds a deterministic Rust scene model for multiple persistent RuView actors, synchronized poses, inter-person contacts, confidence and observation provenance. Includes a bounded line parser, canonical serializer, direct `PoseTrack` adapter, confidence-aware phase segmentation, provenance-sensitive range validation, 14 feature-enabled unit tests and Criterion parser/serializer benchmarks. Raw 20 Hz observations remain separate from semantic phases; observed range anomalies are warnings rather than medical safety claims. MEASURED on the implementation container: two-actor parse 3.40 µs, serialization 3.29 µs.
+
+### Changed
+- **`@ruvnet/rvagent` startup optimization — stdio time-to-first-response ~242 ms → ~189 ms (−22%; MEASURED, median of repeated `initialize` round-trips against `dist/index.js`, this container, reproduce with a piped-stdin timer).** Two changes: (1) `./http-transport.js` is now imported **lazily** inside the `RVAGENT_HTTP_PORT` branch — it chain-loads the MCP SDK's `streamableHttp` module (~48 ms MEASURED via per-module `import()` timing), which the default stdio path never uses; (2) the advertised JSON Schemas generated from the Zod sources are memoized per tool instead of re-walking the Zod tree on every `tools/list` (matters under the session-per-server HTTP model where each session lists tools). No behavior change: 99/99 jest tests, HTTP session flow re-smoke-tested through the lazy path. The `@ruvnet/ruview` harness CLI was profiled too and left alone — 50 ms vs the ~29 ms bare `node -e ''` floor on the same box (MEASURED), i.e. already near the interpreter floor with zero dependencies.
+
 ### Fixed
+- **EngineBridge now honors `WDP_GUARD_INTERVAL_US`/`WDP_SOFT_GUARD_US`/`WDP_TDM_SLOTS`+`WDP_TDM_SLOT_US`** (#1309, PR #1312, @erichkusuki). The governed trust path previously built its multistatic fuser from a hardcoded `MultistaticConfig::default()` (60 ms guard), so multi-node deployments with WiFi/ESP-NOW time sync (10–150 ms drift) failed every governed cycle regardless of configuration — while the startup log claimed the override took effect. New `StreamingEngine::set_multistatic_config()`; `EngineBridge::new()` takes an `Option<MultistaticConfig>` threaded from the same env-derived config as `AppState.multistatic_fuser`. Hardware-verified on a live 2-node ESP32-S3 setup (90 s window, 0 fusion errors; previously every cycle failed).
+- **`/api/v1/stream/pose` WebSocket reachable with `RUVIEW_API_TOKEN` set + dashboard bearer-token field** (#1310, PR #1313, @erichkusuki). Browsers cannot attach an `Authorization` header to a WS upgrade, so the Live Demo pose stream always failed when auth was on; the path is now on a narrow exact-match exemption list (mirrors `/ws/sensing`), with a regression test pinning that the exemption doesn't leak to other `/api/v1/*` paths. The QuickSettings panel gains an "API Access" field storing the bearer token in `localStorage`; the token is applied at `api.service.js` module load so the very first request carries it.
+- **Display-less DevKitC-1 boards: `sdkconfig.defaults.devkitc` build overlay** (#1308, PR #1311, @erichkusuki). The ADR-045 runtime display probe false-positives on stock ESP32-S3-DevKitC-1 (floating QSPI pins), which silently skipped the RuView#893 MGMT+DATA CSI upgrade and collapsed CSI yield to 0 pps. The overlay compiles display support out (`has_display` constant-false). Also fixes stale `espressif/idf:v5.2` README references to v5.4 (source requires `esp_driver_uart`, IDF ≥5.3). Hardware-verified on 2× DevKitC-1-N16R8 (0 → 40–45 pps).
+- **ADR-263/264/265 implemented — the RuView npm surface fixed end-to-end (`@ruvnet/ruview@0.2.0`, `@ruvnet/rvagent@0.2.0`, `@ruv/ruview-cli`).** Harness (ADR-263 O1–O9): `claim-check` now **fails closed** on empty input (CLI exit 2 + `empty_text` tool error); the MCP stdio server dispatches `tools/call` asynchronously over promise-based `spawn` — `ping` answers while a long `verify`/`calibrate` runs (pinned by a new e2e test that runs a 3 s fake proof and asserts sub-second ping); the two `optionalDependencies` are gone so a cold `npx` installs exactly 1 package (MEASURED: was 4 packages / 620 kB / 71 files, `npm i` in a clean prefix); child output is captured as bounded rolling tails (no more 1 MiB `maxBuffer` kills); `node_monitor` passes the port via `sys.argv` instead of splicing it into `python -c` source; the MCP `serverInfo.version` reads package.json; `.claude/skills/*/SKILL.md` are generated from `skills/*.md` by a `prepack` sync script (byte-equality pinned by test); `which()` is a memoized dep-free PATH scan; tools are underscore-canonical (`ruview_claim_check`, …) with the dotted names accepted as call-time aliases, plus `resources/list`/`prompts/list` stubs; the guardrail's `METRIC_TERMS` matching is precision-fixed (word-boundary `map`/`f1`/`auc`/`iou`, code-span + label scrubbing, quantitative-claims-only) — ADR-263/264/265 and both package READMEs now PASS `claim-check` while real untagged claims still flag. 30/30 tests (MEASURED, `node --test`). rvagent (ADR-264 O1–O9): `exports` fixed (types-first, the never-built `dist/index.cjs` `require` target removed — verified broken in the published 0.1.0 tarball); tarball is map-free (127,704 B unpacked / 46 files / 0 maps — MEASURED, `npm pack --dry-run`, down from 188 kB with 44 maps); the Streamable HTTP transport is **actually wired** behind `RVAGENT_HTTP_PORT` with one transport + one MCP server per session (`mcp-session-id` routing), a 1 MiB body cap (413), and a port-aware localhost origin gate — the "dual-transport" description is now true; tools renamed to underscore-canonical with dotted router aliases; ONE Zod validation gate per call with the advertised JSON Schema generated from the same Zod source (`zod-to-json-schema`); `train_count` closes its log fds (was leaking 2/job) and persists job records to `<jobsDir>/<id>.json` so `job_status` survives restarts, with bounded log-tail reads; `detectCogBinary` actually probes its candidate paths; version reads package.json; `@types/express` dropped, `@types/jest` aligned to jest 29; README rewritten to match reality (no phantom `stdio`/`http`/`policy grant` subcommands; unimplemented ADR-124 catalog tools labeled roadmap). 99/99 jest tests (MEASURED); stdio handshake + HTTP session flow + 403/400/404/413 gates smoke-tested live. CLI: bin renamed `ruview-cli` (the `ruview` bin belongs to `@ruvnet/ruview`, ADR-265 D4), version single-sourced. Distribution (ADR-265 D1–D4): new `npm-packages.yml` (3-package × Node 20/22 matrix: tests, version-literal grep gate, pack-content/size gate, tarball-install smoke test incl. the fail-closed claim-check and an ESM-import probe that would have caught the broken `require` export, README claim-check) and `ruview-npm-release.yml` (publish from CI only, `npm publish --provenance`); `ci.yml` NODE_VERSION 18→20.
+- **Multistatic fusion never ran on a mixed-mode ESP32 mesh — live bridge fed raw, un-canonicalized per-node CSI to the fuser (#1170).** `node_frame_from_state` (`multistatic_bridge.rs`) wrapped each node's **raw** amplitude vector (HT20 ≈ 64 bins, HT40 ≈ 128/192) into a struct *named* `CanonicalCsiFrame` without ever resampling, so `MultistaticFuser::fuse` tripped `DimensionMismatch` on every cycle, silently fell back to per-node sum/dedup, and spun `total_engine_errors` unbounded. Added `HardwareNormalizer::resample_to_canonical` (resample-only, **no z-score** — preserves the amplitude scale the person-score's `variance/mean²` relies on) and run every node frame through it onto the canonical 56-tone grid before fusion. Heterogeneous meshes now fuse instead of erroring. Pinned by `heterogeneous_node_counts_canonicalize_and_fuse` (mixed 64/192 → fuses), `resample_to_canonical_is_length_only_no_zscore`, and an updated `test_node_frame_conversion`; the pre-existing `engine_bridge::observe_cycle_counts_engine_errors` was retargeted to force a `TimestampMismatch` (its old 56-vs-30 setup now canonicalizes cleanly). `wifi-densepose-signal` 501 / `wifi-densepose-sensing-server` 677 tests, 0 failed.
+- **`csi_fps_ema` reported the CSI frame rate 40–840× too high under bursty UDP delivery (#1180).** `update_csi_fps_ema` only rejected deltas `≤ 0` or `≥ 1 s`, so a 36 µs intra-burst arrival delta yielded `1/dt ≈ 27 kHz` straight into the EMA — the metric measured server arrival jitter, not the node's ~40 fps production rate. Added a `MIN_PLAUSIBLE_CSI_DT_SEC = 0.005` floor (derived from the firmware's 50 fps `CSI_MIN_SEND_INTERVAL_US` ceiling, ×4 slack) and made `observe_csi_frame_arrival` keep its anchor across sub-floor bursts so the next genuine inter-frame gap measures true cadence. Pinned by `subms_burst_delta_rejected`, `burst_interleaved_with_nominal_stays_in_band`, and `observe_csi_frame_arrival_ignores_subms_bursts`.
+- **`stream_sender` ENOMEM backoff starved low-rate control packets under a weak uplink (#1183, follow-up to #1135/#1159).** The global `s_backoff_until_us` gate (triggered by the 50 Hz CSI flood at weak RSSI) also suppressed the ≤48 B, ≤1 Hz `feature_state` / mesh `HEALTH` / sync packets that contribute negligible buffer pressure, so telemetry failed essentially every cycle. Added `stream_sender_send_priority()` — bypasses the backoff gate, reports ENOMEM quietly, and never extends/resets the global streak — and routed `feature_state`, HEALTH/anomaly (`rv_mesh_send`), and sync packets through it. Also fixed the misleading `"HEALTH sent"` log that printed unconditionally even when `rv_mesh_send` returned `ESP_FAIL` (now prints `sent`/`FAILED` from the actual return). Firmware builds clean (ESP-IDF v5.4).
 - **Multistatic fusion guard interval is now operator-configurable — fixes permanent trust demotion with WiFi-synced ESP32 nodes (#1049).** Two independently-clocked ESP32-S3 boards on ESP-NOW sync drift 10–150 ms (typ. ~70 ms) — the 100 ms beacon + WiFi-MAC jitter cannot hold them within the published 60 ms default guard, so the governed-trust cycle permanently demoted to `Restricted`, suppressed all pose output, and spun the error counter to 200k+ with **no escape hatch but a container restart**. Added a **direct `WDP_GUARD_INTERVAL_US` override** (+ optional `WDP_SOFT_GUARD_US`) to `multistatic_guard_config_from_env`, so a deployment can lift the hard guard past its measured spread (e.g. `WDP_GUARD_INTERVAL_US=200000`) without having to know its exact TDM schedule. Precedence is most-specific-wins: a direct override beats the existing `WDP_TDM_SLOTS`+`WDP_TDM_SLOT_US` schedule-derived guard, which beats the 60 ms/20 ms default; the override is applied on top of whichever base is selected, the soft band is always clamped strictly below the hard guard, and a malformed/zero value is ignored (falls back to the base rather than breaking fusion). The effective guard is now logged at startup. Pinned by 6 new tests (`multistatic_guard_config_tests`): direct-override-wins / beats-TDM-derived / soft-clamped-below-hard / lowering-hard-pulls-soft-down / malformed-or-zero-falls-back / default-when-unset. `wifi-densepose-sensing-server` bin tests **449 → 455**, 0 failed; Python proof VERDICT PASS, hash unchanged (off the signal proof path).
 
 ### Security
@@ -23,6 +36,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`homecore-recorder` security review (ADR-132 surfaces) — two real bounding fixes; SQL-injection & NaN-index dimensions confirmed clean with evidence.** Beyond-SOTA review of the HA-compat state recorder (DB persistence + history + ruvector semantic search), the crux being its DB-backed SQL-injection surface. **Findings + fixes:** (1) **Memory-DoS — unbounded `get_state_history`.** The history query carried no `LIMIT`, so a wide `[since, until]` window over a high-frequency entity (a per-second sensor ≈ 86k rows/day) would load an unbounded row set into a single in-memory `Vec`. Added a hard `LIMIT MAX_HISTORY_ROWS` (1,000,000 — generous enough never to truncate a realistic history graph, bounded enough to cap the worst case); the sibling search paths were already `k`-bounded. (2) **Disk-DoS / documented-but-missing `purge`.** The README + HA-compat table advertised `Recorder::purge(older_than)` as a capability, but **no such method existed** — i.e. no retention path at all → unbounded disk growth. Implemented a **transactional** `purge` that deletes `states` + `events` strictly **older than** the cutoff (**exclusive** boundary — idempotent, no off-by-one; a row at the cutoff instant is kept) and **garbage-collects** orphaned `state_attributes` blobs (a dedup-shared blob is dropped only once its last referencing state is gone); all three deletes run in one transaction so a mid-purge failure rolls back cleanly (no states-deleted-but-events-kept corruption). **Confirmed clean with evidence:** SQL injection — **every** query in `db.rs` uses bound `?` parameters (no `format!`/string-concat of user data into SQL); the lone `format!` builds the LIKE *pattern*, which is itself bound as a parameter with `ESCAPE '\\'` and metacharacter escaping. Pinned: a state value `'; DROP TABLE states; --` is stored/queried **literally** (table survives), and a `%`/`_` in a search query matches **literally**, not as a wildcard. NaN-index poisoning (the calibration/vitals/geo class) — **structurally impossible** here: embeddings are SHA-256 → `i32` → `f32` (an `i32` cast to `f32` is always finite, never NaN/Inf), with an all-zero-digest norm guard; probed empty-index search, empty-string query, and `k=0` — all return `Ok(0)`, **no panic**. Fail-closed write path — a removal event yields `Ok(None)`, semantic-index failure is logged not propagated (best-effort, never blocks the durable SQLite write), and `EntityId` parsing failures fall back rather than panic. **6 new pinning tests** (SQL-injection literal-storage, LIKE-metacharacter literalness, history `LIMIT`, purge exclusive-boundary, purge attribute-GC-keeps-shared, purge old-events): `homecore-recorder` **19 → 25** (`--no-default-features`) / **25 → 31** (`--features ruvector`), 0 failed; the purge-boundary test is a true pin (fails deleting 2 rows under an inclusive cutoff, passes deleting 1 under the exclusive cutoff). Behaviour otherwise unchanged; Python deterministic proof unchanged (recorder is off the signal proof path).
 
 ### Added
+- **ADR-263/264/265: deep review of the RuView npm surface (`@ruvnet/ruview`, `@ruvnet/rvagent`, `@ruv/ruview-cli`) with optimization strategies recorded as ADRs.** ADR-263 reviews the published `@ruvnet/ruview@0.1.0` harness: fail-open `claim-check` on empty input (HIGH), `spawnSync` head-of-line blocking of the MCP stdio server during long `verify`/`calibrate` runs (HIGH), optionalDependencies tripling the cold `npx` install for a code path that never uses them (MEASURED, `npm i` in a clean prefix: 4 packages / 620 kB / 71 files default vs 1 package / 172 kB / 22 files with `--omit=optional`), 1 MiB `maxBuffer` truncation risk, `python -c` port-interpolation surface in `node_monitor`, hardcoded MCP server version, duplicated skill payload — optimizations O1–O8. ADR-264 reviews `@ruvnet/rvagent@0.1.0` + the private CLI **against the published registry tarball**: `exports.require` → nonexistent `dist/index.cjs` (HIGH, every CJS consumer breaks), 44 dead source-map files = 62,698 B of the 188 kB unpacked payload pointing at unshipped `../src` (MEASURED), stdio-only server described as "dual-transport" (CLAIMED capability), mixed dot/underscore tool naming, double Zod validation + hand-duplicated advertised schemas, 2-fd leak per training job, unbounded request body in the unwired HTTP scaffold, dead `detectCogBinary` candidate list, `ruview` bin-name collision — optimizations O1–O9. ADR-265 adds the cross-cutting distribution layer: an `npm-packages.yml` CI matrix (tests + pack-content/size gate + tarball-install smoke test — none of the three packages currently has any CI, and `ci.yml` pins Node 18 against `engines >= 20`), publish-from-CI-only with `npm publish --provenance`, version single-sourcing from package.json, bin/namespace ownership (the `ruview` bin belongs to `@ruvnet/ruview`), and claim-check enforcement on package READMEs/descriptions. Docs only — no runtime code changed; the findings are the work orders for the follow-up PRs.
 - **ADR-131 §11–§12: HOMECORE-UI wired to a real backend — single-origin BFF gateway + production front-end (no mock in prod).** Implements the §11 wiring decision so the dashboard stops rendering fabricated data. **Front-end (DONE + verified under Node):** `api.js` rewritten so every data accessor is async and calls the §11.2 gateway routes; the in-browser mock is demoted to a **dev-only fixture** reachable only via `?demo=1`/`HOMECORE_UI_DEMO` (§2.2); all ten panels now `await` and render a **typed empty/error state** on upstream failure (no mock fallback in production) — 3 panels converted by hand, 7 via a parallel agent swarm. **New `homecore-server` BFF gateway (`src/gateway.rs`, compile-pending — no Rust toolchain in the authoring env):** promotes `homecore-server` to the single origin (§2.1); adds `/api/homecore/*` + `/api/cal/*` merged into `build_app`, with `reqwest` + CLI/env flags (`--calibration-url`/`--calibration-token`/`--apps-dir`/`--gateway-timeout-ms`). Real handlers: calibration **reverse-proxy** (W2), `GET /api/homecore/rooms` with the §11.3 **RoomState adapter** (`breathing`→`breathing_bpm`, `heartbeat`→`heart_bpm`, `None`→`null` preserving not-trained-vs-withheld, injected `anomaly.threshold`/`room_id`), **COG supervisor** over `/var/lib/cognitum/apps/` (W4), and **appliance metrics** from `/proc` + TCP service probes (W6); SEED-device/appliance routes (seeds/federation/witness/privacy/settings/automations/events-history/hailo/tokens — W3/W5) return a typed `503 upstream_unavailable` and the UI shows error states. **Tests:** front-end **5 files green** — import-graph, boot, render-smoke (22), interaction (3), and a **new prod-errors suite (13)** that runs with demo OFF + gateway unreachable and proves every panel renders an error state, never mock, never throws (it caught + fixed a real unhandled-rejection in the events automation builder). **Gateway compiled, tested, and run on Rust 1.89:** `cargo test -p homecore-server --no-default-features` = **12/12 pass** (6 gateway + 6 UI mount); the binary was **run live** — `GET /api/homecore/appliance` returns real `/proc` metrics + TCP service probes, unauth → `401`, `cogs` → `[]` (no apps dir), SEED-tier → typed `503`, and against a mock calibration upstream the `/api/cal/*` proxy passes through (`200`) and `GET /api/homecore/rooms` adapts `RoomState` to the UI shape (`breathing`→`breathing_bpm`, `heartbeat:null`→`heart_bpm:null`, injected `anomaly.threshold`/`room_id`). **Live testing caught + fixed a real bug** — a double-`v1` segment in the `/api/cal/*` proxy URL. **Remaining (intrinsic, not an env limit):** W3/W5/W6-Hailo/federation depend on services/hardware **not in this repo** (recorder/automation HTTP wrappers, real SEED nodes, Hailo stat source), so they return honest `503`s rather than fabricate data; W1/W2/W4/W6-appliance are functional now. ADR-131 §10/§12.1 updated with per-wave status.
 - **ADR-131: HOMECORE-UI — the complete operational dashboard for the two-tier Cognitum stack, served by `homecore-server` at `/homecore`.** A zero-dependency, no-build-step vanilla TS/JS + CSS frontend (the `rufield-viewer` "Axum + vanilla-JS" pattern) that extends the Cognitum Appliance shell as a first-class nav section (Framework | Guide | Cog Store | **HOMECORE** | Status). **Complete, not a scaffold** (per the ADR's revised §2/§7): all **10 panels** ship fully built and rendered — §4.1 System Dashboard (v0 Appliance health strip + SEED fleet grid + ESP32 summary + COG status row + event-bus sparkline), §4.2 SEED Detail (vector store / witness chain / 5 onboard sensors / reflex rules / cognitive-fragility / ingest packet-type), §4.3 SEED Fleet Map (Appliance→SEED→ESP32 hierarchy, ESP-NOW mesh, cross-SEED fusion badges, ADR-105 federation), §4.4 Entity & State Browser (domain-grouped, **live WebSocket `subscribe_events` patching — never polls**, first-class provenance badges, keyword filter, context-causality slide-over), §4.5 RoomState/Sensing (mixture-of-specialists), §4.6 COG Management + App Registry, §4.7 Calibration Wizard (5-step baseline→enroll→train→verify), §4.8 Event Bus + Automation builder, §4.9 Witness/Audit log (two-tier SHA-256 + Ed25519 timeline, privacy-mode banner, pagination, export), §4.10 Settings. **Design system is the exact production Cognitum palette** (`tokens.css` carries `--cyan #4ecdc4` … `--r 10px` verbatim, §3.1) so there is no visual seam with the Cog Store (§3.3 invariant). **§6 UX invariants enforced in code and pinned by tests:** tier-origin provenance is always-visible (never collapsed); `stale`/`vetoed` flags and the kNN fragility score are prominent (amber/red tint + banners, never grey-on-grey); a `null` specialist renders "Not trained / calibrate to enable" **visually distinct from** veto-`withheld` (rendered as explicitly withheld, never zero) **distinct from** an error; all IDs/hashes/endpoints/payloads use `--mono`; Hailo-sourced COGs (`arch: hailo10`) are visually distinguished from CPU-only (`arch: arm`). **Wiring:** `homecore-server` gains a `--ui-dir`/`HOMECORE_UI_DIR` flag and mounts the assets via `tower-http` `ServeDir` at `/homecore` alongside the unchanged HA-compat `/api` surface (new testable `build_app()`), with **5 Rust integration tests** (`#[cfg(test)] mod ui_tests`, `tower::oneshot`) asserting index / design tokens / all-10-panels are served, the API coexists, and an empty `--ui-dir` disables the mount. **JS test + benchmark suite (`ui/`, runs under plain `node`, no npm install): 24 checks / 0 failed** — an import/export graph verifier (15 modules consistent), a DOM-shim render-smoke that *executes every panel* (21 checks: ui helpers + mock contracts + all 10 panels render without throwing), and an interaction suite (3 checks: live WS state-patch, ws.js handshake/parse, calibration backend contract). **Benchmark:** total bundle **136.8 KB uncompressed across 18 files — ~37× smaller than HA's ~5 MB Lit bundle** (the ADR-126 §1.1 foil), slowest panel **1.5 ms/cold-render**. **Honest scope (§7.1):** the live HOMECORE REST API (`/api/config|states|services`) and the WebSocket `subscribe_events` feed are driven for real; panels whose backing service is **not** in this binary (SEED HTTPS API, calibration ADR-151, ADR-105 federation) render against a **contract-conformant mock layer flagged with a DEMO banner** and swap to live the moment those endpoints land — no mock data is ever presented as real. **Not verified in this environment:** the Rust crate was edited and the integration tests written but **not compiled/run here** (no Rust toolchain present); `cargo test -p homecore-server` + `cargo build` must be run on a Rust host before merge.
 - **ADR-175: int8 quantization of the WiFlow-STD "half" pose model — MEASURED fp32-vs-int8 accuracy/size trade-off (honest negative).** Sub-deliverable 8.2 of the benchmark/optimization milestone, and the reading of the SOTA brief's "one untested edge lever" (QAT-int8 on the 843,834-param half model that strictly dominates the published 2.23M model). A new committed script `v2/crates/wifi-densepose-train/scripts/quantize_half_int8.py` quantizes `half_best.pth` to int8 two ways and scores both with the **same** upstream `calculate_pck`/`calculate_mpjpe` that produced the fp32 sweep numbers, under **one locked normalization** (ADR-173 torso-diameter PCK — neck idx2→pelvis idx12, `use_torso_norm=True`, the standard MM-Fi/GraphPose-Fi convention), on the **same** seed-42 file-level 70/15/15 test split (52,560 NaN-free / 54,000 full windows). **MEASURED on ruvultra (RTX 5080, torch 2.11.0+cu128, fbgemm; clean test, torso-PCK):** fp32 = 96.62% PCK@20 / 99.47% PCK@50 / 0.008981 MPJPE / 3.351 MB (fp32-CPU reproduces fp32-GPU to 4 dp, so the int8 deltas are pure quantization, not CPU/GPU drift); **int8 static PTQ = 40.98% PCK@20 (−55.64 pp), 1.046 MB** — naive static QDQ **collapses** on this model (the brief's 2.23M "sweet spot" does NOT transfer to the 843k half model at the tight @20 threshold); **int8 QAT (3-epoch FX fake-quant fine-tune from half_best) = 67.48% PCK@20 (−29.15 pp) / 98.69% PCK@50 (−0.78 pp), 1.043 MB.** **Verdict (honest no):** int8 is **not a win** at the strict PCK@20 edge target — QAT recovers a large share of the PTQ collapse and is near-lossless at the loose PCK@50 (coarse localization survives int8, fine does not), but a **3.2× size win at −29 pp PCK@20** is a bad trade when the half model already fits edge flash at fp32 → **keep fp32/fp16 on the edge for now.** **Disclosed gap:** the QAT *fake-quant* val PCK@20 reached 83.45% but the *converted* int8 model scores 67.48% — a real ~16 pp `convert_fx` gap (fbgemm int8 kernels ≠ straight-through estimate, esp. the axial-attention einsum/softmax); we report the converted-int8 number, not the fake-quant proxy. **MEASURED:** every table number + the PTQ collapse + the QAT partial recovery + the conversion gap. **CLAIMED/not done:** ONNX/TFLite export, on-edge-SoC latency/energy (int8 measured on x86 fbgemm — size transfers, latency does NOT), mixed-precision keeping attention fp32, longer/better-tuned QAT. **Honest limitations:** single in-domain eval split (no cross-environment split), x86-int8 not edge-SoC-int8, lightly-tuned QAT. Additive only — no production Rust or signal-pipeline change; Python deterministic proof unchanged (`f8e76f21…46f7a`, bit-exact — off the signal proof path).

CLAUDE.md

@@ -14,6 +14,7 @@ Dual codebase: Python v1 (`v1/`) and Rust port (`v2/`).
 | `wifi-densepose-mat` | Mass Casualty Assessment Tool — disaster survivor detection |
 | `wifi-densepose-hardware` | ESP32 aggregator, TDM protocol, channel hopping firmware; `ieee80211bf/` 802.11bf forward-compat protocol model (ADR-153) |
 | `wifi-densepose-ruvector` | RuVector v2.0.4 integration + cross-viewpoint fusion (5 modules) |
+| `wifi-densepose-posecode` | ADR-266 multi-actor semantic motion scenes, PoseTrack adapter, bounded parser, confidence-aware phase segmentation |
 | `wifi-densepose-wasm` | WebAssembly bindings for browser deployment |
 | `wifi-densepose-cli` | CLI tool (`wifi-densepose` binary) — `calibrate`/`calibrate-serve`/`enroll`/`train-room`/`room-watch` + MAT (MAT gated behind the `mat` feature; build `--no-default-features` for the aarch64/appliance calibration binary) |
 | `wifi-densepose-calibration` | ADR-151 per-room calibration & specialist training — `baseline → enroll → extract → train` → bank of small specialists (presence/posture/breathing/heartbeat/restlessness/anomaly) + multistatic fusion; pure Rust, edge-deployable |
@@ -62,7 +63,7 @@ All 5 ruvector crates integrated in workspace:
 - `ruvector-attention` → `model.rs` (apply_spatial_attention) + `bvp.rs`
 
 ### Architecture Decisions
-43 ADRs in `docs/adr/` (ADR-001 through ADR-043). Key ones:
+182 ADRs in `docs/adr/` (numbered ADR-001 through ADR-265, with gaps). Key ones:
 - ADR-014: SOTA signal processing (Accepted)
 - ADR-015: MM-Fi + Wi-Pose training datasets (Accepted)
 - ADR-016: RuVector training pipeline integration (Accepted — complete)
@@ -77,6 +78,11 @@ All 5 ruvector crates integrated in workspace:
 - ADR-148: Drone swarm control system / `ruview-swarm` (In Progress)
 - ADR-152: WiFi-Pose SOTA 2026 intake — geometry conditioning, WiFlow-STD benchmark (measurement (a) complete: claims MEASURED-EQUIVALENT at ~96% PCK@20), MAE recipe (Proposed; §2.1–2.3, 2.6 implemented)
 - ADR-153: IEEE 802.11bf-2025 forward-compatibility protocol model (Accepted — amends ADR-152 §2.4)
+- ADR-182: `npx ruview` harness minted via MetaHarness (Accepted — P1+P2 shipped as `@ruvnet/ruview`)
+- ADR-263: `@ruvnet/ruview` npm harness deep review + optimization strategy (Proposed)
+- ADR-264: `@ruvnet/rvagent` MCP server + `@ruv/ruview-cli` deep review + optimization strategy (Proposed)
+- ADR-265: RuView npm distribution strategy — CI gate, provenance, version single-sourcing (Proposed)
+- ADR-266: Multi-actor PoseCode scenes from persistent RuView tracks (Accepted)
 
 ### Supported Hardware
 

Makefile

@@ -51,26 +51,26 @@ verify-audit:
 
 # ─── Rust Builds ─────────────────────────────────────────────
 build-rust:
-	cd rust-port/wifi-densepose-rs && cargo build --release
+	cd v2 && cargo build --release
 
 build-wasm:
-	cd rust-port/wifi-densepose-rs && wasm-pack build crates/wifi-densepose-wasm --target web --release
+	cd v2 && wasm-pack build crates/wifi-densepose-wasm --target web --release
 
 build-wasm-mat:
-	cd rust-port/wifi-densepose-rs && wasm-pack build crates/wifi-densepose-wasm --target web --release -- --features mat
+	cd v2 && wasm-pack build crates/wifi-densepose-wasm --target web --release -- --features mat
 
 test-rust:
-	cd rust-port/wifi-densepose-rs && cargo test --workspace
+	cd v2 && cargo test --workspace --no-default-features
 
 bench:
-	cd rust-port/wifi-densepose-rs && cargo bench --package wifi-densepose-signal
+	cd v2 && cargo bench --package wifi-densepose-signal
 
 # ─── Run ─────────────────────────────────────────────────────
 run-api:
-	uvicorn v1.src.api.main:app --host 0.0.0.0 --port 8000
+	uvicorn archive.v1.src.api.main:app --host 0.0.0.0 --port 8000
 
 run-api-dev:
-	uvicorn v1.src.api.main:app --host 0.0.0.0 --port 8000 --reload
+	uvicorn archive.v1.src.api.main:app --host 0.0.0.0 --port 8000 --reload
 
 run-viz:
 	python3 -m http.server 3000 --directory ui
@@ -81,7 +81,7 @@ run-docker:
 # ─── Clean ───────────────────────────────────────────────────
 clean:
 	rm -f .install.log
-	cd rust-port/wifi-densepose-rs && cargo clean 2>/dev/null || true
+	cd v2 && cargo clean 2>/dev/null || true
 
 # ─── Help ────────────────────────────────────────────────────
 help:

README.md

@@ -617,7 +617,8 @@ Verify the plugin structure: `bash plugins/ruview/scripts/smoke.sh`. Full detail
 | [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. |
-| [Architecture Decisions](docs/adr/README.md) | 96 ADRs — why each technical choice was made, organized by domain (hardware, signal processing, ML, platform, infrastructure) |
+| [Architecture Decisions](docs/adr/README.md) | 183 ADRs — why each technical choice was made, organized by domain (hardware, signal processing, ML, platform, infrastructure) |
+| [Multi-actor PoseCode](v2/crates/wifi-densepose-posecode/) | Rust scene protocol converting persistent RuView pose tracks into confidence-scored actors, synchronized motion phases, contacts and deterministic text. [ADR-266](docs/adr/ADR-266-multi-actor-posecode-scenes.md). |
 | [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. |
 | [Desktop App](v2/crates/wifi-densepose-desktop/README.md) | **WIP** — Tauri v2 desktop app for node management, OTA updates, WASM deployment, and mesh visualization |

docs/adr/ADR-263-ruview-npm-harness-deep-review.md

@@ -0,0 +1,191 @@
+# ADR-263: `@ruvnet/ruview` npm Harness — Deep Review + Optimization Strategy
+
+| Field | Value |
+|-------|-------|
+| **Status** | Accepted — **implemented** (O1–O9, `@ruvnet/ruview@0.2.0`): fail-closed `claim-check`, async MCP dispatch (ping answered mid-`verify`, pinned by e2e test), zero-dependency install, bounded output tails, argv-passed monitor port, package.json-sourced version, prepack skill sync, memoized `which()`, underscore-canonical tools with dotted aliases, word-boundary guardrail matching. 30/30 tests (MEASURED, `node --test test/*.test.mjs`); CI gate in ADR-265's `npm-packages.yml` |
+| **Date** | 2026-07-02 |
+| **Deciders** | ruv |
+| **Codename** | **RUVIEW-NPM-REVIEW-1** |
+| **Supersedes / amends** | none (records review of the ADR-182 P1+P2 artifact; feeds ADR-265 distribution strategy) |
+
+## Context
+
+ADR-182 minted and published **`@ruvnet/ruview@0.1.0`** (`harness/ruview/`) — the
+`npx ruview` operator harness: a dependency-free ESM CLI + minimal MCP stdio server
+exposing six `ruview.*` tools (onboard / claim_check / verify / node_monitor /
+calibrate / node_flash), five skill playbooks, and the executable
+MEASURED-vs-CLAIMED guardrail (`src/guardrails.js`). The package is live on npm
+(0.1.0, 49.5 kB unpacked / 21 files — MEASURED, `npm view @ruvnet/ruview` +
+`npm pack --dry-run`) and is the recommended MCP registration path
+(`npx -y @ruvnet/ruview mcp start` in the bundled `.claude/settings.json`).
+
+This ADR is the first dedicated deep review of that npm artifact: correctness,
+fail-open/fail-closed posture, performance (cold start + request handling),
+packaging hygiene, and security of the subprocess surface. All 17 bundled tests
+pass on Node 22 (MEASURED, `node --test test/*.test.mjs`, 17/17, ~108 ms).
+
+## Findings
+
+Severity reflects impact on the package's stated contract: *fail-closed operator
+tools + an honesty guardrail that must never fail open*.
+
+### F1 (HIGH, fail-open): `claim-check` passes silently on empty input
+
+`bin/cli.js` `claim-check` with **neither `--text` nor `--file`** sends
+`text: undefined` → `claimCheck(String(args.text ?? ''))` → `''` → `ok: true`,
+**exit 0**. A CI hook wired as `npx ruview claim-check --text "$BODY"` where
+`$BODY` expands empty therefore reports PASS. This is the single tool whose whole
+purpose is to fail closed; empty input must be an error, not a pass.
+Reproducer: `node bin/cli.js claim-check` → `{"ok": true}`, exit 0.
+
+### F2 (HIGH, head-of-line blocking): MCP server is fully synchronous
+
+`src/mcp-server.js` dispatches `tools/call` inside the readline `line` handler,
+and every heavyweight handler in `src/tools.js` uses **`spawnSync`**
+(`ruview.verify` up to 180 s, `ruview.calibrate` up to 300–600 s,
+`ruview.node_monitor` up to `seconds+10`). While one call runs, the event loop is
+blocked: `ping`, `tools/list`, and concurrent `tools/call` requests are not even
+read from stdin. Hosts that health-check with `ping` during a long `calibrate`
+will conclude the server is dead and kill it mid-run.
+
+### F3 (MEDIUM, cold start): optionalDependencies triple the `npx` install for a path that never uses them
+
+`package.json` declares `optionalDependencies` on `@metaharness/kernel` and
+`@metaharness/host-claude-code`. npm installs optional deps **by default**, so
+every cold `npx -y @ruvnet/ruview mcp start` fetches 3 extra packages (kernel +
+host + transitive `@ruvector/emergent-time`). MEASURED (npm 10.9.7, this
+container): default install = **4 packages, 620 kB, 71 files**; with
+`--omit=optional` = **1 package, 172 kB, 22 files**. The operator-tool and MCP
+paths never import these — only `doctor`/`install` do, and both already
+dynamic-import inside `try/catch` and degrade gracefully when absent
+(`kernel/host: not installed (ok…)`). The optional deps buy nothing on the hot
+path and cost 3 registry round-trips + ~450 kB on every cold start.
+
+### F4 (MEDIUM, silent truncation): `spawnSync` default `maxBuffer` (1 MiB)
+
+`run()` in `src/tools.js` never sets `maxBuffer`. `cargo run -p
+wifi-densepose-cli` (the `calibrate` fallback path) and a chatty `verify.py` can
+exceed 1 MiB of stdout, at which point the child is killed with `ENOBUFS` and the
+tool reports a spawn error that looks like a proof/calibration failure. The
+handlers only ever consume the last 8 kB/1.5 kB; buffering should be bounded but
+generous (e.g. `maxBuffer: 16 MiB`) or streamed with a tail ring.
+
+### F5 (MEDIUM, injection surface): `node_monitor` interpolates the port into Python source
+
+The handler builds a `python -c` script by string interpolation:
+`` `ser=serial.Serial(${JSON.stringify(port)},115200,…)` `` and
+`` `while time.time()-t<${dur}:` ``. `JSON.stringify` produces a *JavaScript*
+string literal; Python string-literal semantics differ at the edges (`\uXXXX` is
+shared, but e.g. JS emits raw U+2028/U+2029 unescaped pre-ES2019 rules aside, and
+any future non-JSON-safe field added the same way would be executable). `port`
+arrives from the MCP caller (an agent), so this is an agent-controlled string
+concatenated into an interpreter invocation. `dur` is `Number()`-guarded; `port`
+should be passed out-of-band (`sys.argv`/env), never spliced into source.
+
+### F6 (LOW, drift): server version hardcoded
+
+`SERVER_INFO = { name: 'ruview', version: '0.1.0' }` in `src/mcp-server.js`
+duplicates `package.json.version` (the CLI's `--version` already reads
+package.json at runtime). First release bump will drift the MCP handshake
+version.
+
+### F7 (LOW, duplication): every skill ships twice
+
+`skills/*.md` and `.claude/skills/*/SKILL.md` are byte-identical (same sha256 in
+`.harness/manifest.json`). ~8 kB of the 49.5 kB unpacked payload is duplicate
+content, and — worse than size — two copies must be kept in sync by hand.
+
+### F8 (LOW, perf + portability): `which()` is uncached and shells out
+
+`which()` runs up to twice per tool call (`python` then `python3`), each a
+blocking `spawnSync`; the POSIX branch spawns a shell (`shell: true`). Results
+are stable for the process lifetime and should be memoized; the lookup can be
+done dep-free with a PATH scan instead of a shell.
+
+### F9 (LOW, interop): dot-named tools + minimal protocol surface
+
+Tool names (`ruview.onboard`, `ruview.claim_check`, …) contain dots. MCP itself
+does not restrict names, but downstream host APIs commonly enforce
+`^[a-zA-Z0-9_-]{1,64}$` for tool names; hosts must then sanitize or reject.
+The server also answers `resources/list` / `prompts/list` with `-32601` (it does
+not advertise those capabilities, so this is spec-legal, but empty-list stubs are
+cheaper than every host's error path). Protocol version is pinned to
+`2024-11-05` with no negotiation fallback. None of this breaks Claude Code today;
+it narrows portability, which is the harness's whole pitch (9 hosts, ADR-182).
+
+### F10 (LOW, CI gap): the published package has zero CI
+
+No workflow under `.github/workflows/` runs `harness/ruview` tests (checked:
+no workflow references `harness/ruview`, `ruview-mcp`, or `ruview-cli`), and
+`ci.yml` pins `NODE_VERSION: '18'` while the package declares
+`engines.node >= 20`. Note also `node --test test/` (directory form) fails on
+Node 22 while the documented glob form passes — CI should pin the working
+invocation. Consolidated CI/publish strategy is ADR-265.
+
+### F11 (MEDIUM, guardrail precision): `METRIC_TERMS` substring matching false-positives on ordinary prose
+
+Found by dogfooding this review: `claimCheck` matches metric terms with
+`lower.includes(t)`, so the two-character terms `'map'` and `'f1'` fire inside
+ordinary words and labels — "source **map**s", "the **map**s can never
+resolve", finding IDs like "**F1** (HIGH…)". MEASURED reproducer: running
+`npx ruview claim-check --file` over this ADR and ADR-264 yields 4 and 16
+medium findings respectively, the majority of which are `map`/`F1`
+false positives on lines carrying no accuracy claim. A guardrail that cries
+wolf trains people to ignore it — precision is part of its fail-closed
+contract. Short/ambiguous terms need word-boundary matching (`\bmap\b`,
+`\bf1\b`, likewise `auc`, `iou`), and section-heading label patterns
+(`F\d+`, `O\d+`) should not count as metric mentions.
+
+## Decision
+
+Adopt the following optimization strategy, in priority order. Each item is
+independently shippable; F-numbers map to findings.
+
+- **O1 (F1):** `claim-check` with no `--text`/`--file` (or empty text after read)
+  exits 2 with a usage error. Add a regression test pinning exit ≠ 0.
+- **O2 (F2):** make the MCP dispatch async: convert `run()`/`which()` to
+  promise-based `spawn`, make `tools/call` handlers `async`, and keep reading
+  stdin while calls run (respond to `ping`/`tools/list` concurrently; serialize
+  only same-tool hardware operations). Acceptance: `ping` round-trips < 50 ms
+  while a synthetic 30 s `calibrate` is in flight.
+- **O3 (F3):** drop the two `optionalDependencies`; `doctor`/`install` already
+  degrade and should print the exact `npm i @metaharness/kernel
+  @metaharness/host-claude-code` hint on the miss path. Acceptance: cold
+  `npm i @ruvnet/ruview` installs exactly 1 package (MEASURED baseline above).
+- **O4 (F4):** set `maxBuffer: 16 * 1024 * 1024` in `run()` (or stream + tail).
+- **O5 (F5):** pass `port` to the monitor script via `sys.argv`
+  (`python -c script -- <port>`), never by source interpolation.
+- **O6 (F6):** read the MCP `serverInfo.version` from `package.json` once at
+  startup (same pattern the CLI already uses).
+- **O7 (F7):** make `skills/*.md` the single source and generate
+  `.claude/skills/*/SKILL.md` in a `prepack` script (or vice versa); manifest
+  hashes then pin one canonical set.
+- **O8 (F8, F9):** memoize `which()`; add underscore aliases for the dot-named
+  tools (accept both in `tools/call`, advertise the underscore form) and add
+  empty `resources/list` / `prompts/list` stubs.
+- **O9 (F11):** switch `METRIC_TERMS` matching to word-boundary regexes for
+  short terms (`map`, `f1`, `auc`, `iou`) and skip label tokens matching
+  `\b[FO]\d+\b`. Acceptance: `claim-check --file` over ADR-263/264/265 reports
+  only the genuinely tagged-or-taggable percentage lines, and the existing 17
+  guardrail tests still pass plus new false-positive pins ("source maps",
+  "F1 (HIGH)" → no finding).
+
+Non-goals: no new runtime dependencies (the zero-dep MCP server is a feature,
+not an accident — keep it), no build step, no change to the fail-closed tool
+contracts.
+
+## Consequences
+
+- The honesty guardrail becomes fail-closed end-to-end (its current empty-input
+  pass is the exact failure mode the guardrail exists to prevent).
+- `npx` cold start drops ~450 kB / 3 packages (MEASURED baseline in F3) with no
+  feature loss; `doctor` output already communicates the optional-dep story.
+- Long-running `verify`/`calibrate` no longer starve the MCP channel — the
+  harness survives host health checks during real calibration runs.
+- Two-copy skill drift becomes impossible at pack time.
+- Costs: async conversion touches every handler signature in `src/tools.js`
+  (mechanical, ~6 handlers); alias tools add a small compatibility table.
+- Verification for the implementing PR: bundled tests extended for O1/O2/O5
+  (target ≥ 20 tests), `npm pack --dry-run` file-count asserted, and the F3
+  install measurement re-run and quoted MEASURED in the PR body — which must
+  itself pass `npx ruview claim-check`.

docs/adr/ADR-264-rvagent-mcp-and-cli-npm-deep-review.md

@@ -0,0 +1,169 @@
+# ADR-264: `@ruvnet/rvagent` MCP Server + `@ruv/ruview-cli` — Deep Review + Optimization Strategy
+
+| Field | Value |
+|-------|-------|
+| **Status** | Accepted — **implemented** (O1–O9, `@ruvnet/rvagent@0.2.0`): `exports` fixed (types-first, no phantom `.cjs`), map-free tarball (127,704 B unpacked / 46 files / 0 maps — MEASURED, `npm pack --dry-run`, from 188 kB), Streamable HTTP **wired** behind `RVAGENT_HTTP_PORT` with per-session transports + 1 MiB body cap + port-aware origin gate, underscore tool names with dotted router aliases, single Zod validation gate with generated JSON Schemas, fd-leak fixed + persisted job records + bounded log tails, probing `detectCogBinary`, package.json-sourced version, `ruview-cli` bin renamed. 99/99 jest tests (MEASURED); both transports smoke-tested live |
+| **Date** | 2026-07-02 |
+| **Deciders** | ruv |
+| **Codename** | **RUVIEW-NPM-REVIEW-2** |
+| **Supersedes / amends** | none (reviews the ADR-104/ADR-124 artifacts; feeds ADR-265 distribution strategy) |
+
+## Context
+
+Two TypeScript npm packages expose RuView sensing to agents and shells:
+
+- **`@ruvnet/rvagent@0.1.0`** (`tools/ruview-mcp/`) — SENSE-BRIDGE, the MCP
+  server over the sensing-server HTTP API + cog binaries: 12 tools
+  (csi/pose/count/registry/train/job + ADR-124 BFLD/presence/vitals). Published
+  (188 kB unpacked — MEASURED, `npm view @ruvnet/rvagent`). Deps:
+  `@modelcontextprotocol/sdk` + `zod`.
+- **`@ruv/ruview-cli@0.0.1`** (`tools/ruview-cli/`) — `private: true` yargs CLI
+  mirroring the same capabilities; intentionally duplicates `http.ts`/`cog.ts`/
+  `config.ts` (~150 lines) to stay standalone.
+
+This ADR records a deep review of both: packaging correctness (verified against
+the **published** tarball, not just the source tree), protocol/interop, resource
+lifecycle, and the honesty of the package's own self-description — the same
+MEASURED-vs-CLAIMED bar the project applies to accuracy numbers.
+
+## Findings
+
+### F1 (HIGH, broken export): `require` condition points at a file that does not exist
+
+`package.json` `exports["."].require = "./dist/index.cjs"`, but the build is
+plain `tsc` (ESM only) and **the published 0.1.0 tarball contains no
+`index.cjs`** (verified by listing the registry tarball). Any CJS consumer doing
+`require('@ruvnet/rvagent')` resolves to a nonexistent file →
+`ERR_MODULE_NOT_FOUND`. Additionally the `types` condition is listed **after**
+`import`/`require`; TypeScript requires `types` first or it may be ignored under
+`moduleResolution: bundler/node16`.
+
+### F2 (MEDIUM, tarball bloat): a third of the published package is dead source maps
+
+The 0.1.0 tarball ships **44 `.map` files = 62,698 B** against 78,209 B of
+actual `.js` (MEASURED, extracted registry tarball). `src/` is not published, so
+every `sourceMappingURL` points at `../src/*.ts` that consumers do not have —
+the maps can never resolve. Also `files` lists `CHANGELOG.md`, which does not
+exist in `tools/ruview-mcp/` (npm silently skips it), so the advertised file set
+is partly fictional.
+
+### F3 (MEDIUM, honesty): the package description claims a transport it does not start
+
+The description reads "**dual-transport MCP server (stdio + Streamable HTTP)**",
+but `main()` in `src/index.ts` wires **stdio only**. `http-transport.ts` is a
+complete, tested scaffold that nothing imports at runtime — there is no flag,
+env var, or subcommand that starts it. By this project's own rule this is a
+CLAIMED capability presented as shipped. Either wire it (`--http` /
+`RVAGENT_HTTP_PORT` gate) or de-claim the description until it is.
+
+### F4 (MEDIUM, interop + inconsistency): two tool-naming conventions, one of them dot-based
+
+Six tools use `ruview_snake_case`; six (ADR-124 additions) use
+`ruview.dotted.names`. Same interop caveat as ADR-263 F9 (host tool-name
+regexes commonly `^[a-zA-Z0-9_-]{1,64}$`), plus the split convention makes the
+tool surface look like two products. Standardize on underscores and accept the
+dotted forms as aliases for one deprecation cycle.
+
+### F5 (MEDIUM, double work + drift): every tool input is validated twice from two hand-maintained schemas
+
+`CallToolRequestSchema` handler runs `TOOL_INPUT_SCHEMAS[name].safeParse(args)`,
+then each tool handler runs its own `schema.parse(args)` again — two full Zod
+passes per call. Separately, the `inputSchema` JSON advertised via `tools/list`
+is **hand-written** and duplicates the Zod schema field-by-field (defaults,
+min/max, descriptions) — schema drift between what is advertised and what is
+enforced is a matter of time. Parse once at the gate, pass the typed result to
+handlers, and generate the advertised JSON Schema from the Zod source
+(`zod-to-json-schema` at build time, or Zod 4's native `z.toJSONSchema` when the
+SDK's peer range allows).
+
+### F6 (MEDIUM, resource lifecycle): `train_count` leaks 2 fds per job; job registry is process-local
+
+`trainCount` opens `logFdOut`/`logFdErr` with `openSync` and never closes them
+in the parent — the spawned cargo child inherits duplicates, but the parent's
+descriptors stay open for the MCP server's lifetime: 2 leaked fds per training
+job. `jobRegistry` is an in-memory `Map`, so `ruview_job_status` after a server
+restart reports "not found" for a training run that is still burning GPU (the
+source comments acknowledge this; the fix — persist `~/.ruview/jobs/<id>.json`,
+already the documented layout — is small). Also `jobStatus` re-`import`s
+`node:fs` on every poll and reads the entire log to return 20 lines.
+
+### F7 (MEDIUM, security/robustness of the HTTP scaffold): unbounded body + one shared session transport
+
+`http-transport.ts` buffers the request body with no size cap (memory DoS the
+moment it is wired to a socket), reuses a **single**
+`StreamableHTTPServerTransport` with `sessionIdGenerator` for all clients (the
+SDK's stateful mode expects one transport per session — a second client's
+`initialize` collides), and the Origin allowlist is exact-match
+(`http://localhost` will not match a real browser origin `http://localhost:5173`).
+Must be fixed **before** F3 wires it in; bearer-token + 127.0.0.1 defaults are
+already right.
+
+### F8 (LOW, dead/misleading code): `detectCogBinary` always returns the bare name
+
+It builds a 4-candidate appliance-path array and then returns
+`candidates[candidates.length - 1]` — i.e. always `name` — without checking
+existence. The candidates are dead weight that reads as if path detection
+happens. Either probe with `existsSync` or delete the array.
+
+### F9 (LOW, drift + hygiene): hardcoded versions, unused/mismatched devDeps, bin-name collision
+
+`PACKAGE_VERSION = "0.1.0"` (index.ts) duplicates package.json;
+`@types/express` is unused (`http-transport` uses `node:http`); `@types/jest@30`
+against `jest@29`; `ruview-cli` hardcodes `.version("0.0.1")`. And
+`@ruv/ruview-cli` claims the **`ruview`** bin name, which collides with
+`@ruvnet/ruview`'s bin (ADR-182) if both are ever installed globally —
+ADR-263/265 give the `ruview` name to the harness; the CLI must rename or fold.
+
+## Decision
+
+- **O1 (F1):** fix `exports`: drop the `require` condition (ESM-only is fine for
+  a bin-first package) or add a real CJS build; put `types` first. Add a CI
+  smoke test that does `npm pack` + `node -e "import('<tarball install>')"`.
+- **O2 (F2):** publish without maps: `declarationMap: false`, `sourceMap: false`
+  in a `tsconfig.build.json` used by `prepack` (or add `!dist/**/*.map` to
+  `files`). Remove the phantom `CHANGELOG.md` entry or create the file.
+  Acceptance: unpacked size ≤ ~125 kB (from 188 kB — MEASURED, `npm pack --dry-run`).
+- **O3 (F3, F7):** wire the HTTP transport behind an explicit opt-in
+  (`RVAGENT_HTTP_PORT` or `--http`), after F7 fixes: per-session transport map
+  keyed by `mcp-session-id`, 1 MiB body cap, origin matching that honors ports
+  (compare `URL.origin` prefixes or document exact origins). Until then, change
+  the description to "stdio MCP server (Streamable HTTP scaffold, unwired)".
+- **O4 (F4):** rename dotted tools to underscore (`ruview_bfld_last_scan`, …),
+  keep dotted aliases in the call router for one release, note it in the README.
+- **O5 (F5):** single validation gate: the registry maps name → Zod schema →
+  typed handler; advertised `inputSchema` generated from Zod at build time.
+- **O6 (F6):** close parent fds after spawn (`closeSync` post-`spawn` — the
+  child holds its own copies), persist job records to
+  `<jobsDir>/<id>.json`, and read log tails with a bounded read.
+- **O7 (F8):** make `detectCogBinary` actually probe (`existsSync` over the
+  candidates) — it is the entire reason the function exists.
+- **O8 (F9):** single-source versions from package.json; drop `@types/express`;
+  align `@types/jest` with jest 29 (or move to `node:test` like the harness and
+  drop the jest toolchain entirely — it is the heaviest devDep in both
+  packages).
+- **O9 (F9, scope):** fold `@ruv/ruview-cli` into `rvagent` as a second bin
+  (`rvagent-cli`) sharing `http/cog/config`, or keep it private-forever and say
+  so in its README. Its `ruview` bin name is surrendered to `@ruvnet/ruview`
+  either way.
+
+## Consequences
+
+- CJS consumers stop hitting a guaranteed-broken export path (F1 is the only
+  finding that fails for every consumer of that entry point deterministically).
+- The published artifact shrinks ~33% (MEASURED, F2 tarball listing: 62,698 B
+  of maps in a 188 kB unpacked payload) and stops advertising files/transports
+  it does not contain — the package description itself passes the project's
+  claim-check bar.
+- One schema source ends advertised-vs-enforced drift and halves per-call
+  validation cost; naming unification makes the 12-tool surface read as one
+  product and survive strict host tool-name validation.
+- Long-lived MCP servers stop accumulating fds during training campaigns, and
+  job polling survives restarts.
+- Costs: the alias cycle (O4) briefly doubles the advertised tool count unless
+  aliases are router-only (recommended: router-only, advertise underscore names
+  exclusively); folding the CLI (O9) retires a package name already in use in
+  scripts, so it needs a deprecation note.
+- Verification for the implementing PR: `npm pack --dry-run` asserted file list
+  (no `.map`, no phantom entries), pack-size budget in CI (ADR-265), jest/`node
+  --test` suite green, and a tarball-install smoke test for both `import` and
+  the `rvagent` bin.

docs/adr/ADR-265-ruview-npm-distribution-strategy.md

@@ -0,0 +1,124 @@
+# ADR-265: RuView npm Distribution Strategy — CI Gate, Provenance, Version Single-Sourcing, Namespace
+
+| Field | Value |
+|-------|-------|
+| **Status** | Accepted — **D1–D4 implemented**: `.github/workflows/npm-packages.yml` (matrix gate: tests, version-literal grep, pack-content/size gate, tarball-install smoke test, README claim-check), `.github/workflows/ruview-npm-release.yml` (publish-from-CI with `npm publish --provenance`), version single-sourcing (all three packages read package.json), `ruview` bin owned by `@ruvnet/ruview` (`@ruv/ruview-cli` bin renamed `ruview-cli`), `ci.yml` NODE_VERSION 18→20. D5 (no workspace) stands as recorded |
+| **Date** | 2026-07-02 |
+| **Deciders** | ruv |
+| **Codename** | **RUVIEW-NPM-DIST** |
+| **Supersedes / amends** | none (cross-cutting layer above ADR-263 and ADR-264; complements ADR-182 P3/P4) |
+
+## Context
+
+The monorepo now ships (or stages) **three Node packages** with no shared
+distribution engineering:
+
+| Package | Dir | Published | Bin(s) | Tests in CI |
+|---------|-----|-----------|--------|-------------|
+| `@ruvnet/ruview` | `harness/ruview/` | 0.1.0 (live) | `ruview` | **none** |
+| `@ruvnet/rvagent` | `tools/ruview-mcp/` | 0.1.0 (live) | `rvagent`, `ruview-mcp` | **none** |
+| `@ruv/ruview-cli` | `tools/ruview-cli/` | private | `ruview` (collides) | **none** |
+
+Cross-cutting facts established during the ADR-263/264 reviews:
+
+- **Zero CI coverage.** No workflow under `.github/workflows/` references any of
+  the three directories. Two of the packages are *live on the registry* and were
+  published from a laptop state CI never saw. Meanwhile the Rust side has a
+  1,031+-test gate and a witness-bundle culture (ADR-028) — the npm surface is
+  the only shipped artifact class with no verification gate at all.
+- **`ci.yml` pins `NODE_VERSION: '18'`** while all three packages declare
+  `engines.node >= 20`.
+- **Version triplication.** Each package hardcodes its version in source at
+  least once beyond package.json (harness `SERVER_INFO`, rvagent
+  `PACKAGE_VERSION`, cli `.version("0.0.1")`).
+- **Bin-name collision.** Two packages claim the `ruview` bin.
+- **No provenance.** Neither published package carries npm provenance
+  attestations, in a project whose differentiator is signed, reproducible
+  evidence (ADR-028 witness bundles, ADR-182 P4 ed25519/SLSA design).
+- **No pack-content gate.** ADR-264 F1/F2 (broken `require` target, 33% dead map weight — MEASURED, tarball listing — and a phantom
+  `CHANGELOG.md` in `files`) are exactly the defect class an
+  `npm pack --dry-run` assertion catches in seconds.
+
+## Decision
+
+Adopt one distribution layer for all Node packages. Per-package code fixes live
+in ADR-263/264; this ADR fixes the machinery around them.
+
+### D1 — One `npm-packages.yml` CI workflow (the gate)
+
+Matrix over `[harness/ruview, tools/ruview-mcp, tools/ruview-cli]` ×
+Node `[20, 22]`:
+
+1. `npm ci` where a lockfile is committed (the TS packages); the harness
+   installs with `npm install` — repo policy gitignores lockfiles under
+   `harness/`, and the package is dependency-free after ADR-263 O3 so there is
+   nothing to pin.
+2. `npm test` (harness: `node --test test/*.test.mjs` — pin the glob form,
+   the directory form fails on Node 22; TS packages: build + jest or `node:test`
+   per ADR-264 O8).
+3. **Pack gate:** `npm pack --dry-run --json` asserted against a checked-in
+   expected file list + a max unpacked-size budget per package (harness ≤ 60 kB;
+   rvagent ≤ 130 kB post ADR-264 O2). Any new/missing/renamed shipped file is a
+   reviewed diff, not a surprise.
+4. **Tarball smoke test:** install the packed tarball into a temp dir; run
+   `ruview --version`, `ruview doctor`, `rvagent` `--help`-equivalent, and a
+   Node `import()` of each declared export condition — this is the test that
+   would have caught ADR-264 F1 (`require` → nonexistent `dist/index.cjs`).
+5. Bump `ci.yml` `NODE_VERSION` to `'20'` (independent of the matrix above).
+
+### D2 — Publish only from CI, with provenance
+
+Manual `npm publish` from laptops stops. A tag-triggered workflow
+(`ruview-npm-release.yml`, mirroring the firmware release discipline) runs the
+D1 gate, then `npm publish --provenance --access public` under the GitHub OIDC
+token. Consequence: every published version is attested to a public commit +
+workflow run — the npm-side analogue of the ADR-028 witness bundle. The
+`prepublishOnly` script in each package runs the pack gate locally as a
+belt-and-braces (publishing outside CI fails loudly, not silently).
+
+### D3 — Version single-sourcing
+
+Rule: **package.json is the only place a version string lives.** Runtime code
+reads it (`createRequire(import.meta.url)('./package.json').version` or a
+build-time define for the TS packages). CI greps for `\d+\.\d+\.\d+` literals in
+`src/` of each package and fails on match (allowlist: test fixtures). This
+retires ADR-263 F6 and ADR-264 F9 permanently instead of per-incident.
+
+### D4 — Namespace and bin ownership
+
+- `@ruvnet/ruview` **owns the `ruview` bin** (it is the published front door,
+  ADR-182). `@ruv/ruview-cli` renames its bin or folds into `rvagent`
+  (ADR-264 O9) — decided here so neither package ADR relitigates it.
+- New Node packages in this repo use the `@ruvnet/` scope (the `@ruv/` scope
+  holds `rvcsi` legacies; do not grow it).
+- Every package README + description must pass
+  `npx ruview claim-check` — enforced in the D1 gate. The guardrail package
+  linting its sibling packages' claims is the cheapest dogfooding we have
+  (ADR-264 F3 is the standing example of why).
+
+### D5 — Shared-code policy (bounded)
+
+Do **not** introduce an npm workspace or a shared runtime package yet: three
+packages, two of which may merge (ADR-264 O9), do not justify workspace
+machinery, and the harness's zero-dep property is load-bearing. Revisit if a
+fourth package appears or if the `http/cog/config` duplication survives the
+ADR-264 O9 fold. Record the duplication as intentional in each file header (the
+CLI already does this).
+
+## Consequences
+
+- The npm artifacts get the same class of gate the Rust workspace has had since
+  ADR-028: no publish without tests, no shipped file set without an asserted
+  manifest, no version without provenance. The two defects that reached the
+  registry (broken `require` condition, dead maps) become CI-impossible.
+- Cold-path costs stay near zero: the D1 matrix is 6 fast jobs (the harness
+  suite runs in ~108 ms MEASURED; TS builds dominate at a few tens of seconds).
+- Publishing gains one constraint (must go through CI) and loses one failure
+  mode (laptop-state publishes) — the right trade for a project whose brand is
+  reproducible evidence.
+- D3's grep gate is blunt but cheap; if it over-fires, scope it to
+  `version`-adjacent identifiers before weakening it.
+- Follow-ups tracked elsewhere: per-package code fixes (ADR-263 O1–O8, ADR-264
+  O1–O9); ADR-182 P4 (metaharness router + ed25519 provenance chain) remains
+  the deeper provenance story that D2's npm attestations complement, not
+  replace.

docs/adr/ADR-266-multi-actor-posecode-scenes.md

@@ -0,0 +1,141 @@
+# ADR-266: Multi-Actor PoseCode Scenes
+
+| Field | Value |
+|-------|-------|
+| Status | Accepted, crate implementation complete |
+| Date | 2026-07-15 |
+| Deciders | ruv |
+| Crate | `wifi-densepose-posecode` |
+| Related | ADR-029, ADR-037, ADR-082, ADR-101, ADR-170 |
+
+## Context
+
+RuView already maintains multiple persistent `PoseTrack` aggregates. Each track
+contains 17 COCO keypoints, a lifecycle, an AETHER identity embedding and a
+stable `TrackId`. The missing layer is a compact, agent-readable representation
+of what those tracked people do together over time.
+
+PoseCode 0.1 provides a useful vocabulary for one actor, sequential movement
+phases, semantic joint actions, contacts and browser rendering. Its current
+protocol does not represent multiple actors, shared world coordinates,
+inter-person contact, observation confidence or track provenance.
+
+Encoding every 20 Hz RuView frame as text would also be incorrect. It would
+produce 1,200 steps per person per minute, discard observation uncertainty and
+couple the sensing hot path to a presentation language.
+
+## Decision
+
+Create the leaf crate `wifi-densepose-posecode` and define a backwards-minded
+0.2 scene extension with these invariants:
+
+1. A `Scene` owns named actors and synchronized phases.
+2. Each actor can carry the originating RuView `TrackId` and confidence.
+3. Every joint target and inter-person contact carries confidence.
+4. Actor positions and travel use one room-calibrated three-dimensional frame.
+5. Raw `SceneFrame` observations remain separate from compact semantic phases.
+6. `PhaseSegmenter` emits a phase on actor membership change, motion settling
+   or a bounded maximum duration.
+7. Serialization is canonical and deterministic.
+8. The parser has hard document, line, actor, phase and target limits.
+9. General range-of-motion violations are errors for authored scenes but only
+   warnings for observed WiFi scenes. RF pose estimates are not medical joint
+   measurements and must not create false safety claims.
+
+The text form is:
+
+```posecode
+posecode scene "Assisted squat"
+source observed_wifi_csi
+actor patient:
+  rig humanoid
+  pose start = standing
+  track 7
+  confidence 0.82
+  position 0 0 0
+actor therapist:
+  rig humanoid
+  pose start = standing
+  track 12
+  confidence 0.76
+  position 1.2 0 0
+step "Lower" 1.5s flow:
+  patient.knee_left: flex 95 0.8
+  therapist.shoulder_left: flex 30 0.7
+  contact therapist.hand_left patient.shoulder_right 0.7
+repeat 1
+```
+
+## Architecture
+
+`RuViewAdapter` consumes references to existing `PoseTrack` values. It does not
+duplicate assignment or identity tracking. It calculates elbows and knees from
+three-point interior angles, estimates hip and shoulder sagittal movement in a
+calibrated coordinate frame and maps the hip midpoint to actor position.
+The adapter is exposed by the crate's `ruview` feature so the protocol, parser
+and segmenter remain usable without pulling the full signal and RuVector graph.
+
+The adapter uses keypoint confidence when available. Current trackers that have
+not populated that field receive an explicit configurable fallback confidence,
+degraded by track staleness. Non-finite coordinates and terminated tracks fail
+closed.
+
+`PhaseSegmenter` consumes ordered frames. High-rate frames remain available for
+live rendering and evidence storage while the resulting scene records only
+meaningful synchronized targets. This preserves both fidelity and readability.
+
+## Security and Resource Bounds
+
+The public parser accepts at most 1 MiB per document and 4,096 bytes per line.
+The scene validator defaults to 32 actors, 10,000 phases and 64 joint targets
+per actor per phase. All coordinates, angles and confidence values must be
+finite. References to undeclared actors are rejected. Durations, repeats and
+timeline addition are bounded.
+
+No network, filesystem, model or renderer capability is present in the crate.
+It is a deterministic transformation leaf over owned data.
+
+## Consequences
+
+RuView can now produce privacy-preserving multi-person replays, structured fall
+and interaction evidence, exercise comparison inputs and agent-readable motion
+records without video.
+
+The crate does not solve RF source separation. Its multi-person accuracy is
+bounded by the upstream pose model and `PoseTracker`. Contact inference is also
+not fabricated; contacts must be observed by a future calibrated classifier or
+authored explicitly.
+
+The current COCO skeleton has no toe keypoints, so ankle rotation and precise
+foot contact cannot be inferred honestly. Those targets are omitted rather
+than guessed.
+
+## Acceptance Criteria
+
+1. A scene containing two actors, simultaneous targets and a cross-actor
+   contact parses and serializes deterministically.
+2. Unknown actors, non-finite values, reversed timestamps and unbounded inputs
+   fail closed.
+3. One RuView track converts to finite semantic targets with the same TrackId.
+4. Observed out-of-range angles produce warnings, not medical errors.
+5. Phase count is smaller than input frame count for a normal motion sequence.
+6. Focused crate tests and the complete workspace test suite pass before merge.
+
+## Measured Results
+
+On the implementation container with Rust 1.88, Criterion measured the canonical
+two-actor scene parser at 3.40 microseconds and serializer at 3.29 microseconds
+per operation. The protocol-only dependency surface is three runtime crates:
+`serde`, `serde_json` and `thiserror`.
+
+The protocol-only configuration passes 13 unit tests, documentation tests,
+Rustfmt and Clippy with warnings denied. The `ruview` feature passes 14 unit
+tests, including native `PoseTrack` conversion, under the repository's RuVector
+AVX512-capable build configuration.
+
+## References
+
+1. PoseCode repository and protocol, MIT licensed:
+   <https://github.com/posecode-dev/posecode>
+2. RuView multi-person pose decision: ADR-037.
+3. RuView persistent pose tracking: ADR-029 and `pose_tracker.rs`.

docs/adr/README.md

@@ -1,6 +1,6 @@
 # Architecture Decision Records
 
-This folder contains 45 Architecture Decision Records (ADRs) that document every significant technical choice in the RuView / WiFi-DensePose project.
+This folder contains 183 Architecture Decision Records (ADRs) that document every significant technical choice in the RuView / WiFi-DensePose project. (The index tables below list a curated subset per domain; see the directory listing for the full set.)
 
 ## Why ADRs?
 
@@ -120,6 +120,10 @@ Statuses: **Proposed** (under discussion), **Accepted** (approved and/or impleme
 | [ADR-097](ADR-097-adopt-rvcsi-as-ruview-csi-runtime.md) | Adopt rvCSI as RuView's primary CSI runtime (phased adoption) | Proposed |
 | [ADR-098](ADR-098-evaluate-midstream-fit.md) | Evaluate `ruvnet/midstream` for RuView's CSI / WebSocket / mesh pipeline | Rejected |
 | [ADR-099](ADR-099-midstream-introspection-tap.md) | Adopt midstream as RuView's real-time introspection + low-latency tap | Proposed |
+| [ADR-263](ADR-263-ruview-npm-harness-deep-review.md) | `@ruvnet/ruview` npm harness — deep review + optimization strategy | Proposed |
+| [ADR-264](ADR-264-rvagent-mcp-and-cli-npm-deep-review.md) | `@ruvnet/rvagent` MCP server + `@ruv/ruview-cli` — deep review + optimization strategy | Proposed |
+| [ADR-265](ADR-265-ruview-npm-distribution-strategy.md) | RuView npm distribution strategy — CI gate, provenance, version single-sourcing, namespace | Proposed |
+| [ADR-266](ADR-266-multi-actor-posecode-scenes.md) | Multi-actor PoseCode scenes from persistent RuView tracks | Accepted |
 
 ---
 

firmware/esp32-csi-node/README.md

@@ -4,7 +4,7 @@
 
 This firmware captures WiFi Channel State Information (CSI) from an ESP32-S3 (production) or ESP32-C6 (research target — Wi-Fi 6 / 802.15.4 / TWT / LP-core hibernation, see [ADR-110](../../docs/adr/ADR-110-esp32-c6-firmware-extension.md)) and transforms it into real-time presence detection, vital sign monitoring, and programmable sensing -- all without cameras or wearables. Part of the [WiFi-DensePose](../../README.md) project.
 
-[![ESP-IDF v5.2](https://img.shields.io/badge/ESP--IDF-v5.2-blue.svg)](https://docs.espressif.com/projects/esp-idf/en/v5.2/)
+[![ESP-IDF v5.4](https://img.shields.io/badge/ESP--IDF-v5.4-blue.svg)](https://docs.espressif.com/projects/esp-idf/en/v5.4/)
 [![Target: ESP32-S3 / ESP32-C6](https://img.shields.io/badge/target-ESP32--S3%20%7C%20ESP32--C6-purple.svg)](https://www.espressif.com/en/products/socs/esp32-s3)
 [![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-green.svg)](../../LICENSE)
 [![Binary: ~943 KB](https://img.shields.io/badge/binary-~943%20KB-orange.svg)](#memory-budget)
@@ -48,10 +48,18 @@ with `--flash_size 4MB`.
 # From the repository root:
 MSYS_NO_PATHCONV=1 docker run --rm \
   -v "$(pwd)/firmware/esp32-csi-node:/project" -w /project \
-  espressif/idf:v5.2 bash -c \
+  espressif/idf:v5.4 bash -c \
   "rm -rf build sdkconfig && idf.py set-target esp32s3 && idf.py build"
 ```
 
+> **Display-less boards (ESP32-S3-DevKitC-1 and similar):** build with the
+> `sdkconfig.defaults.devkitc` overlay instead — the default build compiles
+> display support in, and the runtime panel probe false-positives on boards
+> with no panel, which disables the RuView#893 MGMT+DATA CSI upgrade and
+> collapses CSI yield to 0 pps. See the header of
+> [`sdkconfig.defaults.devkitc`](sdkconfig.defaults.devkitc) for the exact
+> build command.
+
 ### 2. Flash
 
 Offsets must match `partitions_display.csv` (8 MB) or `partitions_4mb.csv` (4 MB):
@@ -250,7 +258,7 @@ Offset  Size  Field
 # From the repository root:
 MSYS_NO_PATHCONV=1 docker run --rm \
   -v "$(pwd)/firmware/esp32-csi-node:/project" -w /project \
-  espressif/idf:v5.2 bash -c \
+  espressif/idf:v5.4 bash -c \
   "rm -rf build sdkconfig && idf.py set-target esp32s3 && idf.py build"
 ```
 
@@ -268,7 +276,7 @@ To change Kconfig settings before building:
 ```bash
 MSYS_NO_PATHCONV=1 docker run --rm -it \
   -v "$(pwd)/firmware/esp32-csi-node:/project" -w /project \
-  espressif/idf:v5.2 bash -c \
+  espressif/idf:v5.4 bash -c \
   "idf.py set-target esp32s3 && idf.py menuconfig"
 ```
 

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

@@ -319,7 +319,9 @@ static void emit_feature_state(void)
                               (uint64_t)esp_timer_get_time(),
                               profile);
 
-    int sent = stream_sender_send((const uint8_t *)&pkt, sizeof(pkt));
+    /* feature_state is ~1 Hz and small — priority path so the CSI ENOMEM
+     * backoff can't starve it (#1183). */
+    int sent = stream_sender_send_priority((const uint8_t *)&pkt, sizeof(pkt));
     if (sent < 0) {
         ESP_LOGW(TAG, "feature_state emit failed");
     }
@@ -333,11 +335,14 @@ static void slow_loop_cb(TimerHandle_t t)
      * detect sync-error drift. */
     uint8_t nid[8];
     node_id_bytes(nid);
-    rv_mesh_send_health(s_role, s_mesh_epoch, nid);
+    /* #1183: report the actual send result — the old log printed "HEALTH sent"
+     * unconditionally even when rv_mesh_send returned ESP_FAIL. */
+    esp_err_t health_rc = rv_mesh_send_health(s_role, s_mesh_epoch, nid);
 
-    ESP_LOGI(TAG, "slow tick (state=%u, feature_state_seq=%u, role=%u, epoch=%u) HEALTH sent",
+    ESP_LOGI(TAG, "slow tick (state=%u, feature_state_seq=%u, role=%u, epoch=%u) HEALTH %s",
              (unsigned)s_state, (unsigned)s_feature_state_seq,
-             (unsigned)s_role, (unsigned)s_mesh_epoch);
+             (unsigned)s_role, (unsigned)s_mesh_epoch,
+             health_rc == ESP_OK ? "sent" : "FAILED");
 }
 
 /* ---- Public API ---- */

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

@@ -341,7 +341,9 @@ static void wifi_csi_callback(void *ctx, wifi_csi_info_t *info)
             memcpy(&sync[24], &s_sequence, 4);    /* high-water seq for pairing */
             uint32_t zero32 = 0;
             memcpy(&sync[28], &zero32, 4);        /* reserved (room for leader_id low32) */
-            int sr = stream_sender_send(sync, sizeof(sync));
+            /* Sync packets are 32 B at ~0.5 Hz — priority path so the CSI
+             * ENOMEM backoff can't starve cross-node time alignment (#1183). */
+            int sr = stream_sender_send_priority(sync, sizeof(sync));
             static uint32_t s_sync_count = 0;
             s_sync_count++;
             if (s_sync_count <= 3 || (s_sync_count % 60) == 0) {

firmware/esp32-csi-node/main/mmwave_detect.h

@@ -0,0 +1,37 @@
+/**
+ * @file mmwave_detect.h
+ * @brief Pure (host-testable) mmWave frame-validation predicates for probe-time
+ *        sensor detection. No ESP-IDF deps — safe to #include in a host unit test.
+ *
+ * Detection must validate a *full* frame, never a bare header byte/pattern: a
+ * floating UART with no sensor reads line noise that can contain header-looking
+ * bytes, which the old loose checks mistook for a real sensor (#1107 MR60,
+ * #1135 LD2410). These predicates are the validate-before-trust gate.
+ */
+#ifndef MMWAVE_DETECT_H
+#define MMWAVE_DETECT_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * True iff buf[i..] begins a *validated* LD2410 report frame within [0,len):
+ *   F4 F3 F2 F1 | len(LE,2) | data[len] | F8 F7 F6 F5
+ * Requires the head magic, a sane intra-frame length, AND the matching tail at
+ * head+6+len. Pure noise that merely contains 0xF4F3F2F1 fails the tail check.
+ */
+static inline bool mmwave_ld2410_valid_at(const uint8_t *buf, int i, int len)
+{
+    if (i < 0 || i + 5 >= len) return false;
+    if (!(buf[i] == 0xF4 && buf[i+1] == 0xF3 && buf[i+2] == 0xF2 && buf[i+3] == 0xF1))
+        return false;
+    uint16_t flen = (uint16_t)buf[i+4] | ((uint16_t)buf[i+5] << 8);
+    /* Real LD2410 report frames are small (basic=13, engineering=35). */
+    if (flen < 1 || flen > 64) return false;
+    int tail = i + 6 + (int)flen;
+    if (tail + 3 >= len) return false;
+    return buf[tail] == 0xF8 && buf[tail+1] == 0xF7
+        && buf[tail+2] == 0xF6 && buf[tail+3] == 0xF5;
+}
+
+#endif /* MMWAVE_DETECT_H */

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

@@ -26,6 +26,7 @@
  */
 
 #include "mmwave_sensor.h"
+#include "mmwave_detect.h"
 
 #include <string.h>
 #include <math.h>
@@ -401,10 +402,12 @@ static mmwave_type_t probe_at_baud(uint32_t baud)
                     }
                 }
             }
-            /* LD2410: 4-byte header 0xF4F3F2F1 (already specific enough). */
-            if (i + 3 < len && buf[i] == 0xF4 && buf[i+1] == 0xF3
-                && buf[i+2] == 0xF2 && buf[i+3] == 0xF1
-                && baud == MMWAVE_LD2410_BAUD) {
+            /* LD2410: require a *full validated* report frame, not just the
+             * 4-byte head. A floating UART1 at 256000 baud can emit the head
+             * pattern 0xF4F3F2F1 from line noise (#1135 bug #2). The shared
+             * predicate (host-unit-tested in mmwave_detect.h) demands a sane
+             * intra-frame length AND the matching tail 0xF8F7F6F5. */
+            if (baud == MMWAVE_LD2410_BAUD && mmwave_ld2410_valid_at(buf, i, len)) {
                 ld2410_header_seen++;
             }
         }

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

@@ -188,7 +188,9 @@ size_t rv_mesh_encode_calibration_start(uint8_t sender_role,
 esp_err_t rv_mesh_send(const uint8_t *frame, size_t len)
 {
     if (frame == NULL || len == 0) return ESP_ERR_INVALID_ARG;
-    int sent = stream_sender_send(frame, len);
+    /* Mesh control packets (HEALTH, anomaly) are low-rate and tiny — send them
+     * on the priority path so the CSI ENOMEM backoff can't starve them (#1183). */
+    int sent = stream_sender_send_priority(frame, len);
     if (sent < 0) {
         ESP_LOGW(TAG, "rv_mesh_send: stream_sender failed (len=%u)",
                  (unsigned)len);

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

@@ -26,9 +26,16 @@ static struct sockaddr_in s_dest_addr;
  * rapid-fire CSI callbacks can exhaust the pbuf pool and crash the device.
  */
 static int64_t s_backoff_until_us = 0;       /* esp_timer timestamp to resume */
-#define ENOMEM_COOLDOWN_MS  100              /* suppress sends for 100 ms */
+#define ENOMEM_COOLDOWN_MS  100              /* base backoff; doubles per streak */
+#define ENOMEM_COOLDOWN_MAX_MS 2000          /* cap on the exponential backoff */
 #define ENOMEM_LOG_INTERVAL 50               /* log every Nth suppressed send */
 static uint32_t s_enomem_suppressed = 0;
+/* Consecutive ENOMEM episodes without an intervening successful send. A fixed
+ * 100 ms backoff is too short to drain sustained lwIP/WiFi buffer pressure
+ * (#1135 bug #1: tier-2 + concurrent TX keeps the node stuck), so the backoff
+ * grows 100→200→400→…→2000 ms per streak and resets on the first send that
+ * succeeds. */
+static uint32_t s_enomem_streak = 0;
 
 static int sender_init_internal(const char *ip, uint16_t port)
 {
@@ -93,16 +100,52 @@ int stream_sender_send(const uint8_t *data, size_t len)
                       (struct sockaddr *)&s_dest_addr, sizeof(s_dest_addr));
     if (sent < 0) {
         if (errno == ENOMEM) {
-            /* Start backoff to let lwIP reclaim buffers */
-            s_backoff_until_us = esp_timer_get_time() +
-                                 (int64_t)ENOMEM_COOLDOWN_MS * 1000;
-            ESP_LOGW(TAG, "sendto ENOMEM — backing off for %d ms", ENOMEM_COOLDOWN_MS);
+            /* Exponential backoff: double the cooldown each consecutive ENOMEM
+             * (capped) so sustained buffer pressure actually drains instead of
+             * the node re-failing every 100 ms forever (#1135 bug #1). */
+            uint32_t shift = s_enomem_streak < 5 ? s_enomem_streak : 5;
+            uint32_t cooldown = ENOMEM_COOLDOWN_MS << shift;
+            if (cooldown > ENOMEM_COOLDOWN_MAX_MS) cooldown = ENOMEM_COOLDOWN_MAX_MS;
+            s_enomem_streak++;
+            s_backoff_until_us = esp_timer_get_time() + (int64_t)cooldown * 1000;
+            ESP_LOGW(TAG, "sendto ENOMEM — backing off for %lu ms (streak %lu)",
+                     (unsigned long)cooldown, (unsigned long)s_enomem_streak);
         } else {
             ESP_LOGW(TAG, "sendto failed: errno %d", errno);
         }
         return -1;
     }
 
+    /* A send got through — buffer pressure cleared; reset the backoff streak. */
+    s_enomem_streak = 0;
+    return sent;
+}
+
+int stream_sender_send_priority(const uint8_t *data, size_t len)
+{
+    if (s_sock < 0) {
+        return -1;
+    }
+
+    /* Priority path (#1183): low-rate control packets (feature_state, HEALTH,
+     * mesh sync) bypass the global ENOMEM backoff gate so the high-rate CSI
+     * stream cannot starve them. These are ≤48 B at ≤1 Hz — negligible pbuf
+     * pressure, so they won't re-trigger the crash cascade that the backoff
+     * (driven by the 50 Hz CSI flood) exists to prevent.
+     *
+     * Crucially, an ENOMEM here is reported quietly and does NOT extend the
+     * global streak/backoff: a tiny control packet failing is a symptom of
+     * the bulk-stream pressure, not a cause, so it must not feed the cooldown
+     * that suppresses the next CSI frame. Likewise a success does not reset
+     * the streak — the bulk path owns that signal. */
+    int sent = sendto(s_sock, data, len, 0,
+                      (struct sockaddr *)&s_dest_addr, sizeof(s_dest_addr));
+    if (sent < 0) {
+        if (errno != ENOMEM) {
+            ESP_LOGW(TAG, "priority sendto failed: errno %d", errno);
+        }
+        return -1;
+    }
     return sent;
 }
 

firmware/esp32-csi-node/main/stream_sender.h

@@ -36,6 +36,20 @@ int stream_sender_init_with(const char *ip, uint16_t port);
  */
 int stream_sender_send(const uint8_t *data, size_t len);
 
+/**
+ * Send a low-rate control packet, bypassing the ENOMEM backoff gate (#1183).
+ *
+ * Intended for ≤48 B, ≤1 Hz control traffic (feature_state, HEALTH, mesh
+ * sync) that must not be starved by the global backoff the high-rate CSI
+ * stream triggers. An ENOMEM on this path is reported quietly and does NOT
+ * extend or reset the global backoff streak.
+ *
+ * @param data Frame data buffer.
+ * @param len  Length of data to send.
+ * @return Number of bytes sent, or -1 on error.
+ */
+int stream_sender_send_priority(const uint8_t *data, size_t len);
+
 /**
  * Close the UDP sender socket.
  */

firmware/esp32-csi-node/sdkconfig.defaults.devkitc

@@ -0,0 +1,16 @@
+# DevKitC-1 (display-less) production overlay.
+#
+# The stock ESP32-S3-DevKitC-1 has no AMOLED panel, but the ADR-045 runtime
+# probe false-positives on it: with no TCA9554 and floating QSPI pins, the
+# SH8601 init sequence reports success, display_is_active() returns true, and
+# main.c skips the RuView#893 MGMT+DATA promiscuous upgrade — CSI yield
+# collapses to 0 pps (the exact symptom #893 fixed). Compiling display support
+# out makes has_display constant-false so the upgrade always applies.
+#
+# Build (from repo root, per README "Docker — the only reliable method"):
+#   MSYS_NO_PATHCONV=1 docker run --rm \
+#     -v "$(pwd)/firmware/esp32-csi-node:/project" -w /project \
+#     espressif/idf:v5.4 bash -c \
+#     "rm -rf build sdkconfig && idf.py -DSDKCONFIG_DEFAULTS='sdkconfig.defaults;sdkconfig.defaults.devkitc' set-target esp32s3 && idf.py -DSDKCONFIG_DEFAULTS='sdkconfig.defaults;sdkconfig.defaults.devkitc' build"
+
+# CONFIG_DISPLAY_ENABLE is not set

firmware/esp32-csi-node/test/Makefile

@@ -44,9 +44,9 @@ FUZZ_DURATION ?= 30
 FUZZ_JOBS     ?= 1
 
 .PHONY: all clean run_serialize run_edge run_nvs run_all test_adr110 run_adr110 \
-        test_vitals run_vitals host_tests
+        test_vitals run_vitals test_mmwave_detect run_mmwave_detect host_tests
 
-all: fuzz_serialize fuzz_edge fuzz_nvs test_adr110 test_vitals
+all: fuzz_serialize fuzz_edge fuzz_nvs test_adr110 test_vitals test_mmwave_detect
 
 # --- ADR-110 encoding unit tests ---
 # Host-side, no libFuzzer needed — plain C99 deterministic table tests
@@ -69,8 +69,19 @@ test_vitals: test_vitals_count_presence.c $(MAIN_DIR)/edge_processing.h
 run_vitals: test_vitals
 	./test_vitals
 
-host_tests: run_adr110 run_vitals
-	@echo "Host tests passed (ADR-110 + vitals #998/#996)"
+# --- mmWave LD2410 detection predicate (#1135 bug #2) ---
+# Host-side, no libFuzzer. Proves a floating-UART head pattern (0xF4F3F2F1)
+# without a valid frame length+tail is REJECTED, so a phantom LD2410 is never
+# detected on a node with no sensor wired. Tests the real predicate the
+# firmware uses (../main/mmwave_detect.h) — test and firmware can't disagree.
+test_mmwave_detect: test_mmwave_detect.c $(MAIN_DIR)/mmwave_detect.h
+	cc -std=c99 -Wall -Wextra -I$(MAIN_DIR) -o $@ $<
+
+run_mmwave_detect: test_mmwave_detect
+	./test_mmwave_detect
+
+host_tests: run_adr110 run_vitals run_mmwave_detect
+	@echo "Host tests passed (ADR-110 + vitals #998/#996 + mmwave detect #1135)"
 
 # --- Serialize fuzzer ---
 # Tests csi_serialize_frame() with random wifi_csi_info_t inputs.

firmware/esp32-csi-node/test/test_mmwave_detect.c

@@ -0,0 +1,80 @@
+/**
+ * @file test_mmwave_detect.c
+ * @brief Host-side unit tests for the LD2410 frame-validation predicate (#1135).
+ *
+ * Proves the phantom-detection fix: a floating UART can emit the 4-byte head
+ * 0xF4F3F2F1, but the predicate rejects it unless a sane length + matching tail
+ * 0xF8F7F6F5 are also present. Tests the REAL predicate from mmwave_detect.h
+ * (the same code the firmware's probe_at_baud calls).
+ *
+ *   cc -std=c99 -Wall -I../main -o test_mmwave_detect test_mmwave_detect.c && ./test_mmwave_detect
+ *
+ * Exits 0 on all-pass; prints the failing case otherwise.
+ */
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include "mmwave_detect.h"
+
+static int failures = 0;
+#define CHECK(cond, msg) do { \
+    if (!(cond)) { printf("FAIL: %s\n", msg); failures++; } \
+    else        { printf("ok:   %s\n", msg); } \
+} while (0)
+
+/* Build a valid LD2410 report frame: F4F3F2F1 | len(LE) | data[len] | F8F7F6F5 */
+static int make_frame(uint8_t *out, uint16_t dlen)
+{
+    int n = 0;
+    out[n++] = 0xF4; out[n++] = 0xF3; out[n++] = 0xF2; out[n++] = 0xF1;
+    out[n++] = (uint8_t)(dlen & 0xFF); out[n++] = (uint8_t)(dlen >> 8);
+    for (uint16_t k = 0; k < dlen; k++) out[n++] = (uint8_t)(0xAA ^ k);
+    out[n++] = 0xF8; out[n++] = 0xF7; out[n++] = 0xF6; out[n++] = 0xF5;
+    return n;
+}
+
+int main(void)
+{
+    uint8_t buf[256];
+
+    /* 1. A real basic-report frame (data len 13) validates. */
+    int n = make_frame(buf, 13);
+    CHECK(mmwave_ld2410_valid_at(buf, 0, n), "valid basic frame (len=13) accepted");
+
+    /* 2. A real engineering-report frame (data len 35) validates. */
+    n = make_frame(buf, 35);
+    CHECK(mmwave_ld2410_valid_at(buf, 0, n), "valid engineering frame (len=35) accepted");
+
+    /* 3. Head magic present but NO valid tail — the #1135 phantom case. */
+    memset(buf, 0x00, sizeof(buf));
+    buf[0]=0xF4; buf[1]=0xF3; buf[2]=0xF2; buf[3]=0xF1; buf[4]=13; buf[5]=0;
+    /* data present but tail is zeros, not F8F7F6F5 */
+    CHECK(!mmwave_ld2410_valid_at(buf, 0, 64), "head magic without valid tail REJECTED (#1135)");
+
+    /* 4. Head magic with insane length is rejected. */
+    memset(buf, 0xFF, sizeof(buf));
+    buf[0]=0xF4; buf[1]=0xF3; buf[2]=0xF2; buf[3]=0xF1; buf[4]=0xFF; buf[5]=0xFF; /* len=65535 */
+    CHECK(!mmwave_ld2410_valid_at(buf, 0, 200), "head magic with oversized length REJECTED");
+
+    /* 5. Pure noise (no head) is rejected. */
+    for (int k = 0; k < 64; k++) buf[k] = (uint8_t)(0x5A + k);
+    CHECK(!mmwave_ld2410_valid_at(buf, 0, 64), "non-header noise REJECTED");
+
+    /* 6. Truncated frame (tail would run past the buffer) is rejected. */
+    n = make_frame(buf, 13);
+    CHECK(!mmwave_ld2410_valid_at(buf, 0, n - 2), "truncated frame (tail past buffer) REJECTED");
+
+    /* 7. Valid frame at a non-zero offset still validates. */
+    memset(buf, 0x00, sizeof(buf));
+    n = make_frame(buf + 7, 13);
+    CHECK(mmwave_ld2410_valid_at(buf, 7, 7 + n), "valid frame at offset 7 accepted");
+
+    /* 8. Repeated head bytes without a frame (worst-case noise) rejected. */
+    for (int k = 0; k + 3 < 64; k += 4) {
+        buf[k]=0xF4; buf[k+1]=0xF3; buf[k+2]=0xF2; buf[k+3]=0xF1;
+    }
+    CHECK(!mmwave_ld2410_valid_at(buf, 0, 64), "repeated bare head bytes REJECTED");
+
+    printf("\n%s (%d failures)\n", failures ? "FAILED" : "ALL PASS", failures);
+    return failures ? 1 : 0;
+}

harness/ruview/.claude/skills/calibrate-room/SKILL.md

@@ -6,24 +6,24 @@ description: Run the ADR-151 per-room calibration pipeline — baseline → enro
 # calibrate-room
 
 Turn a provisioned node + sensing-server into a working room model. Pure-Rust,
-edge-deployable (ADR-151). Use the `ruview.calibrate` tool (installed
+edge-deployable (ADR-151). Use the `ruview_calibrate` tool (installed
 `wifi-densepose` binary, else `cargo run -p wifi-densepose-cli`).
 
 ## Sequence
 
 1. **baseline** — capture the empty room (Welford amplitude + von Mises phase). Leave
    the room empty.
-   `ruview.calibrate {step: "baseline"}`
+   `ruview_calibrate {step: "baseline"}`
 2. **enroll** — record the occupant(s) doing the target activities.
-   `ruview.calibrate {step: "enroll"}`
+   `ruview_calibrate {step: "enroll"}`
 3. **train-room** — train the bank of small specialists from baseline + enrollment.
-   `ruview.calibrate {step: "train-room"}`
+   `ruview_calibrate {step: "train-room"}`
 4. **room-watch** — live presence/posture/breathing from the trained room.
-   `ruview.calibrate {step: "room-watch"}`  (or the `room-watch` skill)
+   `ruview_calibrate {step: "room-watch"}`  (or the `room-watch` skill)
 
 ## Honesty
 
 The specialists are calibrated to *this* room; cross-room transfer is a separate
 problem (LoRA recalibration, ADR-079 P9). Report which room a number came from, and
 tag presence/vitals accuracy MEASURED only with a held-out check — run
-`ruview.claim_check` on the writeup.
+`ruview_claim_check` on the writeup.

harness/ruview/.claude/skills/onboard/SKILL.md

@@ -8,12 +8,12 @@ description: Zero-to-sensing path picker for RuView (WiFi-DensePose) — pick do
 Get a newcomer from nothing to a working RuView setup. **First fact to set:** WiFi
 sensing infers *coarse* pose/presence/breathing from Channel State Information — it
 is **not a camera**, and any accuracy number must be MEASURED against a baseline
-(use the `verify` skill / `ruview.claim_check` tool). Never present WiFi output as
+(use the `verify` skill / `ruview_claim_check` tool). Never present WiFi output as
 camera-grade.
 
 ## Pick a path
 
-Run `ruview.onboard {path}` or decide from:
+Run `ruview_onboard {path}` or decide from:
 
 1. **docker-demo** — fastest, no hardware. Replays sample CSI into the dashboard.
    `docker run -p 8000:8000 ruvnet/wifi-densepose` → open `http://localhost:8000`.
@@ -26,5 +26,5 @@ Run `ruview.onboard {path}` or decide from:
 ## Then
 
 - Live sensing → go to **provision-node**, then **calibrate-room**.
-- Evaluating a model/claim → go to **verify** and run `ruview.claim_check` on any
+- Evaluating a model/claim → go to **verify** and run `ruview_claim_check` on any
   report before you quote a number.

harness/ruview/.claude/skills/provision-node/SKILL.md

@@ -28,7 +28,7 @@ esptool --chip esp32s3 -p <PORT> -b 460800 write_flash \
   0xf000 ota_data_initial.bin  0x20000 esp32-csi-node-s3-8mb.bin
 ```
 
-(`ruview.node_flash` returns the exact pinned command rather than running an
+(`ruview_node_flash` returns the exact pinned command rather than running an
 unattended flash.)
 
 ## 3. Provision
@@ -44,6 +44,6 @@ Never echo or commit the WiFi password.
 
 ## 4. Confirm CSI is flowing
 
-`ruview.node_monitor {port}` — PASS criteria: serial shows `CSI cb #...` callbacks and
+`ruview_node_monitor {port}` — PASS criteria: serial shows `CSI cb #...` callbacks and
 (on a bare board) `CSI filter upgraded to MGMT+DATA`. No callbacks → the node isn't
 capturing; do not proceed to calibration.

harness/ruview/.claude/skills/train-pose/SKILL.md

@@ -29,5 +29,5 @@ or temporal leakage. Example honest result (ADR-181):
 1. Run the mean-pose baseline on the same split.
 2. Report `(model − baseline)` in pp, with the split definition (chronological /
    blocked-gap / grouped-bucket; no leakage).
-3. `ruview.claim_check` the writeup — it flags any untagged or 100%/perfect claim.
+3. `ruview_claim_check` the writeup — it flags any untagged or 100%/perfect claim.
 4. If it's a benchmark vs SOTA, tag MEASURED-EQUIVALENT only with the reproducer.

harness/ruview/.claude/skills/verify/SKILL.md

@@ -9,7 +9,7 @@ The "prove everything" skill. Nothing ships as validated without this.
 
 ## Deterministic proof (Trust Kill Switch)
 
-`ruview.verify` runs `archive/v1/data/proof/verify.py`: it feeds a reference signal
+`ruview_verify` runs `archive/v1/data/proof/verify.py`: it feeds a reference signal
 through the production pipeline and hashes the output against
 `expected_features.sha256`. Must print **VERDICT: PASS**. If numpy/scipy changed the
 hash, regenerate with `verify.py --generate-hash` then re-verify.
@@ -28,7 +28,7 @@ crate versions — a recipient can re-verify with one command.
 
 ## Claim honesty
 
-Run `ruview.claim_check {text}` on any report, README section, PR body, or model card
+Run `ruview_claim_check {text}` on any report, README section, PR body, or model card
 before quoting accuracy. It flags:
 - untagged accuracy numbers (must be MEASURED / CLAIMED / SYNTHETIC),
 - MEASURED claims with no reproducer cited,

harness/ruview/.harness/manifest.json

@@ -13,27 +13,27 @@
   ],
   "files": {
     ".claude/settings.json": "b0ea971383716f18b89db73010b8f0ea0f1b16bdec4cd1068245772ba1c27bdd",
-    ".claude/skills/calibrate-room/SKILL.md": "6a6c8211a7109feb76620c618963c10ad9a9f633ffce7676e631a80a1181986d",
-    ".claude/skills/onboard/SKILL.md": "22323732fe746b38b77a7c8c052e952dff2fe87ae939ba125379125827385f21",
-    ".claude/skills/provision-node/SKILL.md": "5ffe5a75873e873b80758d9c81005774d4191317227f2e9aa4345cbce3f29751",
-    ".claude/skills/train-pose/SKILL.md": "b3ee95bfb0b678eb3d101138b9ea0e7cab3db3a9906d19c4059f9cca0598e87b",
-    ".claude/skills/verify/SKILL.md": "c0314d5ead465d9089b6a4917fd125051a5be20dc07ba92d5b601fcaada32e19",
-    "CLAUDE.md": "7ecdb2b9d9abcf4aa22dd3ce553b60216a135e147893a59fa944fc1a8c81f5ef",
+    ".claude/skills/calibrate-room/SKILL.md": "4b29c7c331f47acad3c0f51b3d3d8f5b5573e316e081bae71dbe21a47fa95240",
+    ".claude/skills/onboard/SKILL.md": "97ee71f0aa985cfc03bb8e764789bb55c4f9fd5dae10a116c1071eab85b5893f",
+    ".claude/skills/provision-node/SKILL.md": "5f73823794ed5f0b25c102aa8b1bf2dd534a1ec468173d8330c2af0ca24f239c",
+    ".claude/skills/train-pose/SKILL.md": "92aebd4423470eb10eabaee642ec3493284d98b7ae9785e0f34378c709746e65",
+    ".claude/skills/verify/SKILL.md": "2d38d240e9810a7827e2ebd3717dc0f85c646cc92e46c3812fe77c5b9eb40b76",
+    "CLAUDE.md": "1d7af0c310dd8093b4ae6c9c94a1c0cc9ff02ac9c8d5b45caba5363c3af99475",
     "LICENSE": "631f94984f626818d42ecf717aa6e8e0afd4f9f355ca706bd2effafbd1416d06",
-    "README.md": "b77d30428de8efb6758f2ca3eb22e84849013b2c0e6c601d488d2ea5a6f0da44",
-    "bin/cli.js": "b0d74690cff4329dfe342271fc475eaa140b767bdb66b37cf4992ad209012fe8",
-    "package.json": "2af49561ef0d59cafc4b99885816e580635b2d2ad329dfe17c69b9df6f8afceb",
-    "skills/calibrate-room.md": "6a6c8211a7109feb76620c618963c10ad9a9f633ffce7676e631a80a1181986d",
-    "skills/onboard.md": "22323732fe746b38b77a7c8c052e952dff2fe87ae939ba125379125827385f21",
-    "skills/provision-node.md": "5ffe5a75873e873b80758d9c81005774d4191317227f2e9aa4345cbce3f29751",
-    "skills/train-pose.md": "b3ee95bfb0b678eb3d101138b9ea0e7cab3db3a9906d19c4059f9cca0598e87b",
-    "skills/verify.md": "c0314d5ead465d9089b6a4917fd125051a5be20dc07ba92d5b601fcaada32e19",
-    "src/guardrails.js": "1631cea02c4354fe6126c576300faf5f8b68ae2f5e2e3a658c99eb25a7403e55",
-    "src/mcp-server.js": "e51379f5ebb0b7b4670c7412714e559931ef1be8df20551f8f7309b53f0fb7af",
-    "src/tools.js": "b558f61bb202abf5a967ce3a6ccaea351f2d186238cf49c7fc151d1de028eee8"
+    "README.md": "ac35157d66243a5f9eba262bdf2d593e978d935b3dde6e455b7acf650768eac6",
+    "bin/cli.js": "85d8394375edb1e967418451452e68bdbe26e69fc6877ed4936894f6101e1a12",
+    "package.json": "4509b68bb4211217f1e9f3f95f3134b326ee23a2322aef8d19b99a4b1d415b08",
+    "skills/calibrate-room.md": "4b29c7c331f47acad3c0f51b3d3d8f5b5573e316e081bae71dbe21a47fa95240",
+    "skills/onboard.md": "97ee71f0aa985cfc03bb8e764789bb55c4f9fd5dae10a116c1071eab85b5893f",
+    "skills/provision-node.md": "5f73823794ed5f0b25c102aa8b1bf2dd534a1ec468173d8330c2af0ca24f239c",
+    "skills/train-pose.md": "92aebd4423470eb10eabaee642ec3493284d98b7ae9785e0f34378c709746e65",
+    "skills/verify.md": "2d38d240e9810a7827e2ebd3717dc0f85c646cc92e46c3812fe77c5b9eb40b76",
+    "src/guardrails.js": "66407b00d31c4f7939b75ee3e29598855c36a4154ccf1436655a4e52b0d7c034",
+    "src/mcp-server.js": "ad0f21be65a37237b9c2aad69e6e75166e5f101d902cb986377043545a7a80fb",
+    "src/tools.js": "1d72377ae53ad2b0c6dc03eb66f584422d8a60e442cb0d4f08355590f3edf031"
   },
   "meta": {
     "surface": "cli+mcp",
     "adr": "ADR-182"
   }
-}
+}

harness/ruview/.harness/manifest.sha256

@@ -1 +1 @@
-6c6c1431c37472494c9b309c8b5d761dd4fc41e30313baead6320831fb982e57  manifest.json
+380d4bf928fd7c5fa753d11a30c1e24e2ea471caca57b439f765a9d864cef472  manifest.json

harness/ruview/CLAUDE.md

@@ -10,15 +10,15 @@ accuracy number:
 1. It must be tagged **MEASURED** (with a reproducer named), **CLAIMED**, or **SYNTHETIC**.
 2. Pose PCK is quoted only as a **delta over the mean-pose baseline** on a leakage-free
    held-out split. (A mean-pose predictor already scores ~50% PCK.)
-3. Run `ruview.claim_check` on any report/PR/model-card. It flags untagged numbers and
+3. Run `ruview_claim_check` on any report/PR/model-card. It flags untagged numbers and
    the retracted "100%/perfect accuracy" framing.
 4. Firmware is "hardware-validated" only with a captured **boot log on real silicon** —
    never on a build-passes signal.
 
 ## Tools
 
-`ruview.onboard`, `ruview.claim_check`, `ruview.verify`, `ruview.node_monitor`,
-`ruview.calibrate`, `ruview.node_flash`. All fail-closed. Mutating/hardware tools
+`ruview_onboard`, `ruview_claim_check`, `ruview_verify`, `ruview_node_monitor`,
+`ruview_calibrate`, `ruview_node_flash`. All fail-closed. Mutating/hardware tools
 (`node_flash`) require explicit confirmation and are Windows/ESP-IDF gated.
 
 ## Skills

harness/ruview/README.md

@@ -7,34 +7,36 @@ crucially — **refuse to overstate accuracy**. Minted from the RuView monorepo
 
 WiFi sensing infers *coarse* pose/presence/breathing from Channel State Information.
 It is **not a camera**. Every accuracy number this harness emits must be MEASURED
-against a baseline — that rule is enforced in code (`ruview.claim_check`).
+against a baseline — that rule is enforced in code (`ruview_claim_check`).
 
 ## Quick start
 
 ```bash
 npx @ruvnet/ruview                       # onboard — pick a setup path
-npx @ruvnet/ruview claim-check --text "we hit 100% accuracy"   # the honesty guardrail
+npx @ruvnet/ruview claim-check --file REPORT.md   # the honesty guardrail (non-zero exit on untagged claims)
 npx @ruvnet/ruview verify                # run the deterministic proof (VERDICT: PASS)
 npx @ruvnet/ruview doctor                # self-check (tools + optional kernel/host)
 npx @ruvnet/ruview --help
 ```
 
-The operator tools are pure Node and run with **zero install weight**. The
-`@metaharness/kernel` + host adapter are `optionalDependencies` — only `doctor` /
-`install` use them, only if present.
+The operator tools are pure Node and run with **zero install weight** — the
+package has no dependencies at all (ADR-263 O3). `doctor` / `install` can
+additionally use `@metaharness/kernel` + a host adapter if you install them
+(`npm i @metaharness/kernel @metaharness/host-claude-code`); everything else
+runs without them.
 
-## Tools (`ruview.*`)
+## Tools (`ruview_*`)
 
 Exposed both as CLI verbs and as an MCP server (`npx @ruvnet/ruview mcp start`):
 
 | Tool | What it does |
 |------|--------------|
-| `ruview.onboard` | Pick docker-demo / repo-build / live-esp32; print the next command |
-| `ruview.claim_check` | Lint text for untagged / overstated accuracy claims (guardrail) |
-| `ruview.verify` | Run `verify.py` deterministic proof → VERDICT |
-| `ruview.node_monitor` | Assert CSI is flowing on an ESP32 (read-only) |
-| `ruview.calibrate` | ADR-151 room pipeline (baseline→enroll→train-room→room-watch) |
-| `ruview.node_flash` | Build+flash firmware (Windows/ESP-IDF; mutating, guarded) |
+| `ruview_onboard` | Pick docker-demo / repo-build / live-esp32; print the next command |
+| `ruview_claim_check` | Lint text for untagged / overstated accuracy claims (guardrail) |
+| `ruview_verify` | Run `verify.py` deterministic proof → VERDICT |
+| `ruview_node_monitor` | Assert CSI is flowing on an ESP32 (read-only) |
+| `ruview_calibrate` | ADR-151 room pipeline (baseline→enroll→train-room→room-watch) |
+| `ruview_node_flash` | Build+flash firmware (Windows/ESP-IDF; mutating, guarded) |
 
 Every tool is **fail-closed**: missing repo / python / binary / port → an honest
 negative, never a fabricated success.

harness/ruview/bin/cli.js

@@ -18,14 +18,14 @@ const NAME = 'ruview';
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const SKILLS_DIR = join(ROOT, 'skills');
 
-// Map friendly CLI verbs → registry tool names.
+// Map friendly CLI verbs → registry tool names (underscore-canonical, ADR-263).
 const VERB_TO_TOOL = {
-  onboard: 'ruview.onboard',
-  verify: 'ruview.verify',
-  'claim-check': 'ruview.claim_check',
-  calibrate: 'ruview.calibrate',
-  monitor: 'ruview.node_monitor',
-  flash: 'ruview.node_flash',
+  onboard: 'ruview_onboard',
+  verify: 'ruview_verify',
+  'claim-check': 'ruview_claim_check',
+  calibrate: 'ruview_calibrate',
+  monitor: 'ruview_node_monitor',
+  flash: 'ruview_node_flash',
 };
 
 function pjson(o) { console.log(JSON.stringify(o, null, 2)); }
@@ -112,13 +112,18 @@ export async function run(args) {
     const toolArgs = { ...flags };
     if (cmd === 'claim-check') {
       if (flags.file) toolArgs.text = readFileSync(flags.file, 'utf8');
-      const res = runTool('ruview.claim_check', toolArgs);
+      // Fail closed (ADR-263 O1): an honesty gate must never PASS on no input.
+      if (typeof toolArgs.text !== 'string' || toolArgs.text.trim().length === 0) {
+        console.error('claim-check: no input — pass --text "..." or --file <path> (empty input is an error, not a PASS).');
+        return 2;
+      }
+      const res = await runTool('ruview_claim_check', toolArgs);
       pjson(res);
       return res.ok ? 0 : 1;
     }
     if (cmd === 'monitor' && flags.seconds) toolArgs.seconds = Number(flags.seconds);
     if (cmd === 'calibrate' && typeof flags.args === 'string') toolArgs.args = flags.args.split(',');
-    const res = runTool(VERB_TO_TOOL[cmd], toolArgs);
+    const res = await runTool(VERB_TO_TOOL[cmd], toolArgs);
     pjson(res);
     return res.ok ? 0 : 1;
   }

harness/ruview/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvnet/ruview",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "RuView WiFi-sensing operator agent harness — onboard, calibrate, train, and verify camera-free WiFi-CSI sensing, with the project's MEASURED-vs-CLAIMED honesty guardrail enforced. Minted via metaharness (ADR-182).",
   "type": "module",
   "bin": {
@@ -23,11 +23,10 @@
   "scripts": {
     "test": "node --test test/*.test.mjs",
     "doctor": "node ./bin/cli.js doctor",
-    "mcp": "node ./bin/cli.js mcp start"
-  },
-  "optionalDependencies": {
-    "@metaharness/kernel": "^0.1.0",
-    "@metaharness/host-claude-code": "^0.1.0"
+    "mcp": "node ./bin/cli.js mcp start",
+    "sync-skills": "node ./scripts/sync-skills.mjs",
+    "prepack": "node ./scripts/sync-skills.mjs",
+    "prepublishOnly": "npm test"
   },
   "keywords": [
     "wifi-sensing",

harness/ruview/scripts/sync-skills.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// ADR-263 O7: skills/*.md is the single source of truth; the host-projected
+// copies (.claude/skills/<name>/SKILL.md) are GENERATED here at pack time.
+// Run with --check to verify without writing (used by tests/CI).
+
+import { readdirSync, readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const SRC = join(ROOT, 'skills');
+const DST = join(ROOT, '.claude', 'skills');
+const checkOnly = process.argv.includes('--check');
+
+let drift = 0;
+for (const f of readdirSync(SRC).filter((f) => f.endsWith('.md'))) {
+  const name = f.replace(/\.md$/, '');
+  const src = readFileSync(join(SRC, f), 'utf8');
+  const dstDir = join(DST, name);
+  const dstFile = join(dstDir, 'SKILL.md');
+  const current = existsSync(dstFile) ? readFileSync(dstFile, 'utf8') : null;
+  if (current === src) continue;
+  drift++;
+  if (checkOnly) {
+    console.error(`DRIFT: .claude/skills/${name}/SKILL.md != skills/${f}`);
+  } else {
+    mkdirSync(dstDir, { recursive: true });
+    writeFileSync(dstFile, src);
+    console.error(`synced .claude/skills/${name}/SKILL.md`);
+  }
+}
+if (checkOnly && drift > 0) {
+  console.error(`sync-skills --check: ${drift} file(s) out of sync — run \`npm run sync-skills\`.`);
+  process.exit(1);
+}
+console.error(`sync-skills: ${drift === 0 ? 'all in sync' : `${drift} file(s) ${checkOnly ? 'OUT OF SYNC' : 'synced'}`}`);

harness/ruview/skills/calibrate-room.md

@@ -6,24 +6,24 @@ description: Run the ADR-151 per-room calibration pipeline — baseline → enro
 # calibrate-room
 
 Turn a provisioned node + sensing-server into a working room model. Pure-Rust,
-edge-deployable (ADR-151). Use the `ruview.calibrate` tool (installed
+edge-deployable (ADR-151). Use the `ruview_calibrate` tool (installed
 `wifi-densepose` binary, else `cargo run -p wifi-densepose-cli`).
 
 ## Sequence
 
 1. **baseline** — capture the empty room (Welford amplitude + von Mises phase). Leave
    the room empty.
-   `ruview.calibrate {step: "baseline"}`
+   `ruview_calibrate {step: "baseline"}`
 2. **enroll** — record the occupant(s) doing the target activities.
-   `ruview.calibrate {step: "enroll"}`
+   `ruview_calibrate {step: "enroll"}`
 3. **train-room** — train the bank of small specialists from baseline + enrollment.
-   `ruview.calibrate {step: "train-room"}`
+   `ruview_calibrate {step: "train-room"}`
 4. **room-watch** — live presence/posture/breathing from the trained room.
-   `ruview.calibrate {step: "room-watch"}`  (or the `room-watch` skill)
+   `ruview_calibrate {step: "room-watch"}`  (or the `room-watch` skill)
 
 ## Honesty
 
 The specialists are calibrated to *this* room; cross-room transfer is a separate
 problem (LoRA recalibration, ADR-079 P9). Report which room a number came from, and
 tag presence/vitals accuracy MEASURED only with a held-out check — run
-`ruview.claim_check` on the writeup.
+`ruview_claim_check` on the writeup.

harness/ruview/skills/onboard.md

@@ -8,12 +8,12 @@ description: Zero-to-sensing path picker for RuView (WiFi-DensePose) — pick do
 Get a newcomer from nothing to a working RuView setup. **First fact to set:** WiFi
 sensing infers *coarse* pose/presence/breathing from Channel State Information — it
 is **not a camera**, and any accuracy number must be MEASURED against a baseline
-(use the `verify` skill / `ruview.claim_check` tool). Never present WiFi output as
+(use the `verify` skill / `ruview_claim_check` tool). Never present WiFi output as
 camera-grade.
 
 ## Pick a path
 
-Run `ruview.onboard {path}` or decide from:
+Run `ruview_onboard {path}` or decide from:
 
 1. **docker-demo** — fastest, no hardware. Replays sample CSI into the dashboard.
    `docker run -p 8000:8000 ruvnet/wifi-densepose` → open `http://localhost:8000`.
@@ -26,5 +26,5 @@ Run `ruview.onboard {path}` or decide from:
 ## Then
 
 - Live sensing → go to **provision-node**, then **calibrate-room**.
-- Evaluating a model/claim → go to **verify** and run `ruview.claim_check` on any
+- Evaluating a model/claim → go to **verify** and run `ruview_claim_check` on any
   report before you quote a number.

harness/ruview/skills/provision-node.md

@@ -28,7 +28,7 @@ esptool --chip esp32s3 -p <PORT> -b 460800 write_flash \
   0xf000 ota_data_initial.bin  0x20000 esp32-csi-node-s3-8mb.bin
 ```
 
-(`ruview.node_flash` returns the exact pinned command rather than running an
+(`ruview_node_flash` returns the exact pinned command rather than running an
 unattended flash.)
 
 ## 3. Provision
@@ -44,6 +44,6 @@ Never echo or commit the WiFi password.
 
 ## 4. Confirm CSI is flowing
 
-`ruview.node_monitor {port}` — PASS criteria: serial shows `CSI cb #...` callbacks and
+`ruview_node_monitor {port}` — PASS criteria: serial shows `CSI cb #...` callbacks and
 (on a bare board) `CSI filter upgraded to MGMT+DATA`. No callbacks → the node isn't
 capturing; do not proceed to calibration.

harness/ruview/skills/train-pose.md

@@ -29,5 +29,5 @@ or temporal leakage. Example honest result (ADR-181):
 1. Run the mean-pose baseline on the same split.
 2. Report `(model − baseline)` in pp, with the split definition (chronological /
    blocked-gap / grouped-bucket; no leakage).
-3. `ruview.claim_check` the writeup — it flags any untagged or 100%/perfect claim.
+3. `ruview_claim_check` the writeup — it flags any untagged or 100%/perfect claim.
 4. If it's a benchmark vs SOTA, tag MEASURED-EQUIVALENT only with the reproducer.

harness/ruview/skills/verify.md

@@ -9,7 +9,7 @@ The "prove everything" skill. Nothing ships as validated without this.
 
 ## Deterministic proof (Trust Kill Switch)
 
-`ruview.verify` runs `archive/v1/data/proof/verify.py`: it feeds a reference signal
+`ruview_verify` runs `archive/v1/data/proof/verify.py`: it feeds a reference signal
 through the production pipeline and hashes the output against
 `expected_features.sha256`. Must print **VERDICT: PASS**. If numpy/scipy changed the
 hash, regenerate with `verify.py --generate-hash` then re-verify.
@@ -28,7 +28,7 @@ crate versions — a recipient can re-verify with one command.
 
 ## Claim honesty
 
-Run `ruview.claim_check {text}` on any report, README section, PR body, or model card
+Run `ruview_claim_check {text}` on any report, README section, PR body, or model card
 before quoting accuracy. It flags:
 - untagged accuracy numbers (must be MEASURED / CLAIMED / SYNTHETIC),
 - MEASURED claims with no reproducer cited,

harness/ruview/src/guardrails.js

@@ -4,15 +4,44 @@
 // The project was accused of AI-slop; the cultural fix is that every accuracy
 // number must be tagged MEASURED (with a reproducer) or CLAIMED/SYNTHETIC, and
 // the retracted "100% accuracy" framing must never reappear untagged. This module
-// is the static enforcement of that, shared by the `ruview.claim_check` MCP tool,
+// is the static enforcement of that, shared by the `ruview_claim_check` MCP tool,
 // the `npx ruview claim-check` CLI, and the claude-code pre-output hook.
 
-/** Phrases that signal a quantitative accuracy claim. */
+/** Phrases that signal a quantitative accuracy claim (safe as substrings). */
 const METRIC_TERMS = [
-  'accuracy', 'pck', 'pck@', 'f1', 'precision', 'recall', 'map', 'auc',
-  'iou', 'mpjpe', 'error rate', 'detection rate', 'true positive',
+  'accuracy', 'pck', 'precision', 'recall',
+  'mpjpe', 'error rate', 'detection rate', 'true positive',
 ];
 
+// Short/ambiguous metric tokens (ADR-263 F11): 'map' is usually the English
+// word or a file extension, 'f1'/'o1' collide with finding/option labels.
+// They only count as metric mentions when word-bounded, not a `.map` file
+// reference, and the line (after scrubbing) carries a number — "mAP 62.3" is
+// a claim, "F-numbers map to findings" is not.
+// 'map' additionally must not be a `.map` file suffix or a hyphenated
+// compound ("map-free", "map-reduce") — mAP the metric never appears as either.
+const METRIC_TERMS_SHORT = [/(?<![.\w])map\b(?!-)/, /\bf1\b/, /\bauc\b/, /\biou\b/];
+// Finding/option labels (F1, O2, …) count as labels unless the token sits in a
+// metric context: an immediately following score/=/%/digit or colon ("F1: 0.91"),
+// or a number later in the same clause ("F1 reaches 0.91" — an F1-score claim).
+// Bare option refs ("F7 fixes", "O1–O9", "ADR-263 O2") carry no clause number of
+// their own and stay labels. (A surviving 'f1' still only fires as a metric when
+// its scrubbed line actually carries a number — see mentionsMetricTerm.)
+const LABEL_TOKEN_RE = /\b[fo]\d+\b(?!\s*(?:score|=|\d|%|:))(?![^\n.;]*\d)/g;
+const CODE_SPAN_RE = /`[^`]*`/g; // backticked identifiers are code, not claims
+const HAS_NUMBER_RE = /\d/;
+
+/** Line with code spans and finding/option labels removed. */
+function scrubLine(lower) {
+  return lower.replace(CODE_SPAN_RE, ' ').replace(LABEL_TOKEN_RE, ' ');
+}
+
+function mentionsMetricTerm(lower, scrubbed) {
+  if (METRIC_TERMS.some((t) => lower.includes(t))) return true;
+  if (!HAS_NUMBER_RE.test(scrubbed)) return false;
+  return METRIC_TERMS_SHORT.some((re) => re.test(scrubbed));
+}
+
 /** Tags that make a claim honest (case-insensitive). */
 const HONEST_TAGS = ['measured', 'claimed', 'synthetic', 'unvalidated', 'baseline'];
 
@@ -20,6 +49,8 @@ const HONEST_TAGS = ['measured', 'claimed', 'synthetic', 'unvalidated', 'baselin
 const REPRODUCER_HINTS = [
   'verify.py', 'witness', 'mean-pose', 'mean pose', 'held-out', 'held out',
   'baseline', 'reproduce', 'sha256', 'boot log', 'pck@20 vs', 'expected_features',
+  // Packaging-claim reproducers (ADR-263/264 npm reviews): the tarball itself.
+  'npm pack', 'npm view', 'npm i ', 'npm install', 'tarball', 'cargo test',
 ];
 
 const PERCENT_RE = /\b(\d{1,3}(?:\.\d+)?)\s?%/g;
@@ -49,7 +80,8 @@ export function claimCheck(text) {
 
     const hasPercent = PERCENT_RE.test(line);
     PERCENT_RE.lastIndex = 0; // reset stateful global regex
-    const mentionsMetric = METRIC_TERMS.some((t) => lower.includes(t));
+    const scrubbed = scrubLine(lower);
+    const mentionsMetric = mentionsMetricTerm(lower, scrubbed);
     if (!hasPercent && !mentionsMetric) return;
 
     const tagged = HONEST_TAGS.some((t) => lower.includes(t));
@@ -67,6 +99,15 @@ export function claimCheck(text) {
       return;
     }
 
+    // A quantitative claim needs a number. Digits hidden in a code span still
+    // count — "accuracy reached `0.95`" is a claim — so test the line with only
+    // finding/option labels stripped, NOT the code-span-scrubbed copy: scrubbing
+    // dropped `0.95` and wrongly short-circuited both the untagged and the
+    // MEASURED-without-reproducer checks below. A bare metric word in prose
+    // ("precision matters here", "every accuracy number must be MEASURED") has no
+    // number and is not a taggable claim (ADR-263 F11).
+    if (!hasPercent && !HAS_NUMBER_RE.test(lower.replace(LABEL_TOKEN_RE, ' '))) return;
+
     // A metric/percent with no honesty tag at all.
     if (!tagged) {
       findings.push({
@@ -79,7 +120,8 @@ export function claimCheck(text) {
       return;
     }
 
-    // Tagged MEASURED but cites no reproducer — still a gap.
+    // Tagged MEASURED but cites no reproducer — still a gap (reached now even
+    // when the only number is inside a code span, e.g. "accuracy `0.97` (MEASURED)").
     if (lower.includes('measured') && !hasReproducer) {
       findings.push({
         severity: 'medium',

harness/ruview/src/mcp-server.js

@@ -3,14 +3,23 @@
 //
 // Dependency-free on purpose: a published `npx ruview` must `mcp start` without
 // pulling the full MCP SDK. Implements the subset hosts use: `initialize`,
-// `tools/list`, `tools/call`, and the `notifications/initialized` ack. Logs go to
-// stderr ONLY — stdout is the JSON-RPC channel and must stay clean.
+// `tools/list`, `tools/call`, `ping`, empty `resources/list`/`prompts/list`
+// stubs, and the `notifications/initialized` ack. Logs go to stderr ONLY —
+// stdout is the JSON-RPC channel and must stay clean.
+//
+// ADR-263 O2: `tools/call` is dispatched asynchronously — a long-running
+// verify/calibrate no longer blocks ping/tools/list, so hosts that health-check
+// mid-run see a live server. Responses may therefore arrive out of request
+// order, which JSON-RPC permits (ids correlate them).
 
 import { createInterface } from 'node:readline';
+import { readFileSync } from 'node:fs';
 import { listTools, runTool } from './tools.js';
 
 const PROTOCOL_VERSION = '2024-11-05';
-const SERVER_INFO = { name: 'ruview', version: '0.1.0' };
+// Single-source the version from package.json (ADR-263 O6).
+const PKG = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const SERVER_INFO = { name: 'ruview', version: PKG.version };
 
 function send(msg) {
   process.stdout.write(JSON.stringify(msg) + '\n');
@@ -19,7 +28,7 @@ function result(id, res) { send({ jsonrpc: '2.0', id, result: res }); }
 function error(id, code, message) { send({ jsonrpc: '2.0', id, error: { code, message } }); }
 function log(...a) { process.stderr.write('[ruview-mcp] ' + a.join(' ') + '\n'); }
 
-function handle(msg) {
+async function handle(msg) {
   const { id, method, params } = msg;
   switch (method) {
     case 'initialize':
@@ -27,19 +36,24 @@ function handle(msg) {
         protocolVersion: PROTOCOL_VERSION,
         capabilities: { tools: { listChanged: false } },
         serverInfo: SERVER_INFO,
-        instructions: 'RuView WiFi-sensing operator tools. All results are fail-closed; accuracy claims must pass ruview.claim_check.',
+        instructions: 'RuView WiFi-sensing operator tools. All results are fail-closed; accuracy claims must pass ruview_claim_check.',
       });
     case 'notifications/initialized':
     case 'initialized':
-      return; // notification — no response
+    case 'notifications/cancelled':
+      return; // notifications — no response
     case 'ping':
       return result(id, {});
     case 'tools/list':
       return result(id, { tools: listTools() });
+    case 'resources/list':
+      return result(id, { resources: [] });
+    case 'prompts/list':
+      return result(id, { prompts: [] });
     case 'tools/call': {
       const name = params?.name;
       const args = params?.arguments || {};
-      const out = runTool(name, args);
+      const out = await runTool(name, args);
       // MCP content envelope: text block with the JSON, isError reflects ok=false.
       return result(id, {
         content: [{ type: 'text', text: JSON.stringify(out, null, 2) }],
@@ -52,17 +66,42 @@ function handle(msg) {
 }
 
 export function startMcpServer() {
-  log(`starting (protocol ${PROTOCOL_VERSION}, ${listTools().length} tools)`);
+  log(`starting v${SERVER_INFO.version} (protocol ${PROTOCOL_VERSION}, ${listTools().length} tools)`);
   const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+  // tools/call runs are serialized through a FIFO promise chain: hardware/mutating
+  // tools (calibrate, serial monitor, flash) must never overlap. ping/tools/list/
+  // initialize/resources/prompts stay immediate (ADR-263 O2 — a health check must
+  // answer during a long tool run). `toolChain` also lets stdin-close drain the
+  // in-flight call so its response is flushed instead of dropped by process.exit.
+  let toolChain = Promise.resolve();
+
+  const dispatch = (msg) => handle(msg).catch((err) => {
+    if (msg && msg.id !== undefined) error(msg.id, -32603, String(err && err.message || err));
+    log('handler error:', String(err));
+  });
+
   rl.on('line', (line) => {
     const s = line.trim();
     if (!s) return;
     let msg;
     try { msg = JSON.parse(s); } catch { return log('bad JSON line dropped'); }
-    try { handle(msg); } catch (err) {
-      if (msg && msg.id !== undefined) error(msg.id, -32603, String(err && err.message || err));
-      log('handler error:', String(err));
+    if (msg && msg.method === 'tools/call') {
+      toolChain = toolChain.then(() => dispatch(msg)); // one tool at a time
+    } else {
+      dispatch(msg); // health/list/handshake answer immediately, even mid tool run
     }
   });
-  rl.on('close', () => { log('stdin closed — exiting'); process.exit(0); });
+
+  rl.on('close', () => {
+    // Wait for any queued/in-flight tool call to settle (its response written)
+    // before exiting — fire-and-forget used to race this and drop the response.
+    toolChain.then(() => {
+      log('stdin closed — exiting');
+      const done = () => process.exit(0);
+      // Pipe writes are async; flush buffered stdout before exit.
+      if (process.stdout.writableLength) process.stdout.once('drain', done);
+      else done();
+    });
+  });
 }

harness/ruview/src/tools.js

@@ -7,10 +7,15 @@
 // `wifi-densepose` binary, an ESP32 on a port) is absent, it returns an honest
 // negative — never a fabricated success. This mirrors the project's "prove
 // everything" rule and the RuField fail-closed posture (ADR-262 §3.3).
+//
+// ADR-263: handlers are async (promise-based spawn, never spawnSync) so the MCP
+// server keeps answering ping/tools/list while a long verify/calibrate runs.
+// Canonical tool names use underscores (host tool-name regexes commonly enforce
+// ^[a-zA-Z0-9_-]{1,64}$); the historical dotted names are accepted as aliases.
 
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { existsSync, accessSync, constants } from 'node:fs';
+import { join, dirname, resolve, delimiter } from 'node:path';
 import { claimCheck, summarize } from './guardrails.js';
 
 /** Walk up from `start` to find the RuView monorepo root (or null). */
@@ -27,22 +32,75 @@ export function findRepoRoot(start = process.cwd()) {
   return null;
 }
 
-function which(cmd) {
-  const probe = process.platform === 'win32'
-    ? spawnSync('where', [cmd], { encoding: 'utf8' })
-    : spawnSync('command', ['-v', cmd], { encoding: 'utf8', shell: true });
-  return probe.status === 0 ? (probe.stdout || '').trim().split(/\r?\n/)[0] : null;
+// Dep-free PATH scan (ADR-263 O8) — no shell subprocess per lookup. Only hits
+// are memoized: a miss can resolve later in a long-lived MCP session (the
+// operator installs python/the CLI mid-run), so misses are re-probed each call.
+const whichCache = new Map();
+export function which(cmd) {
+  if (whichCache.has(cmd)) return whichCache.get(cmd);
+  const isWin = process.platform === 'win32';
+  const exts = isWin
+    ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean)
+    : [''];
+  let found = null;
+  outer:
+  for (const dir of (process.env.PATH || '').split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of isWin ? ['', ...exts] : exts) {
+      const p = join(dir, cmd + ext);
+      try {
+        accessSync(p, isWin ? constants.F_OK : constants.X_OK);
+        found = p;
+        break outer;
+      } catch { /* keep scanning */ }
+    }
+  }
+  if (found !== null) whichCache.set(cmd, found);
+  return found;
 }
 
-function run(cmd, args, opts = {}) {
-  const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: opts.timeout ?? 120000, ...opts });
-  return {
-    status: r.status,
-    ok: r.status === 0,
-    stdout: (r.stdout || '').slice(-8000),
-    stderr: (r.stderr || '').slice(-4000),
-    error: r.error ? r.error.message : null,
-  };
+// Bounded output tails (ADR-263 O4): spawnSync's default 1 MiB maxBuffer killed
+// chatty children with ENOBUFS; handlers only ever surface the last few kB, so
+// keep rolling tails instead of the full stream.
+const STDOUT_TAIL = 65536;
+const STDERR_TAIL = 16384;
+
+/** Promise-based spawn with timeout + rolling output tails. */
+export function run(cmd, args, opts = {}) {
+  const timeout = opts.timeout ?? 120000;
+  return new Promise((resolvePromise) => {
+    let stdout = '';
+    let stderr = '';
+    let child;
+    try {
+      child = spawn(cmd, args, { cwd: opts.cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (e) {
+      resolvePromise({ status: null, ok: false, stdout: '', stderr: '', error: e.message });
+      return;
+    }
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timeout);
+    child.stdout.on('data', (d) => {
+      stdout = (stdout + d).slice(-STDOUT_TAIL);
+    });
+    child.stderr.on('data', (d) => {
+      stderr = (stderr + d).slice(-STDERR_TAIL);
+    });
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      resolvePromise({ status: null, ok: false, stdout, stderr, error: e.message });
+    });
+    child.on('close', (status) => {
+      clearTimeout(timer);
+      resolvePromise({
+        status,
+        ok: status === 0,
+        stdout,
+        stderr,
+        error: timedOut ? `timed out after ${timeout} ms` : null,
+      });
+    });
+  });
 }
 
 const ONBOARD_PATHS = {
@@ -51,12 +109,36 @@ const ONBOARD_PATHS = {
   'live-esp32': 'Real sensing. Flash an ESP32-S3 (see `provision-node` skill), point it at the sensing-server, then `calibrate → enroll → train-room → room-watch` (see `calibrate-room`). Good for an actual install.',
 };
 
+// Read-only serial monitor script; the port arrives via sys.argv (ADR-263 O5 —
+// never spliced into interpreter source).
+const MONITOR_SCRIPT = [
+  'import sys,time',
+  'try:',
+  ' import serial',
+  'except Exception as e:',
+  " print('NO_PYSERIAL'); sys.exit(3)",
+  'port=sys.argv[1]',
+  'dur=float(sys.argv[2])',
+  'ser=serial.Serial(port,115200,timeout=1)',
+  'csi=0; n=0; t=time.time()',
+  'while time.time()-t<dur:',
+  ' ln=ser.readline()',
+  ' if not ln: continue',
+  " s=ln.decode('utf-8','replace')",
+  ' n+=1',
+  " if 'CSI cb' in s or 'csi_collector' in s: csi+=1",
+  " if 'MGMT+DATA' in s: print('UPGRADE_MGMT_DATA')",
+  'ser.close()',
+  "print(f'LINES={n} CSI={csi}')",
+].join('\n');
+
 /**
  * The tool registry. Each entry: { title, description, inputSchema, handler }.
- * inputSchema is JSON-Schema (object). handler(args) → JSON-serializable result.
+ * inputSchema is JSON-Schema (object). handler(args) → JSON-serializable result
+ * (sync or promise). Canonical names are underscore-form.
  */
 export const TOOLS = {
-  'ruview.onboard': {
+  ruview_onboard: {
     title: 'Onboard',
     description: 'Pick a RuView setup path (docker-demo | repo-build | live-esp32) and print the next concrete command.',
     inputSchema: {
@@ -74,46 +156,50 @@ export const TOOLS = {
         repo_root: repo,
         paths: ONBOARD_PATHS,
         recommend: repo ? 'repo-build' : 'docker-demo',
-        note: 'WiFi sensing infers coarse pose/presence from CSI — it is not a camera. Accuracy claims must be MEASURED vs a baseline (run `ruview.claim_check`).',
+        note: 'WiFi sensing infers coarse pose/presence from CSI — it is not a camera. Accuracy claims must be MEASURED vs a baseline (run `ruview_claim_check`).',
       };
     },
   },
 
-  'ruview.claim_check': {
+  ruview_claim_check: {
     title: 'Claim check',
-    description: 'Static lint: scan text for untagged or overstated accuracy claims (the "prove everything" guardrail). Returns findings.',
+    description: 'Static lint: scan text for untagged or overstated accuracy claims (the "prove everything" guardrail). Returns findings. Fail-closed: empty input is an error, not a pass.',
     inputSchema: {
       type: 'object',
       required: ['text'],
       properties: { text: { type: 'string', description: 'The text to lint (a report, README section, PR body, model card).' } },
     },
     handler(args = {}) {
-      const result = claimCheck(String(args.text ?? ''));
+      const text = typeof args.text === 'string' ? args.text : '';
+      if (text.trim().length === 0) {
+        return { ok: false, reason: 'empty_text', hint: 'Pass the text to lint — an empty input must not pass an honesty gate.' };
+      }
+      const result = claimCheck(text);
       return { ...result, summary: summarize(result) };
     },
   },
 
-  'ruview.verify': {
+  ruview_verify: {
     title: 'Verify (witness)',
     description: 'Run the deterministic proof (archive/v1/data/proof/verify.py) and report VERDICT. Fail-closed if not in a RuView repo or python is missing.',
     inputSchema: {
       type: 'object',
       properties: { repo: { type: 'string', description: 'RuView repo root. Default: auto-detect from cwd.' } },
     },
-    handler(args = {}) {
+    async handler(args = {}) {
       const repo = args.repo ? resolve(args.repo) : findRepoRoot();
       if (!repo) return { ok: false, reason: 'not_in_ruview_repo', hint: 'Run inside the RuView monorepo or pass {repo}.' };
       const proof = join(repo, 'archive', 'v1', 'data', 'proof', 'verify.py');
       if (!existsSync(proof)) return { ok: false, reason: 'proof_missing', path: proof };
       const py = which('python') || which('python3');
       if (!py) return { ok: false, reason: 'python_missing', hint: 'Install python to run the deterministic proof.' };
-      const r = run(py, [proof], { cwd: repo, timeout: 180000 });
+      const r = await run(py, [proof], { cwd: repo, timeout: 180000 });
       const verdict = /VERDICT:\s*PASS/i.test(r.stdout) ? 'PASS' : (/VERDICT:\s*FAIL/i.test(r.stdout) ? 'FAIL' : 'UNKNOWN');
       return { ok: r.ok && verdict === 'PASS', verdict, exit: r.status, tail: r.stdout.slice(-1200), stderr: r.stderr.slice(-400) };
     },
   },
 
-  'ruview.node_monitor': {
+  ruview_node_monitor: {
     title: 'Node monitor',
     description: 'Open an ESP32 serial port and assert CSI is flowing (MGMT+DATA). Fail-closed if python+pyserial or the port is absent. Read-only.',
     inputSchema: {
@@ -123,31 +209,13 @@ export const TOOLS = {
         seconds: { type: 'number', description: 'Capture window (default 12).' },
       },
     },
-    handler(args = {}) {
+    async handler(args = {}) {
       const port = args.port;
-      if (!port) return { ok: false, reason: 'no_port', hint: 'Pass {port} (e.g. COM8).' };
+      if (!port || typeof port !== 'string') return { ok: false, reason: 'no_port', hint: 'Pass {port} (e.g. COM8).' };
       const py = which('python') || which('python3');
       if (!py) return { ok: false, reason: 'python_missing' };
       const dur = Number(args.seconds) > 0 ? Number(args.seconds) : 12;
-      const script = [
-        'import sys,time',
-        'try:',
-        ' import serial',
-        'except Exception as e:',
-        " print('NO_PYSERIAL'); sys.exit(3)",
-        `ser=serial.Serial(${JSON.stringify(port)},115200,timeout=1)`,
-        'csi=0; n=0; t=time.time()',
-        `while time.time()-t<${dur}:`,
-        ' ln=ser.readline()',
-        ' if not ln: continue',
-        " s=ln.decode('utf-8','replace')",
-        ' n+=1',
-        " if 'CSI cb' in s or 'csi_collector' in s: csi+=1",
-        " if 'MGMT+DATA' in s: print('UPGRADE_MGMT_DATA')",
-        'ser.close()',
-        "print(f'LINES={n} CSI={csi}')",
-      ].join('\n');
-      const r = run(py, ['-c', script], { timeout: (dur + 10) * 1000 });
+      const r = await run(py, ['-c', MONITOR_SCRIPT, port, String(dur)], { timeout: (dur + 10) * 1000 });
       if (r.stdout.includes('NO_PYSERIAL')) return { ok: false, reason: 'pyserial_missing', hint: 'pip install pyserial' };
       if (!r.ok) return { ok: false, reason: 'port_error', stderr: r.stderr, error: r.error };
       const csi = Number((r.stdout.match(/CSI=(\d+)/) || [])[1] || 0);
@@ -156,7 +224,7 @@ export const TOOLS = {
     },
   },
 
-  'ruview.calibrate': {
+  ruview_calibrate: {
     title: 'Calibrate room',
     description: 'Run the ADR-151 room pipeline via the wifi-densepose CLI (baseline→enroll→train-room). Fail-closed if the binary is absent.',
     inputSchema: {
@@ -166,7 +234,7 @@ export const TOOLS = {
         args: { type: 'array', items: { type: 'string' }, description: 'Extra CLI args passed through.' },
       },
     },
-    handler(args = {}) {
+    async handler(args = {}) {
       const step = args.step || 'baseline';
       const bin = which('wifi-densepose');
       const repo = findRepoRoot();
@@ -174,13 +242,13 @@ export const TOOLS = {
       const passthru = Array.isArray(args.args) ? args.args.map(String) : [];
       // Prefer the installed binary; otherwise cargo-run from the repo.
       const r = bin
-        ? run(bin, [step, ...passthru], { timeout: 300000 })
-        : run('cargo', ['run', '-q', '-p', 'wifi-densepose-cli', '--', step, ...passthru], { cwd: repo, timeout: 600000 });
+        ? await run(bin, [step, ...passthru], { timeout: 300000 })
+        : await run('cargo', ['run', '-q', '-p', 'wifi-densepose-cli', '--', step, ...passthru], { cwd: repo, timeout: 600000 });
       return { ok: r.ok, step, via: bin ? 'binary' : 'cargo', exit: r.status, tail: r.stdout.slice(-1500), stderr: r.stderr.slice(-500) };
     },
   },
 
-  'ruview.node_flash': {
+  ruview_node_flash: {
     title: 'Node flash',
     description: 'Build+flash an ESP32 firmware variant. MUTATING + hardware. Fail-closed off-Windows or without ESP-IDF. Never claims hardware validation without a boot log.',
     inputSchema: {
@@ -203,14 +271,27 @@ export const TOOLS = {
   },
 };
 
-/** Run one tool by name; returns the structured result (or an error envelope). */
-export function runTool(name, args) {
-  const tool = TOOLS[name];
-  if (!tool) return { ok: false, reason: 'unknown_tool', name, available: Object.keys(TOOLS) };
+// Historical dotted names (pre-ADR-263) accepted as call-time aliases; the
+// underscore form is what tools/list advertises.
+export const TOOL_ALIASES = Object.fromEntries(
+  Object.keys(TOOLS).map((name) => [name.replace(/_/, '.'), name])
+);
+
+/** Resolve a canonical or aliased tool name (or null). */
+export function resolveToolName(name) {
+  if (TOOLS[name]) return name;
+  if (TOOL_ALIASES[name]) return TOOL_ALIASES[name];
+  return null;
+}
+
+/** Run one tool by name (canonical or dotted alias); always resolves to the structured result. */
+export async function runTool(name, args) {
+  const canonical = resolveToolName(name);
+  if (!canonical) return { ok: false, reason: 'unknown_tool', name, available: Object.keys(TOOLS) };
   try {
-    return tool.handler(args || {});
+    return await TOOLS[canonical].handler(args || {});
   } catch (err) {
-    return { ok: false, reason: 'tool_threw', name, error: String(err && err.message || err) };
+    return { ok: false, reason: 'tool_threw', name: canonical, error: String(err && err.message || err) };
   }
 }
 

harness/ruview/test/mcp.test.mjs

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+// MCP stdio server e2e — spawns `bin/cli.js mcp start` and speaks JSON-RPC.
+// Pins ADR-263 O2 (ping answered while a long tools/call runs), O6 (version
+// from package.json), and O8 (underscore names advertised, dotted accepted,
+// resources/prompts stubs).
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { which } from '../src/tools.js';
+
+const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const CLI = join(PKG_ROOT, 'bin', 'cli.js');
+
+/** Start the MCP server; returns {send, next, close} where next(id) resolves the response with that id. */
+function startServer() {
+  const child = spawn(process.execPath, [CLI, 'mcp', 'start'], { stdio: ['pipe', 'pipe', 'pipe'] });
+  const waiters = new Map();
+  let buf = '';
+  child.stdout.on('data', (d) => {
+    buf += d;
+    let nl;
+    while ((nl = buf.indexOf('\n')) !== -1) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      const msg = JSON.parse(line);
+      const w = waiters.get(msg.id);
+      if (w) { waiters.delete(msg.id); w(msg); }
+    }
+  });
+  return {
+    send(msg) { child.stdin.write(JSON.stringify(msg) + '\n'); },
+    next(id) { return new Promise((res) => waiters.set(id, res)); },
+    close() { child.stdin.end(); child.kill(); },
+  };
+}
+
+test('MCP handshake: initialize reports the package.json version; list endpoints respond', async () => {
+  const pkg = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'));
+  const s = startServer();
+  try {
+    s.send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+    const init = await s.next(1);
+    assert.equal(init.result.serverInfo.version, pkg.version, 'ADR-263 O6: version must match package.json');
+
+    s.send({ jsonrpc: '2.0', id: 2, method: 'tools/list' });
+    const tools = (await s.next(2)).result.tools;
+    assert.equal(tools.length, 6);
+    for (const t of tools) assert.match(t.name, /^[a-zA-Z0-9_-]{1,64}$/, `advertised name not host-safe: ${t.name}`);
+
+    s.send({ jsonrpc: '2.0', id: 3, method: 'resources/list' });
+    assert.deepEqual((await s.next(3)).result, { resources: [] });
+    s.send({ jsonrpc: '2.0', id: 4, method: 'prompts/list' });
+    assert.deepEqual((await s.next(4)).result, { prompts: [] });
+
+    // Dotted legacy name still callable (alias).
+    s.send({ jsonrpc: '2.0', id: 5, method: 'tools/call', params: { name: 'ruview.onboard', arguments: {} } });
+    const call = await s.next(5);
+    assert.equal(call.result.isError, false);
+  } finally {
+    s.close();
+  }
+});
+
+test('MCP server answers ping while a long tools/call is in flight (ADR-263 O2)', { skip: !which('python') && !which('python3') ? 'python not on PATH' : false }, async () => {
+  // Fake RuView repo whose verify.py sleeps 3 s then passes.
+  const repo = mkdtempSync(join(tmpdir(), 'ruview-mcp-e2e-'));
+  const proofDir = join(repo, 'archive', 'v1', 'data', 'proof');
+  mkdirSync(proofDir, { recursive: true });
+  writeFileSync(join(proofDir, 'verify.py'), 'import time\ntime.sleep(3)\nprint("VERDICT: PASS")\n');
+
+  const s = startServer();
+  try {
+    s.send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+    await s.next(1);
+
+    const verifyDone = s.next(10);
+    s.send({ jsonrpc: '2.0', id: 10, method: 'tools/call', params: { name: 'ruview_verify', arguments: { repo } } });
+
+    // Give the server a beat to start the child, then ping.
+    await new Promise((r) => setTimeout(r, 300));
+    const t0 = Date.now();
+    const pinged = s.next(11);
+    s.send({ jsonrpc: '2.0', id: 11, method: 'ping' });
+    await pinged;
+    const pingMs = Date.now() - t0;
+    assert.ok(pingMs < 1000, `ping took ${pingMs} ms while verify was in flight — server is blocking`);
+
+    const verify = await verifyDone;
+    const payload = JSON.parse(verify.result.content[0].text);
+    assert.equal(payload.verdict, 'PASS');
+  } finally {
+    s.close();
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test('tools/call executions are serialized — two slow calls run sequentially', { skip: !which('python') && !which('python3') ? 'python not on PATH' : false }, async () => {
+  // Two verify.py that each sleep 0.8 s. Serialized ⇒ ~1.6 s+; concurrent ⇒ ~0.8 s.
+  const repo = mkdtempSync(join(tmpdir(), 'ruview-mcp-serial-'));
+  const proofDir = join(repo, 'archive', 'v1', 'data', 'proof');
+  mkdirSync(proofDir, { recursive: true });
+  writeFileSync(join(proofDir, 'verify.py'), 'import time\ntime.sleep(0.8)\nprint("VERDICT: PASS")\n');
+
+  const s = startServer();
+  try {
+    s.send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+    await s.next(1);
+
+    const t0 = Date.now();
+    const a = s.next(20);
+    const b = s.next(21);
+    s.send({ jsonrpc: '2.0', id: 20, method: 'tools/call', params: { name: 'ruview_verify', arguments: { repo } } });
+    s.send({ jsonrpc: '2.0', id: 21, method: 'tools/call', params: { name: 'ruview_verify', arguments: { repo } } });
+    const [ra, rb] = await Promise.all([a, b]);
+    const elapsed = Date.now() - t0;
+
+    assert.equal(JSON.parse(ra.result.content[0].text).verdict, 'PASS');
+    assert.equal(JSON.parse(rb.result.content[0].text).verdict, 'PASS');
+    assert.ok(elapsed > 1400, `two 0.8 s tool calls finished in ${elapsed} ms — they overlapped instead of serializing`);
+  } finally {
+    s.close();
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test('stdin close flushes an in-flight tools/call response before exit', async () => {
+  const child = spawn(process.execPath, [CLI, 'mcp', 'start'], { stdio: ['pipe', 'pipe', 'pipe'] });
+  let out = '';
+  child.stdout.on('data', (d) => { out += d; });
+  const exited = new Promise((res) => child.on('exit', res));
+
+  // Write a tools/call then immediately close stdin. The old fire-and-forget
+  // dispatch raced rl 'close' → process.exit and could drop this response.
+  child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 42, method: 'tools/call', params: { name: 'ruview_onboard', arguments: {} } }) + '\n');
+  child.stdin.end();
+
+  await exited;
+  const msgs = out.trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
+  const resp = msgs.find((m) => m.id === 42);
+  assert.ok(resp, 'the in-flight tools/call response must be flushed to stdout before exit');
+  assert.equal(resp.result.isError, false);
+});

harness/ruview/test/tools.test.mjs

@@ -1,12 +1,18 @@
 // SPDX-License-Identifier: MIT
 // RuView harness tests — Node's built-in test runner (no devDeps to install).
-// Run: `node --test test/`  (or `npm test`).
+// Run: `node --test test/*.test.mjs`  (or `npm test`).
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import { readdirSync, readFileSync, mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join, dirname, delimiter } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
 import { claimCheck, summarize } from '../src/guardrails.js';
-import { TOOLS, runTool, listTools, findRepoRoot } from '../src/tools.js';
-import { run } from '../bin/cli.js';
+import { TOOLS, TOOL_ALIASES, runTool, listTools, findRepoRoot, run, which } from '../src/tools.js';
+import { run as cliRun } from '../bin/cli.js';
+
+const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 
 test('guardrail flags the retracted 100% framing as high severity', () => {
   const r = claimCheck('Our model reaches 100% accuracy on every pose.');
@@ -37,71 +43,190 @@ test('guardrail ignores non-metric prose', () => {
   assert.equal(claimCheck('').ok, true);
 });
 
+// ADR-263 F11/O9: precision pins — short metric tokens must not fire on prose.
+test('guardrail does not false-positive on "map"/"F1" prose (ADR-263 F11)', () => {
+  assert.equal(claimCheck('F-numbers map to findings.').ok, true);
+  assert.equal(claimCheck('### F1 (HIGH, broken export): `require` points at a missing file').ok, true);
+  assert.equal(claimCheck('The 0.1.0 tarball ships 44 `.map` files = 62,698 B of dead weight.').ok, true);
+  assert.equal(claimCheck('the source maps can never resolve').ok, true);
+  assert.equal(claimCheck('- **O1 (F1):** fix `exports` (see F2 for the 33% map weight — MEASURED, tarball listing)').ok, true);
+  assert.equal(claimCheck('ADR-264: exports fix, map-free tarball, session-per-transport').ok, true);
+});
+
+test('guardrail still catches real short-token metric claims', () => {
+  assert.equal(claimCheck('We reach mAP 62.3 on COCO.').ok, false);
+  assert.equal(claimCheck('F1 score of 0.91 on the held set.').ok, false, 'f1 with a real score must still fire');
+  assert.equal(claimCheck('IoU 0.75 across rooms.').ok, false);
+});
+
+// Digits hidden in a code span still make a claim — scrubbing must not blind the
+// number gate to `0.95` (regression: code-span number bypassed the gate).
+test('guardrail flags an accuracy number stated inside a code span', () => {
+  const r = claimCheck('Count accuracy reached `0.95` in our tests.');
+  assert.equal(r.ok, false, JSON.stringify(r.findings));
+  assert.ok(r.findings.some((f) => /not tagged/i.test(f.reason)));
+});
+
+// A MEASURED claim whose only number hides in a code span must still reach the
+// missing-reproducer check (regression: the scrubbed gate short-circuited it).
+// Bare metric prose with no number at all (e.g. the README rule text) stays a pass.
+test('guardrail flags a MEASURED code-span number with no reproducer', () => {
+  const r = claimCheck('Detection accuracy `0.97` on the set (MEASURED).');
+  assert.equal(r.ok, false, JSON.stringify(r.findings));
+  assert.ok(r.findings.some((f) => /no reproducer/i.test(f.reason)));
+  assert.equal(claimCheck('Every accuracy number must be MEASURED against a baseline.').ok, true);
+});
+
+// F1-score phrasings ("F1: 0.91", "F1 reaches 0.91") were scrubbed as option
+// labels and slipped through; option refs alone must still not false-positive.
+test('guardrail catches F1-score claims but not bare option refs (ADR-263 F11)', () => {
+  assert.equal(claimCheck('F1: 0.91 on the held-out set.').ok, false, 'F1: value is a metric claim');
+  assert.equal(claimCheck('F1 reaches 0.91 on the held-out set.').ok, false, 'F1 with a nearby number is a claim');
+  assert.equal(claimCheck('Options O1–O9 are tracked in ADR-263 O2.').ok, true, 'option labels are not metrics');
+  assert.equal(claimCheck('ADR-263 O2 lands the exports fix.').ok, true);
+});
+
 test('summarize gives PASS/finding text', () => {
   assert.match(summarize(claimCheck('nothing here')), /PASS/);
   assert.match(summarize(claimCheck('100% accuracy')), /finding/);
 });
 
-test('registry exposes the documented tools with schemas', () => {
+test('registry exposes the documented tools with schemas (underscore-canonical)', () => {
   const names = Object.keys(TOOLS);
-  for (const n of ['ruview.onboard', 'ruview.claim_check', 'ruview.verify', 'ruview.node_monitor', 'ruview.calibrate', 'ruview.node_flash']) {
+  for (const n of ['ruview_onboard', 'ruview_claim_check', 'ruview_verify', 'ruview_node_monitor', 'ruview_calibrate', 'ruview_node_flash']) {
     assert.ok(names.includes(n), `missing ${n}`);
     assert.equal(TOOLS[n].inputSchema.type, 'object');
+    assert.match(n, /^[a-zA-Z0-9_-]{1,64}$/, 'canonical names must satisfy host tool-name regexes');
   }
   assert.equal(listTools().length, names.length);
 });
 
-test('ruview.onboard returns paths and a recommendation', () => {
-  const r = runTool('ruview.onboard', {});
+test('dotted legacy names resolve via aliases (ADR-263 O8)', async () => {
+  assert.equal(TOOL_ALIASES['ruview.claim_check'], 'ruview_claim_check');
+  assert.equal(TOOL_ALIASES['ruview.node_monitor'], 'ruview_node_monitor');
+  const r = await runTool('ruview.onboard', {});
+  assert.equal(r.ok, true);
+});
+
+test('ruview_onboard returns paths and a recommendation', async () => {
+  const r = await runTool('ruview_onboard', {});
   assert.equal(r.ok, true);
   assert.ok(r.paths['live-esp32']);
   assert.ok(['repo-build', 'docker-demo'].includes(r.recommend));
 });
 
-test('ruview.claim_check tool wraps the guardrail', () => {
-  const r = runTool('ruview.claim_check', { text: '100% accuracy' });
+test('ruview_claim_check tool wraps the guardrail', async () => {
+  const r = await runTool('ruview_claim_check', { text: '100% accuracy' });
   assert.equal(r.ok, false);
   assert.match(r.summary, /honesty|tag|MEASURED|finding/i);
 });
 
-test('unknown tool fails closed', () => {
-  const r = runTool('ruview.does_not_exist', {});
+// ADR-263 F1/O1: the honesty gate must fail closed on empty input.
+test('ruview_claim_check fails closed on empty/missing text', async () => {
+  const empty = await runTool('ruview_claim_check', { text: '' });
+  assert.equal(empty.ok, false);
+  assert.equal(empty.reason, 'empty_text');
+  const missing = await runTool('ruview_claim_check', {});
+  assert.equal(missing.ok, false);
+  assert.equal(missing.reason, 'empty_text');
+});
+
+test('unknown tool fails closed', async () => {
+  const r = await runTool('ruview_does_not_exist', {});
   assert.equal(r.ok, false);
   assert.equal(r.reason, 'unknown_tool');
 });
 
-test('node_monitor fails closed without a port', () => {
-  const r = runTool('ruview.node_monitor', {});
+test('node_monitor fails closed without a port', async () => {
+  const r = await runTool('ruview_node_monitor', {});
   assert.equal(r.ok, false);
   assert.equal(r.reason, 'no_port');
 });
 
-test('node_flash refuses without confirm (mutating guard)', () => {
-  const r = runTool('ruview.node_flash', { port: 'COM8', variant: 's3-8mb' });
+test('node_flash refuses without confirm (mutating guard)', async () => {
+  const r = await runTool('ruview_node_flash', { port: 'COM8', variant: 's3-8mb' });
   assert.equal(r.ok, false);
   // either not-confirmed (win32) or unsupported_platform (posix) — both fail-closed
   assert.ok(['not_confirmed', 'unsupported_platform'].includes(r.reason));
 });
 
-test('verify fails closed when not in a RuView repo', () => {
+test('verify fails closed when not in a RuView repo', async () => {
   // point at a tmp dir with no repo markers
-  const r = runTool('ruview.verify', { repo: process.platform === 'win32' ? 'C:/Windows/Temp' : '/tmp' });
+  const r = await runTool('ruview_verify', { repo: process.platform === 'win32' ? 'C:/Windows/Temp' : '/tmp' });
   assert.equal(r.ok, false);
   assert.ok(['proof_missing', 'python_missing'].includes(r.reason), r.reason);
 });
 
+// ADR-263 F2/O2: registry-level concurrency — a slow child must not block
+// other tool calls (run() is promise-based, never spawnSync).
+test('run() is non-blocking: a fast tool completes while a slow child runs', async () => {
+  const slow = run('node', ['-e', 'setTimeout(() => {}, 2000)'], { timeout: 5000 });
+  const t0 = Date.now();
+  const fast = await runTool('ruview_onboard', {});
+  const elapsed = Date.now() - t0;
+  assert.equal(fast.ok, true);
+  assert.ok(elapsed < 1000, `onboard took ${elapsed} ms while a 2 s child was running`);
+  const r = await slow;
+  assert.equal(r.ok, true);
+});
+
+test('run() reports a timeout as a failure, not a hang', async () => {
+  const r = await run('node', ['-e', 'setTimeout(() => {}, 10000)'], { timeout: 300 });
+  assert.equal(r.ok, false);
+  assert.match(String(r.error), /timed out/);
+});
+
+test('run() bounds captured output instead of dying on big streams (ADR-263 O4)', async () => {
+  // 4 MiB of stdout would have hit spawnSync's 1 MiB default maxBuffer (ENOBUFS).
+  const r = await run('node', ['-e', "process.stdout.write('x'.repeat(4 * 1024 * 1024)); console.log('TAIL_MARKER')"], { timeout: 30000 });
+  assert.equal(r.ok, true);
+  assert.ok(r.stdout.length <= 65536, `tail not bounded: ${r.stdout.length}`);
+  assert.ok(r.stdout.includes('TAIL_MARKER'), 'tail must keep the end of the stream');
+});
+
+test('which() finds node and re-probes misses (hits are cached)', () => {
+  assert.ok(which('node'), 'node must be on PATH in the test env');
+  assert.equal(which('definitely-not-a-binary-xyz'), null);
+  assert.equal(which('definitely-not-a-binary-xyz'), null); // re-probed, still absent
+});
+
+// ADR-263 O8: a miss must not be cached — an operator who installs a tool
+// mid-session (e.g. python after a python_missing failure) must be found next call.
+test('which() re-probes after a miss so a newly-installed tool is found', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'ruview-which-'));
+  const name = 'ruview-probe-xyz';
+  const isWin = process.platform === 'win32';
+  const bin = join(dir, isWin ? `${name}.cmd` : name);
+  const prevPath = process.env.PATH;
+  try {
+    assert.equal(which(name), null, 'not on PATH yet → miss');
+    writeFileSync(bin, isWin ? '@echo off\n' : '#!/bin/sh\n', { mode: 0o755 });
+    process.env.PATH = dir + delimiter + prevPath;
+    assert.ok(which(name), 'installed mid-session → the miss must not have been cached');
+  } finally {
+    process.env.PATH = prevPath;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test('CLI run(): claim-check exits non-zero on a bad claim', async () => {
-  const code = await run(['claim-check', '--text', '100% accuracy']);
+  const code = await cliRun(['claim-check', '--text', '100% accuracy']);
   assert.notEqual(code, 0);
 });
 
+// ADR-263 F1/O1: the CLI must not PASS silently with no input.
+test('CLI run(): claim-check with no input exits 2 (fail-closed)', async () => {
+  assert.equal(await cliRun(['claim-check']), 2);
+  assert.equal(await cliRun(['claim-check', '--text', '   ']), 2);
+});
+
 test('CLI run(): doctor exits 0 (tools-only path)', async () => {
-  const code = await run(['doctor']);
+  const code = await cliRun(['doctor']);
   assert.equal(code, 0);
 });
 
 test('CLI run(): unknown command exits non-zero', async () => {
-  assert.notEqual(await run(['definitely-not-a-command']), 0);
+  assert.notEqual(await cliRun(['definitely-not-a-command']), 0);
 });
 
 test('findRepoRoot locates this monorepo from cwd', () => {
@@ -109,3 +234,23 @@ test('findRepoRoot locates this monorepo from cwd', () => {
   const root = findRepoRoot();
   assert.ok(root === null || typeof root === 'string');
 });
+
+// ADR-263 F7/O7: skills ship from one source; the projected copies must match.
+test('.claude/skills/*/SKILL.md are byte-identical to skills/*.md', () => {
+  const srcDir = join(PKG_ROOT, 'skills');
+  for (const f of readdirSync(srcDir).filter((f) => f.endsWith('.md'))) {
+    const name = f.replace(/\.md$/, '');
+    const src = readFileSync(join(srcDir, f), 'utf8');
+    const projected = readFileSync(join(PKG_ROOT, '.claude', 'skills', name, 'SKILL.md'), 'utf8');
+    assert.equal(projected, src, `skill drift: ${name} — run \`npm run sync-skills\``);
+  }
+});
+
+// ADR-263 F6/O6 + F3/O3: package hygiene pins.
+test('package.json has no optionalDependencies and no hardcoded server version drift', () => {
+  const pkg = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'));
+  assert.equal(pkg.optionalDependencies, undefined, 'ADR-263 O3: optional deps tripled the cold npx install');
+  assert.equal(pkg.dependencies, undefined, 'the harness is dependency-free by design');
+  const mcpSrc = readFileSync(join(PKG_ROOT, 'src', 'mcp-server.js'), 'utf8');
+  assert.ok(!/version:\s*'\d+\.\d+\.\d+'/.test(mcpSrc), 'ADR-263 O6: server version must come from package.json');
+});

scripts/firmware-release-guard.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+#
+# firmware-release-guard.sh — guard against shipping firmware built from a
+# stale generated `sdkconfig` (the v0.8.3-esp32 release bug).
+#
+# Symptom it catches: an incremental build reuses a leftover `sdkconfig`
+# instead of `sdkconfig.defaults`, so an "8MB" build silently links the 4MB
+# dual-OTA partition layout (no spiffs, ota_1 @ 0x1F0000) and the released
+# `partition-table.bin` does not match the flash-size variant it claims to be.
+#
+# What it does: for the named flash-size variant, regenerate the EXPECTED
+# partition table from the partition CSV that variant must use, and byte-compare
+# it against the freshly built `partition-table.bin`. Also cross-checks the
+# flash size recorded in the build's `flasher_args.json`. Exits non-zero on any
+# mismatch so a release pipeline fails closed.
+#
+# Usage:
+#   scripts/firmware-release-guard.sh <8mb|4mb> <build-dir>
+#
+# Example:
+#   scripts/firmware-release-guard.sh 8mb firmware/esp32-csi-node/build
+#
+set -euo pipefail
+
+VARIANT="${1:-}"
+BUILD_DIR="${2:-}"
+
+if [[ -z "$VARIANT" || -z "$BUILD_DIR" ]]; then
+  echo "usage: $0 <8mb|4mb> <build-dir>" >&2
+  exit 2
+fi
+
+# Firmware project root (this script lives in <repo>/scripts).
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+FW_DIR="$SCRIPT_DIR/../firmware/esp32-csi-node"
+
+case "$VARIANT" in
+  8mb) EXPECT_CSV="partitions_display.csv"; EXPECT_FLASH="8MB" ;;
+  4mb) EXPECT_CSV="partitions_4mb.csv";     EXPECT_FLASH="4MB" ;;
+  *)   echo "ERROR: unknown variant '$VARIANT' (want 8mb|4mb)" >&2; exit 2 ;;
+esac
+
+BUILT_PT="$BUILD_DIR/partition_table/partition-table.bin"
+CSV_PATH="$FW_DIR/$EXPECT_CSV"
+
+[[ -f "$BUILT_PT" ]]  || { echo "ERROR: built partition table not found: $BUILT_PT" >&2; exit 1; }
+[[ -f "$CSV_PATH" ]]  || { echo "ERROR: expected CSV not found: $CSV_PATH" >&2; exit 1; }
+
+# Locate the ESP-IDF partition table generator.
+GEN="${IDF_PATH:-}/components/partition_table/gen_esp32part.py"
+if [[ ! -f "$GEN" ]]; then
+  GEN="C:/Users/ruv/esp/v5.4/esp-idf/components/partition_table/gen_esp32part.py"
+fi
+[[ -f "$GEN" ]] || { echo "ERROR: gen_esp32part.py not found (set IDF_PATH)" >&2; exit 1; }
+
+PY="${PYTHON:-python}"
+command -v "$PY" >/dev/null 2>&1 || PY="C:/Espressif/tools/python/v5.4/venv/Scripts/python.exe"
+
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+EXPECT_PT="$TMP/expected-partition-table.bin"
+
+# Regenerate the expected table from the CSV this variant must use.
+"$PY" "$GEN" --quiet "$CSV_PATH" "$EXPECT_PT"
+
+fail=0
+
+if ! cmp -s "$EXPECT_PT" "$BUILT_PT"; then
+  echo "FAIL: built partition table does not match $EXPECT_CSV for the $VARIANT variant." >&2
+  echo "      The build likely reused a stale sdkconfig. Decoded built table:" >&2
+  "$PY" "$GEN" "$BUILT_PT" 2>/dev/null | grep -vE '^#|^Parsing|^Verifying' | sed 's/^/        /' >&2
+  fail=1
+fi
+
+# Cross-check the flash size the build actually targeted.
+FA="$BUILD_DIR/flasher_args.json"
+if [[ -f "$FA" ]]; then
+  GOT_FLASH="$("$PY" - "$FA" <<'PYEOF'
+import json,sys
+with open(sys.argv[1]) as f: d=json.load(f)
+print(d.get("flash_settings",{}).get("flash_size",""))
+PYEOF
+)"
+  if [[ "$GOT_FLASH" != "$EXPECT_FLASH" ]]; then
+    echo "FAIL: flasher_args.json flash_size='$GOT_FLASH', expected '$EXPECT_FLASH'." >&2
+    fail=1
+  fi
+fi
+
+if [[ "$fail" -ne 0 ]]; then
+  exit 1
+fi
+
+echo "OK: $VARIANT firmware build matches $EXPECT_CSV (flash_size=$EXPECT_FLASH)."

tools/ruview-cli/package-lock.json

@@ -12,7 +12,7 @@
         "yargs": "^17.7.2"
       },
       "bin": {
-        "ruview": "dist/index.js"
+        "ruview-cli": "dist/index.js"
       },
       "devDependencies": {
         "@types/node": "^20.14.0",

tools/ruview-cli/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ruv/ruview-cli",
   "version": "0.0.1",
-  "description": "RuView CLI — shell access to WiFi-DensePose sensing, inference, and training capabilities",
+  "description": "RuView CLI — shell access to WiFi-DensePose sensing, inference, and training capabilities. Private/unpublished; the `ruview` bin name belongs to @ruvnet/ruview (ADR-265 D4).",
   "private": true,
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "ruview": "dist/index.js"
+    "ruview-cli": "dist/index.js"
   },
   "files": [
     "dist"
@@ -15,7 +15,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest --passWithNoTests",
     "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit"
   },

tools/ruview-cli/src/index.ts

@@ -25,6 +25,7 @@
  * See ADR-104 for the full design rationale and security model.
  */
 
+import { createRequire } from "node:module";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { csiCommand } from "./commands/csi.js";
@@ -34,9 +35,15 @@ import { cogsCommand } from "./commands/cogs.js";
 import { trainCommand } from "./commands/train.js";
 import { jobCommand } from "./commands/job.js";
 
+// Single-source the version from package.json (ADR-265 D3).
+const require = createRequire(import.meta.url);
+const VERSION: string = (require("../package.json") as { version: string }).version;
+
+// Bin name is `ruview-cli`: the bare `ruview` bin belongs to @ruvnet/ruview
+// (ADR-264 O9 / ADR-265 D4).
 const cli = yargs(hideBin(process.argv))
-  .scriptName("ruview")
-  .version("0.0.1")
+  .scriptName("ruview-cli")
+  .version(VERSION)
   .usage("$0 <command> [options]")
   .strict()
   .help()

tools/ruview-mcp/README.md

@@ -2,52 +2,63 @@
 
 **SENSE-BRIDGE** is a dual-transport [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) server that bridges the RuView WiFi-DensePose sensing stack to AI agents (Claude Code, Cursor, ruflo swarms, and any MCP-compatible client).
 
-Install once; AI agents can then call `ruview.presence.now`, `ruview.vitals.get_heart_rate`, `ruview.bfld.last_scan`, and more — without writing HTTP or WebSocket client code.
+Install once; AI agents can then call `ruview_presence_now`, `ruview_vitals_get_heart_rate`, `ruview_bfld_last_scan`, and more — without writing HTTP or WebSocket client code.
 
 ## Quickstart
 
 ```bash
-# 1. Add to Claude Code
-claude mcp add rvagent -- npx @ruvnet/rvagent stdio
+# 1. Add to Claude Code (stdio transport — the default)
+claude mcp add rvagent -- npx -y @ruvnet/rvagent
 
 # 2. Or run directly
-RUVIEW_SENSING_SERVER_URL=http://cognitum-v0:3000 npx @ruvnet/rvagent stdio
+RUVIEW_SENSING_SERVER_URL=http://cognitum-v0:3000 npx @ruvnet/rvagent
 
-# 3. Streamable HTTP (remote agents, ruflo swarms)
+# 3. Streamable HTTP (remote agents, ruflo swarms) — explicit opt-in
 RUVIEW_SENSING_SERVER_URL=http://cognitum-v0:3000 \
 RVAGENT_HTTP_TOKEN=your-secret \
-npx @ruvnet/rvagent http --port 3001
-# POST JSON-RPC to http://127.0.0.1:3001/mcp
+RVAGENT_HTTP_PORT=3001 npx @ruvnet/rvagent
+# POST JSON-RPC to http://127.0.0.1:3001/mcp (initialize first; then send the
+# returned mcp-session-id header on every request)
 ```
 
 Requirements: **Node.js >= 20**. The `wifi-densepose-sensing-server` Rust binary must be reachable at `RUVIEW_SENSING_SERVER_URL` (default `http://localhost:3000`).
 
-## Feature matrix
+## Tools
+
+Canonical tool names are underscore-form (ADR-264 — host tool-name validators
+commonly enforce `^[a-zA-Z0-9_-]{1,64}$`). The pre-0.1.1 dotted names
+(`ruview.presence.now`, …) are still accepted at call time as deprecated
+aliases; `tools/list` advertises the underscore form only.
 
 | Tool | Description | ADR |
 |------|-------------|-----|
-| `ruview.presence.now` | Current occupancy: `present`, `n_persons`, `confidence` | ADR-124 §4.1 |
-| `ruview.vitals.get_breathing` | Breathing rate bpm (null if unavailable) | ADR-124 §4.1 |
-| `ruview.vitals.get_heart_rate` | Heart rate bpm (null if unavailable) | ADR-124 §4.1 |
-| `ruview.vitals.get_all` | Full `EdgeVitalsMessage` surface | ADR-124 §4.1 |
-| `ruview.bfld.last_scan` | Latest BFLD scan: `identity_risk_score`, `privacy_class`, `n_frames` | ADR-118/124 |
-| `ruview.bfld.subscribe` | Subscribe to `ruview/<node_id>/bfld/*` events for `duration_s` seconds | ADR-122/124 |
-| *(next iters)* | `pose.latest`, `primitives.*`, `node.*`, `vector.*`, `policy.*` | ADR-124 §4.1/4.1a |
+| `ruview_csi_latest` | Latest 56×20 CSI window from the sensing-server | ADR-101/102 |
+| `ruview_pose_infer` | Single-shot 17-keypoint pose inference via cog binary | ADR-101 |
+| `ruview_count_infer` | Single-shot person-count inference via cog binary | ADR-103 |
+| `ruview_registry_list` | Cognitum edge module registry (category/search filters) | ADR-102 |
+| `ruview_train_count` | Kick off a count-cog training run (background job) | ADR-103 |
+| `ruview_job_status` | Poll a training job (persists across server restarts) | ADR-103 |
+| `ruview_presence_now` | Current occupancy: `present`, `n_persons`, `confidence` | ADR-124 §4.1 |
+| `ruview_vitals_get_breathing` | Breathing rate bpm (null if unavailable) | ADR-124 §4.1 |
+| `ruview_vitals_get_heart_rate` | Heart rate bpm (null if unavailable) | ADR-124 §4.1 |
+| `ruview_vitals_get_all` | Full `EdgeVitalsMessage` surface | ADR-124 §4.1 |
+| `ruview_bfld_last_scan` | Latest BFLD scan: `identity_risk_score`, `privacy_class`, `n_frames` | ADR-118/124 |
+| `ruview_bfld_subscribe` | Subscribe to `ruview/<node_id>/bfld/*` events for `duration_s` seconds | ADR-122/124 |
+| *(roadmap, ADR-124 §4.1/4.1a)* | `pose.latest`, `primitives.*`, `node.*`, `vector.*`, and the `policy.*` governance layer are catalogued in `src/schemas/` but **not yet implemented** | ADR-124 |
 
-**Transport security (ADR-124 §6)**:
-- **stdio**: process-level isolation — no auth needed for local Claude Code / Cursor.
-- **Streamable HTTP** (`POST /mcp`): Origin header validation (cross-origin → 403), optional bearer token (`RVAGENT_HTTP_TOKEN` → 401 on mismatch), binds `127.0.0.1` by default per MCP spec.
+**Transport security (ADR-124 §6, hardened per ADR-264)**:
+- **stdio** (default): process-level isolation — no auth needed for local Claude Code / Cursor.
+- **Streamable HTTP** (`/mcp`, opt-in via `RVAGENT_HTTP_PORT`): one transport + one MCP server per session (routed by `mcp-session-id`), Origin validation (localhost on any port allowed; anything else → 403), optional bearer token (`RVAGENT_HTTP_TOKEN` → 401 on mismatch), 1 MiB request-body cap (413), binds `127.0.0.1` by default per MCP spec.
 
-**Schema validation**: every tool call runs `zod.safeParse` before dispatch; invalid arguments return `McpError(InvalidParams)` rather than a wrapped string.
-
-**Policy layer** (ADR-124 §4.1a): `ruview.policy.*` tools gate every sensing call — `vitals.*` is default-deny until a policy grant is registered via `npx @ruvnet/rvagent policy grant`. Presence and node-list are allow by default.
+**Schema validation**: each tool declares one Zod schema; the CallTool gate parses exactly once and the advertised JSON Schema is generated from the same Zod source. Invalid arguments return `McpError(InvalidParams)` rather than a wrapped string.
 
 ## ADR cross-reference
 
 | ADR | Decision |
 |-----|----------|
 | [ADR-124](../../docs/adr/ADR-124-rvagent-mcp-ruvector-npm-integration.md) | SENSE-BRIDGE: dual-transport MCP server + ruvector npm + ruflo integration |
-| [ADR-118](../../docs/adr/ADR-118-bfld-beamforming-feedback-layer-for-detection.md) | BFLD pipeline — source of `bfld.last_scan` wire format |
+| [ADR-264](../../docs/adr/ADR-264-rvagent-mcp-and-cli-npm-deep-review.md) | npm deep review — exports fix, map-free tarball, naming, session-per-transport |
+| [ADR-118](../../docs/adr/ADR-118-bfld-beamforming-feedback-layer-for-detection.md) | BFLD pipeline — source of `bfld_last_scan` wire format |
 | [ADR-122](../../docs/adr/ADR-122-bfld-ruview-ha-matter-exposure.md) | MQTT topic routing `ruview/<node_id>/bfld/*` |
 | [ADR-115](../../docs/adr/ADR-115-home-assistant-integration.md) | `EdgeVitalsMessage` WebSocket surface (`ws.py:74-88` parity) |
 | [ADR-055](../../docs/adr/ADR-055-integrated-sensing-server.md) | Sensing-server REST API (`/api/v1/*`) |
@@ -58,7 +69,7 @@ Requirements: **Node.js >= 20**. The `wifi-densepose-sensing-server` Rust binary
 cd tools/ruview-mcp
 npm install
 npm run build   # tsc
-npm test        # jest — 93 tests across 7 suites
+npm test        # jest — 99 tests across 7 suites
 ```
 
 Source: `tools/ruview-mcp/src/`. Tests: `tools/ruview-mcp/tests/`.

tools/ruview-mcp/package-lock.json

@@ -1,24 +1,24 @@
 {
   "name": "@ruvnet/rvagent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ruvnet/rvagent",
-      "version": "0.1.0",
+      "version": "0.2.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.0.0",
-        "zod": "^3.23.8"
+        "zod": "^3.23.8",
+        "zod-to-json-schema": "^3.25.2"
       },
       "bin": {
         "ruview-mcp": "dist/index.js",
         "rvagent": "dist/index.js"
       },
       "devDependencies": {
-        "@types/express": "^5.0.6",
-        "@types/jest": "^30.0.0",
+        "@types/jest": "^29.5.14",
         "@types/node": "^20.14.0",
         "jest": "^29.7.0",
         "ts-jest": "^29.1.0",
@@ -629,16 +629,6 @@
         }
       }
     },
-    "node_modules/@jest/diff-sequences": {
-      "version": "30.4.0",
-      "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.4.0.tgz",
-      "integrity": "sha512-zOpzlfUs45l6u7jm39qr87JCHUDsaeCtvL+kQe/Vn9jSnRB4/5IPXISm0h9I1vZW/o00Kn4UTJ2MOlhnUGwv3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
     "node_modules/@jest/environment": {
       "version": "29.7.0",
       "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-29.7.0.tgz",
@@ -700,16 +690,6 @@
         "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
-    "node_modules/@jest/get-type": {
-      "version": "30.1.0",
-      "resolved": "https://registry.npmjs.org/@jest/get-type/-/get-type-30.1.0.tgz",
-      "integrity": "sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
     "node_modules/@jest/globals": {
       "version": "29.7.0",
       "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-29.7.0.tgz",
@@ -726,30 +706,6 @@
         "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
-    "node_modules/@jest/pattern": {
-      "version": "30.4.0",
-      "resolved": "https://registry.npmjs.org/@jest/pattern/-/pattern-30.4.0.tgz",
-      "integrity": "sha512-RAWn3+f9u8BsHijKJ71uHcFp6vmyEt6VvoWXkl6hKF3qVIuWNmudVjg12DlBPGup/frIl5UcUlH5HfEuvHpEXg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "jest-regex-util": "30.4.0"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@jest/pattern/node_modules/jest-regex-util": {
-      "version": "30.4.0",
-      "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-30.4.0.tgz",
-      "integrity": "sha512-mWlvLviKIgIQ8VCuM1xRdD0TWp3zlzionlmDBjuXVBs+VkmXq6FgW9T4Emr7oGz/Rk6feDCGyiugolcQEyp3mg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
     "node_modules/@jest/reporters": {
       "version": "29.7.0",
       "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-29.7.0.tgz",
@@ -1061,52 +1017,6 @@
         "@babel/types": "^7.28.2"
       }
     },
-    "node_modules/@types/body-parser": {
-      "version": "1.19.6",
-      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
-      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/connect": "*",
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/connect": {
-      "version": "3.4.38",
-      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
-      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/express": {
-      "version": "5.0.6",
-      "resolved": "https://registry.npmjs.org/@types/express/-/express-5.0.6.tgz",
-      "integrity": "sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/body-parser": "*",
-        "@types/express-serve-static-core": "^5.0.0",
-        "@types/serve-static": "^2"
-      }
-    },
-    "node_modules/@types/express-serve-static-core": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.1.1.tgz",
-      "integrity": "sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "@types/qs": "*",
-        "@types/range-parser": "*",
-        "@types/send": "*"
-      }
-    },
     "node_modules/@types/graceful-fs": {
       "version": "4.1.9",
       "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.9.tgz",
@@ -1117,13 +1027,6 @@
         "@types/node": "*"
       }
     },
-    "node_modules/@types/http-errors": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
-      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@types/istanbul-lib-coverage": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
@@ -1152,229 +1055,14 @@
       }
     },
     "node_modules/@types/jest": {
-      "version": "30.0.0",
-      "resolved": "https://registry.npmjs.org/@types/jest/-/jest-30.0.0.tgz",
-      "integrity": "sha512-XTYugzhuwqWjws0CVz8QpM36+T+Dz5mTEBKhNs/esGLnCIlGdRy+Dq78NRjd7ls7r8BC8ZRMOrKlkO1hU0JOwA==",
+      "version": "29.5.14",
+      "resolved": "https://registry.npmjs.org/@types/jest/-/jest-29.5.14.tgz",
+      "integrity": "sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "expect": "^30.0.0",
-        "pretty-format": "^30.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/@jest/expect-utils": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.4.1.tgz",
-      "integrity": "sha512-ZBn5CglH8fBsQsvs4VWNzD4aWfUYks+IdOOQU3MEK71ol/BcVm+P+rtb1KpiFBpSWSCE27uOahyyf1vfqOVbcQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/get-type": "30.1.0"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/@jest/schemas": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-30.4.1.tgz",
-      "integrity": "sha512-i6b4qw5qnP8c5FEeBJg/uZQ4ddrkN6Ca8qISJh0pr7a5hfn3h3v5x60BEbOC7OYAGZNMs1LfFLwnW2CuK8F57Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@sinclair/typebox": "^0.34.0"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/@jest/types": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.4.1.tgz",
-      "integrity": "sha512-f1x/vJXIfjOlEmejYpbkbgw1gOqpPECwMvMEtBqe47j7H2Hg8h8w3o3ikhSXq3MI15kg+oQ0exWO0uCtTNJLoQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/pattern": "30.4.0",
-        "@jest/schemas": "30.4.1",
-        "@types/istanbul-lib-coverage": "^2.0.6",
-        "@types/istanbul-reports": "^3.0.4",
-        "@types/node": "*",
-        "@types/yargs": "^17.0.33",
-        "chalk": "^4.1.2"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/@sinclair/typebox": {
-      "version": "0.34.49",
-      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.34.49.tgz",
-      "integrity": "sha512-brySQQs7Jtn0joV8Xh9ZV/hZb9Ozb0pmazDIASBkYKCjXrXU3mpcFahmK/z4YDhGkQvP9mWJbVyahdtU5wQA+A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/jest/node_modules/ansi-styles": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
-      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/@types/jest/node_modules/ci-info": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz",
-      "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/sibiraj-s"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/@types/jest/node_modules/expect": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/expect/-/expect-30.4.1.tgz",
-      "integrity": "sha512-PMARsyh/JtqC20HoGqlFcIlQAyqUtW4PlI1rup1uhYJtKuwAjbvWi3GQMAn+STdHum/dk8xrKfUM1+5SAwpolA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/expect-utils": "30.4.1",
-        "@jest/get-type": "30.1.0",
-        "jest-matcher-utils": "30.4.1",
-        "jest-message-util": "30.4.1",
-        "jest-mock": "30.4.1",
-        "jest-util": "30.4.1"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/jest-diff": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.4.1.tgz",
-      "integrity": "sha512-CRpFK0RtLriVDGcPPAnR6HMVI8bSR2jnUIgralhauzYQZIb4RH9AtEInTuQr65LmmGggGcRT6HIASxwqsVsmlA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/diff-sequences": "30.4.0",
-        "@jest/get-type": "30.1.0",
-        "chalk": "^4.1.2",
-        "pretty-format": "30.4.1"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/jest-matcher-utils": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.4.1.tgz",
-      "integrity": "sha512-zvYfX5CaeEkFrrLS9suWe9rvJrm9J1Iv3ua8kIBv9GEPzcnsfBf0bob37la7s67fs0nlBC3EuvkOLnXQKxtx4A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/get-type": "30.1.0",
-        "chalk": "^4.1.2",
-        "jest-diff": "30.4.1",
-        "pretty-format": "30.4.1"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/jest-message-util": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.4.1.tgz",
-      "integrity": "sha512-kwCKIvq0MCW1HzLoGola9Te6JUdzgV0loyKJ3Qghrkz9i5/RRIHsL95BMQc2HBBhlBKC4j22K9p11TGHH8RBpQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.27.1",
-        "@jest/types": "30.4.1",
-        "@types/stack-utils": "^2.0.3",
-        "chalk": "^4.1.2",
-        "graceful-fs": "^4.2.11",
-        "jest-util": "30.4.1",
-        "picomatch": "^4.0.3",
-        "pretty-format": "30.4.1",
-        "slash": "^3.0.0",
-        "stack-utils": "^2.0.6"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/jest-mock": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.4.1.tgz",
-      "integrity": "sha512-/i8SVb8/NSB7RfNi8gfqu8gxLV23KaL5EpAttyb9iz8qWRIqXRLflycz/32wXsYkOnaUlx8NAKnJYtpsmXUmfw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "30.4.1",
-        "@types/node": "*",
-        "jest-util": "30.4.1"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/jest-util": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.4.1.tgz",
-      "integrity": "sha512-vjQb1sACEiv13DKJMDToJpzVW0joCsIQrmbg0fi7CyOOt+g9jTuQl2A216pWRBYhOVt53XbL/2LbMKg1BECWOw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/types": "30.4.1",
-        "@types/node": "*",
-        "chalk": "^4.1.2",
-        "ci-info": "^4.2.0",
-        "graceful-fs": "^4.2.11",
-        "picomatch": "^4.0.3"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@types/jest/node_modules/picomatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
-      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/@types/jest/node_modules/pretty-format": {
-      "version": "30.4.1",
-      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.4.1.tgz",
-      "integrity": "sha512-K6KiKMHTL4jjX4u3Kir2EW07nRfcqVTXIImx50wbjHQTcZPgg+gjVeNTIT3l3L1Rd4UefxfogquC9J37SoFyyw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jest/schemas": "30.4.1",
-        "ansi-styles": "^5.2.0",
-        "react-is-18": "npm:react-is@^18.3.1",
-        "react-is-19": "npm:react-is@^19.2.5"
-      },
-      "engines": {
-        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+        "expect": "^29.0.0",
+        "pretty-format": "^29.0.0"
       }
     },
     "node_modules/@types/node": {
@@ -1387,41 +1075,6 @@
         "undici-types": "~6.21.0"
       }
     },
-    "node_modules/@types/qs": {
-      "version": "6.15.1",
-      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.15.1.tgz",
-      "integrity": "sha512-GZHUBZR9hckSUhrxmp1nG6NwdpM9fCunJwyThLW1X3AyHgd9IlHb6VANpQQqDr2o/qQp6McZ3y/IA2rVzKzSbw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/range-parser": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
-      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/send": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.1.tgz",
-      "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/@types/serve-static": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-2.2.0.tgz",
-      "integrity": "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/http-errors": "*",
-        "@types/node": "*"
-      }
-    },
     "node_modules/@types/stack-utils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.3.tgz",
@@ -4355,22 +4008,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/react-is-18": {
-      "name": "react-is",
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
-      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/react-is-19": {
-      "name": "react-is",
-      "version": "19.2.6",
-      "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.6.tgz",
-      "integrity": "sha512-XjBR15BhXuylgWGuslhDKqlSayuqvqBX91BP8pauG8kd1zY8kotkNWbXksTCNRarse4kuGbe2kIY05ARtwNIvw==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/require-directory": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",

tools/ruview-mcp/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@ruvnet/rvagent",
-  "version": "0.1.0",
-  "description": "SENSE-BRIDGE: dual-transport MCP server (stdio + Streamable HTTP) exposing RuView WiFi-DensePose sensing primitives to AI agents",
+  "version": "0.2.0",
+  "description": "SENSE-BRIDGE: dual-transport MCP server (stdio default; Streamable HTTP opt-in via RVAGENT_HTTP_PORT) exposing RuView WiFi-DensePose sensing primitives to AI agents",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "bin": {
@@ -18,8 +17,7 @@
   },
   "files": [
     "dist",
-    "README.md",
-    "CHANGELOG.md"
+    "README.md"
   ],
   "scripts": {
     "build": "tsc",
@@ -27,7 +25,8 @@
     "start": "node dist/index.js",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --forceExit",
     "lint": "eslint src --ext .ts",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
   },
   "keywords": [
     "mcp",
@@ -53,11 +52,11 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "zod": "^3.23.8"
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.25.2"
   },
   "devDependencies": {
-    "@types/express": "^5.0.6",
-    "@types/jest": "^30.0.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.14.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.0",

tools/ruview-mcp/src/config.ts

@@ -8,6 +8,7 @@
 
 import os from "node:os";
 import path from "node:path";
+import { existsSync } from "node:fs";
 import type { RuviewConfig } from "./types.js";
 
 function env(key: string): string | undefined {
@@ -51,17 +52,35 @@ export function loadConfig(): RuviewConfig {
 }
 
 /**
- * Attempt to locate a cog binary on PATH or in common install locations.
- * Returns the bare binary name if not found (will fail gracefully at invocation).
+ * Ordered cog-binary candidate paths for a host of the given CPU architecture.
+ * The native-arch build is probed FIRST: an appliance that ships both
+ * `cog-<id>-arm` and `cog-<id>-x86_64` must never hand back the wrong-arch
+ * binary (ADR-264 F8/O7 — the pre-review order tried `-arm` unconditionally).
+ * The `/usr/local/bin` and bare-name (PATH) fallbacks follow, arch-agnostic.
+ *
+ * Pure and arch-injectable so the ordering is unit-testable.
+ */
+export function cogBinaryCandidates(
+  name: string,
+  arch: string = process.arch
+): string[] {
+  const id = name.replace("cog-", "");
+  const dir = `/var/lib/cognitum/apps/${id}`;
+  const arm = `${dir}/cog-${id}-arm`;
+  const x86 = `${dir}/cog-${id}-x86_64`;
+  // arm64 → prefer -arm; everything else (notably x64) → prefer -x86_64.
+  const archOrdered = arch === "arm64" ? [arm, x86] : [x86, arm];
+  return [...archOrdered, `/usr/local/bin/${name}`];
+}
+
+/**
+ * Locate a cog binary in the common appliance install locations, probing each
+ * candidate in native-arch-first order. Falls back to the bare name (PATH
+ * resolution at spawn time) when no candidate exists.
  */
 function detectCogBinary(name: string): string {
-  // Common install paths for Cognitum cog binaries on Linux/macOS appliances.
-  const candidates = [
-    `/var/lib/cognitum/apps/${name.replace("cog-", "")}/cog-${name.replace("cog-", "")}-arm`,
-    `/var/lib/cognitum/apps/${name.replace("cog-", "")}/cog-${name.replace("cog-", "")}-x86_64`,
-    `/usr/local/bin/${name}`,
-    name, // bare name — rely on PATH
-  ];
-  // Return the first candidate that might exist; actual existence is checked at call time.
-  return candidates[candidates.length - 1] ?? name;
+  for (const candidate of cogBinaryCandidates(name)) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return name; // bare name — rely on PATH; spawn fails gracefully if absent
 }

tools/ruview-mcp/src/http-transport.ts

@@ -1,30 +1,44 @@
 /**
- * Streamable HTTP transport scaffold for @ruvnet/rvagent (ADR-124 §3).
+ * Streamable HTTP transport for @ruvnet/rvagent (ADR-124 §3, hardened per
+ * ADR-264 F7/O3).
  *
- * Binds to 127.0.0.1 by default and mounts a POST /mcp endpoint backed by
+ * Binds to 127.0.0.1 by default and mounts an /mcp endpoint backed by
  * StreamableHTTPServerTransport from @modelcontextprotocol/sdk.
  *
- * Security model (ADR-124 §6):
- *   - Origin validation: requests from origins other than the configured
- *     allowlist are rejected with 403 Forbidden before reaching the MCP layer.
- *   - Default allowlist: ['http://localhost', 'http://127.0.0.1'] — covers
- *     Claude Code and Cursor on the same machine.
+ * Session model (ADR-264 F7): the SDK's stateful mode requires ONE transport
+ * (and one MCP Server) per session. An `initialize` POST creates a fresh
+ * transport + server pair via the caller-supplied factory; follow-up
+ * POST/GET/DELETE requests are routed to their session by the
+ * `mcp-session-id` header. Transports are dropped when their session closes.
+ *
+ * Security model (ADR-124 §6 + ADR-264 F7):
+ *   - Origin validation: browser-style requests whose Origin is not local
+ *     are rejected with 403 before reaching the MCP layer. With NO explicit
+ *     allowlist, localhost origins match on hostname, ANY port
+ *     (http://localhost:5173 is local). When an explicit allowedOrigins list is
+ *     configured, matching is exact — the any-port-localhost convenience is off,
+ *     so a localhost peer on an unlisted port must be added to be accepted.
  *   - Bearer token: when RVAGENT_HTTP_TOKEN is set, requests must carry
  *     Authorization: Bearer <token>; missing/wrong tokens → 401.
+ *   - Body cap: request bodies over 1 MiB are rejected with 413 (the
+ *     unbounded-buffering DoS from the pre-ADR-264 scaffold).
  *   - Bind address: defaults to 127.0.0.1 per MCP spec security requirement.
  *     Set RVAGENT_HTTP_HOST=0.0.0.0 only for intentional fleet deployment.
  *
  * Usage:
  *   import { createHttpTransport } from './http-transport.js';
- *   const { server: httpServer, transport } = await createHttpTransport(mcpServer);
+ *   const { httpServer } = await createHttpTransport(() => buildServer(config));
  *   // httpServer is a node:http.Server — call httpServer.close() to shut down.
  */
 
 import { createServer, type Server as HttpServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { randomUUID } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import type { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
 
+export type McpServerFactory = () => McpServer;
+
 export interface HttpTransportOptions {
   /** TCP host to bind (default: 127.0.0.1). */
   host?: string;
@@ -32,8 +46,8 @@ export interface HttpTransportOptions {
   port?: number;
   /**
    * Allowed Origin header values. Requests with an Origin not in this list
-   * are rejected with 403. Use '*' to disable Origin validation entirely
-   * (not recommended outside of local-dev flags).
+   * (and not a localhost origin) are rejected with 403. Use '*' to disable
+   * Origin validation entirely (not recommended outside of local-dev flags).
    */
   allowedOrigins?: string[];
   /**
@@ -42,32 +56,51 @@ export interface HttpTransportOptions {
    * Defaults to process.env.RVAGENT_HTTP_TOKEN (undefined = auth disabled).
    */
   bearerToken?: string;
+  /** Maximum accepted request body size in bytes (default: 1 MiB). */
+  maxBodyBytes?: number;
+  /**
+   * Maximum number of concurrent live sessions (default: 64). When a new
+   * `initialize` arrives at the cap, the oldest-idle session is evicted (its
+   * transport closed) to make room — bounds memory against a flaky client that
+   * loops `initialize` or a malicious localhost peer (ADR-264 F7).
+   */
+  maxSessions?: number;
+  /**
+   * Idle time-to-live for a session in ms (default: 5 min). Sessions with no
+   * request activity for longer than this are swept and closed.
+   */
+  sessionIdleMs?: number;
+  /** How often the idle-session sweeper runs, in ms (default: 60 s). */
+  sweepIntervalMs?: number;
 }
 
 export interface HttpTransportResult {
   /** The raw Node.js HTTP server — call .close() to shut down. */
   httpServer: HttpServer;
-  /** The MCP Streamable HTTP transport instance wired to the MCP server. */
-  transport: StreamableHTTPServerTransport;
+  /** Live sessions keyed by session id (exposed for tests/observability). */
+  sessions: Map<string, StreamableHTTPServerTransport>;
   /** The bound address string (e.g. "http://127.0.0.1:3001"). */
   boundAddress: string;
 }
 
 const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_PORT = 3001;
-const LOCALHOST_ORIGINS = new Set([
-  "http://localhost",
-  "http://127.0.0.1",
-  "https://localhost",
-  "https://127.0.0.1",
-]);
+const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+const DEFAULT_MAX_SESSIONS = 64;
+const DEFAULT_SESSION_IDLE_MS = 5 * 60 * 1000;
+const DEFAULT_SWEEP_INTERVAL_MS = 60 * 1000;
+const LOCAL_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"]);
 
 /**
  * Validate Origin header against the allowlist.
  * Returns true if the request should be allowed, false if it should be rejected.
  *
- * An absent Origin header is allowed (same-origin non-browser requests, curl, etc.).
- * A present Origin that is not in the allowlist is rejected.
+ * An absent Origin header is allowed (same-origin non-browser requests, curl,
+ * etc.). When NO explicit allowlist was configured (empty list), a localhost
+ * origin is allowed on any port as a convenience — real browser origins carry
+ * ports (ADR-264 F7). When an explicit allowlist IS configured, matching is
+ * exact: the any-port-localhost shortcut is disabled so an operator who pins an
+ * allowlist actually gets it (a looped-back peer on an unlisted port is denied).
  */
 export function isOriginAllowed(
   origin: string | undefined,
@@ -75,76 +108,222 @@ export function isOriginAllowed(
 ): boolean {
   if (origin === undefined) return true; // no Origin = not a cross-origin browser request
   if (allowedOrigins.includes("*")) return true;
-  return allowedOrigins.some((o) => o === origin);
+  if (allowedOrigins.includes(origin)) return true;
+  // Explicit allowlist ⇒ exact matching only; skip the localhost convenience.
+  if (allowedOrigins.length > 0) return false;
+  try {
+    const u = new URL(origin);
+    return (
+      (u.protocol === "http:" || u.protocol === "https:") &&
+      LOCAL_HOSTNAMES.has(u.hostname === "::1" ? "[::1]" : u.hostname)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/** Read a request body with a hard size cap; null = payload too large. */
+function readBody(
+  req: IncomingMessage,
+  maxBytes: number
+): Promise<string | null> {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    let tooLarge = false;
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk: Buffer) => {
+      if (tooLarge) return; // keep draining so the 413 response can flush
+      size += chunk.length;
+      if (size > maxBytes) {
+        tooLarge = true;
+        chunks.length = 0;
+        resolve(null);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (!tooLarge) resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    req.on("error", reject);
+  });
+}
+
+function json(res: ServerResponse, status: number, body: object): void {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
 }
 
 /**
- * Build and wire a Streamable HTTP transport to the provided MCP server.
- * Returns the Node.js HTTP server (not yet listening) plus the transport.
+ * Build the HTTP server around a per-session MCP transport map.
+ * Returns the Node.js HTTP server (not yet listening) plus the session map.
  * Call httpServer.listen(port, host) or rely on createHttpTransport which
  * does that for you.
  */
 export function buildHttpApp(
-  mcpServer: McpServer,
+  serverFactory: McpServerFactory,
   opts: HttpTransportOptions = {}
-): { httpServer: HttpServer; transport: StreamableHTTPServerTransport } {
-  const allowedOrigins: string[] = opts.allowedOrigins ?? [
-    ...LOCALHOST_ORIGINS,
-  ];
+): { httpServer: HttpServer; sessions: Map<string, StreamableHTTPServerTransport> } {
+  const allowedOrigins: string[] = opts.allowedOrigins ?? [];
   const bearerToken = opts.bearerToken ?? process.env["RVAGENT_HTTP_TOKEN"];
+  const maxBodyBytes = opts.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  const maxSessions = opts.maxSessions ?? DEFAULT_MAX_SESSIONS;
+  const sessionIdleMs = opts.sessionIdleMs ?? DEFAULT_SESSION_IDLE_MS;
+  const sweepIntervalMs = opts.sweepIntervalMs ?? DEFAULT_SWEEP_INTERVAL_MS;
+  const sessions = new Map<string, StreamableHTTPServerTransport>();
+  // lastSeen tracks per-session request activity so the sweeper and the
+  // oldest-idle eviction can bound the session map (ADR-264 F7).
+  const lastSeen = new Map<string, number>();
 
-  const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: () => randomUUID(),
-  });
+  /** Mark a session as freshly used. */
+  function touch(sessionId: string): void {
+    lastSeen.set(sessionId, Date.now());
+  }
 
-  const httpServer = createServer(
-    (req: IncomingMessage, res: ServerResponse) => {
-      // ── Origin validation ────────────────────────────────────────────────
+  /** Close a session's transport and drop it from the bookkeeping maps. */
+  function closeSession(id: string): void {
+    const transport = sessions.get(id);
+    sessions.delete(id);
+    lastSeen.delete(id);
+    if (transport) {
+      try {
+        void transport.close(); // onclose is idempotent against the maps above
+      } catch {
+        /* best-effort: a half-open transport must not block eviction */
+      }
+    }
+  }
+
+  /** Evict the session that has been idle longest — called when at capacity. */
+  function evictOldestIdle(): void {
+    let oldestId: string | undefined;
+    let oldestSeen = Infinity;
+    for (const [id, seen] of lastSeen) {
+      if (seen < oldestSeen) {
+        oldestSeen = seen;
+        oldestId = id;
+      }
+    }
+    if (oldestId !== undefined) closeSession(oldestId);
+  }
+
+  /** Periodic sweep: close sessions idle beyond sessionIdleMs. */
+  function sweepIdleSessions(): void {
+    const now = Date.now();
+    for (const [id, seen] of lastSeen) {
+      if (now - seen > sessionIdleMs) closeSession(id);
+    }
+  }
+  const sweepTimer = setInterval(sweepIdleSessions, sweepIntervalMs);
+  sweepTimer.unref(); // never keep the process alive just to sweep
+
+  const httpServer = createServer((req: IncomingMessage, res: ServerResponse) => {
+    void (async () => {
+      // ── Origin validation ──────────────────────────────────────────────
       const origin = req.headers["origin"] as string | undefined;
       if (!isOriginAllowed(origin, allowedOrigins)) {
-        res.writeHead(403, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Forbidden: cross-origin request rejected" }));
+        json(res, 403, { error: "Forbidden: cross-origin request rejected" });
         return;
       }
 
-      // ── Bearer token auth ────────────────────────────────────────────────
+      // ── Bearer token auth ──────────────────────────────────────────────
       if (bearerToken !== undefined && bearerToken !== "") {
         const authHeader = req.headers["authorization"] as string | undefined;
         const supplied = authHeader?.startsWith("Bearer ")
           ? authHeader.slice("Bearer ".length)
           : undefined;
         if (supplied !== bearerToken) {
-          res.writeHead(401, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Unauthorized: missing or invalid bearer token" }));
+          json(res, 401, { error: "Unauthorized: missing or invalid bearer token" });
           return;
         }
       }
 
-      // ── Route: POST /mcp ─────────────────────────────────────────────────
-      if (req.method === "POST" && req.url === "/mcp") {
-        let body = "";
-        req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
-        req.on("end", () => {
-          let parsed: unknown;
-          try {
-            parsed = JSON.parse(body);
-          } catch {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Bad Request: invalid JSON body" }));
-            return;
-          }
-          void transport.handleRequest(req, res, parsed);
-        });
+      // ── Route: /mcp ────────────────────────────────────────────────────
+      if (req.url !== "/mcp") {
+        json(res, 404, { error: "Not found. MCP endpoint: /mcp" });
         return;
       }
 
-      // ── Fallback ─────────────────────────────────────────────────────────
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Not found. MCP endpoint: POST /mcp" }));
-    }
-  );
+      const sessionId = req.headers["mcp-session-id"] as string | undefined;
 
-  return { httpServer, transport };
+      if (req.method === "POST") {
+        const body = await readBody(req, maxBodyBytes);
+        if (body === null) {
+          json(res, 413, { error: `Payload too large (max ${maxBodyBytes} bytes)` });
+          return;
+        }
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          json(res, 400, { error: "Bad Request: invalid JSON body" });
+          return;
+        }
+
+        // Existing session → route to its transport.
+        if (sessionId !== undefined) {
+          const transport = sessions.get(sessionId);
+          if (!transport) {
+            json(res, 404, { error: `Unknown session "${sessionId}"` });
+            return;
+          }
+          touch(sessionId);
+          await transport.handleRequest(req, res, parsed);
+          return;
+        }
+
+        // New session: must be an initialize request (ADR-264 F7 — one
+        // transport + one MCP Server per session).
+        if (!isInitializeRequest(parsed)) {
+          json(res, 400, {
+            error: "Bad Request: no mcp-session-id and not an initialize request",
+          });
+          return;
+        }
+        // Bound the session map: at capacity, reclaim the oldest-idle slot
+        // before minting a new session (ADR-264 F7).
+        if (sessions.size >= maxSessions) evictOldestIdle();
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          onsessioninitialized: (id: string) => {
+            sessions.set(id, transport);
+            touch(id);
+          },
+        });
+        transport.onclose = () => {
+          if (transport.sessionId !== undefined) {
+            sessions.delete(transport.sessionId);
+            lastSeen.delete(transport.sessionId);
+          }
+        };
+        const mcpServer = serverFactory();
+        await mcpServer.connect(transport as Parameters<typeof mcpServer.connect>[0]);
+        await transport.handleRequest(req, res, parsed);
+        return;
+      }
+
+      // GET (SSE stream) / DELETE (session termination) — session-scoped.
+      if (req.method === "GET" || req.method === "DELETE") {
+        const transport = sessionId !== undefined ? sessions.get(sessionId) : undefined;
+        if (!transport) {
+          json(res, 400, { error: "Bad Request: missing or unknown mcp-session-id" });
+          return;
+        }
+        if (sessionId !== undefined) touch(sessionId);
+        await transport.handleRequest(req, res);
+        return;
+      }
+
+      json(res, 405, { error: "Method not allowed. Use POST/GET/DELETE on /mcp" });
+    })().catch(() => {
+      if (!res.headersSent) json(res, 500, { error: "Internal server error" });
+      else res.end();
+    });
+  });
+
+  httpServer.on("close", () => clearInterval(sweepTimer));
+
+  return { httpServer, sessions };
 }
 
 /**
@@ -152,19 +331,13 @@ export function buildHttpApp(
  * is bound and listening.
  */
 export async function createHttpTransport(
-  mcpServer: McpServer,
+  serverFactory: McpServerFactory,
   opts: HttpTransportOptions = {}
 ): Promise<HttpTransportResult> {
   const host = opts.host ?? process.env["RVAGENT_HTTP_HOST"] ?? DEFAULT_HOST;
   const port = opts.port ?? Number(process.env["RVAGENT_HTTP_PORT"] ?? DEFAULT_PORT);
 
-  const { httpServer, transport } = buildHttpApp(mcpServer, opts);
-
-  // Wire MCP server to the transport only after the HTTP server is built.
-  // Cast needed: StreamableHTTPServerTransport implements Transport but
-  // exactOptionalPropertyTypes causes a false incompatibility on optional
-  // callback properties; the cast is safe — the SDK types are consistent.
-  await mcpServer.connect(transport as Parameters<typeof mcpServer.connect>[0]);
+  const { httpServer, sessions } = buildHttpApp(serverFactory, opts);
 
   await new Promise<void>((resolve, reject) => {
     httpServer.once("error", reject);
@@ -173,7 +346,7 @@ export async function createHttpTransport(
 
   return {
     httpServer,
-    transport,
+    sessions,
     boundAddress: `http://${host}:${port}`,
   };
 }

tools/ruview-mcp/src/index.ts

@@ -1,29 +1,39 @@
 #!/usr/bin/env node
 /**
- * @ruv/ruview-mcp — RuView MCP Server
+ * @ruvnet/rvagent — RuView MCP Server
  *
  * Exposes RuView's WiFi-DensePose sensing capabilities as Model Context Protocol
  * (MCP) tools that Claude Code, Cursor, Codex, and other MCP-compatible agents
  * can call directly.
  *
- * Tools exposed:
- *   ruview_csi_latest    — pull the latest CSI window from the sensing-server
- *   ruview_pose_infer    — single-shot 17-keypoint pose estimation
- *   ruview_count_infer   — single-shot person count with confidence interval
- *   ruview_registry_list — list cogs from the Cognitum edge registry (ADR-102)
- *   ruview_train_count   — kick off a count-cog training run (returns job ID)
- *   ruview_job_status    — poll a background training job
+ * Transports (ADR-264 O3):
+ *   stdio (default)      node dist/index.js
+ *   Streamable HTTP      RVAGENT_HTTP_PORT=3001 node dist/index.js
+ *                        (127.0.0.1-bound, Origin-gated, optional bearer token —
+ *                        see http-transport.ts for the security model)
  *
- * Usage:
- *   node dist/index.js                   # stdio transport (default)
- *   RUVIEW_SENSING_SERVER_URL=http://cognitum-v0:3000 node dist/index.js
+ * Tool naming (ADR-264 O4): canonical names are underscore-form
+ * (host tool-name regexes commonly enforce ^[a-zA-Z0-9_-]{1,64}$). The
+ * pre-ADR-264 dotted names (ruview.bfld.last_scan, …) remain callable as
+ * router-only aliases for one deprecation cycle; tools/list advertises the
+ * underscore form only.
+ *
+ * Validation (ADR-264 O5): each tool declares ONE Zod schema. The CallTool
+ * gate parses exactly once and hands the typed result to the handler; the
+ * advertised JSON Schema is generated from the same Zod source, so what is
+ * advertised is what is enforced.
  *
  * To register with Claude Code:
- *   claude mcp add ruview -- node /path/to/tools/ruview-mcp/dist/index.js
+ *   claude mcp add ruview -- npx -y @ruvnet/rvagent
  *
- * See ADR-104 for the full design rationale and security model.
+ * See ADR-104 for the original design rationale and ADR-264 for the npm
+ * deep-review this layout implements.
  */
 
+import { createRequire } from "node:module";
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { argv } from "node:process";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -32,6 +42,8 @@ import {
   McpError,
   ErrorCode,
 } from "@modelcontextprotocol/sdk/types.js";
+import type { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
 
 import { loadConfig } from "./config.js";
 import { csiLatestSchema, csiLatest } from "./tools/csi-latest.js";
@@ -44,40 +56,51 @@ import {
   jobStatusSchema,
   jobStatus,
 } from "./tools/train-count.js";
-import { TOOL_INPUT_SCHEMAS } from "./schemas/index.js";
-import { bfldLastScan } from "./tools/bfld-last-scan.js";
-import { bfldSubscribe } from "./tools/bfld-subscribe.js";
-import { presenceNow } from "./tools/presence-now.js";
-import { vitalsGetBreathing } from "./tools/vitals-get-breathing.js";
-import { vitalsGetHeartRate } from "./tools/vitals-get-heart-rate.js";
-import { vitalsGetAll } from "./tools/vitals-get-all.js";
+import { bfldLastScanSchema, bfldLastScan } from "./tools/bfld-last-scan.js";
+import { bfldSubscribeSchema, bfldSubscribe } from "./tools/bfld-subscribe.js";
+import { presenceNowSchema, presenceNow } from "./tools/presence-now.js";
+import {
+  vitalsGetBreathingSchema,
+  vitalsGetBreathing,
+} from "./tools/vitals-get-breathing.js";
+import {
+  vitalsGetHeartRateSchema,
+  vitalsGetHeartRate,
+} from "./tools/vitals-get-heart-rate.js";
+import { vitalsGetAllSchema, vitalsGetAll } from "./tools/vitals-get-all.js";
+// NOTE: ./http-transport.js is imported lazily in main() — it chain-loads the
+// SDK's streamableHttp module (~48 ms MEASURED), which the default stdio path
+// never uses.
 
-const PACKAGE_VERSION = "0.1.0";
+// Single-source the version from package.json (ADR-264 O8/ADR-265 D3).
+const require = createRequire(import.meta.url);
+const PACKAGE_VERSION: string = (
+  require("../package.json") as { version: string }
+).version;
 const SERVER_NAME = "rvagent";
 
 // ── Tool registry ──────────────────────────────────────────────────────────
 
-const TOOLS = [
+type RuviewConfig = ReturnType<typeof loadConfig>;
+
+interface ToolDef {
+  name: string;
+  description: string;
+  /** The single validation source; the advertised JSON Schema derives from it. */
+  schema: z.ZodTypeAny;
+  handler: (parsedArgs: unknown, config: RuviewConfig) => Promise<object>;
+}
+
+export const TOOLS: ToolDef[] = [
   {
     name: "ruview_csi_latest",
     description:
       "Pull the latest CSI window from a running wifi-densepose-sensing-server. " +
       "Returns 56-subcarrier × 20-frame amplitude/phase arrays suitable for " +
       "downstream inference or research analysis.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        sensing_server_url: {
-          type: "string",
-          description:
-            "Base URL of the sensing-server (default: RUVIEW_SENSING_SERVER_URL or http://localhost:3000).",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      const input = csiLatestSchema.parse(args);
-      return csiLatest(input, config);
-    },
+    schema: csiLatestSchema,
+    handler: (args, config) =>
+      csiLatest(args as Parameters<typeof csiLatest>[0], config),
   },
   {
     name: "ruview_pose_infer",
@@ -86,23 +109,9 @@ const TOOLS = [
       "cog-pose-estimation Cog binary (ADR-101). Accepts a CSI window JSON file " +
       "or uses the live sensing-server if no window is provided. " +
       "Returns [{keypoints: [[x,y]×17], confidence}] per detected person.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        window_path: {
-          type: "string",
-          description: "Path to a CSI window JSON file. Omit to use the live sensing-server.",
-        },
-        cog_binary: {
-          type: "string",
-          description: "Path to cog-pose-estimation binary.",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      const input = poseInferSchema.parse(args);
-      return poseInfer(input, config);
-    },
+    schema: poseInferSchema,
+    handler: (args, config) =>
+      poseInfer(args as Parameters<typeof poseInfer>[0], config),
   },
   {
     name: "ruview_count_infer",
@@ -110,29 +119,9 @@ const TOOLS = [
       "Run a single-shot person-count inference using the cog-person-count Cog " +
       "binary (ADR-103). Returns {count, confidence, count_p95_low, count_p95_high} " +
       "with a Stoer-Wagner multi-node fusion upper bound when multiple nodes are active.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        window_path: {
-          type: "string",
-          description: "Path to a CSI window JSON file. Omit to use the live sensing-server.",
-        },
-        cog_binary: {
-          type: "string",
-          description: "Path to cog-person-count binary.",
-        },
-        max_persons: {
-          type: "integer",
-          minimum: 1,
-          maximum: 7,
-          description: "Upper bound on person count (1–7). Default: 7.",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      const input = countInferSchema.parse(args);
-      return countInfer(input, config);
-    },
+    schema: countInferSchema,
+    handler: (args, config) =>
+      countInfer(args as Parameters<typeof countInfer>[0], config),
   },
   {
     name: "ruview_registry_list",
@@ -140,33 +129,9 @@ const TOOLS = [
       "List cogs from the Cognitum edge module registry (ADR-102). " +
       "Fetches /api/v1/edge/registry from the sensing-server, which proxies the " +
       "canonical GCS catalog (105 cogs, 11 categories). Supports category filter and search.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        category: {
-          type: "string",
-          description:
-            "Filter by category: health, security, building, retail, industrial, " +
-            "research, ai, swarm, signal, network, developer.",
-        },
-        search: {
-          type: "string",
-          description: "Search substring matched against cog id and name (case-insensitive).",
-        },
-        refresh: {
-          type: "boolean",
-          description: "Bypass the 1-hour registry cache.",
-        },
-        sensing_server_url: {
-          type: "string",
-          description: "Override the sensing-server URL.",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      const input = registryListSchema.parse(args);
-      return registryList(input, config);
-    },
+    schema: registryListSchema,
+    handler: (args, config) =>
+      registryList(args as Parameters<typeof registryList>[0], config),
   },
   {
     name: "ruview_train_count",
@@ -174,211 +139,139 @@ const TOOLS = [
       "Kick off a cog-person-count training run using the Candle GPU trainer " +
       "(ADR-103). The paired JSONL file provides CSI windows + camera-derived " +
       "person-count labels. Returns a job_id to poll with ruview_job_status.",
-    inputSchema: {
-      type: "object" as const,
-      required: ["paired_jsonl"],
-      properties: {
-        paired_jsonl: {
-          type: "string",
-          description:
-            "Path to the paired JSONL training file (produced by scripts/align-ground-truth.js).",
-        },
-        epochs: {
-          type: "integer",
-          minimum: 1,
-          maximum: 10000,
-          description: "Training epochs (default: 400).",
-        },
-        learning_rate: {
-          type: "number",
-          description: "Initial learning rate (default: 0.001).",
-        },
-        output_dir: {
-          type: "string",
-          description:
-            "Directory for model artifacts (default: v2/crates/cog-person-count/cog/artifacts/).",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      const input = trainCountSchema.parse(args);
-      return trainCount(input, config);
-    },
+    schema: trainCountSchema,
+    handler: (args, config) =>
+      trainCount(args as Parameters<typeof trainCount>[0], config),
   },
   {
     name: "ruview_job_status",
     description:
       "Poll the status of a background training job started by ruview_train_count. " +
       "Returns {status, epochs_done, epochs_total, recent_log} for the given job_id.",
-    inputSchema: {
-      type: "object" as const,
-      required: ["job_id"],
-      properties: {
-        job_id: {
-          type: "string",
-          description: "UUID returned by ruview_train_count.",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      const input = jobStatusSchema.parse(args);
-      return jobStatus(input, config);
-    },
+    schema: jobStatusSchema,
+    handler: (args, config) =>
+      jobStatus(args as Parameters<typeof jobStatus>[0], config),
   },
-  // ── ADR-124 BFLD tools (Phase 4 Refinement) ──────────────────────────────
+  // ── ADR-124 BFLD tools (Phase 4 Refinement; underscore names per ADR-264) ─
   {
-    name: "ruview.bfld.last_scan",
+    name: "ruview_bfld_last_scan",
     description:
       "Return the most recent BFLD scan result for a node (ADR-118/ADR-121). " +
       "Fields: node_id, identity_risk_score [0,1], privacy_class, n_frames, timestamp_ms. " +
       "Proxied from sensing-server GET /api/v1/bfld/<node_id>/last_scan which aggregates " +
       "the MQTT state topics ruview/<node_id>/bfld/* (ADR-122 §2.2).",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        node_id: {
-          type: "string",
-          description: "Target node id. Omit to use the single active node.",
-        },
-        sensing_server_url: {
-          type: "string",
-          description: "Override sensing-server URL for this call only.",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      return bfldLastScan(args as Parameters<typeof bfldLastScan>[0], config);
-    },
+    schema: bfldLastScanSchema,
+    handler: (args, config) =>
+      bfldLastScan(args as Parameters<typeof bfldLastScan>[0], config),
   },
   {
-    name: "ruview.bfld.subscribe",
+    name: "ruview_bfld_subscribe",
     description:
       "Subscribe to BFLD events on ruview/<node_id>/bfld/* for duration_s seconds (ADR-122). " +
       "Returns {ok, subscription_id, expires_at, topic}. When the sensing-server is unreachable, " +
       "returns a synthetic envelope with ok:false,warn:true so the caller can distinguish " +
       "a network error from an invalid request.",
-    inputSchema: {
-      type: "object" as const,
-      required: ["duration_s"],
-      properties: {
-        node_id: {
-          type: "string",
-          description: "Target node id. Omit to use the single active node.",
-        },
-        duration_s: {
-          type: "number",
-          minimum: 0,
-          maximum: 3600,
-          description: "Subscription duration in seconds (max 3600).",
-        },
-        sensing_server_url: {
-          type: "string",
-          description: "Override sensing-server URL for this call only.",
-        },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) => {
-      return bfldSubscribe(args as Parameters<typeof bfldSubscribe>[0], config);
-    },
+    schema: bfldSubscribeSchema,
+    handler: (args, config) =>
+      bfldSubscribe(args as Parameters<typeof bfldSubscribe>[0], config),
   },
-  // ── ADR-124 Presence + Vitals tools (Phase 4 Refinement iter 5) ──────────
+  // ── ADR-124 Presence + Vitals tools ───────────────────────────────────────
   {
-    name: "ruview.presence.now",
+    name: "ruview_presence_now",
     description:
       "Return current occupancy for a node: present, n_persons, confidence, timestamp_ms. " +
       "Wraps EdgeVitalsMessage.presence + n_persons (ADR-124 §4.1, ws.py:74-88).",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        node_id: { type: "string", description: "Target node id." },
-        sensing_server_url: { type: "string", description: "Override sensing-server URL." },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) =>
+    schema: presenceNowSchema,
+    handler: (args, config) =>
       presenceNow(args as Parameters<typeof presenceNow>[0], config),
   },
   {
-    name: "ruview.vitals.get_breathing",
+    name: "ruview_vitals_get_breathing",
     description:
       "Return breathing rate for a node: breathing_rate_bpm (null if unavailable), " +
       "confidence, timestamp_ms. Wraps EdgeVitalsMessage.breathing_rate_bpm (ws.py:82).",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        node_id: { type: "string", description: "Target node id." },
-        window_s: { type: "number", description: "Averaging window in seconds (max 300)." },
-        sensing_server_url: { type: "string", description: "Override sensing-server URL." },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) =>
+    schema: vitalsGetBreathingSchema,
+    handler: (args, config) =>
       vitalsGetBreathing(args as Parameters<typeof vitalsGetBreathing>[0], config),
   },
   {
-    name: "ruview.vitals.get_heart_rate",
+    name: "ruview_vitals_get_heart_rate",
     description:
       "Return heart rate for a node: heartrate_bpm (null if unavailable), " +
       "confidence, timestamp_ms. Wraps EdgeVitalsMessage.heartrate_bpm (ws.py:83).",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        node_id: { type: "string", description: "Target node id." },
-        window_s: { type: "number", description: "Averaging window in seconds (max 300)." },
-        sensing_server_url: { type: "string", description: "Override sensing-server URL." },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) =>
+    schema: vitalsGetHeartRateSchema,
+    handler: (args, config) =>
       vitalsGetHeartRate(args as Parameters<typeof vitalsGetHeartRate>[0], config),
   },
   {
-    name: "ruview.vitals.get_all",
+    name: "ruview_vitals_get_all",
     description:
       "Return the full EdgeVitalsMessage for a node (all fields except raw): " +
       "presence, n_persons, confidence, breathing_rate_bpm, heartrate_bpm, motion, zone_id. " +
       "Full surface of ws.py:74-88.",
-    inputSchema: {
-      type: "object" as const,
-      properties: {
-        node_id: { type: "string", description: "Target node id." },
-        sensing_server_url: { type: "string", description: "Override sensing-server URL." },
-      },
-    },
-    handler: async (args: unknown, config: ReturnType<typeof loadConfig>) =>
+    schema: vitalsGetAllSchema,
+    handler: (args, config) =>
       vitalsGetAll(args as Parameters<typeof vitalsGetAll>[0], config),
   },
-] as const;
+];
 
-// ── Server bootstrap ────────────────────────────────────────────────────────
+/**
+ * Pre-ADR-264 dotted tool names, accepted at call time for one deprecation
+ * cycle. Router-only: tools/list never advertises these.
+ */
+export const TOOL_ALIASES: Record<string, string> = {
+  "ruview.bfld.last_scan": "ruview_bfld_last_scan",
+  "ruview.bfld.subscribe": "ruview_bfld_subscribe",
+  "ruview.presence.now": "ruview_presence_now",
+  "ruview.vitals.get_breathing": "ruview_vitals_get_breathing",
+  "ruview.vitals.get_heart_rate": "ruview_vitals_get_heart_rate",
+  "ruview.vitals.get_all": "ruview_vitals_get_all",
+};
 
-async function main(): Promise<void> {
-  const config = loadConfig();
+/**
+ * Advertised JSON Schema, generated from the Zod source (ADR-264 O5).
+ * Memoized: schemas are static for the process lifetime, and tools/list is
+ * called once per session (per HTTP session under the session-per-server
+ * model) — no point re-walking the Zod tree each time.
+ */
+const jsonSchemaCache = new Map<string, object>();
+export function toolInputJsonSchema(def: ToolDef): object {
+  const cached = jsonSchemaCache.get(def.name);
+  if (cached !== undefined) return cached;
+  const raw = zodToJsonSchema(def.schema, { $refStrategy: "none" }) as Record<
+    string,
+    unknown
+  >;
+  delete raw["$schema"];
+  jsonSchemaCache.set(def.name, raw);
+  return raw;
+}
 
+// ── Server factory ──────────────────────────────────────────────────────────
+
+/**
+ * Build a fully-wired MCP Server. A factory (not a singleton) because each
+ * Streamable-HTTP session needs its own Server instance (ADR-264 F7/O3).
+ */
+export function buildServer(config: RuviewConfig = loadConfig()): Server {
   const server = new Server(
-    {
-      name: SERVER_NAME,
-      version: PACKAGE_VERSION,
-    },
-    {
-      capabilities: {
-        tools: {},
-      },
-    }
+    { name: SERVER_NAME, version: PACKAGE_VERSION },
+    { capabilities: { tools: {} } }
   );
 
-  // List tools handler.
   server.setRequestHandler(ListToolsRequestSchema, () => ({
     tools: TOOLS.map((t) => ({
       name: t.name,
       description: t.description,
-      inputSchema: t.inputSchema,
+      inputSchema: toolInputJsonSchema(t),
     })),
   }));
 
-  // Call tool handler — uniform Zod validation gate (ADR-124 §3 Architecture).
-  // If TOOL_INPUT_SCHEMAS has a schema for the tool name, run safeParse first.
-  // Parse failures throw McpError(InvalidParams) so the client sees a typed
-  // JSON-RPC error rather than a wrapped string error.
+  // Call tool handler — the SINGLE Zod validation gate (ADR-264 O5): parse
+  // once, hand the typed result (with defaults applied) to the handler.
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
+    const { name: rawName, arguments: args } = request.params;
+    const name = TOOL_ALIASES[rawName] ?? rawName;
     const tool = TOOLS.find((t) => t.name === name);
 
     if (!tool) {
@@ -388,7 +281,7 @@ async function main(): Promise<void> {
             type: "text" as const,
             text: JSON.stringify({
               ok: false,
-              error: `Unknown tool "${name}". Available tools: ${TOOLS.map((t) => t.name).join(", ")}`,
+              error: `Unknown tool "${rawName}". Available tools: ${TOOLS.map((t) => t.name).join(", ")}`,
             }),
           },
         ],
@@ -396,22 +289,16 @@ async function main(): Promise<void> {
       };
     }
 
-    // Schema validation gate — applies to all tools registered in TOOL_INPUT_SCHEMAS.
-    const schemaEntry = Object.prototype.hasOwnProperty.call(TOOL_INPUT_SCHEMAS, name)
-      ? TOOL_INPUT_SCHEMAS[name as keyof typeof TOOL_INPUT_SCHEMAS]
-      : undefined;
-    if (schemaEntry !== undefined) {
-      const parsed = schemaEntry.safeParse(args ?? {});
-      if (!parsed.success) {
-        throw new McpError(
-          ErrorCode.InvalidParams,
-          `Invalid arguments for tool "${name}": ${parsed.error.message}`
-        );
-      }
+    const parsed = tool.schema.safeParse(args ?? {});
+    if (!parsed.success) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `Invalid arguments for tool "${rawName}": ${parsed.error.message}`
+      );
     }
 
     try {
-      const result = await tool.handler(args ?? {}, config);
+      const result = await tool.handler(parsed.data, config);
       return {
         content: [
           {
@@ -438,18 +325,59 @@ async function main(): Promise<void> {
     }
   });
 
-  // Wire up stdio transport.
+  return server;
+}
+
+// ── Server bootstrap ────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const config = loadConfig();
+
+  // stdio transport (default, always on).
+  const stdioServer = buildServer(config);
   const transport = new StdioServerTransport();
-  await server.connect(transport);
+  await stdioServer.connect(transport);
+
+  // Streamable HTTP transport — explicit opt-in only (ADR-264 O3). Lazily
+  // imported so the stdio path never pays the streamableHttp load cost.
+  const httpPort = process.env["RVAGENT_HTTP_PORT"];
+  let httpNote = "";
+  if (httpPort !== undefined && httpPort !== "") {
+    const { createHttpTransport } = await import("./http-transport.js");
+    const { boundAddress } = await createHttpTransport(
+      () => buildServer(config),
+      { port: Number(httpPort) }
+    );
+    httpNote = ` HTTP: ${boundAddress}/mcp.`;
+  }
 
   // Log to stderr so it doesn't interfere with the MCP stdio protocol.
   process.stderr.write(
     `[@ruvnet/rvagent] Server v${PACKAGE_VERSION} started. ` +
-      `Sensing server: ${config.sensingServerUrl}\n`
+      `Sensing server: ${config.sensingServerUrl}.${httpNote}\n`
   );
 }
 
-main().catch((e) => {
-  process.stderr.write(`[ruview-mcp] Fatal: ${String(e)}\n`);
-  process.exit(1);
-});
+// CLI guard: boot the server only when this module is the entrypoint — invoked
+// as the `rvagent` / `ruview-mcp` bin or `node dist/index.js`. Importing it as a
+// library (`import { buildServer } from "@ruvnet/rvagent"`) must NOT side-effect
+// connect a StdioServerTransport to the consumer's stdin/stdout. Realpath both
+// sides because npm's bin shim is a symlink and passes a non-normalized,
+// possibly case-skewed argv[1] on Windows (mirrors harness/ruview/bin/cli.js).
+const invokedDirectly = (() => {
+  if (!argv[1]) return false;
+  try {
+    const a = realpathSync(argv[1]);
+    const b = realpathSync(fileURLToPath(import.meta.url));
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  } catch {
+    return false;
+  }
+})();
+
+if (invokedDirectly) {
+  main().catch((e) => {
+    process.stderr.write(`[ruview-mcp] Fatal: ${String(e)}\n`);
+    process.exit(1);
+  });
+}

tools/ruview-mcp/src/tools/train-count.ts

@@ -17,7 +17,16 @@
 
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, appendFileSync, openSync } from "node:fs";
+import {
+  mkdirSync,
+  appendFileSync,
+  openSync,
+  closeSync,
+  readFileSync,
+  writeFileSync,
+  statSync,
+  readSync,
+} from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import type { RuviewConfig, TrainJobResult, JobStatusResult } from "../types.js";
@@ -66,17 +75,101 @@ export const jobStatusSchema = z.object({
 
 export type JobStatusInput = z.infer<typeof jobStatusSchema>;
 
-// In-process job registry (survives for the lifetime of the MCP server process).
-// For a production implementation, persist to ~/.ruview/jobs/<id>.json.
-const jobRegistry = new Map<
-  string,
-  {
-    status: "queued" | "running" | "done" | "failed";
-    log_path: string;
-    queued_at: number;
-    epochs_total: number;
+interface JobRecord {
+  status: "queued" | "running" | "done" | "failed" | "unknown";
+  log_path: string;
+  queued_at: number;
+  epochs_total: number;
+  /**
+   * OS pid of the training child. Persisted so a later process (e.g. after an
+   * MCP server restart) can tell whether a job still marked 'running' actually
+   * outlived the process that spawned it (ADR-264 O6).
+   */
+  pid?: number | undefined;
+  /** Human-readable explanation attached during reconciliation (unknown state). */
+  reason?: string | undefined;
+}
+
+// In-process job registry, mirrored to <jobsDir>/<id>.json on every state
+// change so ruview_job_status survives an MCP server restart (ADR-264 O6).
+const jobRegistry = new Map<string, JobRecord>();
+
+function jobRecordPath(jobsDir: string, jobId: string): string {
+  return path.join(jobsDir, `${jobId}.json`);
+}
+
+function persistJob(jobsDir: string, jobId: string, record: JobRecord): void {
+  try {
+    writeFileSync(
+      jobRecordPath(jobsDir, jobId),
+      JSON.stringify({ job_id: jobId, ...record }, null, 2)
+    );
+  } catch {
+    // Persistence is best-effort; the in-memory record still serves this process.
   }
->();
+}
+
+function loadPersistedJob(jobsDir: string, jobId: string): JobRecord | undefined {
+  try {
+    const raw = JSON.parse(readFileSync(jobRecordPath(jobsDir, jobId), "utf8")) as
+      Partial<JobRecord>;
+    if (typeof raw.log_path !== "string" || typeof raw.status !== "string") {
+      return undefined;
+    }
+    return {
+      status: raw.status,
+      log_path: raw.log_path,
+      queued_at: typeof raw.queued_at === "number" ? raw.queued_at : 0,
+      epochs_total: typeof raw.epochs_total === "number" ? raw.epochs_total : 0,
+      pid: typeof raw.pid === "number" ? raw.pid : undefined,
+      reason: typeof raw.reason === "string" ? raw.reason : undefined,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Is `pid` still a live process? `process.kill(pid, 0)` sends no signal but
+ * probes existence: ESRCH ⇒ gone; EPERM ⇒ alive but owned by another user
+ * (treated as alive so we never falsely reconcile a still-running job).
+ */
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return (e as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/**
+ * Scan log lines (tail) for the "# exit code: N" marker the child.on('close')
+ * handler appends. `found:false` means the process died without the marker —
+ * i.e. this server never saw the close (it restarted mid-run).
+ */
+function findExitMarker(lines: string[]): { found: boolean; code: number | null } {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const m = /^# exit code: (-?\d+|null)$/.exec((lines[i] ?? "").trim());
+    if (m) return { found: true, code: m[1] === "null" ? null : Number(m[1]) };
+  }
+  return { found: false, code: null };
+}
+
+/** Read the last `maxLines` lines of a file without loading the whole log. */
+function tailLines(filePath: string, maxLines: number, maxBytes = 64 * 1024): string[] {
+  const size = statSync(filePath).size;
+  const start = Math.max(0, size - maxBytes);
+  const buf = Buffer.alloc(size - start);
+  const fd = openSync(filePath, "r");
+  try {
+    readSync(fd, buf, 0, buf.length, start);
+  } finally {
+    closeSync(fd);
+  }
+  const lines = buf.toString("utf8").split("\n");
+  return lines.slice(Math.max(0, lines.length - maxLines));
+}
 
 export async function trainCount(
   input: TrainCountInput,
@@ -92,13 +185,16 @@ export async function trainCount(
   const outputDir =
     input.output_dir ?? "v2/crates/cog-person-count/cog/artifacts";
 
-  // Record the job immediately so ruview_job_status can find it.
-  jobRegistry.set(jobId, {
+  // Record the job immediately so ruview_job_status can find it — in memory
+  // and on disk (survives server restarts, ADR-264 O6).
+  const record: JobRecord = {
     status: "queued",
     log_path: logPath,
     queued_at: queuedAt,
     epochs_total: input.epochs,
-  });
+  };
+  jobRegistry.set(jobId, record);
+  persistJob(logDir, jobId, record);
 
   // Write the header synchronously so the log file exists before spawn.
   const header = [
@@ -142,21 +238,29 @@ export async function trainCount(
 
   child.unref(); // Allow the MCP server process to exit without waiting for training.
 
-  const entry = jobRegistry.get(jobId);
-  if (entry) {
-    entry.status = "running";
-  }
+  // The child holds its own duplicates of the log fds; close the parent's
+  // copies immediately or every job leaks 2 fds for the server's lifetime
+  // (ADR-264 F6/O6).
+  closeSync(logFdOut);
+  closeSync(logFdErr);
+
+  // Record the child pid so a later process can reconcile a stale 'running'
+  // record after a server restart (child.pid is undefined only if spawn failed
+  // synchronously, in which case the 'error' handler flips status to 'failed').
+  record.pid = child.pid;
+  record.status = "running";
+  persistJob(logDir, jobId, record);
 
   child.on("error", (e) => {
     appendFileSync(logPath, `\n# ERROR: ${e.message}\n`);
-    const rec = jobRegistry.get(jobId);
-    if (rec) rec.status = "failed";
+    record.status = "failed";
+    persistJob(logDir, jobId, record);
   });
 
   child.on("close", (code) => {
     appendFileSync(logPath, `\n# exit code: ${code}\n`);
-    const rec = jobRegistry.get(jobId);
-    if (rec) rec.status = code === 0 ? "done" : "failed";
+    record.status = code === 0 ? "done" : "failed";
+    persistJob(logDir, jobId, record);
   });
 
   const result: TrainJobResult = {
@@ -178,24 +282,48 @@ export async function trainCount(
 
 export async function jobStatus(
   input: JobStatusInput,
-  _config: RuviewConfig
+  config: RuviewConfig
 ): Promise<object> {
-  const job = jobRegistry.get(input.job_id);
+  // Memory first, then the persisted record (survives server restarts).
+  let job = jobRegistry.get(input.job_id) ?? loadPersistedJob(config.jobsDir, input.job_id);
   if (!job) {
     return {
       ok: false,
-      error: `Job ${input.job_id} not found. ` +
-        "The MCP server may have restarted — check the log directory directly.",
+      error: `Job ${input.job_id} not found in this server or in ${config.jobsDir}.`,
     };
   }
 
-  // Read the last 20 lines of the log file.
+  // Reconcile a 'running' record whose owning process is gone. The status flip
+  // to done/failed lives only in the spawning process's child.on('close'/'error')
+  // handlers; if this server restarted mid-run, the record froze at 'running'
+  // (ADR-264 O6). When the pid is dead, recover the true outcome from the log's
+  // "# exit code: N" marker, else surface an honest 'unknown'.
+  if (job.status === "running" && typeof job.pid === "number" && !isProcessAlive(job.pid)) {
+    let tail: string[] = [];
+    try {
+      tail = tailLines(job.log_path, 40);
+    } catch {
+      /* log unreadable — treated as no marker below */
+    }
+    const marker = findExitMarker(tail);
+    const reconciled: JobRecord = { ...job };
+    if (marker.found) {
+      reconciled.status = marker.code === 0 ? "done" : "failed";
+      reconciled.reason = undefined;
+    } else {
+      reconciled.status = "unknown";
+      reconciled.reason =
+        "process gone, no exit marker — server likely restarted mid-run";
+    }
+    jobRegistry.set(input.job_id, reconciled);
+    persistJob(config.jobsDir, input.job_id, reconciled);
+    job = reconciled;
+  }
+
+  // Bounded tail read — never load a multi-GB training log wholesale.
   let recentLog: string[] = [];
   try {
-    const { readFileSync } = await import("node:fs");
-    const content = readFileSync(job.log_path, "utf8");
-    const lines = content.split("\n");
-    recentLog = lines.slice(Math.max(0, lines.length - 20));
+    recentLog = tailLines(job.log_path, 20);
   } catch {
     recentLog = ["(log not readable yet)"];
   }
@@ -206,6 +334,7 @@ export async function jobStatus(
     log_path: job.log_path,
     recent_log: recentLog,
     epochs_total: job.epochs_total,
+    ...(job.reason !== undefined ? { reason: job.reason } : {}),
   };
 
   return { ok: true, result };

tools/ruview-mcp/src/types.ts

@@ -115,7 +115,12 @@ export interface TrainJobResult {
 /** Output of ruview_job_status. */
 export interface JobStatusResult {
   job_id: string;
-  status: "queued" | "running" | "done" | "failed";
+  /**
+   * 'unknown' is only ever produced by post-restart reconciliation: a record
+   * frozen at 'running' whose owning process is gone and whose log carries no
+   * exit-code marker (see reason).
+   */
+  status: "queued" | "running" | "done" | "failed" | "unknown";
   progress_pct?: number | undefined;
   /** Most recent log lines (last 20). */
   recent_log: string[];
@@ -124,6 +129,8 @@ export interface JobStatusResult {
   epochs_done?: number | undefined;
   /** Total epochs scheduled. */
   epochs_total?: number | undefined;
+  /** Explanation attached when status was reconciled to 'unknown'. */
+  reason?: string | undefined;
 }
 
 // ── Vitals (ADR-124 §6 Python surface parity: ws.py:74-88) ───────────────

tools/ruview-mcp/tests/config.test.ts

@@ -0,0 +1,49 @@
+/**
+ * ADR-264 F8/O7 — cog-binary detection must be architecture-aware.
+ *
+ * detectCogBinary() itself probes hardcoded /var/lib paths, so it is not
+ * cheaply testable without fs mocking. The bug it fixes, however, lives purely
+ * in the candidate ORDER, which cogBinaryCandidates() exposes as a pure,
+ * arch-injectable function — that is what we pin here.
+ */
+
+import { cogBinaryCandidates } from "../src/config.js";
+
+describe("cogBinaryCandidates()", () => {
+  it("probes -arm before -x86_64 on arm64 hosts", () => {
+    const c = cogBinaryCandidates("cog-person-count", "arm64");
+    const arm = c.findIndex((p) => p.endsWith("cog-person-count-arm"));
+    const x86 = c.findIndex((p) => p.endsWith("cog-person-count-x86_64"));
+    expect(arm).toBeGreaterThanOrEqual(0);
+    expect(x86).toBeGreaterThanOrEqual(0);
+    expect(arm).toBeLessThan(x86);
+  });
+
+  it("probes -x86_64 before -arm on x64 hosts", () => {
+    const c = cogBinaryCandidates("cog-person-count", "x64");
+    const arm = c.findIndex((p) => p.endsWith("cog-person-count-arm"));
+    const x86 = c.findIndex((p) => p.endsWith("cog-person-count-x86_64"));
+    expect(x86).toBeLessThan(arm);
+  });
+
+  it("defaults an unknown arch to the x86_64-first order", () => {
+    const c = cogBinaryCandidates("cog-pose-estimation", "riscv64");
+    const arm = c.findIndex((p) => p.endsWith("cog-pose-estimation-arm"));
+    const x86 = c.findIndex((p) => p.endsWith("cog-pose-estimation-x86_64"));
+    expect(x86).toBeLessThan(arm);
+  });
+
+  it("keeps the /usr/local/bin and bare-name PATH fallbacks last", () => {
+    const c = cogBinaryCandidates("cog-person-count", "arm64");
+    // The two arch builds come first; the /usr/local/bin fallback follows them.
+    expect(c[c.length - 1]).toBe("/usr/local/bin/cog-person-count");
+    expect(c).toHaveLength(3);
+  });
+
+  it("derives the id by stripping the cog- prefix once", () => {
+    const c = cogBinaryCandidates("cog-person-count", "x64");
+    expect(c[0]).toBe(
+      "/var/lib/cognitum/apps/person-count/cog-person-count-x86_64"
+    );
+  });
+});

tools/ruview-mcp/tests/http-transport.test.ts

@@ -59,7 +59,9 @@ async function startServer(
   basePort: number
 ): Promise<{ port: number; close: () => Promise<void> }> {
   const port = basePort + Math.floor(Math.random() * 100);
-  const { httpServer } = buildHttpApp(makeMockMcpServer(), opts);
+  // Factory, not instance: each Streamable-HTTP session gets its own MCP
+  // Server (ADR-264 F7/O3).
+  const { httpServer } = buildHttpApp(() => makeMockMcpServer(), opts);
   await new Promise<void>((resolve, reject) => {
     httpServer.once("error", reject);
     httpServer.listen(port, "127.0.0.1", () => resolve());
@@ -95,8 +97,34 @@ describe("isOriginAllowed()", () => {
     expect(isOriginAllowed("https://evil.example.com", ["*"])).toBe(true);
   });
 
-  it("is case-sensitive per RFC 6454", () => {
-    expect(isOriginAllowed("HTTP://localhost", allow)).toBe(false);
+  // ADR-264 F7: real browser origins carry ports — localhost must match on
+  // hostname, any port, even with an empty allowlist.
+  it("allows localhost origins on any port", () => {
+    expect(isOriginAllowed("http://localhost:5173", [])).toBe(true);
+    expect(isOriginAllowed("http://127.0.0.1:8080", [])).toBe(true);
+    expect(isOriginAllowed("https://localhost:3001", [])).toBe(true);
+  });
+
+  it("rejects non-local origins even with a localhost-looking prefix", () => {
+    expect(isOriginAllowed("http://localhost.evil.example.com", [])).toBe(false);
+    expect(isOriginAllowed("https://evil.example.com:443", [])).toBe(false);
+  });
+
+  // ADR-264 F7 hardening: an EXPLICIT allowlist means exact matching only. The
+  // any-port-localhost convenience applies solely to the empty-allowlist case,
+  // so an operator who pins an allowlist actually gets it.
+  it("with an explicit allowlist, rejects a localhost origin on an unlisted port", () => {
+    expect(isOriginAllowed("http://localhost:5173", allow)).toBe(false);
+    expect(isOriginAllowed("http://127.0.0.1:8080", allow)).toBe(false);
+  });
+
+  it("with an explicit allowlist, still accepts an exactly-listed localhost origin", () => {
+    expect(isOriginAllowed("http://localhost", allow)).toBe(true);
+    expect(isOriginAllowed("http://127.0.0.1", allow)).toBe(true);
+  });
+
+  it("is case-sensitive for non-local allowlist entries per RFC 6454", () => {
+    expect(isOriginAllowed("HTTPS://Partner.Example.com", ["https://partner.example.com"])).toBe(false);
   });
 });
 
@@ -165,3 +193,117 @@ describe("HTTP transport bearer-token auth gate", () => {
     expect(r.status).not.toBe(401);
   });
 });
+
+// ── 7. ADR-264 F7/O3 hardening: body cap + per-session routing ─────────────
+
+describe("HTTP transport session + body-cap hardening (ADR-264 F7)", () => {
+  let port: number;
+  let close: () => Promise<void>;
+
+  beforeAll(async () => {
+    const srv = await startServer({ allowedOrigins: ["*"], maxBodyBytes: 64 * 1024 }, 49600);
+    port = srv.port;
+    close = srv.close;
+  });
+
+  afterAll(async () => { await close(); });
+
+  it("rejects oversized request bodies with 413", async () => {
+    const huge = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "x", params: { pad: "y".repeat(128 * 1024) } });
+    const r = await post(port, "/mcp", {}, huge);
+    expect(r.status).toBe(413);
+  });
+
+  it("rejects a non-initialize POST without a session id with 400 (never a shared transport)", async () => {
+    const r = await post(port, "/mcp", {}, MCP_BODY); // tools/list, no mcp-session-id
+    expect(r.status).toBe(400);
+    const body = JSON.parse(r.body) as Record<string, unknown>;
+    expect(body["error"]).toMatch(/initialize/i);
+  });
+
+  it("rejects a POST with an unknown session id with 404", async () => {
+    const r = await post(port, "/mcp", { "mcp-session-id": "no-such-session" }, MCP_BODY);
+    expect(r.status).toBe(404);
+  });
+
+  it("creates a fresh session (and MCP server) per initialize request", async () => {
+    const init = JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "test-client", version: "0.0.0" },
+      },
+    });
+    const r = await post(port, "/mcp", { Accept: "application/json, text/event-stream" }, init);
+    expect([200, 406]).not.toContain(0); // sanity
+    expect(r.status).toBe(200);
+  });
+});
+
+// ── 8. ADR-264 F7: session-map bounds (cap + idle TTL sweep) ───────────────
+
+describe("HTTP transport session bounds (ADR-264 F7)", () => {
+  const initBody = (id: number): string =>
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "test-client", version: "0.0.0" },
+      },
+    });
+
+  // Build directly (not via startServer) so we can inspect the sessions map.
+  async function startWithApp(
+    opts: Parameters<typeof buildHttpApp>[1],
+    basePort: number
+  ): Promise<{
+    port: number;
+    sessions: ReturnType<typeof buildHttpApp>["sessions"];
+    close: () => Promise<void>;
+  }> {
+    const { httpServer, sessions } = buildHttpApp(() => makeMockMcpServer(), opts);
+    const port = basePort + Math.floor(Math.random() * 100);
+    await new Promise<void>((resolve, reject) => {
+      httpServer.once("error", reject);
+      httpServer.listen(port, "127.0.0.1", () => resolve());
+    });
+    const close = () =>
+      new Promise<void>((res, rej) => httpServer.close((e) => (e ? rej(e) : res())));
+    return { port, sessions, close };
+  }
+
+  const ACCEPT = { Accept: "application/json, text/event-stream" };
+
+  it("never exceeds maxSessions — evicts the oldest-idle session at capacity", async () => {
+    const srv = await startWithApp({ allowedOrigins: ["*"], maxSessions: 2 }, 49800);
+    try {
+      for (let i = 0; i < 5; i++) {
+        await post(srv.port, "/mcp", ACCEPT, initBody(i));
+      }
+      expect(srv.sessions.size).toBeLessThanOrEqual(2);
+    } finally {
+      await srv.close();
+    }
+  });
+
+  it("sweeps sessions idle beyond sessionIdleMs", async () => {
+    const srv = await startWithApp(
+      { allowedOrigins: ["*"], sessionIdleMs: 20, sweepIntervalMs: 10 },
+      49900
+    );
+    try {
+      await post(srv.port, "/mcp", ACCEPT, initBody(1));
+      expect(srv.sessions.size).toBe(1);
+      await new Promise((r) => setTimeout(r, 150));
+      expect(srv.sessions.size).toBe(0);
+    } finally {
+      await srv.close();
+    }
+  });
+});

tools/ruview-mcp/tests/manifest.test.ts

@@ -15,11 +15,11 @@
  */
 
 import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkgPath = resolve(__dirname, "../package.json");
+// jest runs from the package root; avoid import.meta (ts-jest transforms this
+// suite to a module target that rejects it — pre-existing suite failure).
+const pkgPath = resolve(process.cwd(), "package.json");
 
 // Parse once; keep raw for snapshot assertions.
 const raw = readFileSync(pkgPath, "utf-8");

tools/ruview-mcp/tests/train-count-reconcile.test.ts

@@ -0,0 +1,96 @@
+/**
+ * ADR-264 O6 — post-restart job reconciliation.
+ *
+ * When the MCP server restarts mid-run, the persisted job record stays frozen
+ * at 'running' (the child.on('close') that flips it lived in the dead process).
+ * ruview_job_status must reconcile such a record against the recorded pid and
+ * the log's "# exit code: N" marker.
+ *
+ * We fabricate a persisted record pointing at a KNOWN-DEAD pid (a synchronous
+ * child that has already exited) and assert the reconciled status.
+ */
+
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { jobStatus } from "../src/tools/train-count.js";
+import type { RuviewConfig } from "../src/types.js";
+
+/** A pid that has certainly exited: spawnSync waits for the child to finish. */
+function deadPid(): number {
+  const r = spawnSync(process.execPath, ["-e", ""]);
+  if (typeof r.pid !== "number") throw new Error("could not spawn probe child");
+  return r.pid;
+}
+
+function makeConfig(jobsDir: string): RuviewConfig {
+  return {
+    sensingServerUrl: "http://127.0.0.1:19999",
+    apiToken: undefined,
+    poseCogBinary: "nonexistent",
+    countCogBinary: "nonexistent",
+    jobsDir,
+  };
+}
+
+/** Write a fake persisted 'running' record + its log, return {jobId, config}. */
+function seedRunningJob(logBody: string): { jobId: string; config: RuviewConfig } {
+  const jobsDir = mkdtempSync(path.join(os.tmpdir(), "rvagent-jobs-"));
+  const jobId = randomUUID();
+  const logPath = path.join(jobsDir, `${jobId}.log`);
+  writeFileSync(logPath, logBody);
+  const record = {
+    job_id: jobId,
+    status: "running",
+    log_path: logPath,
+    queued_at: Date.now() / 1000,
+    epochs_total: 5,
+    pid: deadPid(),
+  };
+  writeFileSync(
+    path.join(jobsDir, `${jobId}.json`),
+    JSON.stringify(record, null, 2)
+  );
+  return { jobId, config: makeConfig(jobsDir) };
+}
+
+describe("ruview_job_status reconciliation (ADR-264 O6)", () => {
+  it("reconciles a dead 'running' job with exit 0 to 'done'", async () => {
+    const { jobId, config } = seedRunningJob(
+      "# training...\nepoch 5/5\n# exit code: 0\n"
+    );
+    const out = (await jobStatus({ job_id: jobId }, config)) as Record<string, unknown>;
+    expect(out["ok"]).toBe(true);
+    const res = out["result"] as Record<string, unknown>;
+    expect(res["status"]).toBe("done");
+  });
+
+  it("reconciles a dead 'running' job with non-zero exit to 'failed'", async () => {
+    const { jobId, config } = seedRunningJob(
+      "# training...\npanic: cuda oom\n# exit code: 101\n"
+    );
+    const out = (await jobStatus({ job_id: jobId }, config)) as Record<string, unknown>;
+    const res = out["result"] as Record<string, unknown>;
+    expect(res["status"]).toBe("failed");
+  });
+
+  it("marks a dead 'running' job with no exit marker as 'unknown' with a reason", async () => {
+    const { jobId, config } = seedRunningJob("# training...\nepoch 2/5\n");
+    const out = (await jobStatus({ job_id: jobId }, config)) as Record<string, unknown>;
+    const res = out["result"] as Record<string, unknown>;
+    expect(res["status"]).toBe("unknown");
+    expect(typeof res["reason"]).toBe("string");
+    expect(res["reason"]).toMatch(/restarted/i);
+  });
+
+  it("treats a signal-killed marker (null) as 'failed'", async () => {
+    const { jobId, config } = seedRunningJob(
+      "# training...\n# exit code: null\n"
+    );
+    const out = (await jobStatus({ job_id: jobId }, config)) as Record<string, unknown>;
+    const res = out["result"] as Record<string, unknown>;
+    expect(res["status"]).toBe("failed");
+  });
+});

tools/ruview-mcp/tsconfig.json

@@ -7,8 +7,8 @@
     "outDir": "dist",
     "rootDir": "src",
     "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
+    "declarationMap": false,
+    "sourceMap": false,
     "strict": true,
     "noUncheckedIndexedAccess": true,
     "exactOptionalPropertyTypes": true,

ui/services/api.service.js

@@ -147,4 +147,17 @@ export class ApiService {
 }
 
 // Create singleton instance
-export const apiService = new ApiService();
+export const apiService = new ApiService();
+
+// Storage key shared with the QuickSettings "API Access" panel.
+export const API_TOKEN_STORAGE_KEY = 'ruview-api-token';
+
+// Apply a previously-saved bearer token at module load — before app init
+// dispatches its first request — so a configured RUVIEW_API_TOKEN works from
+// the very first /api/v1/* call. The server only ever checks the
+// `Authorization: Bearer` header (see bearer_auth.rs) — this intentionally
+// never puts the token in a URL query string.
+try {
+  const storedToken = localStorage.getItem(API_TOKEN_STORAGE_KEY);
+  if (storedToken) apiService.setAuthToken(storedToken);
+} catch { /* storage unavailable (private browsing etc.) */ }

ui/style.css

@@ -4088,6 +4088,20 @@ a:focus-visible,
   color: #fff;
 }
 
+.qs-text-input {
+  padding: var(--space-6) var(--space-8);
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--color-border);
+  background: var(--color-secondary);
+  color: var(--color-text);
+  font-size: var(--font-size-sm);
+}
+
+.qs-text-input:focus {
+  outline: 2px solid var(--color-primary);
+  outline-offset: 1px;
+}
+
 /* --- Screenshot Flash --- */
 
 .screenshot-flash {

ui/utils/quick-settings.js

@@ -1,6 +1,8 @@
 // Quick Settings Panel - Centralized configuration for all UI features
 // Accessible via gear icon in header
 
+import { apiService, API_TOKEN_STORAGE_KEY } from '../services/api.service.js';
+
 export class QuickSettings {
   constructor(app) {
     this.app = app;
@@ -9,6 +11,8 @@ export class QuickSettings {
     this.isOpen = false;
   }
 
+  // A stored token is applied at api.service.js module load (before any
+  // request fires) — this panel only saves/clears it.
   init() {
     this.createButton();
     this.createPanel();
@@ -70,6 +74,18 @@ export class QuickSettings {
             <span class="qs-switch"></span>
           </label>
         </div>
+        <div class="qs-section">
+          <div class="qs-section-title">API Access</div>
+          <div class="qs-row" style="flex-direction: column; align-items: stretch; gap: 6px;">
+            <span>Bearer token (set only if the server enforces RUVIEW_API_TOKEN)</span>
+            <input type="password" id="qs-api-token" class="qs-text-input" placeholder="Paste token..." autocomplete="off" style="width: 100%; box-sizing: border-box;">
+            <div style="display: flex; gap: 8px;">
+              <button class="qs-btn" id="qs-api-token-save">Save & Apply</button>
+              <button class="qs-btn-danger" id="qs-api-token-clear">Clear</button>
+            </div>
+            <span id="qs-api-token-status" style="font-size: 0.85em; opacity: 0.75;"></span>
+          </div>
+        </div>
         <div class="qs-section">
           <div class="qs-section-title">Data</div>
           <div class="qs-row">
@@ -112,6 +128,30 @@ export class QuickSettings {
       }
     });
 
+    this.panel.querySelector('#qs-api-token-save').addEventListener('click', () => {
+      const input = this.panel.querySelector('#qs-api-token');
+      const status = this.panel.querySelector('#qs-api-token-status');
+      const token = input.value.trim();
+      if (!token) {
+        status.textContent = 'Enter a token first, or use Clear to remove one.';
+        return;
+      }
+      try { localStorage.setItem(API_TOKEN_STORAGE_KEY, token); } catch { /* noop */ }
+      apiService.setAuthToken(token);
+      status.textContent = 'Token saved and applied. Reloading...';
+      setTimeout(() => window.location.reload(), 600);
+    });
+
+    this.panel.querySelector('#qs-api-token-clear').addEventListener('click', () => {
+      const input = this.panel.querySelector('#qs-api-token');
+      const status = this.panel.querySelector('#qs-api-token-status');
+      try { localStorage.removeItem(API_TOKEN_STORAGE_KEY); } catch { /* noop */ }
+      apiService.setAuthToken(null);
+      input.value = '';
+      status.textContent = 'Token cleared. Reloading...';
+      setTimeout(() => window.location.reload(), 600);
+    });
+
     this.panel.querySelector('#qs-clear-data').addEventListener('click', () => {
       try {
         localStorage.clear();
@@ -154,6 +194,10 @@ export class QuickSettings {
     if (this.getSetting('compact')) {
       document.body.classList.add('compact-mode');
     }
+    const status = this.panel.querySelector('#qs-api-token-status');
+    let hasToken = false;
+    try { hasToken = !!localStorage.getItem(API_TOKEN_STORAGE_KEY); } catch { /* noop */ }
+    if (status) status.textContent = hasToken ? 'A token is currently set.' : 'No token set (auth is off or unnecessary).';
   }
 
   prefersReducedMotion() {

v2/Cargo.lock

@@ -7533,7 +7533,6 @@ dependencies = [
  "tokio-test",
  "toml 0.8.23",
  "tracing",
- "wifi-densepose-core",
 ]
 
 [[package]]
@@ -10961,7 +10960,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-engine"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "blake3",
  "criterion",
@@ -11092,6 +11091,17 @@ dependencies = [
  "tower-http",
 ]
 
+[[package]]
+name = "wifi-densepose-posecode"
+version = "0.3.0"
+dependencies = [
+ "criterion",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "wifi-densepose-signal",
+]
+
 [[package]]
 name = "wifi-densepose-rufield"
 version = "0.3.0"
@@ -11126,7 +11136,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-sensing-server"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "axum",
  "chrono",
@@ -11161,7 +11171,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-signal"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "chrono",
  "criterion",
@@ -11268,7 +11278,7 @@ dependencies = [
 
 [[package]]
 name = "wifi-densepose-worldgraph"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "petgraph",
  "serde",
@@ -11277,17 +11287,6 @@ dependencies = [
  "wifi-densepose-geo",
 ]
 
-[[package]]
-name = "wifi-densepose-worldmodel"
-version = "0.3.1"
-dependencies = [
- "serde",
- "serde_json",
- "thiserror 2.0.18",
- "tokio",
- "wifi-densepose-worldgraph",
-]
-
 [[package]]
 name = "winapi"
 version = "0.3.9"

v2/Cargo.toml

@@ -46,6 +46,9 @@ members = [
     # PR #491 slot heuristic with a Candle network + Stoer-Wagner fusion.
     # Motivated by #499 ghost-skeleton reports.
     "crates/cog-person-count",
+    # ADR-266: Multi-actor PoseCode scene protocol. Converts persistent
+    # RuvSense PoseTracks into confidence-scored, deterministic motion scenes.
+    "crates/wifi-densepose-posecode",
     # ADR-116: Home Assistant + Matter Cognitum Seed cog. Wraps the
     # ADR-115 MQTT publisher as a Seed-installable artifact with
     # mDNS, embedded broker, RuVector thresholds, Ed25519 witness.
@@ -215,6 +218,7 @@ wifi-densepose-hardware = { version = "0.3.0", path = "crates/wifi-densepose-har
 wifi-densepose-wasm = { version = "0.3.0", path = "crates/wifi-densepose-wasm" }
 wifi-densepose-mat = { version = "0.3.0", path = "crates/wifi-densepose-mat" }
 wifi-densepose-ruvector = { version = "0.3.0", path = "crates/wifi-densepose-ruvector" }
+wifi-densepose-posecode = { version = "0.3.0", path = "crates/wifi-densepose-posecode" }
 wifi-densepose-worldmodel = { version = "0.3.0", path = "crates/worldgraph/wifi-densepose-worldmodel" }
 
 [profile.release]

v2/crates/wifi-densepose-engine/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "wifi-densepose-engine"
 description = "RuView streaming-engine integration layer — composes the ADR-135..146 building blocks into one trust-traceable pipeline cycle"
-version = "0.3.0"
+version = "0.3.1"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true

v2/crates/wifi-densepose-engine/src/lib.rs

@@ -226,6 +226,19 @@ impl StreamingEngine {
         }
     }
 
+    /// Override the multistatic fuser's timestamp guard interval (#1049/#1057).
+    /// Without this, `StreamingEngine::new` always builds
+    /// `MultistaticFuser::with_config(MultistaticConfig::default())` — a
+    /// hardcoded 60 ms hard guard that ignores whatever schedule/override the
+    /// caller derived from `WDP_TDM_SLOTS`/`WDP_GUARD_INTERVAL_US`, so
+    /// WiFi/ESP-NOW-synced multi-node deployments spuriously fail governed
+    /// trust cycles even after widening the guard elsewhere.
+    ///
+    /// Rebuilds the fuser, so call before any frames are processed.
+    pub fn set_multistatic_config(&mut self, cfg: MultistaticConfig) {
+        self.fuser = MultistaticFuser::with_config(cfg);
+    }
+
     /// Activate a per-room calibration adapter (ADR-150 §3.4). From the next
     /// cycle on, the adapter id is part of provenance `model_version` — and
     /// therefore of the witness — so the exact weights shaping inference are

v2/crates/wifi-densepose-posecode/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "wifi-densepose-posecode"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "Multi-actor semantic motion scenes for RuView PoseTrack streams"
+documentation = "https://docs.rs/wifi-densepose-posecode"
+keywords = ["wifi", "pose", "motion", "posecode", "multi-person"]
+categories = ["science", "computer-vision", "parser-implementations"]
+
+[dependencies]
+serde.workspace = true
+serde_json.workspace = true
+thiserror.workspace = true
+wifi-densepose-signal = { version = "0.3.5", path = "../wifi-densepose-signal", default-features = false, optional = true }
+
+[dev-dependencies]
+criterion.workspace = true
+
+[features]
+default = []
+ruview = ["dep:wifi-densepose-signal"]
+
+[[bench]]
+name = "posecode_bench"
+harness = false

v2/crates/wifi-densepose-posecode/benches/posecode_bench.rs

@@ -0,0 +1,37 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use wifi_densepose_posecode::{parse_posecode, to_posecode};
+
+const TWO_ACTORS: &str = r#"posecode scene "crossing"
+source observed_wifi_csi
+actor person_1:
+  rig humanoid
+  pose start = standing
+  track 1
+  confidence 0.8
+  position 0 0 0
+actor person_2:
+  rig humanoid
+  pose start = standing
+  track 2
+  confidence 0.8
+  position 1 0 0
+step "Move" 0.05s linear:
+  person_1.knee_left: flex 30 0.8
+  person_1.hip_left: flex 20 0.8
+  person_2.knee_right: flex 35 0.8
+  person_2.hip_right: flex 25 0.8
+repeat 1
+"#;
+
+fn benchmarks(c: &mut Criterion) {
+    c.bench_function("parse_two_actor_scene", |b| {
+        b.iter(|| parse_posecode(black_box(TWO_ACTORS)).unwrap())
+    });
+    let scene = parse_posecode(TWO_ACTORS).unwrap();
+    c.bench_function("serialize_two_actor_scene", |b| {
+        b.iter(|| to_posecode(black_box(&scene)))
+    });
+}
+
+criterion_group!(benches, benchmarks);
+criterion_main!(benches);

v2/crates/wifi-densepose-posecode/src/adapter.rs

@@ -0,0 +1,443 @@
+//! Conversion from tracked COCO-17 skeletons to semantic joint observations.
+
+use crate::error::{Error, Result};
+use crate::model::{ActorObservation, JointTarget, SceneFrame, Vec3};
+
+const NUM_KEYPOINTS: usize = 17;
+const LEFT_SHOULDER: usize = 5;
+const RIGHT_SHOULDER: usize = 6;
+const LEFT_ELBOW: usize = 7;
+const RIGHT_ELBOW: usize = 8;
+const LEFT_WRIST: usize = 9;
+const RIGHT_WRIST: usize = 10;
+const LEFT_HIP: usize = 11;
+const RIGHT_HIP: usize = 12;
+const LEFT_KNEE: usize = 13;
+const RIGHT_KNEE: usize = 14;
+const LEFT_ANKLE: usize = 15;
+const RIGHT_ANKLE: usize = 16;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TrackState {
+    Tentative,
+    Active,
+    Lost,
+    Terminated,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
+pub struct KeypointObservation {
+    pub position: Vec3,
+    pub confidence: f32,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct TrackObservation {
+    pub id: u64,
+    pub state: TrackState,
+    pub keypoints: [KeypointObservation; NUM_KEYPOINTS],
+    pub time_since_update: u64,
+}
+
+#[cfg(feature = "ruview")]
+impl From<&wifi_densepose_signal::ruvsense::PoseTrack> for TrackObservation {
+    fn from(track: &wifi_densepose_signal::ruvsense::PoseTrack) -> Self {
+        use wifi_densepose_signal::ruvsense::TrackLifecycleState;
+        Self {
+            id: track.id.0,
+            state: match track.lifecycle {
+                TrackLifecycleState::Tentative => TrackState::Tentative,
+                TrackLifecycleState::Active => TrackState::Active,
+                TrackLifecycleState::Lost => TrackState::Lost,
+                TrackLifecycleState::Terminated => TrackState::Terminated,
+            },
+            keypoints: std::array::from_fn(|i| {
+                let point = track.keypoints[i].position();
+                KeypointObservation {
+                    position: Vec3::new(point[0], point[1], point[2]),
+                    confidence: track.keypoints[i].confidence,
+                }
+            }),
+            time_since_update: track.time_since_update,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct AdapterConfig {
+    /// Coordinate system up vector after room calibration.
+    pub world_up: Vec3,
+    /// Coordinate system forward vector after room calibration.
+    pub world_forward: Vec3,
+    /// Ignore tracks below this aggregate confidence.
+    pub min_confidence: f32,
+    /// Confidence used until an inference backend populates keypoint confidence.
+    pub unscored_confidence: f32,
+    /// Emit lost tracks as predicted observations.
+    pub include_lost: bool,
+}
+
+impl Default for AdapterConfig {
+    fn default() -> Self {
+        Self {
+            world_up: Vec3::new(0.0, 1.0, 0.0),
+            world_forward: Vec3::new(0.0, 0.0, 1.0),
+            min_confidence: 0.2,
+            unscored_confidence: 0.5,
+            include_lost: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct RuViewAdapter {
+    config: AdapterConfig,
+}
+
+impl RuViewAdapter {
+    pub fn new(config: AdapterConfig) -> Result<Self> {
+        if !config.world_up.is_finite() || !config.world_forward.is_finite() {
+            return Err(Error::Observation("coordinate axes must be finite".into()));
+        }
+        if !(0.0..=1.0).contains(&config.min_confidence)
+            || !(0.0..=1.0).contains(&config.unscored_confidence)
+        {
+            return Err(Error::Observation("confidence must be in [0, 1]".into()));
+        }
+        if norm(config.world_up) < 1e-6 || norm(config.world_forward) < 1e-6 {
+            return Err(Error::Observation(
+                "coordinate axes must be non-zero".into(),
+            ));
+        }
+        let alignment = dot(normalize(config.world_up), normalize(config.world_forward)).abs();
+        if alignment > 0.98 {
+            return Err(Error::Observation(
+                "world up and forward axes must not be parallel".into(),
+            ));
+        }
+        Ok(Self { config })
+    }
+
+    /// Convert all visible tracks into one synchronized observation frame.
+    pub fn frame(&self, timestamp_ms: u64, tracks: &[TrackObservation]) -> SceneFrame {
+        let actors = tracks
+            .iter()
+            .filter_map(|track| self.actor(track))
+            .collect();
+        SceneFrame {
+            timestamp_ms,
+            actors,
+        }
+    }
+
+    /// Direct bridge for the RuView tracker aggregate. The feature is optional
+    /// so protocol-only consumers do not pull the signal and RuVector graph.
+    #[cfg(feature = "ruview")]
+    pub fn frame_from_pose_tracks(
+        &self,
+        timestamp_ms: u64,
+        tracks: &[&wifi_densepose_signal::ruvsense::PoseTrack],
+    ) -> SceneFrame {
+        let observations: Vec<TrackObservation> =
+            tracks.iter().map(|track| (*track).into()).collect();
+        self.frame(timestamp_ms, &observations)
+    }
+
+    pub fn actor(&self, track: &TrackObservation) -> Option<ActorObservation> {
+        if track.state == TrackState::Terminated
+            || (!self.config.include_lost && track.state == TrackState::Lost)
+        {
+            return None;
+        }
+
+        let confidence = track_confidence(track, self.config.unscored_confidence);
+        if confidence < self.config.min_confidence {
+            return None;
+        }
+
+        let p = |index: usize| track.keypoints[index].position;
+        if track.keypoints.iter().any(|kp| !kp.position.is_finite()) {
+            return None;
+        }
+
+        let left_hip = p(LEFT_HIP);
+        let right_hip = p(RIGHT_HIP);
+        let position = midpoint(left_hip, right_hip);
+        let up = normalize(self.config.world_up);
+        let forward = normalize(sub(
+            self.config.world_forward,
+            scale(up, dot(self.config.world_forward, up)),
+        ));
+
+        let mut joints = Vec::with_capacity(10);
+        add_flexion(
+            &mut joints,
+            "elbow_left",
+            p(LEFT_SHOULDER),
+            p(LEFT_ELBOW),
+            p(LEFT_WRIST),
+            joint_confidence(track, &[LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST], confidence),
+        );
+        add_flexion(
+            &mut joints,
+            "elbow_right",
+            p(RIGHT_SHOULDER),
+            p(RIGHT_ELBOW),
+            p(RIGHT_WRIST),
+            joint_confidence(
+                track,
+                &[RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST],
+                confidence,
+            ),
+        );
+        add_flexion(
+            &mut joints,
+            "knee_left",
+            left_hip,
+            p(LEFT_KNEE),
+            p(LEFT_ANKLE),
+            joint_confidence(track, &[LEFT_HIP, LEFT_KNEE, LEFT_ANKLE], confidence),
+        );
+        add_flexion(
+            &mut joints,
+            "knee_right",
+            right_hip,
+            p(RIGHT_KNEE),
+            p(RIGHT_ANKLE),
+            joint_confidence(track, &[RIGHT_HIP, RIGHT_KNEE, RIGHT_ANKLE], confidence),
+        );
+
+        add_signed_flex(
+            &mut joints,
+            "hip_left",
+            sub(p(LEFT_KNEE), left_hip),
+            up,
+            forward,
+            joint_confidence(track, &[LEFT_HIP, LEFT_KNEE], confidence),
+        );
+        add_signed_flex(
+            &mut joints,
+            "hip_right",
+            sub(p(RIGHT_KNEE), right_hip),
+            up,
+            forward,
+            joint_confidence(track, &[RIGHT_HIP, RIGHT_KNEE], confidence),
+        );
+        add_signed_flex(
+            &mut joints,
+            "shoulder_left",
+            sub(p(LEFT_ELBOW), p(LEFT_SHOULDER)),
+            up,
+            forward,
+            joint_confidence(track, &[LEFT_SHOULDER, LEFT_ELBOW], confidence),
+        );
+        add_signed_flex(
+            &mut joints,
+            "shoulder_right",
+            sub(p(RIGHT_ELBOW), p(RIGHT_SHOULDER)),
+            up,
+            forward,
+            joint_confidence(track, &[RIGHT_SHOULDER, RIGHT_ELBOW], confidence),
+        );
+
+        let shoulder_mid = midpoint(p(LEFT_SHOULDER), p(RIGHT_SHOULDER));
+        let torso = sub(shoulder_mid, position);
+        let hinge = angle_deg(torso, up).clamp(0.0, 180.0);
+        joints.push(JointTarget {
+            joint: "pelvis".into(),
+            action: "hinge".into(),
+            degrees: hinge,
+            confidence: joint_confidence(
+                track,
+                &[LEFT_SHOULDER, RIGHT_SHOULDER, LEFT_HIP, RIGHT_HIP],
+                confidence,
+            ),
+        });
+
+        Some(ActorObservation {
+            actor_id: format!("person_{}", track.id),
+            track_id: track.id,
+            confidence,
+            position,
+            joints,
+        })
+    }
+}
+
+fn track_confidence(track: &TrackObservation, fallback: f32) -> f32 {
+    let scored: Vec<f32> = track
+        .keypoints
+        .iter()
+        .map(|kp| kp.confidence)
+        .filter(|v| v.is_finite() && *v > 0.0)
+        .collect();
+    let measured = if scored.is_empty() {
+        fallback
+    } else {
+        scored.iter().sum::<f32>() / scored.len() as f32
+    };
+    let freshness = 1.0 / (1.0 + track.time_since_update as f32 * 0.2);
+    (measured * freshness).clamp(0.0, 1.0)
+}
+
+fn joint_confidence(track: &TrackObservation, indices: &[usize], fallback: f32) -> f32 {
+    indices.iter().fold(1.0_f32, |confidence, &index| {
+        let measured = track.keypoints[index].confidence;
+        confidence.min(if measured.is_finite() && measured > 0.0 {
+            measured
+        } else {
+            fallback
+        })
+    })
+}
+
+fn add_flexion(out: &mut Vec<JointTarget>, name: &str, a: Vec3, b: Vec3, c: Vec3, confidence: f32) {
+    let inner = angle_deg(sub(a, b), sub(c, b));
+    if inner.is_finite() {
+        out.push(JointTarget {
+            joint: name.into(),
+            action: "flex".into(),
+            degrees: (180.0 - inner).clamp(0.0, 180.0),
+            confidence,
+        });
+    }
+}
+
+fn add_signed_flex(
+    out: &mut Vec<JointTarget>,
+    name: &str,
+    limb: Vec3,
+    up: Vec3,
+    forward: Vec3,
+    confidence: f32,
+) {
+    let down = scale(up, -1.0);
+    let degrees = dot(limb, forward).atan2(dot(limb, down)).to_degrees();
+    if degrees.is_finite() {
+        out.push(JointTarget {
+            joint: name.into(),
+            action: if degrees >= 0.0 { "flex" } else { "extend" }.into(),
+            degrees: degrees.abs().clamp(0.0, 180.0),
+            confidence,
+        });
+    }
+}
+
+fn midpoint(a: Vec3, b: Vec3) -> Vec3 {
+    scale(add(a, b), 0.5)
+}
+fn add(a: Vec3, b: Vec3) -> Vec3 {
+    Vec3::new(a.x + b.x, a.y + b.y, a.z + b.z)
+}
+fn sub(a: Vec3, b: Vec3) -> Vec3 {
+    Vec3::new(a.x - b.x, a.y - b.y, a.z - b.z)
+}
+fn scale(v: Vec3, s: f32) -> Vec3 {
+    Vec3::new(v.x * s, v.y * s, v.z * s)
+}
+fn dot(a: Vec3, b: Vec3) -> f32 {
+    a.x * b.x + a.y * b.y + a.z * b.z
+}
+fn norm(v: Vec3) -> f32 {
+    dot(v, v).sqrt()
+}
+fn normalize(v: Vec3) -> Vec3 {
+    scale(v, 1.0 / norm(v).max(1e-9))
+}
+fn angle_deg(a: Vec3, b: Vec3) -> f32 {
+    let denom = norm(a) * norm(b);
+    if denom < 1e-9 {
+        return 0.0;
+    }
+    (dot(a, b) / denom).clamp(-1.0, 1.0).acos().to_degrees()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn standing_track() -> TrackObservation {
+        let mut keypoints = [KeypointObservation::default(); NUM_KEYPOINTS];
+        let mut set = |index, x, y, z| {
+            keypoints[index] = KeypointObservation {
+                position: Vec3::new(x, y, z),
+                confidence: 0.9,
+            };
+        };
+        set(LEFT_SHOULDER, -0.2, 1.5, 0.0);
+        set(RIGHT_SHOULDER, 0.2, 1.5, 0.0);
+        set(LEFT_ELBOW, -0.25, 1.1, 0.0);
+        set(RIGHT_ELBOW, 0.25, 1.1, 0.0);
+        set(LEFT_WRIST, -0.25, 0.75, 0.0);
+        set(RIGHT_WRIST, 0.25, 0.75, 0.0);
+        set(LEFT_HIP, -0.12, 0.9, 0.0);
+        set(RIGHT_HIP, 0.12, 0.9, 0.0);
+        set(LEFT_KNEE, -0.12, 0.5, 0.0);
+        set(RIGHT_KNEE, 0.12, 0.5, 0.0);
+        set(LEFT_ANKLE, -0.12, 0.05, 0.0);
+        set(RIGHT_ANKLE, 0.12, 0.05, 0.0);
+        TrackObservation {
+            id: 7,
+            state: TrackState::Active,
+            keypoints,
+            time_since_update: 0,
+        }
+    }
+
+    #[test]
+    fn converts_track_to_named_actor() {
+        let adapter = RuViewAdapter::new(AdapterConfig::default()).unwrap();
+        let actor = adapter.actor(&standing_track()).unwrap();
+        assert_eq!(actor.actor_id, "person_7");
+        assert_eq!(actor.track_id, 7);
+        assert!(actor.joints.len() >= 9);
+        assert!(actor.joints.iter().all(|j| j.degrees.is_finite()));
+    }
+
+    #[test]
+    fn rejects_invalid_axes() {
+        let config = AdapterConfig {
+            world_up: Vec3::default(),
+            ..Default::default()
+        };
+        assert!(RuViewAdapter::new(config).is_err());
+    }
+
+    #[test]
+    fn rejects_parallel_coordinate_axes() {
+        let config = AdapterConfig {
+            world_forward: Vec3::new(0.0, 2.0, 0.0),
+            ..Default::default()
+        };
+        assert!(RuViewAdapter::new(config).is_err());
+    }
+
+    #[test]
+    fn filters_stale_low_confidence_tracks() {
+        let mut track = standing_track();
+        track.time_since_update = 100;
+        let adapter = RuViewAdapter::new(AdapterConfig::default()).unwrap();
+        assert!(adapter.actor(&track).is_none());
+    }
+
+    #[cfg(feature = "ruview")]
+    #[test]
+    fn converts_native_ruview_pose_track() {
+        use wifi_densepose_signal::ruvsense::{PoseTrack, TrackId, TrackLifecycleState};
+
+        let source = standing_track();
+        let positions = std::array::from_fn(|i| {
+            let p = source.keypoints[i].position;
+            [p.x, p.y, p.z]
+        });
+        let mut native = PoseTrack::new(TrackId(23), &positions, 0, 128);
+        native.lifecycle = TrackLifecycleState::Active;
+        let observed = TrackObservation::from(&native);
+        assert_eq!(observed.id, 23);
+        assert_eq!(observed.state, TrackState::Active);
+        assert_eq!(
+            observed.keypoints[LEFT_HIP].position,
+            source.keypoints[LEFT_HIP].position
+        );
+    }
+}

v2/crates/wifi-densepose-posecode/src/error.rs

@@ -0,0 +1,24 @@
+//! Error types for parser and adapter boundaries.
+
+/// Crate result alias.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Errors are structured and line anchored where input text is involved.
+#[derive(Debug, thiserror::Error, PartialEq)]
+pub enum Error {
+    #[error("line {line}: {message}")]
+    Parse { line: usize, message: String },
+    #[error("invalid scene: {0}")]
+    Validation(String),
+    #[error("invalid observation: {0}")]
+    Observation(String),
+}
+
+impl Error {
+    pub(crate) fn parse(line: usize, message: impl Into<String>) -> Self {
+        Self::Parse {
+            line,
+            message: message.into(),
+        }
+    }
+}

v2/crates/wifi-densepose-posecode/src/lib.rs

@@ -0,0 +1,29 @@
+//! Multi-actor semantic motion scenes for RuView.
+//!
+//! This crate uses the PoseCode movement vocabulary and implements the
+//! RuView 0.2 multi-actor extension from ADR-266. It deliberately separates
+//! the high-rate observed pose stream from the compact semantic scene:
+//! [`adapter::RuViewAdapter`] converts persistent RuView tracks into observed
+//! frames, [`segmenter::PhaseSegmenter`] reduces those frames to synchronized
+//! phases, and [`serialize::to_posecode`] emits deterministic text.
+
+pub mod adapter;
+pub mod error;
+pub mod model;
+pub mod parser;
+pub mod segmenter;
+pub mod serialize;
+pub mod validate;
+
+pub use adapter::{
+    AdapterConfig, KeypointObservation, RuViewAdapter, TrackObservation, TrackState,
+};
+pub use error::{Error, Result};
+pub use model::*;
+pub use parser::parse_posecode;
+pub use segmenter::{PhaseSegmenter, SegmenterConfig};
+pub use serialize::to_posecode;
+pub use validate::{validate_scene, ValidationConfig, ValidationIssue, ValidationSeverity};
+
+/// Protocol version implemented by this crate.
+pub const PROTOCOL_VERSION: &str = "0.2";

v2/crates/wifi-densepose-posecode/src/model.rs

@@ -0,0 +1,203 @@
+//! Renderer independent scene model.
+
+use serde::{Deserialize, Serialize};
+
+/// Hard limits keep untrusted scene documents bounded in memory and time.
+pub const MAX_ACTORS: usize = 32;
+pub const MAX_PHASES: usize = 10_000;
+pub const MAX_TARGETS_PER_ACTOR: usize = 64;
+pub const MAX_NAME_BYTES: usize = 128;
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
+pub struct Vec3 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+impl Vec3 {
+    pub fn new(x: f32, y: f32, z: f32) -> Self {
+        Self { x, y, z }
+    }
+
+    pub fn is_finite(self) -> bool {
+        self.x.is_finite() && self.y.is_finite() && self.z.is_finite()
+    }
+
+    pub fn distance(self, other: Self) -> f32 {
+        let dx = self.x - other.x;
+        let dy = self.y - other.y;
+        let dz = self.z - other.z;
+        (dx * dx + dy * dy + dz * dz).sqrt()
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
+pub struct EulerDeg {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+impl EulerDeg {
+    pub fn is_finite(self) -> bool {
+        self.x.is_finite() && self.y.is_finite() && self.z.is_finite()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum SceneSource {
+    Authored,
+    ObservedWifiCsi,
+    Imported,
+}
+
+impl Default for SceneSource {
+    fn default() -> Self {
+        Self::Authored
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Actor {
+    pub id: String,
+    pub rig: String,
+    pub start_pose: String,
+    pub track_id: Option<u64>,
+    pub confidence: f32,
+    pub position: Vec3,
+}
+
+impl Actor {
+    pub fn humanoid(id: impl Into<String>) -> Self {
+        Self {
+            id: id.into(),
+            rig: "humanoid".into(),
+            start_pose: "standing".into(),
+            track_id: None,
+            confidence: 1.0,
+            position: Vec3::default(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct JointTarget {
+    pub joint: String,
+    pub action: String,
+    pub degrees: f32,
+    pub confidence: f32,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ActorTargets {
+    pub actor_id: String,
+    pub joints: Vec<JointTarget>,
+    pub ground_lock: Vec<String>,
+    pub travel: Option<Vec3>,
+    pub confidence: f32,
+}
+
+impl ActorTargets {
+    pub fn new(actor_id: impl Into<String>) -> Self {
+        Self {
+            actor_id: actor_id.into(),
+            joints: Vec::new(),
+            ground_lock: Vec::new(),
+            travel: None,
+            confidence: 1.0,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EffectorRef {
+    pub actor_id: String,
+    pub effector: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Contact {
+    pub from: EffectorRef,
+    pub to: EffectorRef,
+    pub confidence: f32,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum Timing {
+    Flow,
+    Settle,
+    Drive,
+    Snap,
+    Linear,
+    EaseIn,
+    EaseOut,
+    EaseInOut,
+}
+
+impl Timing {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Flow => "flow",
+            Self::Settle => "settle",
+            Self::Drive => "drive",
+            Self::Snap => "snap",
+            Self::Linear => "linear",
+            Self::EaseIn => "ease-in",
+            Self::EaseOut => "ease-out",
+            Self::EaseInOut => "ease-in-out",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Phase {
+    pub name: String,
+    pub start_ms: u64,
+    pub duration_ms: u64,
+    pub timing: Timing,
+    pub actors: Vec<ActorTargets>,
+    pub contacts: Vec<Contact>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Scene {
+    pub version: String,
+    pub name: String,
+    pub source: SceneSource,
+    pub actors: Vec<Actor>,
+    pub phases: Vec<Phase>,
+    pub repeat: u32,
+}
+
+impl Scene {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            version: crate::PROTOCOL_VERSION.into(),
+            name: name.into(),
+            source: SceneSource::Authored,
+            actors: Vec::new(),
+            phases: Vec::new(),
+            repeat: 1,
+        }
+    }
+}
+
+/// One actor at one observed instant. Raw observations remain separate from
+/// semantic phases so 20 Hz input does not become unreadable scene text.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ActorObservation {
+    pub actor_id: String,
+    pub track_id: u64,
+    pub confidence: f32,
+    pub position: Vec3,
+    pub joints: Vec<JointTarget>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct SceneFrame {
+    pub timestamp_ms: u64,
+    pub actors: Vec<ActorObservation>,
+}

v2/crates/wifi-densepose-posecode/src/parser.rs

@@ -0,0 +1,375 @@
+//! Bounded line parser for the PoseCode 0.2 multi-actor extension.
+
+use crate::error::{Error, Result};
+use crate::model::*;
+use crate::validate::{validate_scene, ValidationConfig, ValidationSeverity};
+
+const MAX_INPUT_BYTES: usize = 1_048_576;
+const MAX_LINE_BYTES: usize = 4096;
+
+pub fn parse_posecode(source: &str) -> Result<Scene> {
+    if source.len() > MAX_INPUT_BYTES {
+        return Err(Error::parse(0, "document exceeds 1 MiB"));
+    }
+    let mut scene: Option<Scene> = None;
+    let mut current_actor: Option<usize> = None;
+    let mut current_phase: Option<usize> = None;
+    let mut elapsed_ms = 0_u64;
+
+    for (index, raw) in source.lines().enumerate() {
+        let line_no = index + 1;
+        if raw.len() > MAX_LINE_BYTES {
+            return Err(Error::parse(line_no, "line exceeds 4096 bytes"));
+        }
+        let line = strip_comment(raw).trim();
+        if line.is_empty() {
+            continue;
+        }
+
+        if scene.is_none() {
+            let rest = line
+                .strip_prefix("posecode scene ")
+                .ok_or_else(|| Error::parse(line_no, "expected posecode scene header"))?;
+            scene = Some(Scene::new(parse_quoted(rest, line_no)?));
+            continue;
+        }
+        let doc = scene.as_mut().expect("initialized above");
+
+        if let Some(value) = line.strip_prefix("source ") {
+            doc.source = match value {
+                "authored" => SceneSource::Authored,
+                "observed_wifi_csi" => SceneSource::ObservedWifiCsi,
+                "imported" => SceneSource::Imported,
+                _ => return Err(Error::parse(line_no, "unknown source")),
+            };
+            continue;
+        }
+        if let Some(value) = line.strip_prefix("actor ") {
+            let id = value
+                .strip_suffix(':')
+                .ok_or_else(|| Error::parse(line_no, "actor declaration must end with ':'"))?;
+            doc.actors.push(Actor::humanoid(id.trim()));
+            current_actor = Some(doc.actors.len() - 1);
+            current_phase = None;
+            continue;
+        }
+        if let Some(value) = line.strip_prefix("step ") {
+            let (name, tail) = take_quoted(value, line_no)?;
+            let fields: Vec<&str> = tail.trim_end_matches(':').split_whitespace().collect();
+            if fields.len() != 2 {
+                return Err(Error::parse(line_no, "step requires duration and timing"));
+            }
+            let duration_ms = parse_duration(fields[0], line_no)?;
+            let timing = parse_timing(fields[1], line_no)?;
+            doc.phases.push(Phase {
+                name,
+                start_ms: elapsed_ms,
+                duration_ms,
+                timing,
+                actors: Vec::new(),
+                contacts: Vec::new(),
+            });
+            elapsed_ms = elapsed_ms
+                .checked_add(duration_ms)
+                .ok_or_else(|| Error::parse(line_no, "timeline overflow"))?;
+            current_phase = Some(doc.phases.len() - 1);
+            current_actor = None;
+            continue;
+        }
+        if let Some(value) = line.strip_prefix("repeat ") {
+            doc.repeat = value
+                .parse()
+                .map_err(|_| Error::parse(line_no, "repeat must be an integer"))?;
+            if doc.repeat == 0 || doc.repeat > 10_000 {
+                return Err(Error::parse(line_no, "repeat must be 1 to 10000"));
+            }
+            continue;
+        }
+
+        if let Some(ai) = current_actor {
+            parse_actor_field(&mut doc.actors[ai], line, line_no)?;
+            continue;
+        }
+        if let Some(pi) = current_phase {
+            parse_phase_field(&mut doc.phases[pi], line, line_no)?;
+            continue;
+        }
+        return Err(Error::parse(line_no, "directive is outside actor or step"));
+    }
+
+    let scene = scene.ok_or_else(|| Error::parse(0, "empty document"))?;
+    if let Some(issue) = validate_scene(&scene, &ValidationConfig::default())
+        .into_iter()
+        .find(|i| i.severity == ValidationSeverity::Error)
+    {
+        return Err(Error::Validation(format!(
+            "{}: {}",
+            issue.path, issue.message
+        )));
+    }
+    Ok(scene)
+}
+
+fn parse_actor_field(actor: &mut Actor, line: &str, line_no: usize) -> Result<()> {
+    if let Some(value) = line.strip_prefix("rig ") {
+        actor.rig = value.trim().into();
+        return Ok(());
+    }
+    if let Some(value) = line.strip_prefix("pose start = ") {
+        actor.start_pose = value.trim().into();
+        return Ok(());
+    }
+    if let Some(value) = line.strip_prefix("track ") {
+        actor.track_id = Some(
+            value
+                .parse()
+                .map_err(|_| Error::parse(line_no, "track must be an integer"))?,
+        );
+        return Ok(());
+    }
+    if let Some(value) = line.strip_prefix("confidence ") {
+        actor.confidence = parse_confidence(value, line_no)?;
+        return Ok(());
+    }
+    if let Some(value) = line.strip_prefix("position ") {
+        actor.position = parse_vec3(value, line_no)?;
+        return Ok(());
+    }
+    Err(Error::parse(line_no, "unknown actor directive"))
+}
+
+fn parse_phase_field(phase: &mut Phase, line: &str, line_no: usize) -> Result<()> {
+    if let Some(value) = line.strip_prefix("contact ") {
+        let fields: Vec<&str> = value.split_whitespace().collect();
+        if !(fields.len() == 2 || fields.len() == 3) {
+            return Err(Error::parse(
+                line_no,
+                "contact requires two effectors and optional confidence",
+            ));
+        }
+        phase.contacts.push(Contact {
+            from: parse_effector(fields[0], line_no)?,
+            to: parse_effector(fields[1], line_no)?,
+            confidence: if fields.len() == 3 {
+                parse_confidence(fields[2], line_no)?
+            } else {
+                1.0
+            },
+        });
+        return Ok(());
+    }
+    let (lhs, rhs) = line
+        .split_once(':')
+        .ok_or_else(|| Error::parse(line_no, "phase directive requires ':'"))?;
+    let (actor_id, target) = lhs
+        .trim()
+        .split_once('.')
+        .ok_or_else(|| Error::parse(line_no, "target must be actor qualified"))?;
+    let actor = phase_actor_mut(phase, actor_id);
+    match target {
+        "ground-lock" => {
+            actor.ground_lock = rhs
+                .split(',')
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .collect();
+        }
+        "travel" => {
+            actor.travel = Some(parse_vec3_or_xz(rhs, line_no)?);
+        }
+        joint => {
+            let fields: Vec<&str> = rhs.split_whitespace().collect();
+            if !(fields.len() == 2 || fields.len() == 3) {
+                return Err(Error::parse(
+                    line_no,
+                    "joint target requires action, degrees and optional confidence",
+                ));
+            }
+            actor.joints.push(JointTarget {
+                joint: joint.into(),
+                action: fields[0].into(),
+                degrees: fields[1]
+                    .parse()
+                    .map_err(|_| Error::parse(line_no, "degrees must be numeric"))?,
+                confidence: if fields.len() == 3 {
+                    parse_confidence(fields[2], line_no)?
+                } else {
+                    1.0
+                },
+            });
+        }
+    }
+    Ok(())
+}
+
+fn phase_actor_mut<'a>(phase: &'a mut Phase, id: &str) -> &'a mut ActorTargets {
+    if let Some(index) = phase.actors.iter().position(|a| a.actor_id == id) {
+        return &mut phase.actors[index];
+    }
+    phase.actors.push(ActorTargets::new(id));
+    phase.actors.last_mut().expect("just pushed")
+}
+
+fn parse_effector(value: &str, line: usize) -> Result<EffectorRef> {
+    let (actor_id, effector) = value
+        .split_once('.')
+        .ok_or_else(|| Error::parse(line, "effector must be actor qualified"))?;
+    Ok(EffectorRef {
+        actor_id: actor_id.into(),
+        effector: effector.into(),
+    })
+}
+
+fn parse_vec3(value: &str, line: usize) -> Result<Vec3> {
+    let f: Vec<&str> = value.split_whitespace().collect();
+    if f.len() != 3 {
+        return Err(Error::parse(line, "position requires x y z"));
+    }
+    Ok(Vec3::new(
+        parse_f32(f[0], line)?,
+        parse_f32(f[1], line)?,
+        parse_f32(f[2], line)?,
+    ))
+}
+
+fn parse_vec3_or_xz(value: &str, line: usize) -> Result<Vec3> {
+    let f: Vec<&str> = value.split_whitespace().collect();
+    match f.len() {
+        2 => Ok(Vec3::new(
+            parse_f32(f[0], line)?,
+            0.0,
+            parse_f32(f[1], line)?,
+        )),
+        3 => parse_vec3(value, line),
+        _ => Err(Error::parse(line, "travel requires x z or x y z")),
+    }
+}
+
+fn parse_f32(value: &str, line: usize) -> Result<f32> {
+    let v: f32 = value
+        .parse()
+        .map_err(|_| Error::parse(line, "expected finite number"))?;
+    if !v.is_finite() {
+        return Err(Error::parse(line, "expected finite number"));
+    }
+    Ok(v)
+}
+
+fn parse_confidence(value: &str, line: usize) -> Result<f32> {
+    let v = parse_f32(value, line)?;
+    if !(0.0..=1.0).contains(&v) {
+        return Err(Error::parse(line, "confidence must be in [0, 1]"));
+    }
+    Ok(v)
+}
+
+fn parse_duration(value: &str, line: usize) -> Result<u64> {
+    let seconds = value
+        .strip_suffix('s')
+        .ok_or_else(|| Error::parse(line, "duration must end in s"))?;
+    let seconds = parse_f32(seconds, line)?;
+    if seconds <= 0.0 || seconds > 300.0 {
+        return Err(Error::parse(line, "duration must be in (0, 300] seconds"));
+    }
+    Ok((seconds * 1000.0).round() as u64)
+}
+
+fn parse_timing(value: &str, line: usize) -> Result<Timing> {
+    match value {
+        "flow" => Ok(Timing::Flow),
+        "settle" => Ok(Timing::Settle),
+        "drive" => Ok(Timing::Drive),
+        "snap" => Ok(Timing::Snap),
+        "linear" => Ok(Timing::Linear),
+        "ease-in" => Ok(Timing::EaseIn),
+        "ease-out" => Ok(Timing::EaseOut),
+        "ease-in-out" => Ok(Timing::EaseInOut),
+        _ => Err(Error::parse(line, "unknown timing")),
+    }
+}
+
+fn parse_quoted(value: &str, line: usize) -> Result<String> {
+    let (quoted, tail) = take_quoted(value, line)?;
+    if !tail.trim().is_empty() {
+        return Err(Error::parse(line, "unexpected text after quoted name"));
+    }
+    Ok(quoted)
+}
+
+fn take_quoted(value: &str, line: usize) -> Result<(String, &str)> {
+    let rest = value
+        .strip_prefix('"')
+        .ok_or_else(|| Error::parse(line, "expected quoted name"))?;
+    let end = rest
+        .find('"')
+        .ok_or_else(|| Error::parse(line, "unterminated quoted name"))?;
+    Ok((rest[..end].to_string(), &rest[end + 1..]))
+}
+
+fn strip_comment(line: &str) -> &str {
+    let hash = line.find('#');
+    let slash = line.find("//");
+    match (hash, slash) {
+        (Some(a), Some(b)) => &line[..a.min(b)],
+        (Some(a), None) | (None, Some(a)) => &line[..a],
+        (None, None) => line,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SCENE: &str = r#"posecode scene "Assisted squat"
+source observed_wifi_csi
+actor patient:
+  rig humanoid
+  pose start = standing
+  track 7
+  confidence 0.82
+  position 0 0 0
+actor therapist:
+  rig humanoid
+  pose start = standing
+  position 1.2 0 0
+step "Lower" 1.5s flow:
+  patient.knee_left: flex 95 0.8
+  patient.ground-lock: feet
+  therapist.shoulder_left: flex 30
+  contact therapist.hand_left patient.shoulder_right 0.7
+repeat 2
+"#;
+
+    #[test]
+    fn parses_multiple_actors_and_contacts() {
+        let scene = parse_posecode(SCENE).unwrap();
+        assert_eq!(scene.actors.len(), 2);
+        assert_eq!(scene.phases[0].actors.len(), 2);
+        assert_eq!(scene.phases[0].contacts.len(), 1);
+        assert_eq!(scene.repeat, 2);
+    }
+
+    #[test]
+    fn rejects_unknown_actor_reference() {
+        let bad = "posecode scene \"x\"\nactor p1:\n rig humanoid\nstep \"x\" 1s flow:\n ghost.knee_left: flex 20";
+        assert!(parse_posecode(bad).is_err());
+    }
+
+    #[test]
+    fn rejects_non_finite_number() {
+        let bad = "posecode scene \"x\"\nactor p1:\n position NaN 0 0";
+        assert!(parse_posecode(bad).is_err());
+    }
+
+    #[test]
+    fn rejects_duplicate_actors() {
+        let bad = "posecode scene \"x\"\nactor p1:\n rig humanoid\nactor p1:\n rig humanoid";
+        assert!(parse_posecode(bad).is_err());
+    }
+
+    #[test]
+    fn rejects_oversized_document_before_parsing() {
+        let bad = "x".repeat(MAX_INPUT_BYTES + 1);
+        assert!(parse_posecode(&bad).is_err());
+    }
+}

v2/crates/wifi-densepose-posecode/src/segmenter.rs

@@ -0,0 +1,212 @@
+//! Confidence preserving reduction of high-rate observations into phases.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use crate::error::{Error, Result};
+use crate::model::*;
+
+#[derive(Debug, Clone)]
+pub struct SegmenterConfig {
+    pub minimum_phase_ms: u64,
+    pub maximum_phase_ms: u64,
+    pub stable_velocity_deg_s: f32,
+}
+
+impl Default for SegmenterConfig {
+    fn default() -> Self {
+        Self {
+            minimum_phase_ms: 200,
+            maximum_phase_ms: 3_000,
+            stable_velocity_deg_s: 8.0,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct PhaseSegmenter {
+    config: SegmenterConfig,
+}
+
+impl PhaseSegmenter {
+    pub fn new(config: SegmenterConfig) -> Result<Self> {
+        if config.minimum_phase_ms == 0
+            || config.maximum_phase_ms < config.minimum_phase_ms
+            || !config.stable_velocity_deg_s.is_finite()
+            || config.stable_velocity_deg_s < 0.0
+        {
+            return Err(Error::Observation("invalid segmenter configuration".into()));
+        }
+        Ok(Self { config })
+    }
+
+    pub fn segment(&self, name: impl Into<String>, frames: &[SceneFrame]) -> Result<Scene> {
+        if frames.is_empty() {
+            return Err(Error::Observation("at least one frame is required".into()));
+        }
+        for pair in frames.windows(2) {
+            if pair[1].timestamp_ms <= pair[0].timestamp_ms {
+                return Err(Error::Observation(
+                    "timestamps must be strictly increasing".into(),
+                ));
+            }
+        }
+        let mut scene = Scene::new(name);
+        scene.source = SceneSource::ObservedWifiCsi;
+        scene.actors = actors_from_frames(frames);
+
+        if frames.len() == 1 {
+            return Ok(scene);
+        }
+        let mut start = 0_usize;
+        let mut was_stable = true;
+        for i in 1..frames.len() {
+            let dt = frames[i].timestamp_ms - frames[i - 1].timestamp_ms;
+            let velocity = angular_velocity(&frames[i - 1], &frames[i], dt);
+            let stable = velocity <= self.config.stable_velocity_deg_s;
+            let elapsed = frames[i].timestamp_ms - frames[start].timestamp_ms;
+            let membership_changed = actor_ids(&frames[i - 1]) != actor_ids(&frames[i]);
+            let boundary = membership_changed
+                || elapsed >= self.config.maximum_phase_ms
+                || (stable && !was_stable && elapsed >= self.config.minimum_phase_ms);
+            if boundary {
+                scene
+                    .phases
+                    .push(make_phase(scene.phases.len(), &frames[start], &frames[i]));
+                start = i;
+            }
+            was_stable = stable;
+        }
+        let last = frames.len() - 1;
+        if start < last {
+            scene.phases.push(make_phase(
+                scene.phases.len(),
+                &frames[start],
+                &frames[last],
+            ));
+        }
+        Ok(scene)
+    }
+}
+
+fn actors_from_frames(frames: &[SceneFrame]) -> Vec<Actor> {
+    let mut found = BTreeMap::<u64, Actor>::new();
+    for frame in frames {
+        for observed in &frame.actors {
+            found
+                .entry(observed.track_id)
+                .and_modify(|actor| {
+                    actor.confidence = actor.confidence.max(observed.confidence);
+                    actor.position = observed.position;
+                })
+                .or_insert_with(|| {
+                    let mut actor = Actor::humanoid(observed.actor_id.clone());
+                    actor.track_id = Some(observed.track_id);
+                    actor.confidence = observed.confidence;
+                    actor.position = observed.position;
+                    actor
+                });
+        }
+    }
+    found.into_values().collect()
+}
+
+fn make_phase(index: usize, start: &SceneFrame, end: &SceneFrame) -> Phase {
+    let actors = end
+        .actors
+        .iter()
+        .map(|observed| ActorTargets {
+            actor_id: observed.actor_id.clone(),
+            joints: observed.joints.clone(),
+            ground_lock: Vec::new(),
+            travel: Some(observed.position),
+            confidence: observed.confidence,
+        })
+        .collect();
+    Phase {
+        name: format!("Observed {}", index + 1),
+        start_ms: start.timestamp_ms,
+        duration_ms: (end.timestamp_ms - start.timestamp_ms).max(1),
+        timing: Timing::Linear,
+        actors,
+        contacts: Vec::new(),
+    }
+}
+
+fn actor_ids(frame: &SceneFrame) -> BTreeSet<u64> {
+    frame.actors.iter().map(|a| a.track_id).collect()
+}
+
+fn angular_velocity(previous: &SceneFrame, current: &SceneFrame, dt_ms: u64) -> f32 {
+    let mut sum = 0.0;
+    let mut count = 0_u32;
+    for a in &current.actors {
+        let Some(before) = previous.actors.iter().find(|p| p.track_id == a.track_id) else {
+            return f32::INFINITY;
+        };
+        for joint in &a.joints {
+            if let Some(old) = before
+                .joints
+                .iter()
+                .find(|j| j.joint == joint.joint && j.action == joint.action)
+            {
+                sum += (joint.degrees - old.degrees).abs() * joint.confidence.min(old.confidence);
+                count += 1;
+            }
+        }
+    }
+    if count == 0 {
+        return 0.0;
+    }
+    (sum / count as f32) / (dt_ms as f32 / 1000.0).max(0.001)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn frame(ms: u64, angle: f32) -> SceneFrame {
+        SceneFrame {
+            timestamp_ms: ms,
+            actors: vec![ActorObservation {
+                actor_id: "p1".into(),
+                track_id: 1,
+                confidence: 0.9,
+                position: Vec3::default(),
+                joints: vec![JointTarget {
+                    joint: "knee_left".into(),
+                    action: "flex".into(),
+                    degrees: angle,
+                    confidence: 0.9,
+                }],
+            }],
+        }
+    }
+
+    #[test]
+    fn creates_compact_observed_scene() {
+        let frames = vec![
+            frame(0, 0.0),
+            frame(100, 20.0),
+            frame(200, 40.0),
+            frame(300, 40.1),
+            frame(500, 40.1),
+        ];
+        let scene = PhaseSegmenter::new(SegmenterConfig::default())
+            .unwrap()
+            .segment("squat", &frames)
+            .unwrap();
+        assert_eq!(scene.actors.len(), 1);
+        assert!(!scene.phases.is_empty());
+        assert!(scene.phases.len() < frames.len());
+        assert_eq!(scene.source, SceneSource::ObservedWifiCsi);
+    }
+
+    #[test]
+    fn rejects_reversed_time() {
+        let frames = vec![frame(100, 0.0), frame(50, 1.0)];
+        assert!(PhaseSegmenter::new(SegmenterConfig::default())
+            .unwrap()
+            .segment("bad", &frames)
+            .is_err());
+    }
+}

v2/crates/wifi-densepose-posecode/src/serialize.rs

@@ -0,0 +1,131 @@
+//! Canonical deterministic PoseCode text serialization.
+
+use std::fmt::Write;
+
+use crate::model::*;
+
+pub fn to_posecode(scene: &Scene) -> String {
+    let mut out = String::new();
+    writeln!(out, "posecode scene \"{}\"", safe_text(&scene.name)).unwrap();
+    writeln!(out, "source {}", source_name(scene.source)).unwrap();
+    for actor in &scene.actors {
+        writeln!(out, "actor {}:", actor.id).unwrap();
+        writeln!(out, "  rig {}", actor.rig).unwrap();
+        writeln!(out, "  pose start = {}", actor.start_pose).unwrap();
+        if let Some(track) = actor.track_id {
+            writeln!(out, "  track {track}").unwrap();
+        }
+        writeln!(out, "  confidence {}", number(actor.confidence)).unwrap();
+        writeln!(
+            out,
+            "  position {} {} {}",
+            number(actor.position.x),
+            number(actor.position.y),
+            number(actor.position.z)
+        )
+        .unwrap();
+    }
+    for phase in &scene.phases {
+        writeln!(
+            out,
+            "step \"{}\" {}s {}:",
+            safe_text(&phase.name),
+            number(phase.duration_ms as f32 / 1000.0),
+            phase.timing.as_str()
+        )
+        .unwrap();
+        for actor in &phase.actors {
+            for joint in &actor.joints {
+                writeln!(
+                    out,
+                    "  {}.{}: {} {} {}",
+                    actor.actor_id,
+                    joint.joint,
+                    joint.action,
+                    number(joint.degrees),
+                    number(joint.confidence)
+                )
+                .unwrap();
+            }
+            if !actor.ground_lock.is_empty() {
+                writeln!(
+                    out,
+                    "  {}.ground-lock: {}",
+                    actor.actor_id,
+                    actor.ground_lock.join(", ")
+                )
+                .unwrap();
+            }
+            if let Some(p) = actor.travel {
+                writeln!(
+                    out,
+                    "  {}.travel: {} {} {}",
+                    actor.actor_id,
+                    number(p.x),
+                    number(p.y),
+                    number(p.z)
+                )
+                .unwrap();
+            }
+        }
+        for contact in &phase.contacts {
+            writeln!(
+                out,
+                "  contact {}.{} {}.{} {}",
+                contact.from.actor_id,
+                contact.from.effector,
+                contact.to.actor_id,
+                contact.to.effector,
+                number(contact.confidence)
+            )
+            .unwrap();
+        }
+    }
+    writeln!(out, "repeat {}", scene.repeat).unwrap();
+    out
+}
+
+fn source_name(source: SceneSource) -> &'static str {
+    match source {
+        SceneSource::Authored => "authored",
+        SceneSource::ObservedWifiCsi => "observed_wifi_csi",
+        SceneSource::Imported => "imported",
+    }
+}
+
+fn safe_text(value: &str) -> String {
+    value
+        .chars()
+        .filter(|c| !c.is_control() && *c != '"')
+        .collect()
+}
+
+fn number(value: f32) -> String {
+    if value == 0.0 {
+        return "0".into();
+    }
+    let mut text = format!("{value:.4}");
+    while text.ends_with('0') {
+        text.pop();
+    }
+    if text.ends_with('.') {
+        text.pop();
+    }
+    text
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::parse_posecode;
+
+    #[test]
+    fn canonical_text_round_trips() {
+        let mut scene = Scene::new("two people");
+        scene.actors.push(Actor::humanoid("p1"));
+        scene.actors.push(Actor::humanoid("p2"));
+        let text = to_posecode(&scene);
+        assert_eq!(parse_posecode(&text).unwrap(), scene);
+        assert_eq!(to_posecode(&parse_posecode(&text).unwrap()), text);
+    }
+}

v2/crates/wifi-densepose-posecode/src/validate.rs

@@ -0,0 +1,202 @@
+//! Deterministic scene validation with provenance-aware range policy.
+
+use std::collections::HashSet;
+
+use crate::model::*;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ValidationSeverity {
+    Warning,
+    Error,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct ValidationIssue {
+    pub severity: ValidationSeverity,
+    pub path: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ValidationConfig {
+    pub max_actors: usize,
+    pub max_phases: usize,
+    /// Authored values outside general ROM are errors. Observed values are
+    /// warnings because RF estimates are not medical measurements.
+    pub authored_rom_is_error: bool,
+}
+
+impl Default for ValidationConfig {
+    fn default() -> Self {
+        Self {
+            max_actors: MAX_ACTORS,
+            max_phases: MAX_PHASES,
+            authored_rom_is_error: true,
+        }
+    }
+}
+
+pub fn validate_scene(scene: &Scene, config: &ValidationConfig) -> Vec<ValidationIssue> {
+    let mut issues = Vec::new();
+    if scene.name.is_empty() || scene.name.len() > MAX_NAME_BYTES {
+        error(
+            &mut issues,
+            "scene.name",
+            "name must contain 1 to 128 bytes",
+        );
+    }
+    if scene.actors.len() > config.max_actors {
+        error(&mut issues, "scene.actors", "actor limit exceeded");
+    }
+    if scene.phases.len() > config.max_phases {
+        error(&mut issues, "scene.phases", "phase limit exceeded");
+    }
+
+    let mut ids = HashSet::new();
+    for (i, actor) in scene.actors.iter().enumerate() {
+        let path = format!("actors[{i}]");
+        if !valid_id(&actor.id) {
+            error(&mut issues, &path, "invalid actor identifier");
+        }
+        if !ids.insert(actor.id.as_str()) {
+            error(&mut issues, &path, "duplicate actor identifier");
+        }
+        check_confidence(&mut issues, &format!("{path}.confidence"), actor.confidence);
+        if !actor.position.is_finite() {
+            error(
+                &mut issues,
+                &format!("{path}.position"),
+                "position must be finite",
+            );
+        }
+    }
+
+    let actor_ids: HashSet<&str> = scene.actors.iter().map(|a| a.id.as_str()).collect();
+    for (pi, phase) in scene.phases.iter().enumerate() {
+        let path = format!("phases[{pi}]");
+        if phase.duration_ms == 0 || phase.duration_ms > 300_000 {
+            error(
+                &mut issues,
+                &format!("{path}.duration_ms"),
+                "duration must be 1 to 300000 ms",
+            );
+        }
+        let mut phase_actors = HashSet::new();
+        for targets in &phase.actors {
+            if !actor_ids.contains(targets.actor_id.as_str()) {
+                error(&mut issues, &path, "phase references unknown actor");
+            }
+            if !phase_actors.insert(targets.actor_id.as_str()) {
+                error(&mut issues, &path, "actor appears more than once in phase");
+            }
+            if targets.joints.len() > MAX_TARGETS_PER_ACTOR {
+                error(&mut issues, &path, "joint target limit exceeded");
+            }
+            check_confidence(&mut issues, &path, targets.confidence);
+            for joint in &targets.joints {
+                check_confidence(&mut issues, &path, joint.confidence);
+                if !joint.degrees.is_finite() {
+                    error(&mut issues, &path, "joint angle must be finite");
+                    continue;
+                }
+                if let Some((min, max)) = range(&joint.joint, &joint.action) {
+                    if joint.degrees < min || joint.degrees > max {
+                        let severity = if scene.source == SceneSource::Authored
+                            && config.authored_rom_is_error
+                        {
+                            ValidationSeverity::Error
+                        } else {
+                            ValidationSeverity::Warning
+                        };
+                        issues.push(ValidationIssue {
+                            severity,
+                            path: path.clone(),
+                            message: format!(
+                                "{}.{} angle {} outside general range [{}, {}]",
+                                joint.joint, joint.action, joint.degrees, min, max
+                            ),
+                        });
+                    }
+                }
+            }
+        }
+        for contact in &phase.contacts {
+            if !actor_ids.contains(contact.from.actor_id.as_str())
+                || !actor_ids.contains(contact.to.actor_id.as_str())
+            {
+                error(&mut issues, &path, "contact references unknown actor");
+            }
+            check_confidence(&mut issues, &path, contact.confidence);
+        }
+    }
+    issues
+}
+
+fn valid_id(id: &str) -> bool {
+    !id.is_empty()
+        && id.len() <= 64
+        && id
+            .bytes()
+            .enumerate()
+            .all(|(i, b)| b.is_ascii_alphanumeric() || b == b'_' || (i > 0 && b == b'-'))
+}
+
+fn check_confidence(issues: &mut Vec<ValidationIssue>, path: &str, value: f32) {
+    if !value.is_finite() || !(0.0..=1.0).contains(&value) {
+        error(issues, path, "confidence must be finite and in [0, 1]");
+    }
+}
+
+fn error(issues: &mut Vec<ValidationIssue>, path: &str, message: &str) {
+    issues.push(ValidationIssue {
+        severity: ValidationSeverity::Error,
+        path: path.into(),
+        message: message.into(),
+    });
+}
+
+fn range(joint: &str, action: &str) -> Option<(f32, f32)> {
+    match (
+        joint.trim_end_matches("_left").trim_end_matches("_right"),
+        action,
+    ) {
+        ("shoulder", "flex") => Some((0.0, 180.0)),
+        ("shoulder", "extend") => Some((0.0, 60.0)),
+        ("elbow", "flex") => Some((0.0, 154.0)),
+        ("hip", "flex") => Some((0.0, 135.0)),
+        ("hip", "extend") => Some((0.0, 20.0)),
+        ("knee", "flex") => Some((0.0, 144.0)),
+        ("pelvis", "hinge") => Some((0.0, 120.0)),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn observed_rom_is_warning_not_medical_error() {
+        let mut scene = Scene::new("observed");
+        scene.source = SceneSource::ObservedWifiCsi;
+        scene.actors.push(Actor::humanoid("p1"));
+        let mut targets = ActorTargets::new("p1");
+        targets.joints.push(JointTarget {
+            joint: "knee_left".into(),
+            action: "flex".into(),
+            degrees: 170.0,
+            confidence: 0.5,
+        });
+        scene.phases.push(Phase {
+            name: "frame".into(),
+            start_ms: 0,
+            duration_ms: 50,
+            timing: Timing::Linear,
+            actors: vec![targets],
+            contacts: vec![],
+        });
+        let issues = validate_scene(&scene, &ValidationConfig::default());
+        assert_eq!(issues.len(), 1);
+        assert_eq!(issues[0].severity, ValidationSeverity::Warning);
+    }
+}

v2/crates/wifi-densepose-rufield/Cargo.toml

@@ -15,10 +15,10 @@ repository.workspace = true
 # (serde / serde_json / toml / sha2 / ed25519-dalek only — no tch / openblas /
 # ndarray / candle), so they build under `--no-default-features`.
 [dependencies]
-rufield-core = { path = "../../../vendor/rufield/crates/rufield-core" }
-rufield-provenance = { path = "../../../vendor/rufield/crates/rufield-provenance" }
-rufield-privacy = { path = "../../../vendor/rufield/crates/rufield-privacy" }
-rufield-fusion = { path = "../../../vendor/rufield/crates/rufield-fusion" }
+rufield-core = { version = "0.1.0", path = "../../../vendor/rufield/crates/rufield-core" }
+rufield-provenance = { version = "0.1.0", path = "../../../vendor/rufield/crates/rufield-provenance" }
+rufield-privacy = { version = "0.1.0", path = "../../../vendor/rufield/crates/rufield-privacy" }
+rufield-fusion = { version = "0.1.0", path = "../../../vendor/rufield/crates/rufield-fusion" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 

v2/crates/wifi-densepose-sensing-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wifi-densepose-sensing-server"
-version = "0.3.3"
+version = "0.3.4"
 edition.workspace = true
 description = "Lightweight Axum server for WiFi sensing UI with RuVector signal processing"
 license.workspace = true

v2/crates/wifi-densepose-sensing-server/src/bearer_auth.rs

@@ -34,6 +34,15 @@ pub const API_TOKEN_ENV: &str = "RUVIEW_API_TOKEN";
 /// Path prefix the middleware protects when auth is enabled.
 pub const PROTECTED_PREFIX: &str = "/api/v1/";
 
+/// `/api/v1/stream/pose` is a WebSocket upgrade endpoint reachable from
+/// browser code. Unlike a plain fetch(), the browser `WebSocket` constructor
+/// cannot attach an `Authorization` header to the handshake request, so this
+/// path can never carry a bearer token from a stock browser client — the
+/// same reasoning that already exempts `/ws/sensing` (see module docs).
+/// Exempted here rather than moved out of `/api/v1/*` to avoid an API
+/// surface change for existing clients.
+const EXEMPT_PATHS: &[&str] = &["/api/v1/stream/pose"];
+
 /// Cheap, cloneable handle to the configured token (or `None`).
 #[derive(Debug, Clone, Default)]
 pub struct AuthState {
@@ -93,7 +102,8 @@ pub async fn require_bearer(
     let Some(expected) = auth.token.clone() else {
         return next.run(request).await;
     };
-    if !request.uri().path().starts_with(PROTECTED_PREFIX) {
+    let path = request.uri().path();
+    if !path.starts_with(PROTECTED_PREFIX) || EXEMPT_PATHS.contains(&path) {
         return next.run(request).await;
     }
     let supplied = request
@@ -141,6 +151,7 @@ mod tests {
             .route("/health", get(|| async { "ok" }))
             .route("/api/v1/info", get(|| async { "ok" }))
             .route("/api/v1/sensitive", axum::routing::post(|| async { "ok" }))
+            .route("/api/v1/stream/pose", get(|| async { "ok" }))
             .route("/ui/index.html", get(|| async { "<html/>" }))
     }
 
@@ -361,6 +372,26 @@ mod tests {
         );
     }
 
+    /// `/api/v1/stream/pose` is a WebSocket upgrade the browser `WebSocket`
+    /// constructor drives directly — it cannot attach an `Authorization`
+    /// header, so this path must stay reachable even with auth ON (mirrors
+    /// the existing `/ws/sensing` exemption, just inside the `/api/v1/*`
+    /// prefix this time).
+    #[tokio::test]
+    async fn enabled_exempts_pose_stream_websocket() {
+        let r = wrap(AuthState::from_token("s3cr3t"));
+        assert_eq!(
+            status(r.clone(), "GET", "/api/v1/stream/pose", None).await,
+            StatusCode::OK,
+            "pose stream WS must stay reachable without a bearer token"
+        );
+        // The exemption is narrow: it must not leak to other /api/v1/* paths.
+        assert_eq!(
+            status(r, "GET", "/api/v1/info", None).await,
+            StatusCode::UNAUTHORIZED
+        );
+    }
+
     #[test]
     fn ct_eq_basics() {
         assert!(ct_eq(b"abc", b"abc"));

v2/crates/wifi-densepose-sensing-server/src/engine_bridge.rs

@@ -38,6 +38,7 @@ use wifi_densepose_bfld::{PrivacyClass, PrivacyMode};
 use wifi_densepose_engine::{AdapterInfo, EngineError, StreamingEngine, TrustedOutput};
 use wifi_densepose_geo::types::GeoRegistration;
 use wifi_densepose_signal::ruvsense::fusion_quality::CalibrationId;
+use wifi_densepose_signal::ruvsense::multistatic::MultistaticConfig;
 use wifi_densepose_worldgraph::WorldId;
 
 use super::multistatic_bridge::node_frames_from_states;
@@ -79,8 +80,24 @@ pub struct EngineBridge {
 impl EngineBridge {
     /// Build a bridge for one installation. `room_area_id`/`room_name` name the
     /// observation scope; `mode` is the starting privacy mode.
-    pub fn new(mode: PrivacyMode, model_version: u16, room_area_id: &str, room_name: &str) -> Self {
+    ///
+    /// `multistatic_cfg` is `None` on the pure default (60 ms/20 ms guard);
+    /// callers that derive a config from `WDP_TDM_SLOTS`/`WDP_GUARD_INTERVAL_US`
+    /// (see `main.rs::multistatic_guard_config_from_env`) should pass it here
+    /// too — otherwise the governed trust cycle silently keeps using the
+    /// hardcoded default even though the sibling `multistatic_fuser` field on
+    /// `AppState` picked up the override (#1049/#1057).
+    pub fn new(
+        mode: PrivacyMode,
+        model_version: u16,
+        room_area_id: &str,
+        room_name: &str,
+        multistatic_cfg: Option<MultistaticConfig>,
+    ) -> Self {
         let mut engine = StreamingEngine::new(mode, model_version, GeoRegistration::default());
+        if let Some(cfg) = multistatic_cfg {
+            engine.set_multistatic_config(cfg);
+        }
         let room = engine.add_room(room_area_id, room_name);
         Self {
             engine,
@@ -267,7 +284,7 @@ mod tests {
 
     #[test]
     fn empty_states_produce_no_belief() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "living_room", "Living Room");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "living_room", "Living Room", None);
         let out = bridge.process_cycle_from_states(&HashMap::new(), 1_000);
         assert!(out.is_none());
         // No belief published, no sensor wired.
@@ -276,7 +293,7 @@ mod tests {
 
     #[test]
     fn live_cycle_produces_witnessed_belief_with_provenance() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "living_room", "Living Room");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "living_room", "Living Room", None);
         let states = two_node_states();
         let out = bridge
             .process_cycle_from_states(&states, 10_000)
@@ -299,7 +316,7 @@ mod tests {
     fn live_path_is_deterministic() {
         let states = two_node_states_fixed();
         let run = || {
-            let mut b = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
+            let mut b = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
             b.process_cycle_from_states(&states, 5_000).unwrap().unwrap()
         };
         let a = run();
@@ -325,7 +342,7 @@ mod tests {
 
     #[test]
     fn nodes_registered_once_across_cycles() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
         let states = two_node_states();
         bridge.process_cycle_from_states(&states, 1_000);
         bridge.process_cycle_from_states(&states, 2_000);
@@ -336,7 +353,7 @@ mod tests {
 
     #[test]
     fn retention_bounds_world_graph_growth() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
         bridge.set_semantic_retention(5);
         let states = two_node_states();
         for i in 0..20i64 {
@@ -349,7 +366,7 @@ mod tests {
     #[test]
     fn adapter_identity_flows_into_live_witness() {
         let states = two_node_states_fixed();
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
         let base = bridge
             .process_cycle_from_states(&states, 1_000)
             .unwrap()
@@ -381,7 +398,7 @@ mod tests {
     /// the status endpoint, with a zero error count on the happy path.
     #[test]
     fn observe_cycle_records_trust_state() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
         assert!(bridge.last_trust_witness().is_none());
         assert_eq!(bridge.effective_class(), None);
 
@@ -402,17 +419,36 @@ mod tests {
         assert!(!bridge.suppress_raw_outputs());
     }
 
-    /// Error wiring (review finding 1a): two live nodes with mismatched
-    /// subcarrier counts make fusion return a `DimensionMismatch` →
-    /// `EngineError` — previously dropped by `if let Some(Ok(..))` at the
+    /// Error wiring (review finding 1a): a live cycle that fails fusion yields
+    /// an `EngineError` — previously dropped by `if let Some(Ok(..))` at the
     /// call sites. The counter must increment and the last good trust state
     /// must survive a later failure.
+    ///
+    /// Originally this forced the failure with a 56-vs-30 subcarrier mismatch
+    /// (`DimensionMismatch`). Since #1170 the live bridge canonicalizes every
+    /// node onto the 56-tone grid, so heterogeneous counts now fuse cleanly —
+    /// a frame-timestamp spread wider than the fuser's 60 ms guard interval is
+    /// the remaining deterministic way to provoke a fusion error here.
     #[test]
     fn observe_cycle_counts_engine_errors() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
-        let mut mismatched = HashMap::new();
-        mismatched.insert(0u8, node_state_with_history(1.0, 56));
-        mismatched.insert(1u8, node_state_with_history(1.05, 30)); // 30 ≠ 56 subcarriers
+        // Both nodes are 56-subcarrier (canonicalization-clean), but their
+        // frame timestamps are 500 ms apart — far beyond the 60 ms guard —
+        // so the fuser rejects the cycle with TimestampMismatch. Future
+        // offsets keep both instants safely after the bridge's lazy EPOCH.
+        fn mismatched_states() -> HashMap<u8, NodeState> {
+            let now = Instant::now();
+            let mut a = node_state_with_history(1.0, 56);
+            a.last_frame_time = Some(now + std::time::Duration::from_millis(600));
+            let mut b = node_state_with_history(1.05, 56);
+            b.last_frame_time = Some(now + std::time::Duration::from_millis(100));
+            let mut m = HashMap::new();
+            m.insert(0u8, a);
+            m.insert(1u8, b);
+            m
+        }
+
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
+        let mismatched = mismatched_states();
 
         assert!(bridge.observe_cycle(&mismatched, 1_000).is_none());
         assert_eq!(bridge.engine_error_count(), 1);
@@ -442,7 +478,7 @@ mod tests {
     /// mapping bfld's privacy gate applies at `Restricted`.
     #[test]
     fn restricted_class_suppresses_raw_outputs() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
         bridge.set_privacy_mode(PrivacyMode::StrictNoIdentity); // base = Restricted
         bridge
             .observe_cycle(&two_node_states(), 1_000)
@@ -453,7 +489,7 @@ mod tests {
 
     #[test]
     fn identity_strict_mode_is_carried_into_provenance() {
-        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R");
+        let mut bridge = EngineBridge::new(PrivacyMode::PrivateHome, 1, "r", "R", None);
         bridge.set_privacy_mode(PrivacyMode::StrictNoIdentity);
         let out = bridge
             .process_cycle_from_states(&two_node_states(), 7_000)

v2/crates/wifi-densepose-sensing-server/src/main.rs

@@ -518,17 +518,31 @@ const NOVELTY_HISTORY_CAPACITY: usize = 64;
 /// subcarrier ordering / normalisation so banks reject stale data.
 const NOVELTY_SKETCH_VERSION: u16 = 1;
 
+/// Lower plausibility floor (seconds) for a CSI inter-frame delta.
+///
+/// The firmware caps CSI sends at `CSI_MIN_SEND_INTERVAL_US = 20 ms`
+/// (`csi_collector.c`), so a single node cannot physically produce frames
+/// faster than 50 fps. UDP/OS buffering, however, delivers frames in tight
+/// bursts whose intra-burst arrival deltas are tens of microseconds apart —
+/// a 36 µs delta yields `1/dt ≈ 27 kHz`, which the old `< 1 s` guard let
+/// straight into the EMA and inflated `csi_fps_ema` by 1–3 orders of
+/// magnitude (issue #1180). We reject any delta implying more than 200 fps
+/// (4× the physical ceiling, leaving slack for benign arrival jitter); such
+/// deltas are burst artifacts, not distinct production intervals.
+pub(crate) const MIN_PLAUSIBLE_CSI_DT_SEC: f64 = 0.005;
+
 /// ADR-110 iter 18 — EMA update for per-node CSI fps tracking.
 ///
 /// Returns the new EMA value, or `None` if the delta is implausible
-/// (≤ 0, or > 1 second — likely a connection gap, not a real frame
-/// rate sample). α = 1/8 fixed shift, ~8-sample effective window,
-/// matching the firmware-side ESP-NOW offset smoother in §A0.10.
+/// (below [`MIN_PLAUSIBLE_CSI_DT_SEC`] — a sub-ms burst artifact, see
+/// issue #1180 — or `> 1 second`, likely a connection gap rather than a
+/// real frame-rate sample). α = 1/8 fixed shift, ~8-sample effective
+/// window, matching the firmware-side ESP-NOW offset smoother in §A0.10.
 ///
 /// Free function for testability — every transformation that doesn't
 /// touch the rest of `NodeState` lives outside the `impl` block.
 pub(crate) fn update_csi_fps_ema(prev_fps: f64, dt_sec: f64) -> Option<f64> {
-    if !(dt_sec > 0.0 && dt_sec < 1.0) {
+    if !(dt_sec >= MIN_PLAUSIBLE_CSI_DT_SEC && dt_sec < 1.0) {
         return None;
     }
     let instantaneous = 1.0 / dt_sec;
@@ -569,6 +583,35 @@ mod fps_ema_tests {
     fn long_gap_rejected_as_implausible() {
         assert!(update_csi_fps_ema(20.0, 2.0).is_none());
     }
+
+    #[test]
+    fn subms_burst_delta_rejected() {
+        // Issue #1180: a 36 µs intra-burst delta implies ~27 kHz and must
+        // not enter the EMA. Anything below the 5 ms floor is rejected.
+        assert!(update_csi_fps_ema(40.0, 0.000_036).is_none());
+        assert!(update_csi_fps_ema(40.0, 0.001).is_none());
+        // Just above the floor is accepted.
+        assert!(update_csi_fps_ema(40.0, 0.005).is_some());
+    }
+
+    #[test]
+    fn burst_interleaved_with_nominal_stays_in_band() {
+        // A true ~40 fps node whose frames arrive in sub-ms bursts: feeding
+        // only the plausible (nominal-cadence) deltas keeps the EMA near the
+        // ground truth instead of blowing up. Burst deltas are rejected by
+        // the caller (see NodeState::observe_csi_frame_arrival), so the EMA
+        // only ever sees the ~25 ms inter-group gaps.
+        let mut fps = 40.0;
+        for _ in 0..40 {
+            // nominal 25 ms gap (40 fps); intervening sub-ms bursts skipped
+            fps = update_csi_fps_ema(fps, 0.025).unwrap();
+            assert!(update_csi_fps_ema(fps, 0.000_040).is_none());
+        }
+        assert!(
+            (fps - 40.0).abs() < 1.0,
+            "EMA should stay within ~1 Hz of the 40 fps ground truth, got {fps}"
+        );
+    }
 }
 
 impl NodeState {
@@ -653,6 +696,15 @@ impl NodeState {
     pub(crate) fn observe_csi_frame_arrival(&mut self, now: std::time::Instant) {
         if let Some(prev) = self.last_frame_time {
             let dt = now.duration_since(prev).as_secs_f64();
+            // Burst arrivals (sub-floor dt, issue #1180): do NOT re-anchor on
+            // them. Keeping the previous anchor means the next genuine
+            // inter-frame gap measures the true cadence across the whole
+            // burst instead of intra-burst jitter — so a 50 fps node whose
+            // frames arrive in 36 µs bursts every 25 ms still reads ~40 fps,
+            // not 27 kHz.
+            if dt < MIN_PLAUSIBLE_CSI_DT_SEC {
+                return;
+            }
             if let Some(new_ema) = update_csi_fps_ema(self.csi_fps_ema, dt) {
                 self.csi_fps_ema = new_ema;
                 self.csi_fps_samples = self.csi_fps_samples.saturating_add(1);
@@ -7462,6 +7514,11 @@ async fn main() {
     let field_surface: rufield_surface::FieldState =
         Arc::new(RwLock::new(rufield_surface::FieldSurface::from_env()));
 
+    // Populated inside the `multistatic_fuser` field initializer below, then
+    // threaded into `engine_bridge` so both fusion paths honor the same
+    // WDP_TDM_SLOTS/WDP_GUARD_INTERVAL_US-derived guard (#1049/#1057).
+    let mut engine_bridge_multistatic_cfg: Option<MultistaticConfig> = None;
+
     let state: SharedState = Arc::new(RwLock::new(AppStateInner {
         latest_update: None,
         rssi_history: VecDeque::new(),
@@ -7536,7 +7593,7 @@ async fn main() {
             );
             let mut fuser = MultistaticFuser::with_config(MultistaticConfig {
                 min_nodes: 1, // single-node passthrough
-                ..cfg
+                ..cfg.clone()
             });
             if let Some(ref pos_str) = args.node_positions {
                 let positions = field_bridge::parse_node_positions(pos_str);
@@ -7548,6 +7605,10 @@ async fn main() {
                     fuser.set_node_positions(positions);
                 }
             }
+            engine_bridge_multistatic_cfg = Some(MultistaticConfig {
+                min_nodes: 1,
+                ..cfg
+            });
             fuser
         },
         engine_bridge: engine_bridge::EngineBridge::new(
@@ -7555,6 +7616,7 @@ async fn main() {
             1,
             "default",
             "Default Room",
+            engine_bridge_multistatic_cfg,
         ),
         field_model: if args.calibrate {
             info!("Field model calibration enabled — room should be empty during startup");
@@ -8037,6 +8099,36 @@ mod sync_snapshot_helper_tests {
         assert_eq!(snap.csi_fps_samples, 42);
     }
 
+    #[test]
+    fn observe_csi_frame_arrival_ignores_subms_bursts() {
+        // Issue #1180 regression: a ~40 fps node whose frames are delivered
+        // in tight UDP bursts (sub-ms intra-burst deltas) must still report
+        // ~40 fps, not tens of kHz. Synthesize the arrival stream by adding
+        // Durations to a base Instant.
+        use std::time::Duration;
+        let base = std::time::Instant::now();
+        let mut ns = NodeState::new();
+        ns.csi_fps_ema = 40.0; // pretend already warmed up
+        ns.csi_fps_samples = 10;
+
+        // 30 nominal 25 ms groups, each preceded by a 3-frame sub-ms burst.
+        for g in 0..30u64 {
+            let group_t = base + Duration::from_millis(25 * g);
+            ns.observe_csi_frame_arrival(group_t);
+            // burst: two extra arrivals 40 µs and 80 µs later — must be
+            // ignored for rate purposes (anchor must not advance to them).
+            ns.observe_csi_frame_arrival(group_t + Duration::from_micros(40));
+            ns.observe_csi_frame_arrival(group_t + Duration::from_micros(80));
+        }
+
+        assert!(
+            (ns.csi_fps_ema - 40.0).abs() < 2.0,
+            "csi_fps_ema must stay near the 40 fps ground truth despite \
+             sub-ms bursts, got {}",
+            ns.csi_fps_ema
+        );
+    }
+
     #[test]
     fn apply_sync_packet_populates_a_fresh_node() {
         // Mirrors what udp_receiver_task does on the very first sync

v2/crates/wifi-densepose-sensing-server/src/multistatic_bridge.rs

@@ -10,7 +10,7 @@ use std::collections::HashMap;
 use std::sync::LazyLock;
 use std::time::{Duration, Instant};
 
-use wifi_densepose_signal::hardware_norm::{CanonicalCsiFrame, HardwareType};
+use wifi_densepose_signal::hardware_norm::{CanonicalCsiFrame, HardwareNormalizer, HardwareType};
 use wifi_densepose_signal::ruvsense::multiband::MultiBandCsiFrame;
 use wifi_densepose_signal::ruvsense::multistatic::{FusedSensingFrame, MultistaticFuser};
 
@@ -26,6 +26,11 @@ const DEFAULT_FREQ_MHZ: u32 = 2437; // Channel 6
 /// are relative to this instant, avoiding wall-clock/monotonic mixing issues.
 static EPOCH: LazyLock<Instant> = LazyLock::new(Instant::now);
 
+/// Shared length-only canonicalizer (issue #1170). The default 56-tone grid
+/// matches what `MultistaticFuser` (ADR-154) expects. Stateless and immutable,
+/// so a single process-wide instance is safe to share across nodes.
+static NORMALIZER: LazyLock<HardwareNormalizer> = LazyLock::new(HardwareNormalizer::new);
+
 /// Convert a single `NodeState` into a `MultiBandCsiFrame` suitable for
 /// multistatic fusion.
 ///
@@ -38,7 +43,14 @@ pub fn node_frame_from_state(node_id: u8, ns: &NodeState) -> Option<MultiBandCsi
         return None;
     }
 
-    let amplitude: Vec<f32> = latest.iter().map(|&v| v as f32).collect();
+    // Issue #1170: resample the raw amplitude onto the canonical 56-tone grid
+    // BEFORE fusion. ESP32 nodes in mixed HT20/HT40 capture modes report
+    // different subcarrier counts (64 / 128 / 192); feeding those raw into
+    // `MultistaticFuser::fuse` tripped `DimensionMismatch` on every cycle and
+    // silently disabled real multistatic fusion. Length-only canonicalization
+    // (no z-score) keeps the amplitude scale the person-score relies on.
+    let canonical_amp = NORMALIZER.resample_to_canonical(latest);
+    let amplitude: Vec<f32> = canonical_amp.iter().map(|&v| v as f32).collect();
     let n_sub = amplitude.len();
     let phase = vec![0.0_f32; n_sub];
 
@@ -201,15 +213,58 @@ mod tests {
         assert_eq!(frame.channel_frames.len(), 1);
 
         let ch = &frame.channel_frames[0];
-        assert_eq!(ch.amplitude.len(), 3);
-        assert!((ch.amplitude[0] - 10.0_f32).abs() < f32::EPSILON);
-        assert!((ch.amplitude[1] - 20.0_f32).abs() < f32::EPSILON);
-        assert!((ch.amplitude[2] - 30.5_f32).abs() < f32::EPSILON);
+        // Issue #1170: amplitude is now resampled onto the canonical 56-tone
+        // grid regardless of the raw count.
+        assert_eq!(ch.amplitude.len(), 56);
+        // resample_cubic preserves the endpoints (no z-scoring), so the scale
+        // the person-score relies on is intact.
+        assert!((ch.amplitude[0] - 10.0_f32).abs() < 1e-3);
+        assert!((ch.amplitude[55] - 30.5_f32).abs() < 1e-3);
         // Phase should be all zeros
         assert!(ch.phase.iter().all(|&p| p == 0.0));
         assert_eq!(ch.hardware_type, HardwareType::Esp32S3);
     }
 
+    #[test]
+    fn heterogeneous_node_counts_canonicalize_and_fuse() {
+        // Issue #1170 regression: a mixed mesh with HT20 (64-bin) and HT40
+        // (192-bin) nodes must canonicalize to a uniform 56 tones and fuse,
+        // instead of tripping DimensionMismatch on every cycle.
+        let mut states: HashMap<u8, NodeState> = HashMap::new();
+
+        let mut h64 = VecDeque::new();
+        h64.push_back((0..64).map(|i| 1.0 + 0.1 * i as f64).collect::<Vec<f64>>());
+        states.insert(1, make_node_state(h64, Some(Instant::now()), 1));
+
+        let mut h192 = VecDeque::new();
+        h192.push_back((0..192).map(|i| 2.0 + 0.05 * i as f64).collect::<Vec<f64>>());
+        states.insert(3, make_node_state(h192, Some(Instant::now()), 1));
+
+        let frames = node_frames_from_states(&states);
+        assert_eq!(frames.len(), 2, "both nodes should produce frames");
+        for f in &frames {
+            assert_eq!(
+                f.channel_frames[0].amplitude.len(),
+                56,
+                "every node must present the canonical 56-tone dimension"
+            );
+        }
+
+        // The fuser must now accept the cycle (no DimensionMismatch).
+        let fuser = MultistaticFuser::new();
+        let result = fuser.fuse(&frames);
+        assert!(
+            result.is_ok(),
+            "heterogeneous mesh should fuse after canonicalization, got {result:?}"
+        );
+
+        // And the higher-level fallback path returns the fused frame, not the
+        // sum/dedup fallback.
+        let (fused, fallback) = fuse_or_fallback(&fuser, &states, 3.0);
+        assert!(fused.is_some(), "fusion should succeed");
+        assert!(fallback.is_none(), "no fallback when fusion succeeds");
+    }
+
     #[test]
     fn test_stale_node_excluded() {
         let mut states: HashMap<u8, NodeState> = HashMap::new();

v2/crates/wifi-densepose-signal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wifi-densepose-signal"
-version = "0.3.4"
+version = "0.3.5"
 edition.workspace = true
 description = "WiFi CSI signal processing for DensePose estimation"
 license.workspace = true

v2/crates/wifi-densepose-signal/src/hardware_norm.rs

@@ -167,6 +167,22 @@ impl HardwareNormalizer {
             hardware_type: hw,
         })
     }
+
+    /// Resample a raw 1-D CSI vector onto the canonical subcarrier grid
+    /// **without** z-score normalization (length-only canonicalization).
+    ///
+    /// Used by the live multistatic bridge (issue #1170): heterogeneous
+    /// ESP32 capture modes report different subcarrier counts (HT20 ≈ 64,
+    /// HT40 ≈ 128/192), and [`MultistaticFuser`] requires every node frame
+    /// to share one dimension. Full [`Self::normalize`] would z-score the
+    /// amplitude (mean → 0), which saturates the downstream person-score
+    /// (a squared coefficient of variation `variance / mean²`); resampling
+    /// alone makes frames fusable while preserving amplitude scale.
+    ///
+    /// [`MultistaticFuser`]: crate::ruvsense::multistatic::MultistaticFuser
+    pub fn resample_to_canonical(&self, raw: &[f64]) -> Vec<f64> {
+        resample_cubic(raw, self.canonical_subcarriers)
+    }
 }
 
 impl Default for HardwareNormalizer {
@@ -344,6 +360,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn resample_to_canonical_is_length_only_no_zscore() {
+        // Issue #1170: resample_to_canonical must change length to 56 but
+        // NOT z-score (mean must be preserved, not driven to ~0). A raw
+        // amplitude vector with a large positive mean keeps that mean.
+        let norm = HardwareNormalizer::new();
+        let raw: Vec<f64> = (0..192).map(|i| 50.0 + 0.1 * i as f64).collect();
+        let out = norm.resample_to_canonical(&raw);
+        assert_eq!(out.len(), 56, "must resample onto the 56-tone grid");
+        let mean = out.iter().sum::<f64>() / out.len() as f64;
+        assert!(
+            mean > 40.0,
+            "resample-only must preserve amplitude scale (mean ~60), got {mean}"
+        );
+        // Endpoints preserved.
+        assert!((out[0] - raw[0]).abs() < 1e-6);
+        assert!((out[55] - raw[191]).abs() < 0.5);
+    }
+
     #[test]
     fn zscore_produces_zero_mean_unit_std() {
         let data: Vec<f64> = (0..100)