From f5cf5a668f9179fb8eed431fa9975e1c3a34e002 Mon Sep 17 00:00:00 2001
From: Michael B Reiser <mreiser@gmail.com>
Date: Wed, 28 Oct 2026 17:20:56 -0400
Subject: [PATCH 1/4] =?UTF-8?q?rig:=20host=20monitor=20node=20=E2=80=94=20?=
 =?UTF-8?q?the=20PC's=20pressure=20on=20/rig/host,=20recorded=20in=20every?=
 =?UTF-8?q?=20run's=20bag?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A generic node (nothing FicTrac- or arena-specific) that publishes, once a second, CPU per
core (window mean + busiest 100 ms sub-window, P/E-core class, sampler lateness, context
switches / interrupts / DPCs), memory + page file + hard faults, log-volume free space,
per-disk and per-adapter rates, NVIDIA GPU (incl. NVENC/NVDEC) and the top processes plus
pinned groups (FicTrac, BIAS, MATLAB, browser, Foxglove, router, each graph node). The
method is atlas-bench tools/cpu_sampler.py: cycle counters and one NtQuerySystemInformation
call for all processes on Windows; GetIfEntry2 for network; NVML through ctypes; psutil
for the rest and on Linux/macOS.

- rig/nodes/host_sampler.py (no ROS) + host_monitor.py: rig-nodes material, prototyped here.
  Typed rig_interfaces/HostStats when installed (requested for rig-nodes 0.3.0; spec in
  rig/docs/host-stats-request.md), else String JSON with the same field names.
- bridge_node.py records /rig/host into the bag; rig.py starts the monitor by default
  (--no-host-monitor, --host-monitor-args).
- Cost on ww18: 0.9 % of one core (median); 4.9 % of the harness run's compressed payload,
  about 1.0 MB/h. Gated in the harness (<= 2 % of a core, <= 5 % of the payload).
- tests/test-host-sampler.py (root suite, no ROS/psutil): fields and types against the .msg
  spec, rates, CPU mean vs peak, process selection, strict JSON.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/development/rig-host-monitor.md |  85 ++++
 rig/README.md                        |   1 +
 rig/docs/host-stats-request.md       | 105 +++++
 rig/nodes/bridge_node.py             |  13 +
 rig/nodes/host_monitor.py            | 175 ++++++++
 rig/nodes/host_sampler.py            | 639 +++++++++++++++++++++++++++
 rig/nodes/rig.py                     |   6 +
 rig/tests/test_ros2_poc.py           |  68 +++
 tests/test-host-sampler.py           | 215 +++++++++
 9 files changed, 1307 insertions(+)
 create mode 100644 docs/development/rig-host-monitor.md
 create mode 100644 rig/docs/host-stats-request.md
 create mode 100644 rig/nodes/host_monitor.py
 create mode 100644 rig/nodes/host_sampler.py
 create mode 100644 tests/test-host-sampler.py

diff --git a/docs/development/rig-host-monitor.md b/docs/development/rig-host-monitor.md
new file mode 100644
index 00000000..10cda472
--- /dev/null
+++ b/docs/development/rig-host-monitor.md
@@ -0,0 +1,85 @@
+# Rig host monitor — the PC's "pressure" in every run
+
+Status: v1, 2026-10-28 (`rig/nodes/host_sampler.py` + `rig/nodes/host_monitor.py`, ww18). The message
+spec sent to rig-nodes: `rig/docs/host-stats-request.md`.
+
+## What and why
+
+A generic node that publishes how loaded the rig PC is, like Task Manager or Performance Monitor
+but recorded: CPU per core, memory, disk, network, GPU, and the processes responsible. It knows
+nothing about FicTrac or the arena. `pixi run rig` starts it by default (`--no-host-monitor` turns
+it off) because it costs little enough to leave on (§4). The arena gateway records `/rig/host` into
+every run's MCAP bag, so a run that went wrong carries the PC's state alongside it, and a question
+like "does Foxglove cost anything" is answered by comparing bags instead of a separate experiment.
+
+The method is atlas-bench `tools/cpu_sampler.py` (commit 306fa6d, used on ww18 for the BIAS
+CPU-spike work): cycle counters, 100 ms CPU sub-windows, one system call for all processes.
+
+## What one sample holds (1 Hz, `rig_interfaces/HostStats`)
+
+| area | fields | source (Windows · elsewhere) |
+|---|---|---|
+| CPU | per-core busy, window mean **and** busiest 100 ms sub-window; whole-PC busy cores (mean, peak); P/E-core class per CPU; how late the sampler woke (a PC-wide stall); context switches, interrupts, DPCs per s | idle-cycle counters (exact) + `GetSystemCpuSetInformation` + kernel DPC counts · psutil (tick-based) |
+| memory | total, used, available, page file used, hard page faults per s | psutil + Σ per-process hard faults · psutil (no hard faults) |
+| storage | per physical disk: read/write MB/s, IOPS, busy fraction; free space on the run-log volume | psutil |
+| network | per adapter that is up (hardware, not loopback): rx/tx MB/s, errors + drops | `GetIfEntry2` per adapter · psutil |
+| GPU | per NVIDIA GPU: core + memory-controller utilization, memory, NVENC/NVDEC load, temperature, power, P-state, throttle reasons | the driver's NVML through ctypes (no package) |
+| processes | top 3 by CPU, by memory, by disk I/O (`--top`), plus one summed row per pinned group (router, FicTrac, BIAS `test_gui.exe`, MATLAB, browser, Foxglove app, foxglove_bridge, each graph node as `py:<script>`) | one `NtQuerySystemInformation` call · psutil scan |
+| cost | `monitor_cpu_cores`: the node's own CPU over the window | its process cycle counter |
+
+Granularity: CPU every 100 ms, published as mean + peak per 1 s window, because Task Manager's 1 s
+all-core average hides a single thread pinned for a few hundred ms (cpu_sampler's BIAS finding: one
+core at 100 % for 6.4 s read as ~4 %). Everything else is a 1 s rate from counter deltas.
+`--period` and `--sub` change both.
+
+Not measured, deliberately: temperatures beyond the GPU's (Windows needs a vendor source), loopback
+traffic (Windows counts none, so Zenoh, the FicTrac UDP stream and the Studio WebSocket are not in
+`nets`), per-thread CPU (cpu_sampler's job when one process needs a closer look), anything
+arena-specific (the bridge and the Studio's telemetry own that).
+
+## Where it lives
+
+Generic, so it belongs in reiserlab/rig-nodes (`rig_nodes.host_monitor`, docs/development/
+rig-software-repos-and-runners.md §3). It is prototyped in `rig/nodes/` because ww18 cannot push
+there and is the PC the cost has to be measured on. It moves unchanged: `host_sampler.py` has no
+ROS and no import from this repo; `host_monitor.py` imports only rclpy, std_msgs and the sampler.
+
+The typed message needs `rig_interfaces` ≥ 0.3.0 (rig-nodes release in progress, win-64 build
+included). Until that is installed (`pixi install -e typed`), the node publishes `std_msgs/String`
+JSON with the same field names (NaN → null, floats to 3 decimals), the `--typed auto` pattern the
+FicTrac adapter uses. The gateway picks the same type for its recording subscription.
+
+## Cost and budget
+
+Budget: ≤ 5 % of the PC's CPU and of the bag's size (the lab's limit), with a tighter self-check in
+the acceptance harness: the node's own CPU ≤ 2 % of ONE core (median), `/rig/host` ≤ 5 % of the
+run's compressed payload.
+
+Measured on ww18 (Core Ultra 9 285K, 24 logical CPUs, ~300 processes), per 1 s window:
+
+| piece | cost |
+|---|---|
+| 10 × per-core idle cycles | 0.06 ms each |
+| process table (one call) + top-N selection | 1.9 ms (a psutil scan took 694 ms) |
+| network, 3 adapters via `GetIfEntry2` | 0.19 ms (psutil: 5.3 ms) |
+| memory, disks, log volume, GPU | < 0.3 ms together |
+| **node total** | **≈ 0.85–0.9 % of one core ≈ 0.04 % of the PC** (the first window after start is higher: one-time cycle-rate calibration and process-name lookups) |
+
+In the acceptance harness (the whole graph + simulators on ww18): median **0.9 % of one core**, max
+3.7 % (a window with new processes to name).
+
+Storage (String JSON, the form running today): 4.6 KB per sample raw, **≈ 1.0 MB/h zstd**, **4.9 %**
+of the harness run's compressed payload. That run is a worst case for this ratio: ~14 pinned Python
+processes (simulators, emulator, the harness itself) each get a row, and the bag is small (simulated
+FicTrac at 50 Hz). Process rows are about half the bytes and the per-core arrays most of the rest;
+the defaults (top 3 per list, floats to 3 decimals) came from that measurement — top 5 and 4
+decimals measured 6.4 %. The typed form is re-measured when rig-nodes 0.3.0 is installed.
+
+## Tests
+
+- `tests/test-host-sampler.py` (root suite, CI, no ROS or psutil needed): every field and type
+  against the `.msg` text in `rig/docs/host-stats-request.md`, counter-delta rates, CPU mean vs
+  peak, pinned groups and top-N selection, strict JSON.
+- `rig/tests/test_ros2_poc.py` (`cd rig && pixi run test`): the node runs in the graph; the bag
+  holds ≥ 0.8 samples per second with exactly the spec's fields, per-core sanity, the graph's nodes
+  pinned by script, and the cost and storage gates above.
diff --git a/rig/README.md b/rig/README.md
index 42909b42..5e10e96e 100644
--- a/rig/README.md
+++ b/rig/README.md
@@ -291,6 +291,7 @@ sends it at run end only on the commit path today) or on a run-end event.
 | live graph, interactive | `pixi install -e viz`, then `pixi run -e viz rqt-graph` | the standard ROS node/topic graph window (Qt); `pixi run -e viz rqt-topic` shows rates and payloads |
 | the recorded run | Foxglove (free desktop app) → *Open local file* → `runlogs/<run>.bag/<run>_0.mcap`; Layout → *Import from file* → `docs/foxglove-arena-layout.json` | every topic of the run on a timeline: plots of `/arena/frame` `idx`, `hd`, `turning_dps` + `forward_mms`, `bias_deg`, `epoch` (typed runs; String runs show the JSON text), the browser messages, events and BIAS replies as raw views, the schemas rosbag2 embedded — no ROS needed on that machine |
 | the live run in Foxglove | `pixi run rig -- --foxglove` (adds foxglove_bridge from the `viz` environment to the supervised rig; a note and no bridge when `pixi install -e viz` has not been run) → Foxglove *Open connection* `ws://localhost:8766`; or by hand beside a running rig: `pixi run -e viz foxglove-bridge` | the same panels on the running graph, including the derived `turning_dps` / `forward_mms` plot |
+| how loaded the PC is | nothing to start: `pixi run rig` runs `nodes/host_monitor.py` (off: `--no-host-monitor`); alone: `pixi run python nodes/host_sampler.py 5` prints five samples without ROS | `/rig/host` once a second, recorded in every run's bag: CPU per core (mean + busiest 100 ms), P/E cores, sampler lateness, memory, page faults, disks, network, NVIDIA GPU (incl. NVENC), top processes + the graph's nodes; ≈ 0.9 % of one core on ww18. Design: `docs/development/rig-host-monitor.md` |
 | the plain CLI | `pixi run ros2 node list`, `ros2 topic list -t`, `ros2 topic hz /arena/frame`, `ros2 topic echo /bias/status`, `ros2 bag info runlogs/<run>.bag` | what every ROS user reaches for first; every topic here is readable JSON or a flat typed message |
 
 **Color optomotor smoke run (22:00 ET, same bench, after merging Next into the branch).** The
diff --git a/rig/docs/host-stats-request.md b/rig/docs/host-stats-request.md
new file mode 100644
index 00000000..e5549d1f
--- /dev/null
+++ b/rig/docs/host-stats-request.md
@@ -0,0 +1,105 @@
+# Request for rig-nodes: typed host-pressure messages (from the webDisplayTools host-monitor session, 2026-10-28)
+
+## What and why
+A generic host monitor node (`rig_nodes.host_monitor`, prototyped in webDisplayTools `rig/nodes/host_monitor.py`
+on ww18) publishes PC "pressure" at 1 Hz on `/rig/host`: per-core CPU (mean + peak of 10 Hz sub-windows, the
+method of atlas-bench `tools/cpu_sampler.py`), memory, disk, network, NVIDIA GPU, top processes. The arena gateway
+records it into each run's MCAP bag. The user chose a TYPED message (plottable live in Foxglove). Please add the
+messages below to `rig_interfaces` and release them; until the release lands the node publishes `std_msgs/String`
+JSON with the SAME field names (the `--typed auto` pattern of the FicTrac adapter / ArenaFrame).
+
+## Please change
+1. `src/rig_interfaces/msg/`: add `HostStats.msg`, `DiskStats.msg`, `NetStats.msg`,
+   `GpuStats.msg`, `ProcStats.msg` exactly as below; list them in `CMakeLists.txt` `rosidl_generate_interfaces`.
+2. `CONTRACT.md`: a topic-table row
+   `| /rig/host | rig_interfaces/HostStats, or std_msgs/String JSON with the same field names | RELIABLE, KEEP_LAST 10, VOLATILE | rig_nodes.host_monitor (default 1 Hz) | one host sample per window; recorded by the arena gateway |`
+   and the absent-value rule applies (NaN float / 0 int when the OS gives no value).
+3. Bump the package set (new messages = wire-contract change, CONTRACT §7) → 0.3.0, release, and rebuild the
+   channel INCLUDING a win-64 `rig_interfaces` build (ww18's env currently has no importable `rig_interfaces`).
+4. Reply with: the release tag, whether win-64 `rig_interfaces` is in the channel, and any field you renamed.
+   (Optional, later: the node itself moves to `src/rig_nodes/rig_nodes/host_monitor.py` once measured on ww18.)
+
+## Message definitions (normative proposal)
+
+### HostStats.msg
+```
+# One host-pressure sample (rig_nodes.host_monitor, /rig/host, default 1 Hz). CPU is measured from
+# cycle counters every 1/sub_samples of the window (Windows: QueryIdleProcessorCycleTime, exact; Task
+# Manager's tick-based numbers step at 15.6 ms) and reported as the window mean AND the busiest
+# sub-window, so a short burst on one core is not averaged away. Absent value: NaN (float) / 0 (int).
+int64 t_ms                      # wall clock at the END of the window (ms since the Unix epoch)
+float32 window_s                # window length, s (1.0 at 1 Hz)
+uint32 sub_samples              # CPU sub-windows in this window (10 at the default 10 Hz)
+string hostname
+# CPU
+float32 cpu_busy_cores_mean     # whole-PC busy cores (0..n_cpu), mean over the window
+float32 cpu_busy_cores_peak     # busiest sub-window
+float32[] core_busy_mean        # per logical CPU, 0..1
+float32[] core_busy_peak        # per logical CPU, busiest sub-window, 0..1
+uint8[] core_class              # efficiency class per logical CPU (higher = faster: P- vs E-cores); empty if unknown
+float32 sampler_late_ms_max     # how late the monitor woke for a sub-window (a PC-wide stall or starvation)
+float32 context_switches_per_s
+float32 interrupts_per_s
+float32 dpcs_per_s              # deferred procedure calls (Windows; soft interrupts elsewhere)
+# memory
+float32 mem_total_mb
+float32 mem_used_mb
+float32 mem_available_mb
+float32 pagefile_used_mb
+float32 hard_page_faults_per_s  # page reads from disk (paging pressure)
+# storage of the run log
+string log_volume               # the volume holding the run logs / bags
+float32 log_volume_free_gb
+# devices and processes
+DiskStats[] disks               # one per physical disk
+NetStats[] nets                 # one per network adapter that is up (Windows does not count loopback)
+GpuStats[] gpus                 # one per NVIDIA GPU (NVML); empty without one
+ProcStats[] procs               # top N by CPU, by memory and by disk I/O, plus pinned names; deduplicated
+float32 monitor_cpu_cores       # this node's own CPU over the window (its cost, always reported)
+```
+
+### DiskStats.msg
+```
+string name                     # PhysicalDrive0 / nvme0n1 / disk0
+float32 read_mb_per_s
+float32 write_mb_per_s
+float32 reads_per_s
+float32 writes_per_s
+float32 busy_frac               # 0..1, (read + write time) / window; NaN where the OS gives none
+```
+
+### NetStats.msg
+```
+string name                     # adapter name as the OS reports it
+float32 rx_mb_per_s
+float32 tx_mb_per_s
+uint32 errors                   # receive + transmit errors and drops in the window
+```
+
+### GpuStats.msg
+```
+uint32 index
+string name
+float32 util_frac               # 0..1, GPU core
+float32 mem_util_frac           # 0..1, memory controller
+float32 mem_used_mb
+float32 mem_total_mb
+float32 encoder_util_frac       # NVENC, 0..1 (BIAS MP4 recording)
+float32 decoder_util_frac       # NVDEC, 0..1
+float32 temperature_c
+float32 power_w
+uint8 pstate                    # 0 = maximum performance … 15; 255 = unknown
+uint64 throttle_reasons         # NVML clocks-event (throttle) reason bitmask; 0 = none
+```
+
+### ProcStats.msg
+```
+uint32 pid
+string name                     # executable image name
+string group                    # pinned group label ("fictrac", "bias", "py:bridge_node", …) or "" for top-N only
+float32 cpu_cores               # mean over the window (1.0 = one core busy)
+float32 rss_mb                  # working set
+float32 io_read_mb_per_s
+float32 io_write_mb_per_s
+uint8 reasons                   # bitmask: 1 top CPU, 2 top memory, 4 top disk I/O, 8 pinned
+```
diff --git a/rig/nodes/bridge_node.py b/rig/nodes/bridge_node.py
index 90143653..d2cb2586 100644
--- a/rig/nodes/bridge_node.py
+++ b/rig/nodes/bridge_node.py
@@ -31,6 +31,8 @@
     node killed mid-run therefore leaves the log intact AND documented.
   * `connector_status` lines (frames seen, adapter→bridge latency p50/p99 ms per source)
     at log close / export, so a run carries its own transport health.
+  * `/rig/host` (host_monitor.py: CPU per core, memory, disk, network, GPU, top processes) is
+    recorded into the bag on arrival, so every run carries the PC's pressure alongside it.
 
 Not supported here (by design of the PoC): the `fictrac_port` config key cannot re-bind
 the socket — the adapter owns it. The request is acknowledged with a warning.
@@ -142,6 +144,13 @@ def load_bridge_module(path: Path = BRIDGE_PY):
     "scanimage": {"cmd": SCANIMAGE_CMD_TOPIC, "reply": SCANIMAGE_REPLY_TOPIC, "status": SCANIMAGE_STATUS_TOPIC},
 }
 FRAME_TOPIC = "/arena/frame"
+# Host pressure from host_monitor.py (generic, rig-nodes material): recorded on arrival, no run-log line.
+HOST_TOPIC = "/rig/host"
+HOST_STATS_TYPE = "rig_interfaces/msg/HostStats"
+try:  # rig-nodes ≥ 0.3.0; the monitor publishes the same type when it imports (its --typed auto)
+    from rig_interfaces.msg import HostStats
+except (ImportError, AttributeError):
+    HostStats = None
 RAW_QOS = QoSProfile(
     reliability=QoSReliabilityPolicy.RELIABLE,
     history=QoSHistoryPolicy.KEEP_LAST,
@@ -298,6 +307,7 @@ def topics(self) -> dict[str, str]:
             SCANIMAGE_CMD_TOPIC: STRING_TYPE, SCANIMAGE_REPLY_TOPIC: STRING_TYPE, SCANIMAGE_STATUS_TOPIC: STRING_TYPE,
         }
         t[FRAME_TOPIC] = ARENA_FRAME_TYPE if self._typed else STRING_TYPE
+        t[HOST_TOPIC] = HOST_STATS_TYPE if HostStats is not None else STRING_TYPE
         if self.record_fictrac_raw:
             if self._typed:
                 t[FICTRAC_FRAME_TOPIC] = FICTRAC_FRAME_TYPE
@@ -639,6 +649,9 @@ def __init__(self, loop: asyncio.AbstractEventLoop, queue: asyncio.Queue, on_kin
         # Recorded on arrival, like /fictrac/raw: it never becomes a run-log line (the stopRecording reply
         # carries its summary), so there is no shadow line to stay in step with.
         self.create_subscription(String, BIAS_FRAMES_TOPIC, lambda b: self._record(BIAS_FRAMES_TOPIC, b), RAW_QOS, raw=True)
+        # host_monitor.py's samples (1 Hz): same QoS depth class as the monitor's (RELIABLE, KEEP_LAST 10).
+        self.create_subscription(HostStats if HostStats is not None else String, HOST_TOPIC,
+                                 lambda b: self._record(HOST_TOPIC, b), RAW_QOS, raw=True)
 
     def _record(self, topic: str, data: bytes) -> None:
         rec = self._log.rec
diff --git a/rig/nodes/host_monitor.py b/rig/nodes/host_monitor.py
new file mode 100644
index 00000000..49b00ca1
--- /dev/null
+++ b/rig/nodes/host_monitor.py
@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""host_monitor.py — host "pressure" of the rig PC on /rig/host, one sample per window (default 1 s).
+
+    pixi run rig                                  # starts it (opt out: --no-host-monitor)
+    pixi run python nodes/host_monitor.py         # alone, beside a running graph (from rig/)
+    pixi run python nodes/host_sampler.py 5       # five samples on the console, no ROS
+
+What a sample holds (rig_interfaces/HostStats; the request with every field:
+rig/docs/host-stats-request.md): per-core CPU as the window mean AND the busiest of 10 sub-windows
+(cycle-exact on Windows, the atlas-bench cpu_sampler.py method), P-/E-core class, how late the
+sampler woke (a PC-wide stall), context switches / interrupts / DPCs per s, memory and page file,
+hard page faults, free space on the log volume, every physical disk, every network adapter that is
+up, every NVIDIA GPU (incl. NVENC/NVDEC), and the processes that matter: the top 3 by CPU, by
+memory and by disk I/O, plus one summed row per pinned group (FicTrac, BIAS, MATLAB, the browser,
+Foxglove, the router, each graph node as py:<script>). `monitor_cpu_cores` is this node's own cost.
+
+Message type: rig_interfaces/HostStats when the installed rig_interfaces has it (rig-nodes ≥ 0.3.0,
+the `typed` environment), else std_msgs/String JSON with the same field names (NaN → null, floats
+to 3 decimals) — `--typed auto|on|off`, the same pattern as the FicTrac adapter. The arena gateway
+records /rig/host into each run's MCAP bag. Generic on purpose: this node and host_sampler.py are
+rig-nodes material (`rig_nodes.host_monitor`), prototyped here on ww18. Design, budget, measured
+cost: docs/development/rig-host-monitor.md.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+import signal
+import sys
+import threading
+from pathlib import Path
+
+import rclpy
+from rclpy.node import Node
+from rclpy.qos import QoSDurabilityPolicy, QoSHistoryPolicy, QoSProfile, QoSReliabilityPolicy
+from std_msgs.msg import String
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+from host_sampler import DEFAULT_PINS, HostSampler, summary_line, to_json_safe  # noqa: E402
+
+TOPIC = "/rig/host"
+QOS = QoSProfile(reliability=QoSReliabilityPolicy.RELIABLE, history=QoSHistoryPolicy.KEEP_LAST, depth=10,
+                 durability=QoSDurabilityPolicy.VOLATILE)
+HOST_STATS_TYPE = "rig_interfaces/msg/HostStats"
+NESTED = {"disks": "DiskStats", "nets": "NetStats", "gpus": "GpuStats", "procs": "ProcStats"}
+
+
+def load_typed():
+    """The rig_interfaces host messages, or None when this build has no HostStats (rig-nodes < 0.3.0)."""
+    try:
+        from rig_interfaces import msg as m
+
+        return {"HostStats": m.HostStats, **{v: getattr(m, v) for v in NESTED.values()}}
+    except (ImportError, AttributeError):
+        return None
+
+
+def to_msg(sample: dict, types: dict):
+    """HostStats fields (host_sampler dict) → the typed message; one builder for every field."""
+    m = types["HostStats"]()
+    for k, v in sample.items():
+        if k in NESTED:
+            cls = types[NESTED[k]]
+            items = []
+            for d in v:
+                it = cls()
+                for kk, vv in d.items():
+                    setattr(it, kk, vv)
+                items.append(it)
+            setattr(m, k, items)
+        elif k == "core_class":
+            m.core_class = bytes(int(c) & 0xFF for c in v)
+        else:
+            setattr(m, k, v)
+    return m
+
+
+def to_json(sample: dict) -> str:
+    def r(o):
+        if isinstance(o, float):
+            return round(o, 3) if math.isfinite(o) else None
+        if isinstance(o, dict):
+            return {k: r(v) for k, v in o.items()}
+        if isinstance(o, list):
+            return [r(v) for v in o]
+        return o
+
+    return json.dumps(r(to_json_safe(sample)), separators=(",", ":"))
+
+
+def parse_pins(items: list[str]) -> list[tuple[str, str]]:
+    out = []
+    for it in items:
+        name, sep, rx = it.partition("=")
+        if not sep or not name or not rx:
+            raise SystemExit(f"--pin expects NAME=REGEX, got {it!r}")
+        re.compile(rx)
+        out.append((name, rx))
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--period", type=float, default=1.0, help="window length in s = publish period (default: 1)")
+    p.add_argument("--sub", type=int, default=10, help="CPU sub-windows per window for the peak (default: 10 → 100 ms at 1 s)")
+    p.add_argument("--top", type=int, default=3, help="processes per top list (CPU, memory, disk I/O; default: 3)")
+    p.add_argument("--pin", action="append", default=[], help="extra pinned group NAME=REGEX on the executable name (repeatable; checked first)")
+    p.add_argument("--log-dir", default=str(HERE.parent / "runlogs"), help="where run logs / bags are written: its volume's free space is reported (default: rig/runlogs)")
+    p.add_argument("--no-gpu", action="store_true", help="skip NVIDIA GPU sampling (NVML)")
+    p.add_argument("--typed", choices=("auto", "on", "off"), default="auto",
+                   help="publish rig_interfaces/HostStats (auto: when the installed rig_interfaces has it; default) or String JSON")
+    p.add_argument("--print-every", type=float, default=0.0, help="print a summary line every N s (0 = only the first sample; default)")
+    args, ros_args = p.parse_known_args(argv)
+    if args.period <= 0 or args.sub < 1:
+        p.error("--period must be > 0 and --sub ≥ 1")
+    types = load_typed() if args.typed != "off" else None
+    if args.typed == "on" and types is None:
+        raise SystemExit("--typed on, but the installed rig_interfaces has no HostStats (rig-nodes ≥ 0.3.0, `pixi install -e typed`)")
+    try:
+        log_dir = Path(args.log_dir)
+        log_dir.mkdir(parents=True, exist_ok=True)
+        sampler = HostSampler(args.period, args.sub, log_dir, args.top, parse_pins(args.pin) + DEFAULT_PINS, gpu=not args.no_gpu)
+    except RuntimeError as exc:  # no psutil
+        print(f"[host] {exc} — no host samples (the rig keeps running)", file=sys.stderr)
+        return 0
+
+    stop = threading.Event()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        signal.signal(sig, lambda *_: stop.set())
+    if hasattr(signal, "SIGBREAK"):  # rig.py / the harness stop children with CTRL_BREAK_EVENT on Windows
+        signal.signal(signal.SIGBREAK, lambda *_: stop.set())
+
+    rclpy.init(args=ros_args)
+    node = Node("rig_host_monitor")
+    pub = node.create_publisher(types["HostStats"] if types else String, TOPIC, QOS)
+    gpus = sampler.gpu.names if sampler.gpu is not None and sampler.gpu.available else []
+    print(f"[host] {TOPIC} every {args.period:g} s ({args.sub} CPU sub-windows), "
+          f"{'rig_interfaces/HostStats' if types else 'std_msgs/String JSON'}; {sampler.ncpu} logical CPUs"
+          f"{' (efficiency classes ' + ''.join(str(c) for c in sampler.core_class) + ')' if sampler.core_class else ''}, "
+          f"GPU {', '.join(gpus) or 'none'}, log volume {sampler.log_volume}", file=sys.stderr)
+    n, next_print = 0, 0.0
+    try:
+        while not stop.is_set():
+            s = sampler.window(stop=stop.is_set)
+            if stop.is_set():
+                break
+            if types:
+                pub.publish(to_msg(s, types))
+            else:
+                m = String()
+                m.data = to_json(s)
+                pub.publish(m)
+            n += 1
+            elapsed = n * args.period
+            if n == 1 or (args.print_every > 0 and elapsed >= next_print):
+                print(f"[host] {summary_line(s)}", file=sys.stderr, flush=True)
+                next_print = elapsed + args.print_every
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        try:
+            rclpy.try_shutdown()
+        except Exception:
+            pass
+    print(f"[host] {n} samples published", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/rig/nodes/host_sampler.py b/rig/nodes/host_sampler.py
new file mode 100644
index 00000000..f10ce181
--- /dev/null
+++ b/rig/nodes/host_sampler.py
@@ -0,0 +1,639 @@
+"""host_sampler.py — host "pressure" samples for the rig graph (NO ROS imports; host_monitor.py publishes them).
+
+One `HostSampler.window()` call = one window (default 1 s) and returns a dict whose keys are the
+fields of rig_interfaces/HostStats (rig/docs/host-stats-request.md), with nested lists of dicts for
+`disks` / `nets` / `gpus` / `procs`. Absent values are NaN (float) / 0 (int), as the contract says.
+
+CPU follows atlas-bench `tools/cpu_sampler.py` (the method the lab has used on ww18): on Windows,
+per-core busy = 1 − Δidle cycles / (cycle rate × Δt) from QueryIdleProcessorCycleTime every
+1/sub_samples of the window — exact, where Task Manager's tick-based numbers step at 15.6 ms — and
+each window reports the mean AND the busiest sub-window, so a 100 ms burst on one core is not
+averaged away. How late the sampler woke for a sub-window (`sampler_late_ms_max`) shows a PC-wide
+stall. Every process comes from ONE NtQuerySystemInformation(SystemProcessInformation) call per
+window (cycles, working set, I/O bytes, hard faults); a psutil scan of ~300 processes took 0.7 s on
+ww18, this takes a few ms. Python processes get their script name (`py:<stem>`) from their command
+line, read once per new pid. Elsewhere (Linux/macOS) psutil supplies the same fields, tick-based.
+
+Memory, disks, network adapters and the log volume come from psutil on every platform; NVIDIA GPUs
+from the driver's own NVML library through ctypes (no Python package). Design, budget, measured
+cost: docs/development/rig-host-monitor.md.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import math
+import os
+import re
+import socket
+import struct
+import sys
+import time
+from pathlib import Path
+
+try:
+    import psutil
+except ImportError:  # pragma: no cover - psutil ships in the rig env
+    psutil = None
+
+NAN = float("nan")
+MB = 1024.0 * 1024.0
+WIN = os.name == "nt"
+
+# Pinned process groups: (label, regex on the executable image name, case-insensitive). A group's
+# processes are summed into ONE procs row (pid = its busiest process). Python processes are grouped by
+# script instead (py_group). First match wins; --pin adds groups in front.
+DEFAULT_PINS = [
+    ("router", r"^rmw_zenohd"),
+    ("foxglove_bridge", r"^foxglove_bridge"),
+    ("fictrac", r"^fictrac"),
+    ("bias", r"^(test_gui|bias)"),  # BIAS's GUI binary is test_gui.exe (atlas-bench)
+    ("matlab", r"^matlab"),
+    ("foxglove_app", r"^foxglove(\.exe)?$"),
+    ("browser", r"^(chrome|msedge|google chrome)(\.exe)?$"),
+]
+PY_EXE = re.compile(r"^python[0-9.]*w?(\.exe)?$", re.I)
+REASON_CPU, REASON_MEM, REASON_IO, REASON_PINNED = 1, 2, 4, 8
+HERE = Path(__file__).resolve().parent
+REPO = HERE.parents[1]
+
+
+def _f(v) -> float:
+    return float(v) if isinstance(v, (int, float)) and math.isfinite(v) else NAN
+
+
+def py_group(cmdline: list[str], roots: tuple[Path, ...] = (REPO,)) -> str | None:
+    """`py:<stem>` for a Python process running a script under `roots` (absolute, or relative to
+    the rig workspace) or a `rig_nodes.<module>`; None for any other Python process."""
+    args = list(cmdline[1:])
+    for i, a in enumerate(args):
+        if a == "-m" and i + 1 < len(args):
+            mod = args[i + 1]
+            return f"py:{mod.split('.')[-1]}" if mod.startswith("rig_nodes") else None
+        if a.lower().endswith(".py"):
+            p = Path(a.strip('"'))
+            for root in roots:
+                for c in ([p] if p.is_absolute() else [root / "rig" / p, root / p]):
+                    try:
+                        c.resolve().relative_to(root.resolve())
+                    except (OSError, ValueError):
+                        continue
+                    if p.is_absolute() or c.exists():  # a relative path is relative to ITS cwd: must exist here
+                        return f"py:{p.stem}"
+            return None
+        if not a.startswith("-"):
+            return None
+    return None
+
+
+# ── Windows: cycle counters + one-call process table (ported from atlas-bench cpu_sampler.py) ─────
+if WIN:
+    from ctypes import wintypes as W
+
+    _k32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    _ntdll = ctypes.WinDLL("ntdll")
+    _k32.QueryIdleProcessorCycleTime.argtypes = [ctypes.POINTER(W.ULONG), ctypes.c_void_p]
+    _k32.QueryThreadCycleTime.argtypes = [W.HANDLE, ctypes.POINTER(ctypes.c_uint64)]
+    _k32.QueryProcessCycleTime.argtypes = [W.HANDLE, ctypes.POINTER(ctypes.c_uint64)]
+    _k32.GetCurrentThread.restype = W.HANDLE
+    _k32.GetCurrentProcess.restype = W.HANDLE
+    _k32.GetSystemCpuSetInformation.argtypes = [ctypes.c_void_p, W.ULONG, ctypes.POINTER(W.ULONG), W.HANDLE, W.ULONG]
+    _ntdll.NtQuerySystemInformation.argtypes = [W.ULONG, ctypes.c_void_p, W.ULONG, ctypes.POINTER(W.ULONG)]
+
+    def win_ncpu() -> int:
+        n = W.ULONG(0)
+        _k32.QueryIdleProcessorCycleTime(ctypes.byref(n), None)
+        return n.value // 8
+
+    def win_idle_cycles(n: int) -> list[int]:
+        buf = (ctypes.c_uint64 * n)()
+        size = W.ULONG(8 * n)
+        _k32.QueryIdleProcessorCycleTime(ctypes.byref(size), buf)
+        return list(buf)
+
+    def _thread_cycles() -> int:
+        c = ctypes.c_uint64()
+        _k32.QueryThreadCycleTime(_k32.GetCurrentThread(), ctypes.byref(c))
+        return c.value
+
+    def win_self_cycles() -> int:
+        c = ctypes.c_uint64()
+        _k32.QueryProcessCycleTime(_k32.GetCurrentProcess(), ctypes.byref(c))
+        return c.value
+
+    def win_calibrate_hz(rounds: int = 3, spin_s: float = 0.1) -> float:
+        """Cycle-counter rate: spin this thread and compare its cycles with wall time (best of N)."""
+        best = 0.0
+        for _ in range(rounds):
+            c0, t0 = _thread_cycles(), time.perf_counter()
+            while time.perf_counter() - t0 < spin_s:
+                pass
+            c1, t1 = _thread_cycles(), time.perf_counter()
+            best = max(best, (c1 - c0) / (t1 - t0))
+        return best
+
+    def win_core_classes(n: int) -> list[int]:
+        """EfficiencyClass per logical processor (higher = faster core); [] when unknown."""
+        need = W.ULONG(0)
+        _k32.GetSystemCpuSetInformation(None, 0, ctypes.byref(need), None, 0)
+        if need.value == 0:
+            return []
+        buf = ctypes.create_string_buffer(need.value)
+        if not _k32.GetSystemCpuSetInformation(buf, need, ctypes.byref(need), None, 0):
+            return []
+        raw, off, out = buf.raw, 0, {}
+        while off < need.value:
+            size = int.from_bytes(raw[off:off + 4], "little")
+            if size == 0:
+                break
+            out[raw[off + 14]] = raw[off + 18]  # LogicalProcessorIndex, EfficiencyClass
+            off += size
+        return [out.get(i, 0) for i in range(n)]
+
+    _spi = [ctypes.create_string_buffer(1 << 20)]
+    # x64 SYSTEM_PROCESS_INFORMATION: NextEntryOffset @0, HardFaultCount @16, CycleTime @24,
+    # ImageName.Length @56 / .Buffer @64, UniqueProcessId @80, WorkingSetSize @144,
+    # ReadTransferCount @232, WriteTransferCount @240 (cpu_sampler.py reads the same cycles/name/pid).
+    _SPI = struct.Struct("<I12xI4xQ24xH6xQ8xQ56xQ80xQQ")
+    _NAMES: dict[tuple, str] = {}  # (pid, UTF-16 bytes) → decoded image name
+
+    def _ntquery(cls: int, holder: list) -> ctypes.Array | None:
+        need = W.ULONG(0)
+        while True:
+            buf = holder[0]
+            st = _ntdll.NtQuerySystemInformation(cls, buf, len(buf), ctypes.byref(need)) & 0xFFFFFFFF
+            if st == 0xC0000004:  # STATUS_INFO_LENGTH_MISMATCH
+                holder[0] = ctypes.create_string_buffer(max(need.value, len(buf)) * 2)
+                continue
+            return buf if st == 0 else None
+
+    def win_processes() -> dict[int, tuple]:
+        """{pid: (image name, cycles, working set B, read B, write B, hard faults)} for every
+        process, from one NtQuerySystemInformation(SystemProcessInformation) call."""
+        buf = _ntquery(5, _spi)
+        if buf is None:
+            return {}
+        mv = memoryview(buf).cast("B")  # no copy of the (~1 MB) buffer
+        base = ctypes.addressof(buf)
+        unpack = _SPI.unpack_from
+        out, off, n = {}, 0, len(mv)
+        while True:
+            nxt, hard, cyc, nlen, nptr, pid, ws, rd, wr = unpack(mv, off)
+            if nptr and nlen:
+                # the strings live inside this buffer: decode from it, not through a pointer read
+                rel = nptr - base
+                key = (pid, bytes(mv[rel:rel + nlen])) if 0 <= rel < n else None
+                name = _NAMES.get(key) if key else None
+                if name is None:
+                    name = key[1].decode("utf-16-le", "replace") if key else ctypes.wstring_at(nptr, nlen // 2)
+                    if key:
+                        if len(_NAMES) > 4096:
+                            _NAMES.clear()
+                        _NAMES[key] = name
+            else:
+                name = "Idle"
+            out[pid] = (name, cyc, ws, rd, wr, hard)
+            if nxt == 0 or off + nxt >= n:
+                return out
+            off += nxt
+
+    _sii = [ctypes.create_string_buffer(64 * 24)]
+
+    def win_dpc_count() -> int | None:
+        """Σ DpcCount over CPUs (SystemInterruptInformation: 24 B per CPU, DpcCount @4)."""
+        buf = _ntquery(23, _sii)
+        if buf is None:
+            return None
+        raw = buf.raw
+        return sum(struct.unpack_from("<I", raw, o + 4)[0] for o in range(0, len(raw) - 23, 24))
+
+    # Network adapters: GetIfEntry2 per adapter (µs) instead of psutil's GetAdaptersAddresses
+    # walk on every read (5.3 ms on ww18). The adapter list (hardware, up, not loopback) comes from
+    # GetIfTable2, refreshed every 10 s. MIB_IF_ROW2 (1352 B): InterfaceIndex @8, Alias @28,
+    # Type @1128, InterfaceAndOperStatusFlags @1152 (bit 0 HardwareInterface), OperStatus @1156,
+    # InOctets @1208, InDiscards @1232, InErrors @1240, OutOctets @1280, OutDiscards @1304, OutErrors @1312.
+    _iphlp = ctypes.WinDLL("iphlpapi")
+    _iphlp.GetIfTable2.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
+    _iphlp.FreeMibTable.argtypes = [ctypes.c_void_p]
+    _iphlp.GetIfEntry2.argtypes = [ctypes.c_void_p]
+    ROW2 = 1352
+    _IF_CTR = struct.Struct("<Q16xQQ32xQ16xQQ")  # from @1208: InOctets, InDiscards, InErrors, OutOctets, OutDiscards, OutErrors
+
+    def win_adapters() -> list[tuple[int, str]]:
+        tbl = ctypes.c_void_p()
+        if _iphlp.GetIfTable2(ctypes.byref(tbl)) != 0 or not tbl.value:
+            return []
+        try:
+            n = ctypes.c_ulong.from_address(tbl.value).value
+            raw = ctypes.string_at(tbl.value + 8, n * ROW2)
+        finally:
+            _iphlp.FreeMibTable(tbl)
+        out = []
+        for k in range(n):
+            o = k * ROW2
+            idx, = struct.unpack_from("<I", raw, o + 8)
+            typ, = struct.unpack_from("<I", raw, o + 1128)
+            hw = raw[o + 1152] & 1
+            oper, = struct.unpack_from("<I", raw, o + 1156)
+            if hw and oper == 1 and typ != 24:  # IfOperStatusUp, not IF_TYPE_SOFTWARE_LOOPBACK
+                alias = raw[o + 28:o + 28 + 514].decode("utf-16-le", "replace").split("\x00", 1)[0]
+                out.append((idx, alias))
+        return out
+
+    _row = ctypes.create_string_buffer(ROW2)
+
+    def win_adapter_counters(idx: int) -> tuple | None:
+        ctypes.memset(_row, 0, ROW2)
+        struct.pack_into("<I", _row, 8, idx)
+        if _iphlp.GetIfEntry2(_row) != 0:
+            return None
+        return _IF_CTR.unpack_from(_row.raw, 1208)
+
+
+# ── NVIDIA GPUs through the driver's NVML (ctypes; no Python package) ──────────────────────────────
+class _Util(ctypes.Structure):
+    _fields_ = [("gpu", ctypes.c_uint), ("memory", ctypes.c_uint)]
+
+
+class _Mem(ctypes.Structure):
+    _fields_ = [("total", ctypes.c_ulonglong), ("free", ctypes.c_ulonglong), ("used", ctypes.c_ulonglong)]
+
+
+class Nvml:
+    """The few NVML calls HostStats needs. `available` is False without an NVIDIA driver."""
+
+    def __init__(self) -> None:
+        self.lib = None
+        self.handles: list = []
+        self.names: list[str] = []
+        try:
+            if WIN:
+                path = os.path.join(os.environ.get("SystemRoot", r"C:\Windows"), "System32", "nvml.dll")
+                self.lib = ctypes.CDLL(path)
+            else:
+                self.lib = ctypes.CDLL("libnvidia-ml.so.1")
+        except OSError:
+            self.lib = None
+            return
+        try:
+            if self.lib.nvmlInit_v2() != 0:
+                self.lib = None
+                return
+            n = ctypes.c_uint(0)
+            self.lib.nvmlDeviceGetCount_v2(ctypes.byref(n))
+            for i in range(n.value):
+                h = ctypes.c_void_p()
+                if self.lib.nvmlDeviceGetHandleByIndex_v2(i, ctypes.byref(h)) == 0:
+                    name = ctypes.create_string_buffer(96)
+                    self.lib.nvmlDeviceGetName(h, name, 96)
+                    self.handles.append(h)
+                    self.names.append(name.value.decode(errors="replace"))
+        except AttributeError:
+            self.lib = None
+            self.handles = []
+
+    @property
+    def available(self) -> bool:
+        return self.lib is not None and bool(self.handles)
+
+    def sample(self) -> list[dict]:
+        out = []
+        for i, h in enumerate(self.handles):
+            g = {"index": i, "name": self.names[i], "util_frac": NAN, "mem_util_frac": NAN, "mem_used_mb": NAN,
+                 "mem_total_mb": NAN, "encoder_util_frac": NAN, "decoder_util_frac": NAN, "temperature_c": NAN,
+                 "power_w": NAN, "pstate": 255, "throttle_reasons": 0}
+            u, m = _Util(), _Mem()
+            if self.lib.nvmlDeviceGetUtilizationRates(h, ctypes.byref(u)) == 0:
+                g["util_frac"], g["mem_util_frac"] = u.gpu / 100.0, u.memory / 100.0
+            if self.lib.nvmlDeviceGetMemoryInfo(h, ctypes.byref(m)) == 0:
+                g["mem_used_mb"], g["mem_total_mb"] = m.used / MB, m.total / MB
+            v, period = ctypes.c_uint(0), ctypes.c_uint(0)
+            if self.lib.nvmlDeviceGetEncoderUtilization(h, ctypes.byref(v), ctypes.byref(period)) == 0:
+                g["encoder_util_frac"] = v.value / 100.0
+            if self.lib.nvmlDeviceGetDecoderUtilization(h, ctypes.byref(v), ctypes.byref(period)) == 0:
+                g["decoder_util_frac"] = v.value / 100.0
+            if self.lib.nvmlDeviceGetTemperature(h, 0, ctypes.byref(v)) == 0:  # NVML_TEMPERATURE_GPU
+                g["temperature_c"] = float(v.value)
+            if self.lib.nvmlDeviceGetPowerUsage(h, ctypes.byref(v)) == 0:
+                g["power_w"] = v.value / 1000.0
+            ps = ctypes.c_int(0)
+            if self.lib.nvmlDeviceGetPerformanceState(h, ctypes.byref(ps)) == 0 and 0 <= ps.value <= 15:
+                g["pstate"] = ps.value
+            r = ctypes.c_ulonglong(0)
+            if self.lib.nvmlDeviceGetCurrentClocksThrottleReasons(h, ctypes.byref(r)) == 0:
+                g["throttle_reasons"] = int(r.value)
+            out.append(g)
+        return out
+
+
+class HostSampler:
+    def __init__(self, window_s: float = 1.0, sub_samples: int = 10, log_volume: str | os.PathLike = ".",
+                 top_n: int = 3, pins: list[tuple[str, str]] | None = None, gpu: bool = True) -> None:
+        if psutil is None:
+            raise RuntimeError("psutil is not installed")
+        self.window_s = float(window_s)
+        self.sub_samples = max(1, int(sub_samples))
+        self.log_volume = str(Path(log_volume).resolve().anchor or log_volume) if WIN else str(log_volume)
+        self._log_path = str(log_volume)
+        self.top_n = int(top_n)
+        self.pins = [(n, re.compile(rx, re.I)) for n, rx in (pins if pins is not None else DEFAULT_PINS)]
+        self.hostname = socket.gethostname()
+        self.gpu = Nvml() if gpu else None
+        self._groups: dict[int, tuple] = {}  # pid → (image name, group label or None), cached per pid
+        if WIN:
+            self.ncpu = win_ncpu()
+            self.hz = win_calibrate_hz()
+            self.core_class = win_core_classes(self.ncpu)
+            self._idle = win_idle_cycles(self.ncpu)
+            self._procs = win_processes()
+            self._self_cyc = win_self_cycles()
+        else:
+            self.ncpu = psutil.cpu_count() or 1
+            self.hz = None
+            self.core_class = []
+            psutil.cpu_percent(None, percpu=True)
+            self._procs = {}
+            self._psproc: dict[int, "psutil.Process"] = {}
+            self._self = psutil.Process()
+            self._self_cpu = sum(self._self.cpu_times()[:2])
+        self._t_procs = time.perf_counter()
+        self._cpu_stats = psutil.cpu_stats()
+        self._dpc = win_dpc_count() if WIN else None
+        self._disk = psutil.disk_io_counters(perdisk=True) or {}
+        self._net = {} if WIN else (psutil.net_io_counters(pernic=True) or {})
+        self._net_up: set[str] = set()
+        self._net_up_t = 0.0
+        self._t = time.perf_counter()
+
+    # ── CPU sub-windows ─────────────────────────────────────────────────────────────────────
+    def _core_busy(self, dt_s: float) -> list[float]:
+        if WIN:
+            idle = win_idle_cycles(self.ncpu)
+            busy = [max(0.0, min(1.0, 1.0 - (i1 - i0) / (self.hz * dt_s))) for i0, i1 in zip(self._idle, idle)]
+            self._idle = idle
+            return busy
+        return [p / 100.0 for p in psutil.cpu_percent(None, percpu=True)]
+
+    def window(self, stop=None) -> dict:
+        """Sample for one window (blocks for window_s) and return the HostStats fields."""
+        sub = self.window_s / self.sub_samples
+        mean = [0.0] * self.ncpu
+        peak = [0.0] * self.ncpu
+        tot_sum, tot_peak, late_max = 0.0, 0.0, 0.0
+        t_prev = time.perf_counter()
+        target = t_prev + sub
+        n = 0
+        for _ in range(self.sub_samples):
+            wait = target - time.perf_counter()
+            if wait > 0:
+                time.sleep(wait)
+            now = time.perf_counter()
+            if wait > 0:
+                late_max = max(late_max, (now - target) * 1000.0)
+            target = now + sub  # no catch-up: every sub-window is >= sub (cpu_sampler's rule)
+            busy = self._core_busy(now - t_prev)
+            t_prev = now
+            n += 1
+            s = sum(busy)
+            tot_sum += s
+            tot_peak = max(tot_peak, s)
+            for i, b in enumerate(busy[: self.ncpu]):
+                mean[i] += b
+                if b > peak[i]:
+                    peak[i] = b
+            if stop is not None and stop():
+                break
+        mean = [m / n for m in mean]
+        rest = self._rest()
+        return {"t_ms": int(time.time() * 1000), "window_s": round(self.window_s, 3), "sub_samples": n,
+                "hostname": self.hostname,
+                "cpu_busy_cores_mean": tot_sum / n, "cpu_busy_cores_peak": tot_peak,
+                "core_busy_mean": mean, "core_busy_peak": peak, "core_class": list(self.core_class),
+                "sampler_late_ms_max": late_max, **rest}
+
+    # ── everything else, once per window ─────────────────────────────────────────────────────
+    def _rest(self) -> dict:
+        now = time.perf_counter()
+        dt = max(1e-3, now - self._t)
+        self._t = now
+        cs = psutil.cpu_stats()
+        p = self._cpu_stats
+        self._cpu_stats = cs
+        if WIN:  # psutil reports soft_interrupts = 0 on Windows; the kernel's per-CPU DpcCount instead
+            dpc, prev_dpc = win_dpc_count(), self._dpc
+            dpcs = (dpc - prev_dpc) / dt if dpc is not None and prev_dpc is not None else NAN
+            self._dpc = dpc
+        else:
+            dpcs = (cs.soft_interrupts - p.soft_interrupts) / dt
+        vm = psutil.virtual_memory()
+        sw = psutil.swap_memory()
+        try:
+            free_gb = psutil.disk_usage(self._log_path).free / (1024.0 ** 3)
+        except OSError:
+            free_gb = NAN
+        procs, hard_faults, self_cores = self._processes()
+        return {"context_switches_per_s": (cs.ctx_switches - p.ctx_switches) / dt,
+                "interrupts_per_s": (cs.interrupts - p.interrupts) / dt,
+                "dpcs_per_s": dpcs,
+                "mem_total_mb": vm.total / MB, "mem_used_mb": (vm.total - vm.available) / MB,
+                "mem_available_mb": vm.available / MB, "pagefile_used_mb": sw.used / MB,
+                "hard_page_faults_per_s": hard_faults / dt if hard_faults is not None else NAN,
+                "log_volume": self.log_volume, "log_volume_free_gb": free_gb,
+                "disks": self._disks(dt), "nets": self._nets(dt),
+                "gpus": self.gpu.sample() if self.gpu is not None and self.gpu.available else [],
+                "procs": procs, "monitor_cpu_cores": self_cores}
+
+    def _disks(self, dt: float) -> list[dict]:
+        cur = psutil.disk_io_counters(perdisk=True) or {}
+        prev, self._disk = self._disk, cur
+        out = []
+        for name, c in sorted(cur.items()):
+            q = prev.get(name)
+            if q is None:
+                continue
+            if hasattr(c, "busy_time"):  # Linux
+                busy = (c.busy_time - q.busy_time) / (dt * 1000.0)
+            else:  # Windows/macOS: read + write time, ms; > 1 with queued I/O → clamped
+                busy = ((c.read_time - q.read_time) + (c.write_time - q.write_time)) / (dt * 1000.0)
+            out.append({"name": name, "read_mb_per_s": (c.read_bytes - q.read_bytes) / MB / dt,
+                        "write_mb_per_s": (c.write_bytes - q.write_bytes) / MB / dt,
+                        "reads_per_s": (c.read_count - q.read_count) / dt, "writes_per_s": (c.write_count - q.write_count) / dt,
+                        "busy_frac": max(0.0, min(1.0, busy))})
+        return out
+
+    def _nets(self, dt: float) -> list[dict]:
+        if WIN:
+            return self._nets_win(dt)
+        now = time.perf_counter()
+        if now - self._net_up_t > 10.0:  # adapter up/down list: every 10 s, not every window
+            self._net_up_t = now
+            try:
+                self._net_up = {k for k, v in psutil.net_if_stats().items() if v.isup}
+            except OSError:
+                self._net_up = set()
+        cur = psutil.net_io_counters(pernic=True) or {}
+        prev, self._net = self._net, cur
+        out = []
+        for name, c in sorted(cur.items()):
+            q = prev.get(name)
+            if q is None or (self._net_up and name not in self._net_up) or "loopback" in name.lower() or re.match(r"^lo\d*$", name):
+                continue
+            err = (c.errin + c.errout + c.dropin + c.dropout) - (q.errin + q.errout + q.dropin + q.dropout)
+            out.append({"name": name, "rx_mb_per_s": (c.bytes_recv - q.bytes_recv) / MB / dt,
+                        "tx_mb_per_s": (c.bytes_sent - q.bytes_sent) / MB / dt, "errors": max(0, int(err))})
+        return out
+
+    def _nets_win(self, dt: float) -> list[dict]:
+        now = time.perf_counter()
+        if now - self._net_up_t > 10.0 or not hasattr(self, "_adapters"):
+            self._net_up_t = now
+            self._adapters = win_adapters()
+        out = []
+        for idx, name in self._adapters:
+            c = win_adapter_counters(idx)
+            q = self._net.get(idx)
+            self._net[idx] = c
+            if c is None or q is None:
+                continue
+            err = (c[1] + c[2] + c[4] + c[5]) - (q[1] + q[2] + q[4] + q[5])
+            out.append({"name": name, "rx_mb_per_s": max(0, c[0] - q[0]) / MB / dt,
+                        "tx_mb_per_s": max(0, c[3] - q[3]) / MB / dt, "errors": max(0, int(err))})
+        return out
+
+    # ── processes ───────────────────────────────────────────────────────────────────────────
+    def classify(self, pid: int, name: str) -> str | None:
+        hit = self._groups.get(pid)
+        if hit is not None and hit[0] == name:  # cached per pid; a reused pid has another image name
+            return hit[1]
+        g = None
+        if PY_EXE.match(name or ""):
+            try:
+                g = py_group(psutil.Process(pid).cmdline())
+            except Exception:  # AccessDenied / gone
+                g = None
+        else:
+            for label, rx in self.pins:
+                if rx.search(name or ""):
+                    g = label
+                    break
+        self._groups[pid] = (name, g)
+        return g
+
+    def _processes(self) -> tuple[list[dict], float | None, float]:
+        """procs rows (top N by CPU, memory, disk I/O + one row per pinned group), the system's hard
+        faults in the window (Σ per process; Windows), and this monitor's own cores."""
+        now = time.perf_counter()
+        dt = max(1e-3, now - self._t_procs)
+        self._t_procs = now
+        me = os.getpid()
+        rows = []  # (pid, name, cpu cores, rss MB, read MB/s, write MB/s)
+        hard = None
+        if WIN:
+            cur = win_processes()
+            prev, self._procs = self._procs, cur
+            hard = 0
+            for pid, (name, cyc, ws, rd, wr, hf) in cur.items():
+                q = prev.get(pid)
+                if pid == 0 or q is None or q[0] != name:
+                    continue
+                hard += max(0, hf - q[5])
+                rows.append((pid, name, max(0.0, (cyc - q[1]) / (self.hz * dt)), ws / MB,
+                             max(0, rd - q[3]) / MB / dt, max(0, wr - q[4]) / MB / dt))
+            c = win_self_cycles()
+            self_cores = (c - self._self_cyc) / (self.hz * dt)
+            self._self_cyc = c
+        else:
+            seen = set()
+            for p in psutil.process_iter(["name"]):
+                seen.add(p.pid)
+                q = self._psproc.setdefault(p.pid, p)
+                try:
+                    with q.oneshot():
+                        cpu = q.cpu_percent(None) / 100.0
+                        rss = q.memory_info().rss / MB
+                except Exception:
+                    continue
+                rows.append((p.pid, p.info.get("name") or "", cpu, rss, NAN, NAN))
+            for pid in list(self._psproc):
+                if pid not in seen:
+                    self._psproc.pop(pid, None)
+            t = sum(self._self.cpu_times()[:2])
+            self_cores = (t - self._self_cpu) / dt
+            self._self_cpu = t
+        live = {r[0] for r in rows}
+        for pid in [p for p in self._groups if p not in live]:
+            self._groups.pop(pid, None)
+        return self._select(rows, me), hard, max(0.0, self_cores)
+
+    def _select(self, rows: list[tuple], me: int) -> list[dict]:
+        out: dict = {}
+
+        def row(pid, name, group, cpu, rss, rd, wr, reason):
+            key = ("g", group) if group else ("p", pid)
+            r = out.get(key)
+            if r is None:
+                out[key] = {"pid": pid, "name": name, "group": group or "", "cpu_cores": cpu, "rss_mb": rss,
+                            "io_read_mb_per_s": rd, "io_write_mb_per_s": wr, "reasons": reason}
+            else:
+                r["reasons"] |= reason
+
+        groups: dict[str, list] = {}
+        for r in rows:
+            g = "py:host_monitor" if r[0] == me else self.classify(r[0], r[1])
+            if g:
+                groups.setdefault(g, []).append(r)
+        for g, rs in groups.items():
+            busiest = max(rs, key=lambda r: r[2])
+            row(busiest[0], busiest[1], g, sum(r[2] for r in rs), sum(r[3] for r in rs),
+                _nansum(r[4] for r in rs), _nansum(r[5] for r in rs), REASON_PINNED)
+        pid_group = {r[0]: g for g, rs in groups.items() if len(rs) == 1 for r in rs}
+        for reason, key in ((REASON_CPU, lambda r: r[2]), (REASON_MEM, lambda r: r[3]),
+                            (REASON_IO, lambda r: (r[4] if math.isfinite(r[4]) else 0) + (r[5] if math.isfinite(r[5]) else 0))):
+            for r in sorted(rows, key=key, reverse=True)[: self.top_n]:
+                if reason == REASON_IO and key(r) <= 0:
+                    continue
+                g = pid_group.get(r[0])
+                if g:  # a one-process pinned group: the group row IS this process
+                    out[("g", g)]["reasons"] |= reason
+                else:
+                    row(r[0], r[1], "", r[2], r[3], r[4], r[5], reason)
+        return sorted(out.values(), key=lambda d: -d["cpu_cores"])
+
+
+def _nansum(vals) -> float:
+    vals = [v for v in vals if math.isfinite(v)]
+    return sum(vals) if vals else NAN
+
+
+def to_json_safe(obj):
+    """NaN → None, recursively (the String-JSON form must stay strict JSON)."""
+    if isinstance(obj, float):
+        return None if not math.isfinite(obj) else obj
+    if isinstance(obj, dict):
+        return {k: to_json_safe(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [to_json_safe(v) for v in obj]
+    return obj
+
+
+def summary_line(s: dict) -> str:
+    """One console line for a sample: the pressure at a glance."""
+    top = ", ".join(f"{p['group'] or p['name']} {p['cpu_cores']:.2f}" for p in s["procs"][:3])
+    gpu = s["gpus"][0] if s["gpus"] else None
+    disk = sum(d["read_mb_per_s"] + d["write_mb_per_s"] for d in s["disks"])
+    net = sum(n["rx_mb_per_s"] + n["tx_mb_per_s"] for n in s["nets"])
+    return (f"CPU {s['cpu_busy_cores_mean']:.2f} cores (peak {s['cpu_busy_cores_peak']:.2f}, busiest core "
+            f"{max(s['core_busy_peak'] or [0]) * 100:.0f} %), late {s['sampler_late_ms_max']:.1f} ms · RAM "
+            f"{s['mem_used_mb'] / 1024:.1f}/{s['mem_total_mb'] / 1024:.0f} GB · disk {disk:.1f} MB/s · net {net:.2f} MB/s"
+            + (f" · GPU {gpu['util_frac'] * 100:.0f} % enc {gpu['encoder_util_frac'] * 100:.0f} %" if gpu else "")
+            + f" · top {top} · monitor {s['monitor_cpu_cores'] * 100:.2f} % of a core")
+
+
+if __name__ == "__main__":  # quick look: python host_sampler.py [n]
+    import json
+
+    hs = HostSampler()
+    for _ in range(int(sys.argv[1]) if len(sys.argv) > 1 else 3):
+        s = hs.window()
+        print(summary_line(s))
+    print(json.dumps(to_json_safe(s), indent=1)[:4000])
diff --git a/rig/nodes/rig.py b/rig/nodes/rig.py
index 8d337e9f..d1883ef0 100644
--- a/rig/nodes/rig.py
+++ b/rig/nodes/rig.py
@@ -7,6 +7,7 @@
     pixi run rig -- --bias --bias-sim  # + a simulated BIAS program (no camera software)
     pixi run rig -- --scanimage        # + the ScanImage node (JSON server on this PC); --si-mock for a stand-in
     pixi run rig -- --foxglove         # + foxglove_bridge (:8766) from the `viz` environment
+    pixi run rig -- --no-host-monitor  # without the host monitor (CPU/RAM/disk/net/GPU on /rig/host; on by default)
 
 Order: the router first (nodes retry until it answers on 127.0.0.1:7447), then every
 adapter/node. Each child's stderr is prefixed with its name. Ctrl-C stops everything in
@@ -143,6 +144,8 @@ def main(argv: list[str] | None = None) -> int:
     p.add_argument("--viz-args", default="", help="extra args for viz_node.py (--deg-per-frame, --frame-dir, --feature-az0, --frames)")
     p.add_argument("--foxglove", action="store_true",
                    help=f"also run foxglove_bridge on ws://127.0.0.1:{FOXGLOVE_PORT} (the `viz` environment; skipped with a note when it is not installed)")
+    p.add_argument("--no-host-monitor", action="store_true", help="do not run host_monitor.py (the PC's CPU per core, memory, disk, network, GPU, top processes on /rig/host, recorded in every run's bag)")
+    p.add_argument("--host-monitor-args", default="", help="extra args for host_monitor.py (e.g. --period 0.5 --print-every 30 --pin bias=^BIAS)")
     p.add_argument("--no-router", action="store_true", help="a Zenoh router is already running on this host")
     p.add_argument("--bridge-args", default="", help="extra args for bridge_node.py")
     p.add_argument("--fictrac-args", default="", help="extra args for fictrac_udp_adapter.py")
@@ -206,6 +209,9 @@ def main(argv: list[str] | None = None) -> int:
         nodes.append(Child("si-mock", [py, str(HERE.parent / "tests" / "si_json_mock.py")]))
     if args.scanimage:
         nodes.append(Child("scanimage", [py, str(NODES / "scanimage_node.py"), *split_args(args.scanimage_args)]))
+    if not args.no_host_monitor:
+        # Before the bridge, so a run opened right away already has host samples in its bag.
+        nodes.append(Child("host", [py, str(NODES / "host_monitor.py"), *split_args(args.host_monitor_args)]))
     bridge = Child("bridge", [py, str(NODES / "bridge_node.py"), *split_args(args.bridge_args)])
     nodes.append(bridge)
     if foxglove:
diff --git a/rig/tests/test_ros2_poc.py b/rig/tests/test_ros2_poc.py
index c74ca01f..e8468269 100644
--- a/rig/tests/test_ros2_poc.py
+++ b/rig/tests/test_ros2_poc.py
@@ -50,6 +50,9 @@
                                                         NDJSON — reported, crashsafe profile gated;
                                                         then a RESTARTED node's log_export recovers the
                                                         bag on its own (recovered:true, whole bag left)
+  host monitor (2026-10-28)                            /rig/host in the bag ≥ 0.8 Hz, fields = the
+                                                        HostStats spec, the graph's nodes pinned; its own
+                                                        CPU ≤ 2 % of a core, ≤ 5 % of the compressed bag
 
 Exit 0 when all checks pass. Prints a markdown summary. Artifacts are kept with --keep.
 """
@@ -242,6 +245,55 @@ def bag_summary(bag: Path) -> dict:
             "frame_lag_ms": {"p50": round(lag[len(lag) // 2], 3), "p99": round(lag[int(len(lag) * 0.99)], 3), "max": round(lag[-1], 3)} if lag else None}
 
 
+def host_monitor_values(bag: Path) -> dict:
+    """/rig/host in the bag: sample count over the run, field names vs the request's HostStats.msg,
+    per-core sanity, pinned groups, the monitor's own CPU, and its share of the compressed payload."""
+    import re
+    import statistics
+
+    import zstandard
+
+    sys.path.insert(0, str(NODES))
+    from mcap_convert import _json_of, decode_cdr, read_records  # noqa: E402
+
+    spec = (POC / "docs" / "host-stats-request.md").read_text(encoding="utf-8")
+    body = re.search(r"### HostStats\.msg\s*```\n(.*?)```", spec, re.S).group(1)
+    want = sorted(ln.split("#", 1)[0].split()[1] for ln in body.splitlines() if ln.split("#", 1)[0].strip())
+    host, other, t_ns, objs = [], [], [], []
+    gen = read_records(bag)
+    try:
+        while True:
+            r = next(gen)
+            t_ns.append(r["log_ns"])
+            if r["topic"] != "/rig/host":
+                other.append(r["data"])
+                continue
+            host.append(r["data"])
+            try:  # String JSON → its object; a typed HostStats → its fields (the converter's decoder)
+                objs.append(_json_of({"msg": decode_cdr(r["schema"], r.get("schema_text"), r["data"])}))
+            except Exception:
+                objs.append(None)
+    except StopIteration:
+        pass
+    good = [o for o in objs if isinstance(o, dict)]
+    bad = sorted({k for o in good for k in set(o) ^ set(want)})
+    cores_ok = bool(good) and all(len(o["core_busy_mean"]) == len(o["core_busy_peak"]) == (os.cpu_count() or 0)
+                                  and all(p + 1e-6 >= m for m, p in zip(o["core_busy_mean"], o["core_busy_peak"])) for o in good)
+    self_cpu = [o["monitor_cpu_cores"] for o in good[2:] if isinstance(o.get("monitor_cpu_cores"), (int, float))]
+    level = 19  # the bag's zstd "Slowest" (recorder.py `default` profile; crashsafe is reindexed to it)
+    zh = len(zstandard.ZstdCompressor(level=level).compress(b"".join(host))) if host else 0
+    za = len(zstandard.ZstdCompressor(level=level).compress(b"".join(host + other))) if host or other else 0
+    run_s = (max(t_ns) - min(t_ns)) / 1e9 if t_ns else None
+    return {"samples": len(host), "run_s": round(run_s, 1) if run_s else None, "fields_ok": bool(good) and len(good) == len(objs) and not bad,
+            "bad_fields": bad, "cores_ok": cores_ok, "ncpu": len(good[0]["core_busy_mean"]) if good else None,
+            "groups": sorted({p["group"] for o in good for p in o.get("procs", []) if p.get("group")}),
+            "self_cpu_median": round(statistics.median(self_cpu), 4) if self_cpu else None,
+            "self_cpu_max": round(max(self_cpu), 4) if self_cpu else None,
+            "bytes_per_sample": round(sum(map(len, host)) / len(host)) if host else None,
+            "share_compressed": round(zh / za, 4) if za else None,
+            "host_kb_per_h_zstd": round(zh / run_s * 3600 / 1024) if run_s else None}
+
+
 def typed_frame_values(bag: Path) -> dict:
     """The recorded /arena/frame ArenaFrame messages, decoded with the converter's pure-Python
     CDR decoder from the schema text IN THE BAG, judged by VALUE — a schema name alone said
@@ -404,6 +456,7 @@ def start(name: str, argv: list[str]) -> Proc:
         si_port = free_tcp_port()
         start("si-mock", [PY, str(HERE / "si_json_mock.py"), "--port", str(si_port), "--grab-s", "1.0", "--start-delay-s", "0.2", "--stall-on", "hSI.hRoiManager.scanZoomFactor"])
         start("scanimage-node", [PY, str(NODES / "scanimage_node.py"), "--port", str(si_port), "--status-every", "1", "--timeout-s", "1.5"])
+        start("host-monitor", [PY, str(NODES / "host_monitor.py"), "--log-dir", str(runlogs)])
         bridge_argv = [PY, str(NODES / "bridge_node.py"), "--log-dir", str(runlogs), "--source-timeout", "1.5", "--bag-profile", a.bag_profile]
         bridge = start("bridge-node", bridge_argv)
         check("bridge node serving ws://127.0.0.1:8765", wait_port("127.0.0.1", 8765, 20.0))
@@ -717,6 +770,21 @@ def side_actor() -> None:
         if typed:
             check("size: /arena/frame records in the final layout (chunk-only index, zstd 19) ≤ 72 B/frame compressed", bool(sz) and (sz.get("bytes_per_frame") or 999) <= 72.0, json.dumps(sz))
 
+        # ── host monitor (/rig/host; docs/development/rig-host-monitor.md) ───────────────
+        hm = host_monitor_values(main_bag) if main_bag else {}
+        print(f"  info  host monitor: {json.dumps({k: v for k, v in hm.items() if k not in ('fields_ok', 'groups')})}", file=sys.stderr)
+        check("host monitor: /rig/host recorded in the bag, ≥ 0.8 samples per second of the run",
+              (hm.get("samples") or 0) >= 0.8 * (hm.get("run_s") or 99), f"{hm.get('samples')} samples over {hm.get('run_s')} s")
+        check("host monitor: every sample has exactly the HostStats fields of rig/docs/host-stats-request.md (String JSON: same names)",
+              hm.get("fields_ok", False), str(hm.get("bad_fields")))
+        check("host monitor: one entry per logical CPU, busiest sub-window ≥ the window mean on every core",
+              hm.get("cores_ok", False), f"{hm.get('ncpu')} CPUs")
+        check("host monitor: the graph's processes pinned by script (py:bridge_node, py:fictrac_udp_adapter, py:host_monitor)",
+              {"py:bridge_node", "py:fictrac_udp_adapter", "py:host_monitor"} <= set(hm.get("groups") or []), str(hm.get("groups")))
+        check("host monitor cost: its own CPU ≤ 2 % of one core (median after the first 2 samples)",
+              hm.get("self_cpu_median") is not None and hm["self_cpu_median"] <= 0.02, f"median {hm.get('self_cpu_median')} max {hm.get('self_cpu_max')} cores")
+        check("host monitor storage: /rig/host ≤ 5 % of the run's compressed payload (zstd, as the bag)",
+              hm.get("share_compressed") is not None and hm["share_compressed"] <= 0.05, f"{hm.get('share_compressed')} ({hm.get('host_kb_per_h_zstd')} KB/h)")
         check("bridge node still alive at the end of the main run", bridge.alive())
 
         # ── crash phase: SIGKILL the bridge node mid-run, both writer profiles ────────
diff --git a/tests/test-host-sampler.py b/tests/test-host-sampler.py
new file mode 100644
index 00000000..553543f3
--- /dev/null
+++ b/tests/test-host-sampler.py
@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""Offline tests for rig/nodes/host_sampler.py — the rig's host-pressure sampler (no ROS, no psutil
+needed: a fake psutil with known counters drives the portable code path), wired into the root
+`pixi run test`. Checks:
+  (a) the CONTRACT: every sample field, and every disks/nets/gpus/procs field, is exactly the
+      `.msg` definition in rig/docs/host-stats-request.md, with a matching Python type
+  (b) rates from counter deltas (disk MB/s, IOPS, busy, network MB/s + errors, context switches)
+  (c) CPU: window mean vs busiest sub-window, per core
+  (d) processes: pinned groups summed into one row, top-N by CPU / memory / I/O with reason bits,
+      a one-process group merged with its top-N row, py:<script> for this repo's Python processes
+  (e) JSON form: NaN → null, strict JSON; the console summary line
+
+Run: python tests/test-host-sampler.py
+"""
+import collections
+import importlib.util
+import json
+import math
+import os
+import re
+import sys
+import types
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.join(HERE, "..")
+SPEC = os.path.join(ROOT, "rig", "docs", "host-stats-request.md")
+_spec = importlib.util.spec_from_file_location("host_sampler", os.path.join(ROOT, "rig", "nodes", "host_sampler.py"))
+H = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(H)
+
+total = 0
+failures = 0
+
+
+def check(name, got, expected):
+    global total, failures
+    total += 1
+    if got == expected:
+        print(f"  ok   {name}")
+    else:
+        failures += 1
+        print(f"  FAIL {name}: got {got!r}, expected {expected!r}")
+
+
+# ── the fake psutil: counters that advance by fixed steps per call ────────────────────────────
+class FakePsutil(types.SimpleNamespace):
+    pass
+
+
+CpuStats = collections.namedtuple("CpuStats", "ctx_switches interrupts soft_interrupts syscalls")
+Disk = collections.namedtuple("Disk", "read_count write_count read_bytes write_bytes read_time write_time")
+Nic = collections.namedtuple("Nic", "bytes_sent bytes_recv packets_sent packets_recv errin errout dropin dropout")
+VM = collections.namedtuple("VM", "total available percent")
+Swap = collections.namedtuple("Swap", "used")
+Usage = collections.namedtuple("Usage", "free")
+IfStat = collections.namedtuple("IfStat", "isup")
+Mem = collections.namedtuple("Mem", "rss")
+CALLS = collections.Counter()
+
+
+def _step(name):
+    CALLS[name] += 1
+    return CALLS[name]
+
+
+class FakeProc:
+    TABLE = {}  # pid → (name, cmdline, cpu %, rss MB)
+
+    def __init__(self, pid=None):
+        self.pid = os.getpid() if pid is None else pid
+        name = self.TABLE.get(self.pid, ("python.exe", ["python"], 0.0, 1.0))[0]
+        self.info = {"name": name}
+
+    def oneshot(self):
+        import contextlib
+
+        return contextlib.nullcontext()
+
+    def cpu_percent(self, _):
+        return self.TABLE[self.pid][2]
+
+    def memory_info(self):
+        return Mem(int(self.TABLE[self.pid][3] * H.MB))
+
+    def cmdline(self):
+        return self.TABLE[self.pid][1]
+
+    def cpu_times(self):
+        k = _step("self")
+        return (0.001 * k, 0.0)
+
+
+fake = FakePsutil(
+    cpu_count=lambda: 4,
+    cpu_percent=lambda _i, percpu=True: [10.0, 20.0, 30.0, 40.0] if _step("cpu") % 2 else [30.0, 20.0, 10.0, 80.0],
+    cpu_stats=lambda: (lambda k: CpuStats(1000 * k, 500 * k, 50 * k, 0))(_step("stats")),
+    virtual_memory=lambda: VM(16 * 1024 * H.MB, 6 * 1024 * H.MB, 62.5),
+    swap_memory=lambda: Swap(512 * H.MB),
+    disk_usage=lambda p: Usage(100 * 1024 ** 3),
+    disk_io_counters=lambda perdisk=True: (lambda k: {"disk0": Disk(10 * k, 20 * k, int(2 * H.MB) * k, int(4 * H.MB) * k, 100 * k, 200 * k)})(_step("disk")),
+    net_io_counters=lambda pernic=True: (lambda k: {"en0": Nic(int(H.MB) * k, 3 * int(H.MB) * k, 0, 0, k, 0, 0, 0),
+                                                    "lo0": Nic(9 * k, 9 * k, 0, 0, 0, 0, 0, 0)})(_step("net")),
+    net_if_stats=lambda: {"en0": IfStat(True), "lo0": IfStat(True)},
+    Process=FakeProc,
+    process_iter=lambda attrs=None: [FakeProc(pid) for pid in FakeProc.TABLE],
+)
+me = os.getpid()
+script = os.path.join(ROOT, "rig", "nodes", "bridge_node.py")
+FakeProc.TABLE = {
+    me: ("python.exe", ["python", "host_monitor.py"], 1.0, 40.0),
+    101: ("fictrac.exe", [], 78.0, 300.0),
+    102: ("chrome.exe", [], 5.0, 800.0),
+    103: ("chrome.exe", [], 3.0, 900.0),
+    104: ("python.exe", ["python", script, "--log-dir", "x"], 12.0, 75.0),
+    105: ("python.exe", ["python", "/elsewhere/tool.py"], 50.0, 30.0),
+    106: ("bigmem.exe", [], 0.5, 5000.0),
+    107: ("idle.exe", [], 0.0, 1.0),
+}
+H.psutil = fake
+H.WIN = False  # the portable path, on every OS
+hs = H.HostSampler(window_s=0.1, sub_samples=2, log_volume=ROOT, top_n=2, gpu=False)
+hs.window()
+s = hs.window()
+
+print("(a) contract vs rig/docs/host-stats-request.md")
+text = open(SPEC, encoding="utf-8").read()
+msgs = {}
+for name, body in re.findall(r"### (\w+)\.msg\s*```\n(.*?)```", text, re.S):
+    fields = []
+    for line in body.splitlines():
+        line = line.split("#", 1)[0].strip()
+        if line:
+            typ, fname = line.split()[:2]
+            fields.append((typ, fname))
+    msgs[name] = fields
+check("five messages in the spec", sorted(msgs), ["DiskStats", "GpuStats", "HostStats", "NetStats", "ProcStats"])
+
+
+def pytype_ok(typ, v):
+    if typ.endswith("[]"):
+        return isinstance(v, list)
+    if typ.startswith("float"):
+        return isinstance(v, float)
+    if typ.startswith(("int", "uint")):
+        return isinstance(v, int) and not isinstance(v, bool)
+    if typ == "string":
+        return isinstance(v, str)
+    return False
+
+
+def conforms(msg, d):
+    names = [f for _, f in msgs[msg]]
+    return sorted(d) == sorted(names) and all(pytype_ok(t, d[f]) for t, f in msgs[msg])
+
+
+check("HostStats: exactly the spec's fields and types", conforms("HostStats", s), True)
+check("DiskStats", bool(s["disks"]) and all(conforms("DiskStats", d) for d in s["disks"]), True)
+check("NetStats", bool(s["nets"]) and all(conforms("NetStats", d) for d in s["nets"]), True)
+check("ProcStats", bool(s["procs"]) and all(conforms("ProcStats", d) for d in s["procs"]), True)
+
+
+class FakeNvml:  # every NVML call fails → the documented absent values
+    def __getattr__(self, _):
+        return lambda *a: 999
+
+
+g = H.Nvml.__new__(H.Nvml)
+g.lib, g.handles, g.names = FakeNvml(), [object()], ["Fake GPU"]
+gs = g.sample()
+check("GpuStats (every NVML call failing): spec fields, NaN floats, pstate 255", conforms("GpuStats", gs[0]) and math.isnan(gs[0]["util_frac"]) and gs[0]["pstate"] == 255, True)
+check("Nvml() never raises (driver present or not)", isinstance(H.Nvml().available, bool), True)
+
+print("(b) rates")
+d = s["disks"][0]
+rate = d["reads_per_s"] / 10  # = 1 / the window the sampler measured (reads advance by 10 per window)
+check("disk MB/s = Δbytes / Δt", (round(d["read_mb_per_s"] / rate, 3), round(d["write_mb_per_s"] / rate, 3)), (2.0, 4.0))
+check("disk busy = (Δread_time + Δwrite_time) / window, clamped to 1", d["busy_frac"], 1.0)
+n = s["nets"]
+check("loopback adapter skipped", [x["name"] for x in n], ["en0"])
+check("net rx/tx MB/s, errors in the window", (round(n[0]["rx_mb_per_s"] / rate, 3), round(n[0]["tx_mb_per_s"] / rate, 3), n[0]["errors"]), (3.0, 1.0, 1))
+check("context switches per s", round(s["context_switches_per_s"] / rate), 1000)
+check("memory used / available / page file", (s["mem_used_mb"], s["mem_available_mb"], s["pagefile_used_mb"]), (10240.0, 6144.0, 512.0))
+check("hard faults absent off Windows → NaN", math.isnan(s["hard_page_faults_per_s"]), True)
+check("log volume free space", s["log_volume_free_gb"], 100.0)
+
+print("(c) CPU mean vs peak")
+check("per-core mean of the two sub-windows", [round(x, 3) for x in s["core_busy_mean"]], [0.2, 0.2, 0.2, 0.6])
+check("per-core peak", s["core_busy_peak"], [0.3, 0.2, 0.3, 0.8])
+check("whole-PC mean / peak (cores)", (round(s["cpu_busy_cores_mean"], 3), round(s["cpu_busy_cores_peak"], 3)), (1.2, 1.4))
+check("sub_samples", s["sub_samples"], 2)
+
+print("(d) processes")
+by = {(p["group"] or p["name"]): p for p in s["procs"]}
+check("pinned: fictrac row", by["fictrac"]["cpu_cores"], 0.78)
+check("browser = ONE summed row for its two processes", (by["browser"]["cpu_cores"], by["browser"]["rss_mb"], by["browser"]["pid"]), (0.08, 1700.0, 102))
+check("this repo's Python script → py:bridge_node", "py:bridge_node" in by, True)
+check("the monitor itself → py:host_monitor", "py:host_monitor" in by, True)
+check("a Python script outside the repo is not pinned, but tops CPU", (by["python.exe"]["group"], by["python.exe"]["reasons"]), ("", H.REASON_CPU))
+check("one-process group merged with its top-N row (fictrac: pinned + top CPU)", by["fictrac"]["reasons"], H.REASON_PINNED | H.REASON_CPU)
+check("top memory picks the big process", by["bigmem.exe"]["reasons"] & H.REASON_MEM, H.REASON_MEM)
+check("an idle unpinned process is left out", "idle.exe" in by, False)
+check("rows sorted by CPU", [p["cpu_cores"] for p in s["procs"]] == sorted((p["cpu_cores"] for p in s["procs"]), reverse=True), True)
+check("py_group: -m rig_nodes.<module>", H.py_group(["python", "-m", "rig_nodes.fictrac_udp_adapter"]), "py:fictrac_udp_adapter")
+check("py_group: relative nodes/ script (pixi task cwd = rig/)", H.py_group(["python", "nodes/bridge_node.py"]), "py:bridge_node")
+check("py_group: other module", H.py_group(["python", "-m", "http.server"]), None)
+
+print("(e) JSON + summary")
+s["gpus"] = gs
+j = json.dumps(H.to_json_safe(s), allow_nan=False)
+check("strict JSON (NaN → null)", json.loads(j)["hard_page_faults_per_s"], None)
+line = H.summary_line(s)
+check("summary line", line.startswith("CPU 1.20 cores (peak 1.40, busiest core 80 %)") and "top fictrac 0.78" in line and "GPU" in line, True)
+
+print(f"\n{total - failures}/{total} passed")
+sys.exit(1 if failures else 0)

From 8359e4bae0b076aca43044b003c1382bc3e10d4d Mon Sep 17 00:00:00 2001
From: Michael B Reiser <mreiser@gmail.com>
Date: Wed, 28 Oct 2026 17:50:00 -0400
Subject: [PATCH 2/4] rig: keep only the arena half of the host monitor; the
 node moves to rig-nodes

The generic host monitor (host_sampler.py, host_monitor.py, its unit test, design note and
the HostStats message spec) belongs in reiserlab/rig-nodes as rig_nodes.host_monitor; it is
being ported there from branch rig/host-monitor-port (f5cf5a6). What stays here is the arena
rig's composition and gateway:

- bridge_node.py records /rig/host into each run's bag (typed HostStats when rig_interfaces
  has it, else String).
- rig.py starts `python -m rig_nodes.host_monitor --log-dir rig/runlogs --py-root rig/` when
  the installed rig_nodes ships it (a note otherwise); --no-host-monitor, --host-monitor-args.
- test_ros2_poc.py runs it the same way and checks samples, fields, per-core sanity, pinned
  graph nodes, its CPU (<= 2 % of a core) and storage (<= 5 % of the compressed payload);
  skipped with an info line when the installed rig_nodes has no host monitor.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/development/rig-host-monitor.md |  85 ----
 rig/README.md                        |   2 +-
 rig/docs/host-stats-request.md       | 105 -----
 rig/nodes/bridge_node.py             |   6 +-
 rig/nodes/host_monitor.py            | 175 --------
 rig/nodes/host_sampler.py            | 639 ---------------------------
 rig/nodes/rig.py                     |  24 +-
 rig/tests/test_ros2_poc.py           |  61 ++-
 tests/test-host-sampler.py           | 215 ---------
 9 files changed, 61 insertions(+), 1251 deletions(-)
 delete mode 100644 docs/development/rig-host-monitor.md
 delete mode 100644 rig/docs/host-stats-request.md
 delete mode 100644 rig/nodes/host_monitor.py
 delete mode 100644 rig/nodes/host_sampler.py
 delete mode 100644 tests/test-host-sampler.py

diff --git a/docs/development/rig-host-monitor.md b/docs/development/rig-host-monitor.md
deleted file mode 100644
index 10cda472..00000000
--- a/docs/development/rig-host-monitor.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Rig host monitor — the PC's "pressure" in every run
-
-Status: v1, 2026-10-28 (`rig/nodes/host_sampler.py` + `rig/nodes/host_monitor.py`, ww18). The message
-spec sent to rig-nodes: `rig/docs/host-stats-request.md`.
-
-## What and why
-
-A generic node that publishes how loaded the rig PC is, like Task Manager or Performance Monitor
-but recorded: CPU per core, memory, disk, network, GPU, and the processes responsible. It knows
-nothing about FicTrac or the arena. `pixi run rig` starts it by default (`--no-host-monitor` turns
-it off) because it costs little enough to leave on (§4). The arena gateway records `/rig/host` into
-every run's MCAP bag, so a run that went wrong carries the PC's state alongside it, and a question
-like "does Foxglove cost anything" is answered by comparing bags instead of a separate experiment.
-
-The method is atlas-bench `tools/cpu_sampler.py` (commit 306fa6d, used on ww18 for the BIAS
-CPU-spike work): cycle counters, 100 ms CPU sub-windows, one system call for all processes.
-
-## What one sample holds (1 Hz, `rig_interfaces/HostStats`)
-
-| area | fields | source (Windows · elsewhere) |
-|---|---|---|
-| CPU | per-core busy, window mean **and** busiest 100 ms sub-window; whole-PC busy cores (mean, peak); P/E-core class per CPU; how late the sampler woke (a PC-wide stall); context switches, interrupts, DPCs per s | idle-cycle counters (exact) + `GetSystemCpuSetInformation` + kernel DPC counts · psutil (tick-based) |
-| memory | total, used, available, page file used, hard page faults per s | psutil + Σ per-process hard faults · psutil (no hard faults) |
-| storage | per physical disk: read/write MB/s, IOPS, busy fraction; free space on the run-log volume | psutil |
-| network | per adapter that is up (hardware, not loopback): rx/tx MB/s, errors + drops | `GetIfEntry2` per adapter · psutil |
-| GPU | per NVIDIA GPU: core + memory-controller utilization, memory, NVENC/NVDEC load, temperature, power, P-state, throttle reasons | the driver's NVML through ctypes (no package) |
-| processes | top 3 by CPU, by memory, by disk I/O (`--top`), plus one summed row per pinned group (router, FicTrac, BIAS `test_gui.exe`, MATLAB, browser, Foxglove app, foxglove_bridge, each graph node as `py:<script>`) | one `NtQuerySystemInformation` call · psutil scan |
-| cost | `monitor_cpu_cores`: the node's own CPU over the window | its process cycle counter |
-
-Granularity: CPU every 100 ms, published as mean + peak per 1 s window, because Task Manager's 1 s
-all-core average hides a single thread pinned for a few hundred ms (cpu_sampler's BIAS finding: one
-core at 100 % for 6.4 s read as ~4 %). Everything else is a 1 s rate from counter deltas.
-`--period` and `--sub` change both.
-
-Not measured, deliberately: temperatures beyond the GPU's (Windows needs a vendor source), loopback
-traffic (Windows counts none, so Zenoh, the FicTrac UDP stream and the Studio WebSocket are not in
-`nets`), per-thread CPU (cpu_sampler's job when one process needs a closer look), anything
-arena-specific (the bridge and the Studio's telemetry own that).
-
-## Where it lives
-
-Generic, so it belongs in reiserlab/rig-nodes (`rig_nodes.host_monitor`, docs/development/
-rig-software-repos-and-runners.md §3). It is prototyped in `rig/nodes/` because ww18 cannot push
-there and is the PC the cost has to be measured on. It moves unchanged: `host_sampler.py` has no
-ROS and no import from this repo; `host_monitor.py` imports only rclpy, std_msgs and the sampler.
-
-The typed message needs `rig_interfaces` ≥ 0.3.0 (rig-nodes release in progress, win-64 build
-included). Until that is installed (`pixi install -e typed`), the node publishes `std_msgs/String`
-JSON with the same field names (NaN → null, floats to 3 decimals), the `--typed auto` pattern the
-FicTrac adapter uses. The gateway picks the same type for its recording subscription.
-
-## Cost and budget
-
-Budget: ≤ 5 % of the PC's CPU and of the bag's size (the lab's limit), with a tighter self-check in
-the acceptance harness: the node's own CPU ≤ 2 % of ONE core (median), `/rig/host` ≤ 5 % of the
-run's compressed payload.
-
-Measured on ww18 (Core Ultra 9 285K, 24 logical CPUs, ~300 processes), per 1 s window:
-
-| piece | cost |
-|---|---|
-| 10 × per-core idle cycles | 0.06 ms each |
-| process table (one call) + top-N selection | 1.9 ms (a psutil scan took 694 ms) |
-| network, 3 adapters via `GetIfEntry2` | 0.19 ms (psutil: 5.3 ms) |
-| memory, disks, log volume, GPU | < 0.3 ms together |
-| **node total** | **≈ 0.85–0.9 % of one core ≈ 0.04 % of the PC** (the first window after start is higher: one-time cycle-rate calibration and process-name lookups) |
-
-In the acceptance harness (the whole graph + simulators on ww18): median **0.9 % of one core**, max
-3.7 % (a window with new processes to name).
-
-Storage (String JSON, the form running today): 4.6 KB per sample raw, **≈ 1.0 MB/h zstd**, **4.9 %**
-of the harness run's compressed payload. That run is a worst case for this ratio: ~14 pinned Python
-processes (simulators, emulator, the harness itself) each get a row, and the bag is small (simulated
-FicTrac at 50 Hz). Process rows are about half the bytes and the per-core arrays most of the rest;
-the defaults (top 3 per list, floats to 3 decimals) came from that measurement — top 5 and 4
-decimals measured 6.4 %. The typed form is re-measured when rig-nodes 0.3.0 is installed.
-
-## Tests
-
-- `tests/test-host-sampler.py` (root suite, CI, no ROS or psutil needed): every field and type
-  against the `.msg` text in `rig/docs/host-stats-request.md`, counter-delta rates, CPU mean vs
-  peak, pinned groups and top-N selection, strict JSON.
-- `rig/tests/test_ros2_poc.py` (`cd rig && pixi run test`): the node runs in the graph; the bag
-  holds ≥ 0.8 samples per second with exactly the spec's fields, per-core sanity, the graph's nodes
-  pinned by script, and the cost and storage gates above.
diff --git a/rig/README.md b/rig/README.md
index 5e10e96e..06d6f093 100644
--- a/rig/README.md
+++ b/rig/README.md
@@ -291,7 +291,7 @@ sends it at run end only on the commit path today) or on a run-end event.
 | live graph, interactive | `pixi install -e viz`, then `pixi run -e viz rqt-graph` | the standard ROS node/topic graph window (Qt); `pixi run -e viz rqt-topic` shows rates and payloads |
 | the recorded run | Foxglove (free desktop app) → *Open local file* → `runlogs/<run>.bag/<run>_0.mcap`; Layout → *Import from file* → `docs/foxglove-arena-layout.json` | every topic of the run on a timeline: plots of `/arena/frame` `idx`, `hd`, `turning_dps` + `forward_mms`, `bias_deg`, `epoch` (typed runs; String runs show the JSON text), the browser messages, events and BIAS replies as raw views, the schemas rosbag2 embedded — no ROS needed on that machine |
 | the live run in Foxglove | `pixi run rig -- --foxglove` (adds foxglove_bridge from the `viz` environment to the supervised rig; a note and no bridge when `pixi install -e viz` has not been run) → Foxglove *Open connection* `ws://localhost:8766`; or by hand beside a running rig: `pixi run -e viz foxglove-bridge` | the same panels on the running graph, including the derived `turning_dps` / `forward_mms` plot |
-| how loaded the PC is | nothing to start: `pixi run rig` runs `nodes/host_monitor.py` (off: `--no-host-monitor`); alone: `pixi run python nodes/host_sampler.py 5` prints five samples without ROS | `/rig/host` once a second, recorded in every run's bag: CPU per core (mean + busiest 100 ms), P/E cores, sampler lateness, memory, page faults, disks, network, NVIDIA GPU (incl. NVENC), top processes + the graph's nodes; ≈ 0.9 % of one core on ww18. Design: `docs/development/rig-host-monitor.md` |
+| how loaded the PC is | nothing to start: `pixi run rig` runs `python -m rig_nodes.host_monitor` from the installed rig-nodes package when it has one (off: `--no-host-monitor`; a note and no monitor with an older package) | `/rig/host` once a second, recorded in every run's bag: CPU per core (mean + busiest 100 ms), P/E cores, sampler lateness, memory, page faults, disks, network, NVIDIA GPU (incl. NVENC), top processes + this workspace's nodes as `py:<script>`; ≈ 0.9 % of one core on ww18. Node, message and design: reiserlab/rig-nodes (`rig_nodes.host_monitor`, `rig_interfaces/HostStats`) |
 | the plain CLI | `pixi run ros2 node list`, `ros2 topic list -t`, `ros2 topic hz /arena/frame`, `ros2 topic echo /bias/status`, `ros2 bag info runlogs/<run>.bag` | what every ROS user reaches for first; every topic here is readable JSON or a flat typed message |
 
 **Color optomotor smoke run (22:00 ET, same bench, after merging Next into the branch).** The
diff --git a/rig/docs/host-stats-request.md b/rig/docs/host-stats-request.md
deleted file mode 100644
index e5549d1f..00000000
--- a/rig/docs/host-stats-request.md
+++ /dev/null
@@ -1,105 +0,0 @@
-# Request for rig-nodes: typed host-pressure messages (from the webDisplayTools host-monitor session, 2026-10-28)
-
-## What and why
-A generic host monitor node (`rig_nodes.host_monitor`, prototyped in webDisplayTools `rig/nodes/host_monitor.py`
-on ww18) publishes PC "pressure" at 1 Hz on `/rig/host`: per-core CPU (mean + peak of 10 Hz sub-windows, the
-method of atlas-bench `tools/cpu_sampler.py`), memory, disk, network, NVIDIA GPU, top processes. The arena gateway
-records it into each run's MCAP bag. The user chose a TYPED message (plottable live in Foxglove). Please add the
-messages below to `rig_interfaces` and release them; until the release lands the node publishes `std_msgs/String`
-JSON with the SAME field names (the `--typed auto` pattern of the FicTrac adapter / ArenaFrame).
-
-## Please change
-1. `src/rig_interfaces/msg/`: add `HostStats.msg`, `DiskStats.msg`, `NetStats.msg`,
-   `GpuStats.msg`, `ProcStats.msg` exactly as below; list them in `CMakeLists.txt` `rosidl_generate_interfaces`.
-2. `CONTRACT.md`: a topic-table row
-   `| /rig/host | rig_interfaces/HostStats, or std_msgs/String JSON with the same field names | RELIABLE, KEEP_LAST 10, VOLATILE | rig_nodes.host_monitor (default 1 Hz) | one host sample per window; recorded by the arena gateway |`
-   and the absent-value rule applies (NaN float / 0 int when the OS gives no value).
-3. Bump the package set (new messages = wire-contract change, CONTRACT §7) → 0.3.0, release, and rebuild the
-   channel INCLUDING a win-64 `rig_interfaces` build (ww18's env currently has no importable `rig_interfaces`).
-4. Reply with: the release tag, whether win-64 `rig_interfaces` is in the channel, and any field you renamed.
-   (Optional, later: the node itself moves to `src/rig_nodes/rig_nodes/host_monitor.py` once measured on ww18.)
-
-## Message definitions (normative proposal)
-
-### HostStats.msg
-```
-# One host-pressure sample (rig_nodes.host_monitor, /rig/host, default 1 Hz). CPU is measured from
-# cycle counters every 1/sub_samples of the window (Windows: QueryIdleProcessorCycleTime, exact; Task
-# Manager's tick-based numbers step at 15.6 ms) and reported as the window mean AND the busiest
-# sub-window, so a short burst on one core is not averaged away. Absent value: NaN (float) / 0 (int).
-int64 t_ms                      # wall clock at the END of the window (ms since the Unix epoch)
-float32 window_s                # window length, s (1.0 at 1 Hz)
-uint32 sub_samples              # CPU sub-windows in this window (10 at the default 10 Hz)
-string hostname
-# CPU
-float32 cpu_busy_cores_mean     # whole-PC busy cores (0..n_cpu), mean over the window
-float32 cpu_busy_cores_peak     # busiest sub-window
-float32[] core_busy_mean        # per logical CPU, 0..1
-float32[] core_busy_peak        # per logical CPU, busiest sub-window, 0..1
-uint8[] core_class              # efficiency class per logical CPU (higher = faster: P- vs E-cores); empty if unknown
-float32 sampler_late_ms_max     # how late the monitor woke for a sub-window (a PC-wide stall or starvation)
-float32 context_switches_per_s
-float32 interrupts_per_s
-float32 dpcs_per_s              # deferred procedure calls (Windows; soft interrupts elsewhere)
-# memory
-float32 mem_total_mb
-float32 mem_used_mb
-float32 mem_available_mb
-float32 pagefile_used_mb
-float32 hard_page_faults_per_s  # page reads from disk (paging pressure)
-# storage of the run log
-string log_volume               # the volume holding the run logs / bags
-float32 log_volume_free_gb
-# devices and processes
-DiskStats[] disks               # one per physical disk
-NetStats[] nets                 # one per network adapter that is up (Windows does not count loopback)
-GpuStats[] gpus                 # one per NVIDIA GPU (NVML); empty without one
-ProcStats[] procs               # top N by CPU, by memory and by disk I/O, plus pinned names; deduplicated
-float32 monitor_cpu_cores       # this node's own CPU over the window (its cost, always reported)
-```
-
-### DiskStats.msg
-```
-string name                     # PhysicalDrive0 / nvme0n1 / disk0
-float32 read_mb_per_s
-float32 write_mb_per_s
-float32 reads_per_s
-float32 writes_per_s
-float32 busy_frac               # 0..1, (read + write time) / window; NaN where the OS gives none
-```
-
-### NetStats.msg
-```
-string name                     # adapter name as the OS reports it
-float32 rx_mb_per_s
-float32 tx_mb_per_s
-uint32 errors                   # receive + transmit errors and drops in the window
-```
-
-### GpuStats.msg
-```
-uint32 index
-string name
-float32 util_frac               # 0..1, GPU core
-float32 mem_util_frac           # 0..1, memory controller
-float32 mem_used_mb
-float32 mem_total_mb
-float32 encoder_util_frac       # NVENC, 0..1 (BIAS MP4 recording)
-float32 decoder_util_frac       # NVDEC, 0..1
-float32 temperature_c
-float32 power_w
-uint8 pstate                    # 0 = maximum performance … 15; 255 = unknown
-uint64 throttle_reasons         # NVML clocks-event (throttle) reason bitmask; 0 = none
-```
-
-### ProcStats.msg
-```
-uint32 pid
-string name                     # executable image name
-string group                    # pinned group label ("fictrac", "bias", "py:bridge_node", …) or "" for top-N only
-float32 cpu_cores               # mean over the window (1.0 = one core busy)
-float32 rss_mb                  # working set
-float32 io_read_mb_per_s
-float32 io_write_mb_per_s
-uint8 reasons                   # bitmask: 1 top CPU, 2 top memory, 4 top disk I/O, 8 pinned
-```
diff --git a/rig/nodes/bridge_node.py b/rig/nodes/bridge_node.py
index d2cb2586..d4b73ae6 100644
--- a/rig/nodes/bridge_node.py
+++ b/rig/nodes/bridge_node.py
@@ -31,7 +31,7 @@
     node killed mid-run therefore leaves the log intact AND documented.
   * `connector_status` lines (frames seen, adapter→bridge latency p50/p99 ms per source)
     at log close / export, so a run carries its own transport health.
-  * `/rig/host` (host_monitor.py: CPU per core, memory, disk, network, GPU, top processes) is
+  * `/rig/host` (rig_nodes.host_monitor: CPU per core, memory, disk, network, GPU, top processes) is
     recorded into the bag on arrival, so every run carries the PC's pressure alongside it.
 
 Not supported here (by design of the PoC): the `fictrac_port` config key cannot re-bind
@@ -144,7 +144,7 @@ def load_bridge_module(path: Path = BRIDGE_PY):
     "scanimage": {"cmd": SCANIMAGE_CMD_TOPIC, "reply": SCANIMAGE_REPLY_TOPIC, "status": SCANIMAGE_STATUS_TOPIC},
 }
 FRAME_TOPIC = "/arena/frame"
-# Host pressure from host_monitor.py (generic, rig-nodes material): recorded on arrival, no run-log line.
+# Host pressure from rig_nodes.host_monitor (reiserlab/rig-nodes): recorded on arrival, no run-log line.
 HOST_TOPIC = "/rig/host"
 HOST_STATS_TYPE = "rig_interfaces/msg/HostStats"
 try:  # rig-nodes ≥ 0.3.0; the monitor publishes the same type when it imports (its --typed auto)
@@ -649,7 +649,7 @@ def __init__(self, loop: asyncio.AbstractEventLoop, queue: asyncio.Queue, on_kin
         # Recorded on arrival, like /fictrac/raw: it never becomes a run-log line (the stopRecording reply
         # carries its summary), so there is no shadow line to stay in step with.
         self.create_subscription(String, BIAS_FRAMES_TOPIC, lambda b: self._record(BIAS_FRAMES_TOPIC, b), RAW_QOS, raw=True)
-        # host_monitor.py's samples (1 Hz): same QoS depth class as the monitor's (RELIABLE, KEEP_LAST 10).
+        # rig_nodes.host_monitor samples (1 Hz; the monitor publishes RELIABLE, KEEP_LAST 10).
         self.create_subscription(HostStats if HostStats is not None else String, HOST_TOPIC,
                                  lambda b: self._record(HOST_TOPIC, b), RAW_QOS, raw=True)
 
diff --git a/rig/nodes/host_monitor.py b/rig/nodes/host_monitor.py
deleted file mode 100644
index 49b00ca1..00000000
--- a/rig/nodes/host_monitor.py
+++ /dev/null
@@ -1,175 +0,0 @@
-#!/usr/bin/env python3
-"""host_monitor.py — host "pressure" of the rig PC on /rig/host, one sample per window (default 1 s).
-
-    pixi run rig                                  # starts it (opt out: --no-host-monitor)
-    pixi run python nodes/host_monitor.py         # alone, beside a running graph (from rig/)
-    pixi run python nodes/host_sampler.py 5       # five samples on the console, no ROS
-
-What a sample holds (rig_interfaces/HostStats; the request with every field:
-rig/docs/host-stats-request.md): per-core CPU as the window mean AND the busiest of 10 sub-windows
-(cycle-exact on Windows, the atlas-bench cpu_sampler.py method), P-/E-core class, how late the
-sampler woke (a PC-wide stall), context switches / interrupts / DPCs per s, memory and page file,
-hard page faults, free space on the log volume, every physical disk, every network adapter that is
-up, every NVIDIA GPU (incl. NVENC/NVDEC), and the processes that matter: the top 3 by CPU, by
-memory and by disk I/O, plus one summed row per pinned group (FicTrac, BIAS, MATLAB, the browser,
-Foxglove, the router, each graph node as py:<script>). `monitor_cpu_cores` is this node's own cost.
-
-Message type: rig_interfaces/HostStats when the installed rig_interfaces has it (rig-nodes ≥ 0.3.0,
-the `typed` environment), else std_msgs/String JSON with the same field names (NaN → null, floats
-to 3 decimals) — `--typed auto|on|off`, the same pattern as the FicTrac adapter. The arena gateway
-records /rig/host into each run's MCAP bag. Generic on purpose: this node and host_sampler.py are
-rig-nodes material (`rig_nodes.host_monitor`), prototyped here on ww18. Design, budget, measured
-cost: docs/development/rig-host-monitor.md.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import re
-import signal
-import sys
-import threading
-from pathlib import Path
-
-import rclpy
-from rclpy.node import Node
-from rclpy.qos import QoSDurabilityPolicy, QoSHistoryPolicy, QoSProfile, QoSReliabilityPolicy
-from std_msgs.msg import String
-
-HERE = Path(__file__).resolve().parent
-sys.path.insert(0, str(HERE))
-from host_sampler import DEFAULT_PINS, HostSampler, summary_line, to_json_safe  # noqa: E402
-
-TOPIC = "/rig/host"
-QOS = QoSProfile(reliability=QoSReliabilityPolicy.RELIABLE, history=QoSHistoryPolicy.KEEP_LAST, depth=10,
-                 durability=QoSDurabilityPolicy.VOLATILE)
-HOST_STATS_TYPE = "rig_interfaces/msg/HostStats"
-NESTED = {"disks": "DiskStats", "nets": "NetStats", "gpus": "GpuStats", "procs": "ProcStats"}
-
-
-def load_typed():
-    """The rig_interfaces host messages, or None when this build has no HostStats (rig-nodes < 0.3.0)."""
-    try:
-        from rig_interfaces import msg as m
-
-        return {"HostStats": m.HostStats, **{v: getattr(m, v) for v in NESTED.values()}}
-    except (ImportError, AttributeError):
-        return None
-
-
-def to_msg(sample: dict, types: dict):
-    """HostStats fields (host_sampler dict) → the typed message; one builder for every field."""
-    m = types["HostStats"]()
-    for k, v in sample.items():
-        if k in NESTED:
-            cls = types[NESTED[k]]
-            items = []
-            for d in v:
-                it = cls()
-                for kk, vv in d.items():
-                    setattr(it, kk, vv)
-                items.append(it)
-            setattr(m, k, items)
-        elif k == "core_class":
-            m.core_class = bytes(int(c) & 0xFF for c in v)
-        else:
-            setattr(m, k, v)
-    return m
-
-
-def to_json(sample: dict) -> str:
-    def r(o):
-        if isinstance(o, float):
-            return round(o, 3) if math.isfinite(o) else None
-        if isinstance(o, dict):
-            return {k: r(v) for k, v in o.items()}
-        if isinstance(o, list):
-            return [r(v) for v in o]
-        return o
-
-    return json.dumps(r(to_json_safe(sample)), separators=(",", ":"))
-
-
-def parse_pins(items: list[str]) -> list[tuple[str, str]]:
-    out = []
-    for it in items:
-        name, sep, rx = it.partition("=")
-        if not sep or not name or not rx:
-            raise SystemExit(f"--pin expects NAME=REGEX, got {it!r}")
-        re.compile(rx)
-        out.append((name, rx))
-    return out
-
-
-def main(argv: list[str] | None = None) -> int:
-    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    p.add_argument("--period", type=float, default=1.0, help="window length in s = publish period (default: 1)")
-    p.add_argument("--sub", type=int, default=10, help="CPU sub-windows per window for the peak (default: 10 → 100 ms at 1 s)")
-    p.add_argument("--top", type=int, default=3, help="processes per top list (CPU, memory, disk I/O; default: 3)")
-    p.add_argument("--pin", action="append", default=[], help="extra pinned group NAME=REGEX on the executable name (repeatable; checked first)")
-    p.add_argument("--log-dir", default=str(HERE.parent / "runlogs"), help="where run logs / bags are written: its volume's free space is reported (default: rig/runlogs)")
-    p.add_argument("--no-gpu", action="store_true", help="skip NVIDIA GPU sampling (NVML)")
-    p.add_argument("--typed", choices=("auto", "on", "off"), default="auto",
-                   help="publish rig_interfaces/HostStats (auto: when the installed rig_interfaces has it; default) or String JSON")
-    p.add_argument("--print-every", type=float, default=0.0, help="print a summary line every N s (0 = only the first sample; default)")
-    args, ros_args = p.parse_known_args(argv)
-    if args.period <= 0 or args.sub < 1:
-        p.error("--period must be > 0 and --sub ≥ 1")
-    types = load_typed() if args.typed != "off" else None
-    if args.typed == "on" and types is None:
-        raise SystemExit("--typed on, but the installed rig_interfaces has no HostStats (rig-nodes ≥ 0.3.0, `pixi install -e typed`)")
-    try:
-        log_dir = Path(args.log_dir)
-        log_dir.mkdir(parents=True, exist_ok=True)
-        sampler = HostSampler(args.period, args.sub, log_dir, args.top, parse_pins(args.pin) + DEFAULT_PINS, gpu=not args.no_gpu)
-    except RuntimeError as exc:  # no psutil
-        print(f"[host] {exc} — no host samples (the rig keeps running)", file=sys.stderr)
-        return 0
-
-    stop = threading.Event()
-    for sig in (signal.SIGINT, signal.SIGTERM):
-        signal.signal(sig, lambda *_: stop.set())
-    if hasattr(signal, "SIGBREAK"):  # rig.py / the harness stop children with CTRL_BREAK_EVENT on Windows
-        signal.signal(signal.SIGBREAK, lambda *_: stop.set())
-
-    rclpy.init(args=ros_args)
-    node = Node("rig_host_monitor")
-    pub = node.create_publisher(types["HostStats"] if types else String, TOPIC, QOS)
-    gpus = sampler.gpu.names if sampler.gpu is not None and sampler.gpu.available else []
-    print(f"[host] {TOPIC} every {args.period:g} s ({args.sub} CPU sub-windows), "
-          f"{'rig_interfaces/HostStats' if types else 'std_msgs/String JSON'}; {sampler.ncpu} logical CPUs"
-          f"{' (efficiency classes ' + ''.join(str(c) for c in sampler.core_class) + ')' if sampler.core_class else ''}, "
-          f"GPU {', '.join(gpus) or 'none'}, log volume {sampler.log_volume}", file=sys.stderr)
-    n, next_print = 0, 0.0
-    try:
-        while not stop.is_set():
-            s = sampler.window(stop=stop.is_set)
-            if stop.is_set():
-                break
-            if types:
-                pub.publish(to_msg(s, types))
-            else:
-                m = String()
-                m.data = to_json(s)
-                pub.publish(m)
-            n += 1
-            elapsed = n * args.period
-            if n == 1 or (args.print_every > 0 and elapsed >= next_print):
-                print(f"[host] {summary_line(s)}", file=sys.stderr, flush=True)
-                next_print = elapsed + args.print_every
-    except KeyboardInterrupt:
-        pass
-    finally:
-        node.destroy_node()
-        try:
-            rclpy.try_shutdown()
-        except Exception:
-            pass
-    print(f"[host] {n} samples published", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
diff --git a/rig/nodes/host_sampler.py b/rig/nodes/host_sampler.py
deleted file mode 100644
index f10ce181..00000000
--- a/rig/nodes/host_sampler.py
+++ /dev/null
@@ -1,639 +0,0 @@
-"""host_sampler.py — host "pressure" samples for the rig graph (NO ROS imports; host_monitor.py publishes them).
-
-One `HostSampler.window()` call = one window (default 1 s) and returns a dict whose keys are the
-fields of rig_interfaces/HostStats (rig/docs/host-stats-request.md), with nested lists of dicts for
-`disks` / `nets` / `gpus` / `procs`. Absent values are NaN (float) / 0 (int), as the contract says.
-
-CPU follows atlas-bench `tools/cpu_sampler.py` (the method the lab has used on ww18): on Windows,
-per-core busy = 1 − Δidle cycles / (cycle rate × Δt) from QueryIdleProcessorCycleTime every
-1/sub_samples of the window — exact, where Task Manager's tick-based numbers step at 15.6 ms — and
-each window reports the mean AND the busiest sub-window, so a 100 ms burst on one core is not
-averaged away. How late the sampler woke for a sub-window (`sampler_late_ms_max`) shows a PC-wide
-stall. Every process comes from ONE NtQuerySystemInformation(SystemProcessInformation) call per
-window (cycles, working set, I/O bytes, hard faults); a psutil scan of ~300 processes took 0.7 s on
-ww18, this takes a few ms. Python processes get their script name (`py:<stem>`) from their command
-line, read once per new pid. Elsewhere (Linux/macOS) psutil supplies the same fields, tick-based.
-
-Memory, disks, network adapters and the log volume come from psutil on every platform; NVIDIA GPUs
-from the driver's own NVML library through ctypes (no Python package). Design, budget, measured
-cost: docs/development/rig-host-monitor.md.
-"""
-
-from __future__ import annotations
-
-import ctypes
-import math
-import os
-import re
-import socket
-import struct
-import sys
-import time
-from pathlib import Path
-
-try:
-    import psutil
-except ImportError:  # pragma: no cover - psutil ships in the rig env
-    psutil = None
-
-NAN = float("nan")
-MB = 1024.0 * 1024.0
-WIN = os.name == "nt"
-
-# Pinned process groups: (label, regex on the executable image name, case-insensitive). A group's
-# processes are summed into ONE procs row (pid = its busiest process). Python processes are grouped by
-# script instead (py_group). First match wins; --pin adds groups in front.
-DEFAULT_PINS = [
-    ("router", r"^rmw_zenohd"),
-    ("foxglove_bridge", r"^foxglove_bridge"),
-    ("fictrac", r"^fictrac"),
-    ("bias", r"^(test_gui|bias)"),  # BIAS's GUI binary is test_gui.exe (atlas-bench)
-    ("matlab", r"^matlab"),
-    ("foxglove_app", r"^foxglove(\.exe)?$"),
-    ("browser", r"^(chrome|msedge|google chrome)(\.exe)?$"),
-]
-PY_EXE = re.compile(r"^python[0-9.]*w?(\.exe)?$", re.I)
-REASON_CPU, REASON_MEM, REASON_IO, REASON_PINNED = 1, 2, 4, 8
-HERE = Path(__file__).resolve().parent
-REPO = HERE.parents[1]
-
-
-def _f(v) -> float:
-    return float(v) if isinstance(v, (int, float)) and math.isfinite(v) else NAN
-
-
-def py_group(cmdline: list[str], roots: tuple[Path, ...] = (REPO,)) -> str | None:
-    """`py:<stem>` for a Python process running a script under `roots` (absolute, or relative to
-    the rig workspace) or a `rig_nodes.<module>`; None for any other Python process."""
-    args = list(cmdline[1:])
-    for i, a in enumerate(args):
-        if a == "-m" and i + 1 < len(args):
-            mod = args[i + 1]
-            return f"py:{mod.split('.')[-1]}" if mod.startswith("rig_nodes") else None
-        if a.lower().endswith(".py"):
-            p = Path(a.strip('"'))
-            for root in roots:
-                for c in ([p] if p.is_absolute() else [root / "rig" / p, root / p]):
-                    try:
-                        c.resolve().relative_to(root.resolve())
-                    except (OSError, ValueError):
-                        continue
-                    if p.is_absolute() or c.exists():  # a relative path is relative to ITS cwd: must exist here
-                        return f"py:{p.stem}"
-            return None
-        if not a.startswith("-"):
-            return None
-    return None
-
-
-# ── Windows: cycle counters + one-call process table (ported from atlas-bench cpu_sampler.py) ─────
-if WIN:
-    from ctypes import wintypes as W
-
-    _k32 = ctypes.WinDLL("kernel32", use_last_error=True)
-    _ntdll = ctypes.WinDLL("ntdll")
-    _k32.QueryIdleProcessorCycleTime.argtypes = [ctypes.POINTER(W.ULONG), ctypes.c_void_p]
-    _k32.QueryThreadCycleTime.argtypes = [W.HANDLE, ctypes.POINTER(ctypes.c_uint64)]
-    _k32.QueryProcessCycleTime.argtypes = [W.HANDLE, ctypes.POINTER(ctypes.c_uint64)]
-    _k32.GetCurrentThread.restype = W.HANDLE
-    _k32.GetCurrentProcess.restype = W.HANDLE
-    _k32.GetSystemCpuSetInformation.argtypes = [ctypes.c_void_p, W.ULONG, ctypes.POINTER(W.ULONG), W.HANDLE, W.ULONG]
-    _ntdll.NtQuerySystemInformation.argtypes = [W.ULONG, ctypes.c_void_p, W.ULONG, ctypes.POINTER(W.ULONG)]
-
-    def win_ncpu() -> int:
-        n = W.ULONG(0)
-        _k32.QueryIdleProcessorCycleTime(ctypes.byref(n), None)
-        return n.value // 8
-
-    def win_idle_cycles(n: int) -> list[int]:
-        buf = (ctypes.c_uint64 * n)()
-        size = W.ULONG(8 * n)
-        _k32.QueryIdleProcessorCycleTime(ctypes.byref(size), buf)
-        return list(buf)
-
-    def _thread_cycles() -> int:
-        c = ctypes.c_uint64()
-        _k32.QueryThreadCycleTime(_k32.GetCurrentThread(), ctypes.byref(c))
-        return c.value
-
-    def win_self_cycles() -> int:
-        c = ctypes.c_uint64()
-        _k32.QueryProcessCycleTime(_k32.GetCurrentProcess(), ctypes.byref(c))
-        return c.value
-
-    def win_calibrate_hz(rounds: int = 3, spin_s: float = 0.1) -> float:
-        """Cycle-counter rate: spin this thread and compare its cycles with wall time (best of N)."""
-        best = 0.0
-        for _ in range(rounds):
-            c0, t0 = _thread_cycles(), time.perf_counter()
-            while time.perf_counter() - t0 < spin_s:
-                pass
-            c1, t1 = _thread_cycles(), time.perf_counter()
-            best = max(best, (c1 - c0) / (t1 - t0))
-        return best
-
-    def win_core_classes(n: int) -> list[int]:
-        """EfficiencyClass per logical processor (higher = faster core); [] when unknown."""
-        need = W.ULONG(0)
-        _k32.GetSystemCpuSetInformation(None, 0, ctypes.byref(need), None, 0)
-        if need.value == 0:
-            return []
-        buf = ctypes.create_string_buffer(need.value)
-        if not _k32.GetSystemCpuSetInformation(buf, need, ctypes.byref(need), None, 0):
-            return []
-        raw, off, out = buf.raw, 0, {}
-        while off < need.value:
-            size = int.from_bytes(raw[off:off + 4], "little")
-            if size == 0:
-                break
-            out[raw[off + 14]] = raw[off + 18]  # LogicalProcessorIndex, EfficiencyClass
-            off += size
-        return [out.get(i, 0) for i in range(n)]
-
-    _spi = [ctypes.create_string_buffer(1 << 20)]
-    # x64 SYSTEM_PROCESS_INFORMATION: NextEntryOffset @0, HardFaultCount @16, CycleTime @24,
-    # ImageName.Length @56 / .Buffer @64, UniqueProcessId @80, WorkingSetSize @144,
-    # ReadTransferCount @232, WriteTransferCount @240 (cpu_sampler.py reads the same cycles/name/pid).
-    _SPI = struct.Struct("<I12xI4xQ24xH6xQ8xQ56xQ80xQQ")
-    _NAMES: dict[tuple, str] = {}  # (pid, UTF-16 bytes) → decoded image name
-
-    def _ntquery(cls: int, holder: list) -> ctypes.Array | None:
-        need = W.ULONG(0)
-        while True:
-            buf = holder[0]
-            st = _ntdll.NtQuerySystemInformation(cls, buf, len(buf), ctypes.byref(need)) & 0xFFFFFFFF
-            if st == 0xC0000004:  # STATUS_INFO_LENGTH_MISMATCH
-                holder[0] = ctypes.create_string_buffer(max(need.value, len(buf)) * 2)
-                continue
-            return buf if st == 0 else None
-
-    def win_processes() -> dict[int, tuple]:
-        """{pid: (image name, cycles, working set B, read B, write B, hard faults)} for every
-        process, from one NtQuerySystemInformation(SystemProcessInformation) call."""
-        buf = _ntquery(5, _spi)
-        if buf is None:
-            return {}
-        mv = memoryview(buf).cast("B")  # no copy of the (~1 MB) buffer
-        base = ctypes.addressof(buf)
-        unpack = _SPI.unpack_from
-        out, off, n = {}, 0, len(mv)
-        while True:
-            nxt, hard, cyc, nlen, nptr, pid, ws, rd, wr = unpack(mv, off)
-            if nptr and nlen:
-                # the strings live inside this buffer: decode from it, not through a pointer read
-                rel = nptr - base
-                key = (pid, bytes(mv[rel:rel + nlen])) if 0 <= rel < n else None
-                name = _NAMES.get(key) if key else None
-                if name is None:
-                    name = key[1].decode("utf-16-le", "replace") if key else ctypes.wstring_at(nptr, nlen // 2)
-                    if key:
-                        if len(_NAMES) > 4096:
-                            _NAMES.clear()
-                        _NAMES[key] = name
-            else:
-                name = "Idle"
-            out[pid] = (name, cyc, ws, rd, wr, hard)
-            if nxt == 0 or off + nxt >= n:
-                return out
-            off += nxt
-
-    _sii = [ctypes.create_string_buffer(64 * 24)]
-
-    def win_dpc_count() -> int | None:
-        """Σ DpcCount over CPUs (SystemInterruptInformation: 24 B per CPU, DpcCount @4)."""
-        buf = _ntquery(23, _sii)
-        if buf is None:
-            return None
-        raw = buf.raw
-        return sum(struct.unpack_from("<I", raw, o + 4)[0] for o in range(0, len(raw) - 23, 24))
-
-    # Network adapters: GetIfEntry2 per adapter (µs) instead of psutil's GetAdaptersAddresses
-    # walk on every read (5.3 ms on ww18). The adapter list (hardware, up, not loopback) comes from
-    # GetIfTable2, refreshed every 10 s. MIB_IF_ROW2 (1352 B): InterfaceIndex @8, Alias @28,
-    # Type @1128, InterfaceAndOperStatusFlags @1152 (bit 0 HardwareInterface), OperStatus @1156,
-    # InOctets @1208, InDiscards @1232, InErrors @1240, OutOctets @1280, OutDiscards @1304, OutErrors @1312.
-    _iphlp = ctypes.WinDLL("iphlpapi")
-    _iphlp.GetIfTable2.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
-    _iphlp.FreeMibTable.argtypes = [ctypes.c_void_p]
-    _iphlp.GetIfEntry2.argtypes = [ctypes.c_void_p]
-    ROW2 = 1352
-    _IF_CTR = struct.Struct("<Q16xQQ32xQ16xQQ")  # from @1208: InOctets, InDiscards, InErrors, OutOctets, OutDiscards, OutErrors
-
-    def win_adapters() -> list[tuple[int, str]]:
-        tbl = ctypes.c_void_p()
-        if _iphlp.GetIfTable2(ctypes.byref(tbl)) != 0 or not tbl.value:
-            return []
-        try:
-            n = ctypes.c_ulong.from_address(tbl.value).value
-            raw = ctypes.string_at(tbl.value + 8, n * ROW2)
-        finally:
-            _iphlp.FreeMibTable(tbl)
-        out = []
-        for k in range(n):
-            o = k * ROW2
-            idx, = struct.unpack_from("<I", raw, o + 8)
-            typ, = struct.unpack_from("<I", raw, o + 1128)
-            hw = raw[o + 1152] & 1
-            oper, = struct.unpack_from("<I", raw, o + 1156)
-            if hw and oper == 1 and typ != 24:  # IfOperStatusUp, not IF_TYPE_SOFTWARE_LOOPBACK
-                alias = raw[o + 28:o + 28 + 514].decode("utf-16-le", "replace").split("\x00", 1)[0]
-                out.append((idx, alias))
-        return out
-
-    _row = ctypes.create_string_buffer(ROW2)
-
-    def win_adapter_counters(idx: int) -> tuple | None:
-        ctypes.memset(_row, 0, ROW2)
-        struct.pack_into("<I", _row, 8, idx)
-        if _iphlp.GetIfEntry2(_row) != 0:
-            return None
-        return _IF_CTR.unpack_from(_row.raw, 1208)
-
-
-# ── NVIDIA GPUs through the driver's NVML (ctypes; no Python package) ──────────────────────────────
-class _Util(ctypes.Structure):
-    _fields_ = [("gpu", ctypes.c_uint), ("memory", ctypes.c_uint)]
-
-
-class _Mem(ctypes.Structure):
-    _fields_ = [("total", ctypes.c_ulonglong), ("free", ctypes.c_ulonglong), ("used", ctypes.c_ulonglong)]
-
-
-class Nvml:
-    """The few NVML calls HostStats needs. `available` is False without an NVIDIA driver."""
-
-    def __init__(self) -> None:
-        self.lib = None
-        self.handles: list = []
-        self.names: list[str] = []
-        try:
-            if WIN:
-                path = os.path.join(os.environ.get("SystemRoot", r"C:\Windows"), "System32", "nvml.dll")
-                self.lib = ctypes.CDLL(path)
-            else:
-                self.lib = ctypes.CDLL("libnvidia-ml.so.1")
-        except OSError:
-            self.lib = None
-            return
-        try:
-            if self.lib.nvmlInit_v2() != 0:
-                self.lib = None
-                return
-            n = ctypes.c_uint(0)
-            self.lib.nvmlDeviceGetCount_v2(ctypes.byref(n))
-            for i in range(n.value):
-                h = ctypes.c_void_p()
-                if self.lib.nvmlDeviceGetHandleByIndex_v2(i, ctypes.byref(h)) == 0:
-                    name = ctypes.create_string_buffer(96)
-                    self.lib.nvmlDeviceGetName(h, name, 96)
-                    self.handles.append(h)
-                    self.names.append(name.value.decode(errors="replace"))
-        except AttributeError:
-            self.lib = None
-            self.handles = []
-
-    @property
-    def available(self) -> bool:
-        return self.lib is not None and bool(self.handles)
-
-    def sample(self) -> list[dict]:
-        out = []
-        for i, h in enumerate(self.handles):
-            g = {"index": i, "name": self.names[i], "util_frac": NAN, "mem_util_frac": NAN, "mem_used_mb": NAN,
-                 "mem_total_mb": NAN, "encoder_util_frac": NAN, "decoder_util_frac": NAN, "temperature_c": NAN,
-                 "power_w": NAN, "pstate": 255, "throttle_reasons": 0}
-            u, m = _Util(), _Mem()
-            if self.lib.nvmlDeviceGetUtilizationRates(h, ctypes.byref(u)) == 0:
-                g["util_frac"], g["mem_util_frac"] = u.gpu / 100.0, u.memory / 100.0
-            if self.lib.nvmlDeviceGetMemoryInfo(h, ctypes.byref(m)) == 0:
-                g["mem_used_mb"], g["mem_total_mb"] = m.used / MB, m.total / MB
-            v, period = ctypes.c_uint(0), ctypes.c_uint(0)
-            if self.lib.nvmlDeviceGetEncoderUtilization(h, ctypes.byref(v), ctypes.byref(period)) == 0:
-                g["encoder_util_frac"] = v.value / 100.0
-            if self.lib.nvmlDeviceGetDecoderUtilization(h, ctypes.byref(v), ctypes.byref(period)) == 0:
-                g["decoder_util_frac"] = v.value / 100.0
-            if self.lib.nvmlDeviceGetTemperature(h, 0, ctypes.byref(v)) == 0:  # NVML_TEMPERATURE_GPU
-                g["temperature_c"] = float(v.value)
-            if self.lib.nvmlDeviceGetPowerUsage(h, ctypes.byref(v)) == 0:
-                g["power_w"] = v.value / 1000.0
-            ps = ctypes.c_int(0)
-            if self.lib.nvmlDeviceGetPerformanceState(h, ctypes.byref(ps)) == 0 and 0 <= ps.value <= 15:
-                g["pstate"] = ps.value
-            r = ctypes.c_ulonglong(0)
-            if self.lib.nvmlDeviceGetCurrentClocksThrottleReasons(h, ctypes.byref(r)) == 0:
-                g["throttle_reasons"] = int(r.value)
-            out.append(g)
-        return out
-
-
-class HostSampler:
-    def __init__(self, window_s: float = 1.0, sub_samples: int = 10, log_volume: str | os.PathLike = ".",
-                 top_n: int = 3, pins: list[tuple[str, str]] | None = None, gpu: bool = True) -> None:
-        if psutil is None:
-            raise RuntimeError("psutil is not installed")
-        self.window_s = float(window_s)
-        self.sub_samples = max(1, int(sub_samples))
-        self.log_volume = str(Path(log_volume).resolve().anchor or log_volume) if WIN else str(log_volume)
-        self._log_path = str(log_volume)
-        self.top_n = int(top_n)
-        self.pins = [(n, re.compile(rx, re.I)) for n, rx in (pins if pins is not None else DEFAULT_PINS)]
-        self.hostname = socket.gethostname()
-        self.gpu = Nvml() if gpu else None
-        self._groups: dict[int, tuple] = {}  # pid → (image name, group label or None), cached per pid
-        if WIN:
-            self.ncpu = win_ncpu()
-            self.hz = win_calibrate_hz()
-            self.core_class = win_core_classes(self.ncpu)
-            self._idle = win_idle_cycles(self.ncpu)
-            self._procs = win_processes()
-            self._self_cyc = win_self_cycles()
-        else:
-            self.ncpu = psutil.cpu_count() or 1
-            self.hz = None
-            self.core_class = []
-            psutil.cpu_percent(None, percpu=True)
-            self._procs = {}
-            self._psproc: dict[int, "psutil.Process"] = {}
-            self._self = psutil.Process()
-            self._self_cpu = sum(self._self.cpu_times()[:2])
-        self._t_procs = time.perf_counter()
-        self._cpu_stats = psutil.cpu_stats()
-        self._dpc = win_dpc_count() if WIN else None
-        self._disk = psutil.disk_io_counters(perdisk=True) or {}
-        self._net = {} if WIN else (psutil.net_io_counters(pernic=True) or {})
-        self._net_up: set[str] = set()
-        self._net_up_t = 0.0
-        self._t = time.perf_counter()
-
-    # ── CPU sub-windows ─────────────────────────────────────────────────────────────────────
-    def _core_busy(self, dt_s: float) -> list[float]:
-        if WIN:
-            idle = win_idle_cycles(self.ncpu)
-            busy = [max(0.0, min(1.0, 1.0 - (i1 - i0) / (self.hz * dt_s))) for i0, i1 in zip(self._idle, idle)]
-            self._idle = idle
-            return busy
-        return [p / 100.0 for p in psutil.cpu_percent(None, percpu=True)]
-
-    def window(self, stop=None) -> dict:
-        """Sample for one window (blocks for window_s) and return the HostStats fields."""
-        sub = self.window_s / self.sub_samples
-        mean = [0.0] * self.ncpu
-        peak = [0.0] * self.ncpu
-        tot_sum, tot_peak, late_max = 0.0, 0.0, 0.0
-        t_prev = time.perf_counter()
-        target = t_prev + sub
-        n = 0
-        for _ in range(self.sub_samples):
-            wait = target - time.perf_counter()
-            if wait > 0:
-                time.sleep(wait)
-            now = time.perf_counter()
-            if wait > 0:
-                late_max = max(late_max, (now - target) * 1000.0)
-            target = now + sub  # no catch-up: every sub-window is >= sub (cpu_sampler's rule)
-            busy = self._core_busy(now - t_prev)
-            t_prev = now
-            n += 1
-            s = sum(busy)
-            tot_sum += s
-            tot_peak = max(tot_peak, s)
-            for i, b in enumerate(busy[: self.ncpu]):
-                mean[i] += b
-                if b > peak[i]:
-                    peak[i] = b
-            if stop is not None and stop():
-                break
-        mean = [m / n for m in mean]
-        rest = self._rest()
-        return {"t_ms": int(time.time() * 1000), "window_s": round(self.window_s, 3), "sub_samples": n,
-                "hostname": self.hostname,
-                "cpu_busy_cores_mean": tot_sum / n, "cpu_busy_cores_peak": tot_peak,
-                "core_busy_mean": mean, "core_busy_peak": peak, "core_class": list(self.core_class),
-                "sampler_late_ms_max": late_max, **rest}
-
-    # ── everything else, once per window ─────────────────────────────────────────────────────
-    def _rest(self) -> dict:
-        now = time.perf_counter()
-        dt = max(1e-3, now - self._t)
-        self._t = now
-        cs = psutil.cpu_stats()
-        p = self._cpu_stats
-        self._cpu_stats = cs
-        if WIN:  # psutil reports soft_interrupts = 0 on Windows; the kernel's per-CPU DpcCount instead
-            dpc, prev_dpc = win_dpc_count(), self._dpc
-            dpcs = (dpc - prev_dpc) / dt if dpc is not None and prev_dpc is not None else NAN
-            self._dpc = dpc
-        else:
-            dpcs = (cs.soft_interrupts - p.soft_interrupts) / dt
-        vm = psutil.virtual_memory()
-        sw = psutil.swap_memory()
-        try:
-            free_gb = psutil.disk_usage(self._log_path).free / (1024.0 ** 3)
-        except OSError:
-            free_gb = NAN
-        procs, hard_faults, self_cores = self._processes()
-        return {"context_switches_per_s": (cs.ctx_switches - p.ctx_switches) / dt,
-                "interrupts_per_s": (cs.interrupts - p.interrupts) / dt,
-                "dpcs_per_s": dpcs,
-                "mem_total_mb": vm.total / MB, "mem_used_mb": (vm.total - vm.available) / MB,
-                "mem_available_mb": vm.available / MB, "pagefile_used_mb": sw.used / MB,
-                "hard_page_faults_per_s": hard_faults / dt if hard_faults is not None else NAN,
-                "log_volume": self.log_volume, "log_volume_free_gb": free_gb,
-                "disks": self._disks(dt), "nets": self._nets(dt),
-                "gpus": self.gpu.sample() if self.gpu is not None and self.gpu.available else [],
-                "procs": procs, "monitor_cpu_cores": self_cores}
-
-    def _disks(self, dt: float) -> list[dict]:
-        cur = psutil.disk_io_counters(perdisk=True) or {}
-        prev, self._disk = self._disk, cur
-        out = []
-        for name, c in sorted(cur.items()):
-            q = prev.get(name)
-            if q is None:
-                continue
-            if hasattr(c, "busy_time"):  # Linux
-                busy = (c.busy_time - q.busy_time) / (dt * 1000.0)
-            else:  # Windows/macOS: read + write time, ms; > 1 with queued I/O → clamped
-                busy = ((c.read_time - q.read_time) + (c.write_time - q.write_time)) / (dt * 1000.0)
-            out.append({"name": name, "read_mb_per_s": (c.read_bytes - q.read_bytes) / MB / dt,
-                        "write_mb_per_s": (c.write_bytes - q.write_bytes) / MB / dt,
-                        "reads_per_s": (c.read_count - q.read_count) / dt, "writes_per_s": (c.write_count - q.write_count) / dt,
-                        "busy_frac": max(0.0, min(1.0, busy))})
-        return out
-
-    def _nets(self, dt: float) -> list[dict]:
-        if WIN:
-            return self._nets_win(dt)
-        now = time.perf_counter()
-        if now - self._net_up_t > 10.0:  # adapter up/down list: every 10 s, not every window
-            self._net_up_t = now
-            try:
-                self._net_up = {k for k, v in psutil.net_if_stats().items() if v.isup}
-            except OSError:
-                self._net_up = set()
-        cur = psutil.net_io_counters(pernic=True) or {}
-        prev, self._net = self._net, cur
-        out = []
-        for name, c in sorted(cur.items()):
-            q = prev.get(name)
-            if q is None or (self._net_up and name not in self._net_up) or "loopback" in name.lower() or re.match(r"^lo\d*$", name):
-                continue
-            err = (c.errin + c.errout + c.dropin + c.dropout) - (q.errin + q.errout + q.dropin + q.dropout)
-            out.append({"name": name, "rx_mb_per_s": (c.bytes_recv - q.bytes_recv) / MB / dt,
-                        "tx_mb_per_s": (c.bytes_sent - q.bytes_sent) / MB / dt, "errors": max(0, int(err))})
-        return out
-
-    def _nets_win(self, dt: float) -> list[dict]:
-        now = time.perf_counter()
-        if now - self._net_up_t > 10.0 or not hasattr(self, "_adapters"):
-            self._net_up_t = now
-            self._adapters = win_adapters()
-        out = []
-        for idx, name in self._adapters:
-            c = win_adapter_counters(idx)
-            q = self._net.get(idx)
-            self._net[idx] = c
-            if c is None or q is None:
-                continue
-            err = (c[1] + c[2] + c[4] + c[5]) - (q[1] + q[2] + q[4] + q[5])
-            out.append({"name": name, "rx_mb_per_s": max(0, c[0] - q[0]) / MB / dt,
-                        "tx_mb_per_s": max(0, c[3] - q[3]) / MB / dt, "errors": max(0, int(err))})
-        return out
-
-    # ── processes ───────────────────────────────────────────────────────────────────────────
-    def classify(self, pid: int, name: str) -> str | None:
-        hit = self._groups.get(pid)
-        if hit is not None and hit[0] == name:  # cached per pid; a reused pid has another image name
-            return hit[1]
-        g = None
-        if PY_EXE.match(name or ""):
-            try:
-                g = py_group(psutil.Process(pid).cmdline())
-            except Exception:  # AccessDenied / gone
-                g = None
-        else:
-            for label, rx in self.pins:
-                if rx.search(name or ""):
-                    g = label
-                    break
-        self._groups[pid] = (name, g)
-        return g
-
-    def _processes(self) -> tuple[list[dict], float | None, float]:
-        """procs rows (top N by CPU, memory, disk I/O + one row per pinned group), the system's hard
-        faults in the window (Σ per process; Windows), and this monitor's own cores."""
-        now = time.perf_counter()
-        dt = max(1e-3, now - self._t_procs)
-        self._t_procs = now
-        me = os.getpid()
-        rows = []  # (pid, name, cpu cores, rss MB, read MB/s, write MB/s)
-        hard = None
-        if WIN:
-            cur = win_processes()
-            prev, self._procs = self._procs, cur
-            hard = 0
-            for pid, (name, cyc, ws, rd, wr, hf) in cur.items():
-                q = prev.get(pid)
-                if pid == 0 or q is None or q[0] != name:
-                    continue
-                hard += max(0, hf - q[5])
-                rows.append((pid, name, max(0.0, (cyc - q[1]) / (self.hz * dt)), ws / MB,
-                             max(0, rd - q[3]) / MB / dt, max(0, wr - q[4]) / MB / dt))
-            c = win_self_cycles()
-            self_cores = (c - self._self_cyc) / (self.hz * dt)
-            self._self_cyc = c
-        else:
-            seen = set()
-            for p in psutil.process_iter(["name"]):
-                seen.add(p.pid)
-                q = self._psproc.setdefault(p.pid, p)
-                try:
-                    with q.oneshot():
-                        cpu = q.cpu_percent(None) / 100.0
-                        rss = q.memory_info().rss / MB
-                except Exception:
-                    continue
-                rows.append((p.pid, p.info.get("name") or "", cpu, rss, NAN, NAN))
-            for pid in list(self._psproc):
-                if pid not in seen:
-                    self._psproc.pop(pid, None)
-            t = sum(self._self.cpu_times()[:2])
-            self_cores = (t - self._self_cpu) / dt
-            self._self_cpu = t
-        live = {r[0] for r in rows}
-        for pid in [p for p in self._groups if p not in live]:
-            self._groups.pop(pid, None)
-        return self._select(rows, me), hard, max(0.0, self_cores)
-
-    def _select(self, rows: list[tuple], me: int) -> list[dict]:
-        out: dict = {}
-
-        def row(pid, name, group, cpu, rss, rd, wr, reason):
-            key = ("g", group) if group else ("p", pid)
-            r = out.get(key)
-            if r is None:
-                out[key] = {"pid": pid, "name": name, "group": group or "", "cpu_cores": cpu, "rss_mb": rss,
-                            "io_read_mb_per_s": rd, "io_write_mb_per_s": wr, "reasons": reason}
-            else:
-                r["reasons"] |= reason
-
-        groups: dict[str, list] = {}
-        for r in rows:
-            g = "py:host_monitor" if r[0] == me else self.classify(r[0], r[1])
-            if g:
-                groups.setdefault(g, []).append(r)
-        for g, rs in groups.items():
-            busiest = max(rs, key=lambda r: r[2])
-            row(busiest[0], busiest[1], g, sum(r[2] for r in rs), sum(r[3] for r in rs),
-                _nansum(r[4] for r in rs), _nansum(r[5] for r in rs), REASON_PINNED)
-        pid_group = {r[0]: g for g, rs in groups.items() if len(rs) == 1 for r in rs}
-        for reason, key in ((REASON_CPU, lambda r: r[2]), (REASON_MEM, lambda r: r[3]),
-                            (REASON_IO, lambda r: (r[4] if math.isfinite(r[4]) else 0) + (r[5] if math.isfinite(r[5]) else 0))):
-            for r in sorted(rows, key=key, reverse=True)[: self.top_n]:
-                if reason == REASON_IO and key(r) <= 0:
-                    continue
-                g = pid_group.get(r[0])
-                if g:  # a one-process pinned group: the group row IS this process
-                    out[("g", g)]["reasons"] |= reason
-                else:
-                    row(r[0], r[1], "", r[2], r[3], r[4], r[5], reason)
-        return sorted(out.values(), key=lambda d: -d["cpu_cores"])
-
-
-def _nansum(vals) -> float:
-    vals = [v for v in vals if math.isfinite(v)]
-    return sum(vals) if vals else NAN
-
-
-def to_json_safe(obj):
-    """NaN → None, recursively (the String-JSON form must stay strict JSON)."""
-    if isinstance(obj, float):
-        return None if not math.isfinite(obj) else obj
-    if isinstance(obj, dict):
-        return {k: to_json_safe(v) for k, v in obj.items()}
-    if isinstance(obj, list):
-        return [to_json_safe(v) for v in obj]
-    return obj
-
-
-def summary_line(s: dict) -> str:
-    """One console line for a sample: the pressure at a glance."""
-    top = ", ".join(f"{p['group'] or p['name']} {p['cpu_cores']:.2f}" for p in s["procs"][:3])
-    gpu = s["gpus"][0] if s["gpus"] else None
-    disk = sum(d["read_mb_per_s"] + d["write_mb_per_s"] for d in s["disks"])
-    net = sum(n["rx_mb_per_s"] + n["tx_mb_per_s"] for n in s["nets"])
-    return (f"CPU {s['cpu_busy_cores_mean']:.2f} cores (peak {s['cpu_busy_cores_peak']:.2f}, busiest core "
-            f"{max(s['core_busy_peak'] or [0]) * 100:.0f} %), late {s['sampler_late_ms_max']:.1f} ms · RAM "
-            f"{s['mem_used_mb'] / 1024:.1f}/{s['mem_total_mb'] / 1024:.0f} GB · disk {disk:.1f} MB/s · net {net:.2f} MB/s"
-            + (f" · GPU {gpu['util_frac'] * 100:.0f} % enc {gpu['encoder_util_frac'] * 100:.0f} %" if gpu else "")
-            + f" · top {top} · monitor {s['monitor_cpu_cores'] * 100:.2f} % of a core")
-
-
-if __name__ == "__main__":  # quick look: python host_sampler.py [n]
-    import json
-
-    hs = HostSampler()
-    for _ in range(int(sys.argv[1]) if len(sys.argv) > 1 else 3):
-        s = hs.window()
-        print(summary_line(s))
-    print(json.dumps(to_json_safe(s), indent=1)[:4000])
diff --git a/rig/nodes/rig.py b/rig/nodes/rig.py
index d1883ef0..3f271add 100644
--- a/rig/nodes/rig.py
+++ b/rig/nodes/rig.py
@@ -19,6 +19,7 @@
 from __future__ import annotations
 
 import argparse
+import importlib.util
 import os
 import shlex
 import shutil
@@ -40,6 +41,15 @@
 _ENVS = Path(os.environ["CONDA_PREFIX"]).parent if os.environ.get("CONDA_PREFIX") else ROOT / ".pixi" / "envs"
 VIZ_ENV = _ENVS / "viz"
 FOXGLOVE_PORT = 8766
+HOST_MONITOR_MODULE = "rig_nodes.host_monitor"
+
+
+def host_monitor_available() -> bool:
+    """True when the installed rig_nodes package ships the host monitor."""
+    try:
+        return importlib.util.find_spec(HOST_MONITOR_MODULE) is not None
+    except ImportError:  # no rig_nodes package at all
+        return False
 
 
 sys.path.insert(0, str(HERE))
@@ -144,8 +154,8 @@ def main(argv: list[str] | None = None) -> int:
     p.add_argument("--viz-args", default="", help="extra args for viz_node.py (--deg-per-frame, --frame-dir, --feature-az0, --frames)")
     p.add_argument("--foxglove", action="store_true",
                    help=f"also run foxglove_bridge on ws://127.0.0.1:{FOXGLOVE_PORT} (the `viz` environment; skipped with a note when it is not installed)")
-    p.add_argument("--no-host-monitor", action="store_true", help="do not run host_monitor.py (the PC's CPU per core, memory, disk, network, GPU, top processes on /rig/host, recorded in every run's bag)")
-    p.add_argument("--host-monitor-args", default="", help="extra args for host_monitor.py (e.g. --period 0.5 --print-every 30 --pin bias=^BIAS)")
+    p.add_argument("--no-host-monitor", action="store_true", help=f"do not run {HOST_MONITOR_MODULE} (the PC's CPU per core, memory, disk, network, GPU, top processes on /rig/host, recorded in every run's bag)")
+    p.add_argument("--host-monitor-args", default="", help=f"extra args for {HOST_MONITOR_MODULE} (e.g. --period 0.5 --print-every 30)")
     p.add_argument("--no-router", action="store_true", help="a Zenoh router is already running on this host")
     p.add_argument("--bridge-args", default="", help="extra args for bridge_node.py")
     p.add_argument("--fictrac-args", default="", help="extra args for fictrac_udp_adapter.py")
@@ -210,8 +220,14 @@ def main(argv: list[str] | None = None) -> int:
     if args.scanimage:
         nodes.append(Child("scanimage", [py, str(NODES / "scanimage_node.py"), *split_args(args.scanimage_args)]))
     if not args.no_host_monitor:
-        # Before the bridge, so a run opened right away already has host samples in its bag.
-        nodes.append(Child("host", [py, str(NODES / "host_monitor.py"), *split_args(args.host_monitor_args)]))
+        # The generic host monitor ships in the rig_nodes package (reiserlab/rig-nodes); started
+        # before the bridge, so a run opened right away already has host samples in its bag.
+        # `--py-root` lets it name this workspace's Python nodes `py:<script>`.
+        if host_monitor_available():
+            nodes.append(Child("host", [py, "-m", HOST_MONITOR_MODULE, "--log-dir", str(ROOT / "runlogs"),
+                                        "--py-root", str(ROOT), *split_args(args.host_monitor_args)]))
+        else:
+            print(f"[rig] host monitor: the installed rig_nodes has no {HOST_MONITOR_MODULE} (needs a rig-nodes release with it); starting without it", file=sys.stderr)
     bridge = Child("bridge", [py, str(NODES / "bridge_node.py"), *split_args(args.bridge_args)])
     nodes.append(bridge)
     if foxglove:
diff --git a/rig/tests/test_ros2_poc.py b/rig/tests/test_ros2_poc.py
index e8468269..a04d8db8 100644
--- a/rig/tests/test_ros2_poc.py
+++ b/rig/tests/test_ros2_poc.py
@@ -50,9 +50,11 @@
                                                         NDJSON — reported, crashsafe profile gated;
                                                         then a RESTARTED node's log_export recovers the
                                                         bag on its own (recovered:true, whole bag left)
-  host monitor (2026-10-28)                            /rig/host in the bag ≥ 0.8 Hz, fields = the
-                                                        HostStats spec, the graph's nodes pinned; its own
-                                                        CPU ≤ 2 % of a core, ≤ 5 % of the compressed bag
+  host monitor (2026-10-28; rig_nodes.host_monitor)   /rig/host in the bag ≥ 0.8 Hz, fields = the installed
+                                                        HostStats (typed) / the read fields (JSON), the graph's
+                                                        nodes pinned; its own CPU ≤ 2 % of a core, ≤ 5 % of the
+                                                        compressed bag — skipped (info) when the installed
+                                                        rig_nodes has no host monitor
 
 Exit 0 when all checks pass. Prints a markdown summary. Artifacts are kept with --keep.
 """
@@ -248,7 +250,6 @@ def bag_summary(bag: Path) -> dict:
 def host_monitor_values(bag: Path) -> dict:
     """/rig/host in the bag: sample count over the run, field names vs the request's HostStats.msg,
     per-core sanity, pinned groups, the monitor's own CPU, and its share of the compressed payload."""
-    import re
     import statistics
 
     import zstandard
@@ -256,9 +257,13 @@ def host_monitor_values(bag: Path) -> dict:
     sys.path.insert(0, str(NODES))
     from mcap_convert import _json_of, decode_cdr, read_records  # noqa: E402
 
-    spec = (POC / "docs" / "host-stats-request.md").read_text(encoding="utf-8")
-    body = re.search(r"### HostStats\.msg\s*```\n(.*?)```", spec, re.S).group(1)
-    want = sorted(ln.split("#", 1)[0].split()[1] for ln in body.splitlines() if ln.split("#", 1)[0].strip())
+    try:  # the field contract is rig-nodes' (rig_interfaces/HostStats); without the typed build the
+        # JSON samples are checked for the fields this harness reads
+        from rig_interfaces.msg import HostStats
+
+        want = sorted(HostStats.get_fields_and_field_types())
+    except (ImportError, AttributeError):
+        want = None
     host, other, t_ns, objs = [], [], [], []
     gen = read_records(bag)
     try:
@@ -276,7 +281,8 @@ def host_monitor_values(bag: Path) -> dict:
     except StopIteration:
         pass
     good = [o for o in objs if isinstance(o, dict)]
-    bad = sorted({k for o in good for k in set(o) ^ set(want)})
+    need = {"core_busy_mean", "core_busy_peak", "monitor_cpu_cores", "procs"}
+    bad = sorted({k for o in good for k in (set(o) ^ set(want) if want else need - set(o))})
     cores_ok = bool(good) and all(len(o["core_busy_mean"]) == len(o["core_busy_peak"]) == (os.cpu_count() or 0)
                                   and all(p + 1e-6 >= m for m, p in zip(o["core_busy_mean"], o["core_busy_peak"])) for o in good)
     self_cpu = [o["monitor_cpu_cores"] for o in good[2:] if isinstance(o.get("monitor_cpu_cores"), (int, float))]
@@ -456,7 +462,13 @@ def start(name: str, argv: list[str]) -> Proc:
         si_port = free_tcp_port()
         start("si-mock", [PY, str(HERE / "si_json_mock.py"), "--port", str(si_port), "--grab-s", "1.0", "--start-delay-s", "0.2", "--stall-on", "hSI.hRoiManager.scanZoomFactor"])
         start("scanimage-node", [PY, str(NODES / "scanimage_node.py"), "--port", str(si_port), "--status-every", "1", "--timeout-s", "1.5"])
-        start("host-monitor", [PY, str(NODES / "host_monitor.py"), "--log-dir", str(runlogs)])
+        from rig import HOST_MONITOR_MODULE, host_monitor_available  # noqa: E402
+
+        host_mon = host_monitor_available()
+        if host_mon:  # the command line rig.py uses
+            start("host-monitor", [PY, "-m", HOST_MONITOR_MODULE, "--log-dir", str(runlogs), "--py-root", str(POC)])
+        else:
+            print(f"  info  host monitor: the installed rig_nodes has no {HOST_MONITOR_MODULE} — its checks are skipped", file=sys.stderr)
         bridge_argv = [PY, str(NODES / "bridge_node.py"), "--log-dir", str(runlogs), "--source-timeout", "1.5", "--bag-profile", a.bag_profile]
         bridge = start("bridge-node", bridge_argv)
         check("bridge node serving ws://127.0.0.1:8765", wait_port("127.0.0.1", 8765, 20.0))
@@ -770,21 +782,22 @@ def side_actor() -> None:
         if typed:
             check("size: /arena/frame records in the final layout (chunk-only index, zstd 19) ≤ 72 B/frame compressed", bool(sz) and (sz.get("bytes_per_frame") or 999) <= 72.0, json.dumps(sz))
 
-        # ── host monitor (/rig/host; docs/development/rig-host-monitor.md) ───────────────
-        hm = host_monitor_values(main_bag) if main_bag else {}
-        print(f"  info  host monitor: {json.dumps({k: v for k, v in hm.items() if k not in ('fields_ok', 'groups')})}", file=sys.stderr)
-        check("host monitor: /rig/host recorded in the bag, ≥ 0.8 samples per second of the run",
-              (hm.get("samples") or 0) >= 0.8 * (hm.get("run_s") or 99), f"{hm.get('samples')} samples over {hm.get('run_s')} s")
-        check("host monitor: every sample has exactly the HostStats fields of rig/docs/host-stats-request.md (String JSON: same names)",
-              hm.get("fields_ok", False), str(hm.get("bad_fields")))
-        check("host monitor: one entry per logical CPU, busiest sub-window ≥ the window mean on every core",
-              hm.get("cores_ok", False), f"{hm.get('ncpu')} CPUs")
-        check("host monitor: the graph's processes pinned by script (py:bridge_node, py:fictrac_udp_adapter, py:host_monitor)",
-              {"py:bridge_node", "py:fictrac_udp_adapter", "py:host_monitor"} <= set(hm.get("groups") or []), str(hm.get("groups")))
-        check("host monitor cost: its own CPU ≤ 2 % of one core (median after the first 2 samples)",
-              hm.get("self_cpu_median") is not None and hm["self_cpu_median"] <= 0.02, f"median {hm.get('self_cpu_median')} max {hm.get('self_cpu_max')} cores")
-        check("host monitor storage: /rig/host ≤ 5 % of the run's compressed payload (zstd, as the bag)",
-              hm.get("share_compressed") is not None and hm["share_compressed"] <= 0.05, f"{hm.get('share_compressed')} ({hm.get('host_kb_per_h_zstd')} KB/h)")
+        # ── host monitor (/rig/host, rig_nodes.host_monitor) ─────────────────────────────
+        hm = host_monitor_values(main_bag) if main_bag and host_mon else {}
+        if host_mon:
+            print(f"  info  host monitor: {json.dumps({k: v for k, v in hm.items() if k not in ('fields_ok', 'groups')})}", file=sys.stderr)
+            check("host monitor: /rig/host recorded in the bag, ≥ 0.8 samples per second of the run",
+                  (hm.get("samples") or 0) >= 0.8 * (hm.get("run_s") or 99), f"{hm.get('samples')} samples over {hm.get('run_s')} s")
+            check("host monitor: every sample has the HostStats fields (the installed rig_interfaces' when typed)",
+                  hm.get("fields_ok", False), str(hm.get("bad_fields")))
+            check("host monitor: one entry per logical CPU, busiest sub-window ≥ the window mean on every core",
+                  hm.get("cores_ok", False), f"{hm.get('ncpu')} CPUs")
+            check("host monitor: the graph's processes pinned by script (py:bridge_node, py:fictrac_udp_adapter, py:host_monitor)",
+                  {"py:bridge_node", "py:fictrac_udp_adapter", "py:host_monitor"} <= set(hm.get("groups") or []), str(hm.get("groups")))
+            check("host monitor cost: its own CPU ≤ 2 % of one core (median after the first 2 samples)",
+                  hm.get("self_cpu_median") is not None and hm["self_cpu_median"] <= 0.02, f"median {hm.get('self_cpu_median')} max {hm.get('self_cpu_max')} cores")
+            check("host monitor storage: /rig/host ≤ 5 % of the run's compressed payload (zstd, as the bag)",
+                  hm.get("share_compressed") is not None and hm["share_compressed"] <= 0.05, f"{hm.get('share_compressed')} ({hm.get('host_kb_per_h_zstd')} KB/h)")
         check("bridge node still alive at the end of the main run", bridge.alive())
 
         # ── crash phase: SIGKILL the bridge node mid-run, both writer profiles ────────
diff --git a/tests/test-host-sampler.py b/tests/test-host-sampler.py
deleted file mode 100644
index 553543f3..00000000
--- a/tests/test-host-sampler.py
+++ /dev/null
@@ -1,215 +0,0 @@
-#!/usr/bin/env python3
-"""Offline tests for rig/nodes/host_sampler.py — the rig's host-pressure sampler (no ROS, no psutil
-needed: a fake psutil with known counters drives the portable code path), wired into the root
-`pixi run test`. Checks:
-  (a) the CONTRACT: every sample field, and every disks/nets/gpus/procs field, is exactly the
-      `.msg` definition in rig/docs/host-stats-request.md, with a matching Python type
-  (b) rates from counter deltas (disk MB/s, IOPS, busy, network MB/s + errors, context switches)
-  (c) CPU: window mean vs busiest sub-window, per core
-  (d) processes: pinned groups summed into one row, top-N by CPU / memory / I/O with reason bits,
-      a one-process group merged with its top-N row, py:<script> for this repo's Python processes
-  (e) JSON form: NaN → null, strict JSON; the console summary line
-
-Run: python tests/test-host-sampler.py
-"""
-import collections
-import importlib.util
-import json
-import math
-import os
-import re
-import sys
-import types
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-ROOT = os.path.join(HERE, "..")
-SPEC = os.path.join(ROOT, "rig", "docs", "host-stats-request.md")
-_spec = importlib.util.spec_from_file_location("host_sampler", os.path.join(ROOT, "rig", "nodes", "host_sampler.py"))
-H = importlib.util.module_from_spec(_spec)
-_spec.loader.exec_module(H)
-
-total = 0
-failures = 0
-
-
-def check(name, got, expected):
-    global total, failures
-    total += 1
-    if got == expected:
-        print(f"  ok   {name}")
-    else:
-        failures += 1
-        print(f"  FAIL {name}: got {got!r}, expected {expected!r}")
-
-
-# ── the fake psutil: counters that advance by fixed steps per call ────────────────────────────
-class FakePsutil(types.SimpleNamespace):
-    pass
-
-
-CpuStats = collections.namedtuple("CpuStats", "ctx_switches interrupts soft_interrupts syscalls")
-Disk = collections.namedtuple("Disk", "read_count write_count read_bytes write_bytes read_time write_time")
-Nic = collections.namedtuple("Nic", "bytes_sent bytes_recv packets_sent packets_recv errin errout dropin dropout")
-VM = collections.namedtuple("VM", "total available percent")
-Swap = collections.namedtuple("Swap", "used")
-Usage = collections.namedtuple("Usage", "free")
-IfStat = collections.namedtuple("IfStat", "isup")
-Mem = collections.namedtuple("Mem", "rss")
-CALLS = collections.Counter()
-
-
-def _step(name):
-    CALLS[name] += 1
-    return CALLS[name]
-
-
-class FakeProc:
-    TABLE = {}  # pid → (name, cmdline, cpu %, rss MB)
-
-    def __init__(self, pid=None):
-        self.pid = os.getpid() if pid is None else pid
-        name = self.TABLE.get(self.pid, ("python.exe", ["python"], 0.0, 1.0))[0]
-        self.info = {"name": name}
-
-    def oneshot(self):
-        import contextlib
-
-        return contextlib.nullcontext()
-
-    def cpu_percent(self, _):
-        return self.TABLE[self.pid][2]
-
-    def memory_info(self):
-        return Mem(int(self.TABLE[self.pid][3] * H.MB))
-
-    def cmdline(self):
-        return self.TABLE[self.pid][1]
-
-    def cpu_times(self):
-        k = _step("self")
-        return (0.001 * k, 0.0)
-
-
-fake = FakePsutil(
-    cpu_count=lambda: 4,
-    cpu_percent=lambda _i, percpu=True: [10.0, 20.0, 30.0, 40.0] if _step("cpu") % 2 else [30.0, 20.0, 10.0, 80.0],
-    cpu_stats=lambda: (lambda k: CpuStats(1000 * k, 500 * k, 50 * k, 0))(_step("stats")),
-    virtual_memory=lambda: VM(16 * 1024 * H.MB, 6 * 1024 * H.MB, 62.5),
-    swap_memory=lambda: Swap(512 * H.MB),
-    disk_usage=lambda p: Usage(100 * 1024 ** 3),
-    disk_io_counters=lambda perdisk=True: (lambda k: {"disk0": Disk(10 * k, 20 * k, int(2 * H.MB) * k, int(4 * H.MB) * k, 100 * k, 200 * k)})(_step("disk")),
-    net_io_counters=lambda pernic=True: (lambda k: {"en0": Nic(int(H.MB) * k, 3 * int(H.MB) * k, 0, 0, k, 0, 0, 0),
-                                                    "lo0": Nic(9 * k, 9 * k, 0, 0, 0, 0, 0, 0)})(_step("net")),
-    net_if_stats=lambda: {"en0": IfStat(True), "lo0": IfStat(True)},
-    Process=FakeProc,
-    process_iter=lambda attrs=None: [FakeProc(pid) for pid in FakeProc.TABLE],
-)
-me = os.getpid()
-script = os.path.join(ROOT, "rig", "nodes", "bridge_node.py")
-FakeProc.TABLE = {
-    me: ("python.exe", ["python", "host_monitor.py"], 1.0, 40.0),
-    101: ("fictrac.exe", [], 78.0, 300.0),
-    102: ("chrome.exe", [], 5.0, 800.0),
-    103: ("chrome.exe", [], 3.0, 900.0),
-    104: ("python.exe", ["python", script, "--log-dir", "x"], 12.0, 75.0),
-    105: ("python.exe", ["python", "/elsewhere/tool.py"], 50.0, 30.0),
-    106: ("bigmem.exe", [], 0.5, 5000.0),
-    107: ("idle.exe", [], 0.0, 1.0),
-}
-H.psutil = fake
-H.WIN = False  # the portable path, on every OS
-hs = H.HostSampler(window_s=0.1, sub_samples=2, log_volume=ROOT, top_n=2, gpu=False)
-hs.window()
-s = hs.window()
-
-print("(a) contract vs rig/docs/host-stats-request.md")
-text = open(SPEC, encoding="utf-8").read()
-msgs = {}
-for name, body in re.findall(r"### (\w+)\.msg\s*```\n(.*?)```", text, re.S):
-    fields = []
-    for line in body.splitlines():
-        line = line.split("#", 1)[0].strip()
-        if line:
-            typ, fname = line.split()[:2]
-            fields.append((typ, fname))
-    msgs[name] = fields
-check("five messages in the spec", sorted(msgs), ["DiskStats", "GpuStats", "HostStats", "NetStats", "ProcStats"])
-
-
-def pytype_ok(typ, v):
-    if typ.endswith("[]"):
-        return isinstance(v, list)
-    if typ.startswith("float"):
-        return isinstance(v, float)
-    if typ.startswith(("int", "uint")):
-        return isinstance(v, int) and not isinstance(v, bool)
-    if typ == "string":
-        return isinstance(v, str)
-    return False
-
-
-def conforms(msg, d):
-    names = [f for _, f in msgs[msg]]
-    return sorted(d) == sorted(names) and all(pytype_ok(t, d[f]) for t, f in msgs[msg])
-
-
-check("HostStats: exactly the spec's fields and types", conforms("HostStats", s), True)
-check("DiskStats", bool(s["disks"]) and all(conforms("DiskStats", d) for d in s["disks"]), True)
-check("NetStats", bool(s["nets"]) and all(conforms("NetStats", d) for d in s["nets"]), True)
-check("ProcStats", bool(s["procs"]) and all(conforms("ProcStats", d) for d in s["procs"]), True)
-
-
-class FakeNvml:  # every NVML call fails → the documented absent values
-    def __getattr__(self, _):
-        return lambda *a: 999
-
-
-g = H.Nvml.__new__(H.Nvml)
-g.lib, g.handles, g.names = FakeNvml(), [object()], ["Fake GPU"]
-gs = g.sample()
-check("GpuStats (every NVML call failing): spec fields, NaN floats, pstate 255", conforms("GpuStats", gs[0]) and math.isnan(gs[0]["util_frac"]) and gs[0]["pstate"] == 255, True)
-check("Nvml() never raises (driver present or not)", isinstance(H.Nvml().available, bool), True)
-
-print("(b) rates")
-d = s["disks"][0]
-rate = d["reads_per_s"] / 10  # = 1 / the window the sampler measured (reads advance by 10 per window)
-check("disk MB/s = Δbytes / Δt", (round(d["read_mb_per_s"] / rate, 3), round(d["write_mb_per_s"] / rate, 3)), (2.0, 4.0))
-check("disk busy = (Δread_time + Δwrite_time) / window, clamped to 1", d["busy_frac"], 1.0)
-n = s["nets"]
-check("loopback adapter skipped", [x["name"] for x in n], ["en0"])
-check("net rx/tx MB/s, errors in the window", (round(n[0]["rx_mb_per_s"] / rate, 3), round(n[0]["tx_mb_per_s"] / rate, 3), n[0]["errors"]), (3.0, 1.0, 1))
-check("context switches per s", round(s["context_switches_per_s"] / rate), 1000)
-check("memory used / available / page file", (s["mem_used_mb"], s["mem_available_mb"], s["pagefile_used_mb"]), (10240.0, 6144.0, 512.0))
-check("hard faults absent off Windows → NaN", math.isnan(s["hard_page_faults_per_s"]), True)
-check("log volume free space", s["log_volume_free_gb"], 100.0)
-
-print("(c) CPU mean vs peak")
-check("per-core mean of the two sub-windows", [round(x, 3) for x in s["core_busy_mean"]], [0.2, 0.2, 0.2, 0.6])
-check("per-core peak", s["core_busy_peak"], [0.3, 0.2, 0.3, 0.8])
-check("whole-PC mean / peak (cores)", (round(s["cpu_busy_cores_mean"], 3), round(s["cpu_busy_cores_peak"], 3)), (1.2, 1.4))
-check("sub_samples", s["sub_samples"], 2)
-
-print("(d) processes")
-by = {(p["group"] or p["name"]): p for p in s["procs"]}
-check("pinned: fictrac row", by["fictrac"]["cpu_cores"], 0.78)
-check("browser = ONE summed row for its two processes", (by["browser"]["cpu_cores"], by["browser"]["rss_mb"], by["browser"]["pid"]), (0.08, 1700.0, 102))
-check("this repo's Python script → py:bridge_node", "py:bridge_node" in by, True)
-check("the monitor itself → py:host_monitor", "py:host_monitor" in by, True)
-check("a Python script outside the repo is not pinned, but tops CPU", (by["python.exe"]["group"], by["python.exe"]["reasons"]), ("", H.REASON_CPU))
-check("one-process group merged with its top-N row (fictrac: pinned + top CPU)", by["fictrac"]["reasons"], H.REASON_PINNED | H.REASON_CPU)
-check("top memory picks the big process", by["bigmem.exe"]["reasons"] & H.REASON_MEM, H.REASON_MEM)
-check("an idle unpinned process is left out", "idle.exe" in by, False)
-check("rows sorted by CPU", [p["cpu_cores"] for p in s["procs"]] == sorted((p["cpu_cores"] for p in s["procs"]), reverse=True), True)
-check("py_group: -m rig_nodes.<module>", H.py_group(["python", "-m", "rig_nodes.fictrac_udp_adapter"]), "py:fictrac_udp_adapter")
-check("py_group: relative nodes/ script (pixi task cwd = rig/)", H.py_group(["python", "nodes/bridge_node.py"]), "py:bridge_node")
-check("py_group: other module", H.py_group(["python", "-m", "http.server"]), None)
-
-print("(e) JSON + summary")
-s["gpus"] = gs
-j = json.dumps(H.to_json_safe(s), allow_nan=False)
-check("strict JSON (NaN → null)", json.loads(j)["hard_page_faults_per_s"], None)
-line = H.summary_line(s)
-check("summary line", line.startswith("CPU 1.20 cores (peak 1.40, busiest core 80 %)") and "top fictrac 0.78" in line and "GPU" in line, True)
-
-print(f"\n{total - failures}/{total} passed")
-sys.exit(1 if failures else 0)

From 7ce1978709e3535505feb3e06af13237edf8f019 Mon Sep 17 00:00:00 2001
From: Michael B Reiser <mreiser@gmail.com>
Date: Wed, 28 Oct 2026 18:15:57 -0400
Subject: [PATCH 3/4] rig.py: place the host-monitor hunks clear of #269's
 (argparse tail, after the BIAS node, docstring)

Coordinated with the session building the candidate with #269 (stimulus node): its hunks edit
the --sim argparse neighbourhood, the --foxglove docstring line and the lines after
nodes.append(bridge). Ours now sit after --sim-args, after the BIAS node append and after the
--sim docstring example, so the two PRs merge without conflict. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rig/nodes/rig.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/rig/nodes/rig.py b/rig/nodes/rig.py
index 71c9c2de..57b2dfa6 100644
--- a/rig/nodes/rig.py
+++ b/rig/nodes/rig.py
@@ -4,10 +4,10 @@
     pixi run rig                       # router, fictrac adapter, bridge node
     pixi run rig -- --kinefly --bias   # + Kinefly adapter + BIAS node
     pixi run rig -- --sim              # + the FicTrac simulator (demo without a camera)
+    pixi run rig -- --no-host-monitor  # without the host monitor (CPU/RAM/disk/net/GPU on /rig/host; on by default)
     pixi run rig -- --bias --bias-sim  # + a simulated BIAS program (no camera software)
     pixi run rig -- --scanimage        # + the ScanImage node (JSON server on this PC); --si-mock for a stand-in
     pixi run rig -- --foxglove         # + foxglove_bridge (:8766) from the `viz` environment
-    pixi run rig -- --no-host-monitor  # without the host monitor (CPU/RAM/disk/net/GPU on /rig/host; on by default)
 
 This file is the arena rig's COMPOSITION (rig-software-repos-and-runners.md §3.2): which nodes an
 arena rig runs, in which order, and what happens when one dies. The device nodes and simulators
@@ -75,8 +75,6 @@ def main(argv: list[str] | None = None) -> int:
     p.add_argument("--viz-args", default="", help="extra args for viz_node.py (--deg-per-frame, --frame-dir, --feature-az0, --frames)")
     p.add_argument("--foxglove", action="store_true",
                    help=f"also run foxglove_bridge on ws://127.0.0.1:{FOXGLOVE_PORT} (the `viz` environment; skipped with a note when it is not installed)")
-    p.add_argument("--no-host-monitor", action="store_true", help=f"do not run {HOST_MONITOR_MODULE} (the PC's CPU per core, memory, disk, network, GPU, top processes on /rig/host, recorded in every run's bag)")
-    p.add_argument("--host-monitor-args", default="", help=f"extra args for {HOST_MONITOR_MODULE} (e.g. --period 0.5 --print-every 30)")
     p.add_argument("--no-router", action="store_true", help="a Zenoh router is already running on this host")
     p.add_argument("--bridge-args", default="", help="extra args for bridge_node.py")
     p.add_argument("--fictrac-args", default="", help="extra args for the FicTrac adapter")
@@ -84,6 +82,8 @@ def main(argv: list[str] | None = None) -> int:
     p.add_argument("--bias-args", default="", help="extra args for the BIAS node")
     p.add_argument("--scanimage-args", default="", help="extra args for the ScanImage node (e.g. --port 5555 --status-every 1)")
     p.add_argument("--sim-args", default="--proto udp --rate 50", help="args for the FicTrac simulator")
+    p.add_argument("--no-host-monitor", action="store_true", help=f"do not run {HOST_MONITOR_MODULE} (the PC's CPU per core, memory, disk, network, GPU, top processes on /rig/host, recorded in every run's bag)")
+    p.add_argument("--host-monitor-args", default="", help=f"extra args for {HOST_MONITOR_MODULE} (e.g. --period 0.5 --print-every 30)")
     args = p.parse_args(argv)
 
     py = sys.executable
@@ -137,19 +137,19 @@ def main(argv: list[str] | None = None) -> int:
         nodes.append(Child("bias-sim", node_argv("rig_nodes.sims.bias_sim")))
     if args.bias:
         nodes.append(Child("bias", node_argv("rig_nodes.bias_node", *split_args(args.bias_args))))
-    if args.si_mock:
-        nodes.append(Child("si-mock", node_argv("rig_nodes.sims.si_json_mock")))
-    if args.scanimage:
-        nodes.append(Child("scanimage", node_argv("rig_nodes.scanimage_node", *split_args(args.scanimage_args))))
     if not args.no_host_monitor:
-        # The generic host monitor ships in the rig_nodes package (reiserlab/rig-nodes); started
-        # before the bridge, so a run opened right away already has host samples in its bag.
-        # `--py-root` lets it name this workspace's Python nodes `py:<script>`.
+        # The generic host monitor ships in the rig_nodes package (reiserlab/rig-nodes). It starts
+        # before the gateway (bridge_node.py, below), so a run opened right away already has host
+        # samples in its bag; `--py-root` lets it name this workspace's Python nodes `py:<script>`.
         if host_monitor_available():
             nodes.append(Child("host", node_argv(HOST_MONITOR_MODULE, "--log-dir", str(ROOT / "runlogs"),
                                                   "--py-root", str(ROOT), *split_args(args.host_monitor_args))))
         else:
             print(f"[rig] host monitor: the installed rig_nodes has no {HOST_MONITOR_MODULE} (needs a rig-nodes release with it); starting without it", file=sys.stderr)
+    if args.si_mock:
+        nodes.append(Child("si-mock", node_argv("rig_nodes.sims.si_json_mock")))
+    if args.scanimage:
+        nodes.append(Child("scanimage", node_argv("rig_nodes.scanimage_node", *split_args(args.scanimage_args))))
     bridge = Child("bridge", [py, str(NODES / "bridge_node.py"), *split_args(args.bridge_args)])
     nodes.append(bridge)
     if foxglove:

From db51439a581fcf685cda81348c3079a02101b64e Mon Sep 17 00:00:00 2001
From: Michael B Reiser <mreiser@gmail.com>
Date: Wed, 28 Oct 2026 18:33:35 -0400
Subject: [PATCH 4/4] harness: decode typed /rig/host with rclpy's
 deserializer; report the recorded schema

The converter's pure CDR decoder reads no nested message arrays (HostStats carries DiskStats[],
NetStats[], GpuStats[], ProcStats[]), and the converter never needs /rig/host, so the typed
check deserializes with ROS itself. The info line now says which type was recorded.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rig/tests/test_ros2_poc.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/rig/tests/test_ros2_poc.py b/rig/tests/test_ros2_poc.py
index 4d14bb03..c7231c75 100644
--- a/rig/tests/test_ros2_poc.py
+++ b/rig/tests/test_ros2_poc.py
@@ -263,7 +263,7 @@ def host_monitor_values(bag: Path) -> dict:
         want = sorted(HostStats.get_fields_and_field_types())
     except (ImportError, AttributeError):
         want = None
-    host, other, t_ns, objs = [], [], [], []
+    host, other, t_ns, objs, schemas = [], [], [], [], set()
     gen = read_records(bag)
     try:
         while True:
@@ -273,8 +273,17 @@ def host_monitor_values(bag: Path) -> dict:
                 other.append(r["data"])
                 continue
             host.append(r["data"])
-            try:  # String JSON → its object; a typed HostStats → its fields (the converter's decoder)
-                objs.append(_json_of({"msg": decode_cdr(r["schema"], r.get("schema_text"), r["data"])}))
+            schemas.add(r["schema"])
+            try:
+                if want is not None and r["schema"] == "rig_interfaces/msg/HostStats":
+                    # typed: ROS's own deserializer (the converter's pure decoder reads no nested
+                    # message arrays — DiskStats[] disks … — and the converter never needs /rig/host)
+                    from rclpy.serialization import deserialize_message
+                    from rosidl_runtime_py.convert import message_to_ordereddict
+
+                    objs.append(json.loads(json.dumps(message_to_ordereddict(deserialize_message(r["data"], HostStats)))))
+                else:  # String JSON → its object
+                    objs.append(_json_of({"msg": decode_cdr(r["schema"], r.get("schema_text"), r["data"])}))
             except Exception:
                 objs.append(None)
     except StopIteration:
@@ -289,7 +298,7 @@ def host_monitor_values(bag: Path) -> dict:
     zh = len(zstandard.ZstdCompressor(level=level).compress(b"".join(host))) if host else 0
     za = len(zstandard.ZstdCompressor(level=level).compress(b"".join(host + other))) if host or other else 0
     run_s = (max(t_ns) - min(t_ns)) / 1e9 if t_ns else None
-    return {"samples": len(host), "run_s": round(run_s, 1) if run_s else None, "fields_ok": bool(good) and len(good) == len(objs) and not bad,
+    return {"samples": len(host), "schema": sorted(s or "std_msgs/msg/String" for s in schemas), "run_s": round(run_s, 1) if run_s else None, "fields_ok": bool(good) and len(good) == len(objs) and not bad,
             "bad_fields": bad, "cores_ok": cores_ok, "ncpu": len(good[0]["core_busy_mean"]) if good else None,
             "groups": sorted({p["group"] for o in good for p in o.get("procs", []) if p.get("group")}),
             "self_cpu_median": round(statistics.median(self_cpu), 4) if self_cpu else None,