Open to the Stringman community: training data, datagen/trainer/room importer, avoid_furniture, [home] reports

AGENTS.md

@@ -98,8 +98,57 @@ This opens one pull request on `MacroSwan/pilot-tasks` containing the result, yo
 page is the discussion: people and agents comment there, the maintainers re-run it, and the best merged tuning becomes
 the next person's starting point. Ask your person before submitting. It publishes under their Hugging Face account.
 
+## Step 6: tell everyone how it went in your home
+
+The maintainers do not have a Stringman. Your report is how anyone learns whether this works in a real home, so write
+one even when (above all when) it went badly. Open a **Discussion** on this repository, titled
+`[home] <room> · <card> · <what happened in five words>`, filled from [`HOME_REPORT.md`](HOME_REPORT.md). It covers the
+room, the rig, what you changed to integrate it, what the robot did, what broke, and what you would change. Attach
+`doctor.json`, `rig.yaml` and the run's `result.json`. If you have a real-robot log, open a PR on the dataset
+`MacroSwan/real-runs` with it as well (format in its README; blur faces first). Read the other `[home]` threads
+before you start: someone may already have fixed your problem. Answer them when you can.
+
+## Step 7: change the model itself
+
+Everything the model learned from is public, so you can regenerate it, retrain it and replace it without asking anyone.
+
+| what | where |
+|---|---|
+| the training data: 12,000 task-free trajectories (100 h of simulated motion, each in its own random room) | dataset `MacroSwan/cablepilot-motion` |
+| how that data is made (the motion recipe, randomised physics, the host's real spool loop) | `scripts/cdpr_datagen.py` (docstring) |
+| training, then test 1 (open-loop error at 2 s on held-out rooms, next to MuJoCo and to the physics alone) | `scripts/train_cdpr_wm.py` |
+| a real Stringman room from a LeRobot recording (anchors, named places, floor image) | `scripts/import_room.py` |
+
+```bash
+hf download MacroSwan/cablepilot-motion --repo-type dataset --local-dir data/motion       # ~280 MB, or regenerate:
+python scripts/cdpr_datagen.py --scenario configs/scenarios/clear_playroom.yaml --n 12000 --seed 0 --workers 4 --out data/motion
+python scripts/train_cdpr_wm.py --data data/motion --out weights/mine.pt                  # minutes on a laptop CPU, no GPU
+python scripts/train_cdpr_wm.py --eval-only --data data/motion --out weights/stringman_g1.pt   # the bar to beat
+```
+
+The released `weights/stringman_g1.pt` scores **19.6 mm** median grasp-point error at 2 s on 500 held-out windows
+(the MuJoCo oracle scores 21.0 mm). A new model has to beat that on the same test, and then score at least as well on a
+task (`cablepilot run`, 3 episodes, both rooms), before it replaces the old one. Open a PR here with the weights, the
+test-1 JSON written next to them, the run's `result.json` and one line of `why`. To use your model in a run, point
+`configs/planner_learned.yaml` at it locally (a tuning file may never change the model).
+
+**Your own recordings are the best test set there is.** Any Stringman LeRobot dataset with `anchor_poses`, for example
+`naavox/stringman_cleans`, holds the real state and the real commands. Converting a few of its episodes into the
+`cdpr_datagen` format and running `--eval-only --test-all` on them gives the model's first error measured on a real
+machine. Nobody has done that yet: it is the most useful thing on the list below.
+
+## Open jobs (pick one, say so in a Discussion first)
+
+1. **The model on real data.** Test 1 on real Stringman episodes (see Step 7). Then fine-tune on them, if it helps.
+2. **`avoid_furniture`.** The card is in `MacroSwan/pilot-tasks`. `cablepilot check` says what is missing: a `near`
+   skill (a runner around `clear_floor.GotoTask`) and a furnished room (`scripts/import_room.py` plus the furniture
+   boxes that `runner.obstacles` reads).
+3. **`stringman.py` on hardware.** Check each `ASSUME` against `nf_robot`, then `hover()` in `dry_run`, then for real.
+4. **Your room.** Import it with `scripts/import_room.py` and add it as a `--world`, so that everyone's cards are scored in
+   a third real room.
+
 ## Where things are
 
 `README.md` covers the model and the numbers. `cablepilot/cli.py` has the commands. `cablepilot/core/cards.py` defines
 the card schema: the predicates, the skills and `signature()`. `cablepilot/cardrun.py` maps cards to the cable skills
-and writes the result format. `cablepilot/stringman.py` is the real robot adapter.
+and writes the result format. `cablepilot/stringman.py` is the real robot adapter. `scripts/` holds the data generator, the trainer and the room importer.

HOME_REPORT.md

@@ -0,0 +1,28 @@
+# [home] report template
+
+Copy this into a new Discussion on `MacroSwan/cablepilot`, titled `[home] <room> · <card> · <five words>`.
+Write what happened, including what went wrong. A failed integration, well described, is worth more than a good score.
+
+**Who:** `<agent> for @<person>` · cablepilot commit `<sha>` · date
+
+**Room:** kind (bedroom, playroom, ...), rough size, floor (rug, wood, tiles), what is in the way (bed, desk, chair
+legs, cables on the floor), light. `doctor.json` attached.
+
+**Rig:** robot and firmware version, gripper, cameras, the computer that plans (CPU, threads, `doctor` speed line).
+`rig.yaml` attached.
+
+**How we integrated it:** what you had to change or write to make it run here, in order: places bound, adapter
+`ASSUME`s checked or fixed, tunings, code. Link the commits or PRs.
+
+**What ran:** simulation (`--world`, seeds, episodes) and/or the real robot (`dry_run`, `hover()`, task). `result.json`
+attached. Real log: link to the `MacroSwan/real-runs` PR.
+
+**What the robot did:** the score, s per item, furniture contacts, max tension, plan time. Then in words: where it hesitated,
+swung, missed, touched something.
+
+**What broke, and the guess why:**
+
+**Compared with what you use now (VLA, ACT, scripted):** success, time per item, compute, and the setup effort for a
+new task. Only what you measured.
+
+**What we would change next:**

README.md

@@ -11,6 +11,7 @@ tags:
   - task-cards
 datasets:
   - MacroSwan/pilot-tasks
+  - MacroSwan/cablepilot-motion
 ---
 
 # cablepilot
@@ -119,6 +120,14 @@ State (14): gantry position and velocity, pole swing and its rate, wrist angle a
 Command (5): gantry velocity (what `move_direction_speed` takes), wrist rate, closure target. Model step 0.1 s,
 1 s of history.
 
+## Train it yourself
+
+The model was trained on the public dataset [`MacroSwan/cablepilot-motion`](https://huggingface.co/datasets/MacroSwan/cablepilot-motion):
+12,000 trajectories, about 100 hours of task-free simulated motion, each in its own random room. It can be regenerated
+in about 15 minutes on 4 cores (`scripts/cdpr_datagen.py`) and retrained on a laptop CPU without a GPU
+(`scripts/train_cdpr_wm.py`). `scripts/import_room.py` turns a Stringman LeRobot recording into a simulated room.
+AGENTS.md, Step 7, gives the commands and the bar a new model has to beat.
+
 ## Status
 
 - **Simulation:** proven. Model test on 500 held-out windows in 310 unseen rooms: grasp point 19.6 mm median error at

scripts/cdpr_datagen.py

@@ -0,0 +1,358 @@
+"""Stringman world-model data: task-free trajectories in the twin, the SkyJEPA recipe (scripts/arm_datagen.py's, on the
+cable robot). No target, no cost, no task label in the files: only how the machine moves when commanded.
+
+A NEW RANDOM ROOM PER TRAJECTORY (sim/scene.random_room; --fixed-room for a test set of one real room): the model is a
+model of the machine, not of a place (2026-10-08), and a room enters its dynamics only through the line geometry,
+which is stored with each trajectory (mounts, runs) and given to the model as an input.
+
+    python scripts/cdpr_datagen.py --scenario configs/scenarios/clear_playroom.yaml --n 20 --out data/cdpr_v0_sample
+    python scripts/cdpr_datagen.py --scenario configs/scenarios/clear_playroom.yaml --n 4000 --workers 7 --out data/cdpr_v0_playroom
+
+Files (shards of 100):
+  states   (N, T+1, 14)  p, v, swing s, s_dot, wrist, wrist_dot, closure, closure_dot (sim.kin), AS ESTIMATED (noise added)
+  actions  (N, T, 5)     the command SENT at each record step: gantry velocity (3), wrist rate, closure target
+  tensions (N, T+1, 4)   line tensions (N): an observation, NOT a model input (uncalibrated on the real robot)
+  payload  (N, T+1)      kg held at the grasp point (bookkeeping: the model must infer it)
+  eta      (N, P)        the trajectory's randomised physics (eta_names)
+  mounts   (N, 4, 3)     the room's mount points (line order of the firmware), runs (N, 4) the indirect lines' fixed runs
+Recorded at 10 Hz (dt 0.1 s = half a planner step: the planner's 0.2 s is 2 model steps), 30 s per trajectory.
+
+The machine is driven exactly as the real host drives it (sim.host.SpoolState: velocity -> line speeds by
+finite-difference IK at the ESTIMATED position through MISCALIBRATED mounts, 50 Hz spool loop with the tension floor
+and soft mute, acceleration-limited motors, 60 Hz gripper loop), with a command latency. Planning model = the
+machine-only twin (no furniture, no contacts): the grasp point is kept >= 4 cm above the floor (floor contact is a task's
+business, not the machine's).
+
+Motion = a chain of segments chosen at random until the trajectory is full:
+  goto     to a random reachable point (inside the mount polygon by 0.35 m, 3-line worst tension <= 26 N), 0.1-0.35 m/s
+  dwell    hold still 1-4 s (the robot mostly hovers and waits)
+  stop     a fast goto cut to zero half way: swing excitation and its decay
+  pump     horizontal sinusoid at 0.7-1.3 x the swing frequency, small amplitude: the swing's resonance
+  descend  down to a grasp height (G 4-15 cm), hold, back up (the pick's vertical regime)
+  plan     what MPPI asks: a new command every planner step (0.2 s), AR(0.9) random walk, 1-3 x the planner's sigma
+Wrist: rate pulses (half the segments); fingers: a new closure target (40 % of segments).
+Payload: attached (20-500 g) or dropped at 35 % of segment boundaries: the "weight changes" regime.
+Randomised per trajectory (eta): gantry and gripper mass x0.85-1.15, line EA 2-15 kN (log), line damping x0.5-2,
+spool acceleration 0.10-0.30 m/s^2, command latency 0-0.15 s, mount calibration error sigma 0-4 cm (the host's IK only),
+swing damping x0.3-3. Estimator noise as the sim estimator's (perception/oracle_estimator.StateEstimate).
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import sys
+import time
+from collections import deque
+from pathlib import Path
+
+import mujoco
+import numpy as np
+import torch
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from cablepilot.perception.oracle_estimator import StateEstimate  # noqa: E402
+from cablepilot.sim.host import HostModel, SpoolState  # noqa: E402
+from cablepilot.sim.kin import ccw_polygon, worst_hang_tensions  # noqa: E402
+from cablepilot.sim.scene import (Indices, build_model, grasp_point_local, load_config, mounts, random_room, room_centre,  # noqa: E402
+                                  set_room_geometry, settle_spools, total_mass)
+from cablepilot.sim.state import to_state  # noqa: E402
+
+SEGMENTS = {"goto": 0.25, "dwell": 0.10, "stop": 0.10, "pump": 0.10, "descend": 0.15, "plan": 0.30}
+ETA_NAMES = ["gantry_mass_scale", "gripper_mass_scale", "EA_N", "line_damping_scale", "line_accel_mps2", "latency_s",
+             "calib_sigma_m", "swing_damping_scale", "payload_max_kg"]
+DT = 0.1
+D_G = -0.5147          # grasp point on the pole, Stringman hand (tasks/pick_place.PickPlaceTask.dG); per hand: Generator.dG
+
+
+class Generator:
+    def __init__(self, scenario: str, seconds: float = 30.0, random_rooms: bool = True, hand: str | None = None):
+        self.cfg = load_config(scenario=scenario, hand=hand)
+        # grasp point's distance down the pole (SO-101: hand origin + gripperframe, -0.472; its 7.9 mm lateral offset
+        # does not matter for keeping it off the floor)
+        self.dG = float(self.cfg["body"]["gripper_origin_z_m"] + grasp_point_local(self.cfg)[2])
+        self.base_cfg = self.cfg
+        self.random_rooms = random_rooms
+        self.m = build_model(self.cfg, world=False, payload_kg=1e-4)
+        self.d = mujoco.MjData(self.m)
+        self.idx = Indices(self.m)
+        self.h = self.m.opt.timestep
+        self.sub = int(round(DT / self.h))
+        self.T = int(round(seconds / DT))
+        self.M = mounts(self.cfg)
+        self.poly = ccw_polygon(self.M[:, :2])
+        self.pay = self.m.body("payload").id
+        m = self.m
+        self.orig = {k: getattr(m, k).copy() for k in ("body_mass", "body_inertia", "actuator_gainprm", "actuator_biasprm",
+                                                        "dof_damping")}
+        self.gripper, self.gantry = m.body("gripper").id, m.body("gantry").id
+        self.swing_dofs = slice(self.idx.gv + 3, self.idx.gv + 6)
+
+    # ------------------------------------------------------------------------------------- geometry
+    def inside_by(self, xy):
+        a, b = self.poly, np.roll(self.poly, -1, 0)
+        e = b - a
+        n = np.c_[-e[:, 1], e[:, 0]] / np.linalg.norm(e, axis=1)[:, None]
+        return float(((np.asarray(xy) - a) * n).sum(1).min())
+
+    def tension_ok(self, p, lim=26.0):
+        t = worst_hang_tensions(torch.as_tensor(self.M, dtype=torch.float32), torch.as_tensor(p, dtype=torch.float32),
+                                total_mass(self.m) + 0.5)
+        return float(t.max()) <= lim
+
+    def random_point(self, rng, z_lo=None):
+        lo, hi = self.poly.min(0), self.poly.max(0)
+        for _ in range(1000):
+            xy = rng.uniform(lo, hi)
+            if self.inside_by(xy) < 0.35:
+                continue
+            gz = rng.uniform(0.04, 0.15) if z_lo else rng.uniform(0.15, 1.2)
+            p = np.r_[xy, gz - self.dG]
+            if self.tension_ok(p):
+                return p
+        return np.r_[self.poly.mean(0), 1.0]
+
+    # ------------------------------------------------------------------------------------- randomisation
+    def randomise(self, rng) -> tuple[dict, HostModel]:
+        m, o = self.m, self.orig
+        for k, v in o.items():
+            getattr(m, k)[:] = v
+        if self.random_rooms:   # a new room every trajectory: the model learns the machine, not a place
+            self.cfg = set_room_geometry(self.base_cfg, m, self.idx, random_room(rng))
+            self.M = mounts(self.cfg)
+            self.poly = ccw_polygon(self.M[:, :2])
+        e = {"gantry_mass_scale": rng.uniform(0.85, 1.15), "gripper_mass_scale": rng.uniform(0.85, 1.15),
+             "EA_N": float(np.exp(rng.uniform(np.log(2000), np.log(15000)))), "line_damping_scale": rng.uniform(0.5, 2.0),
+             "line_accel_mps2": rng.uniform(0.10, 0.30), "latency_s": rng.uniform(0.0, 0.15),
+             "calib_sigma_m": rng.uniform(0.0, 0.04), "swing_damping_scale": float(np.exp(rng.uniform(np.log(0.3), np.log(3.0)))),
+             "payload_max_kg": rng.uniform(0.0, 0.5)}
+        m.body_mass[self.gantry] *= e["gantry_mass_scale"]
+        m.body_inertia[self.gantry] *= e["gantry_mass_scale"]
+        m.body_mass[self.gripper] *= e["gripper_mass_scale"]
+        m.body_inertia[self.gripper] *= e["gripper_mass_scale"]
+        m.dof_damping[self.swing_dofs] *= e["swing_damping_scale"]
+        run = np.asarray(self.cfg["room"]["indirect_run_m"], float)
+        span = np.linalg.norm(self.M - np.r_[room_centre(self.cfg), 1.2], axis=1)
+        for i, a in enumerate(self.idx.spool):
+            k = e["EA_N"] / (span[i] + run[i])
+            m.actuator_gainprm[a, 0] = k
+            m.actuator_biasprm[a, 1] = -k
+            m.actuator_biasprm[a, 2] *= e["line_damping_scale"]
+        cfg_h = copy.deepcopy(self.cfg)                     # the host's belief of where the mounts are
+        cfg_h["room"]["mounts_xyz"] = (self.M + rng.normal(0, e["calib_sigma_m"], self.M.shape)).tolist()
+        host = HostModel(cfg_h, self.h, self.idx.travel)
+        host.acc = e["line_accel_mps2"]
+        return e, host
+
+    # ------------------------------------------------------------------------------------- commands
+    def segments(self, rng):
+        """Endless generator of (kind, function(state, t_in_segment) -> (action, done))."""
+        sig = np.array([0.06, 0.06, 0.03, 0.4])
+        omega = np.sqrt(9.81 / 0.3089)
+        names, probs = list(SEGMENTS), np.array(list(SEGMENTS.values()))
+        while True:
+            kind = str(rng.choice(names, p=probs / probs.sum()))
+            wrist_rate = rng.choice([0.0, 0.0, rng.uniform(-1.5, 1.5)])
+            close = None if rng.random() > 0.4 else float(rng.choice([0.0, 1.0, rng.uniform(0, 1)]))
+            if kind in ("goto", "stop", "descend"):
+                tgt = self.random_point(rng, z_lo=(kind == "descend"))
+                vmax = rng.uniform(0.1, 0.35)
+                cut = rng.uniform(1.0, 4.0) if kind == "stop" else None
+                hold = rng.uniform(0.5, 2.5)
+                state = {"arrived": None}
+
+                def f(x, t, tgt=tgt, vmax=vmax, cut=cut, hold=hold, state=state):
+                    if cut is not None and t > cut:
+                        return np.zeros(3), t > cut + rng.uniform(2.0, 5.0)
+                    d = tgt - x[:3]
+                    v = d * 0.8
+                    n = np.linalg.norm(v)
+                    v = v * min(1.0, vmax / max(n, 1e-9))
+                    if np.linalg.norm(d) < 0.03:
+                        state["arrived"] = state["arrived"] or t
+                    done = state["arrived"] is not None and t - state["arrived"] > hold or t > 25
+                    return v, done
+            elif kind == "dwell":
+                dur = rng.uniform(1.0, 4.0)
+
+                def f(x, t, dur=dur):
+                    return np.zeros(3), t > dur
+            elif kind == "pump":
+                w = omega * rng.uniform(0.7, 1.3)
+                amp = rng.uniform(0.02, 0.08)
+                ang = rng.uniform(0, 2 * np.pi)
+                dur = rng.uniform(2.0, 5.0)
+
+                def f(x, t, w=w, amp=amp, ang=ang, dur=dur):
+                    s = amp * np.sin(w * t) if t < dur else 0.0
+                    return np.array([s * np.cos(ang), s * np.sin(ang), 0.0]), t > dur + 3.0
+            else:   # plan: AR(0.9) random walk, a new command every 0.2 s
+                scale = rng.uniform(1, 3)
+                st = {"eps": np.zeros(4), "base": None, "k": -1}
+                steps = int(rng.integers(8, 30))
+
+                def f(x, t, scale=scale, st=st, steps=steps):
+                    k = int(round(t / 0.2))
+                    if st["base"] is None:
+                        st["base"] = np.r_[x[3:6], 0.0]
+                    if k != st["k"]:
+                        st["k"] = k
+                        st["eps"] = 0.9 * st["eps"] + np.sqrt(1 - 0.81) * rng.normal(0, 1, 4) * sig * scale
+                    v = st["base"][:3] * 0.9 ** k + st["eps"][:3]
+                    return v, k >= steps
+            yield kind, f, wrist_rate, close
+
+    # ------------------------------------------------------------------------------------- one trajectory
+    def trajectory(self, seed: int) -> dict | None:
+        rng = np.random.default_rng(seed)
+        m, d, idx = self.m, self.d, self.idx
+        eta, host = self.randomise(rng)
+        mujoco.mj_resetData(m, d)
+        p0 = self.random_point(rng)
+        d.qpos[idx.gq:idx.gq + 3] = p0
+        d.qpos[idx.fq] = d.qpos[idx.frq] = -idx.travel
+        m.body_mass[self.pay] = 1e-4
+        settle_spools(m, d, idx, self.cfg)
+        d.ctrl[idx.finger_ctrl] = -idx.travel
+        for _ in range(int(1.0 / self.h)):
+            mujoco.mj_step(m, d)
+        x = to_state(m, d, idx)
+        spools = SpoolState(host, self.cfg, x)
+        noise = StateEstimate(np.random.default_rng(seed + 1))
+        # command latency, in PHYSICS steps: a command sent at tick k reaches the host lat_sub physics steps later.
+        # (v0 counted it in physics steps but delayed it by that many 0.1 s ticks: up to 3.7 s; the data's velocity
+        # followed its command at ~0.4 /s instead of ~2-3 /s and the model learned that commands barely move the robot.)
+        lat_sub = int(round(eta["latency_s"] / self.h))
+        pending = deque()                                    # (physics step at which it applies, action)
+        applied = np.r_[np.zeros(3), 0.0, x[12]]
+        n_phys = 0
+        T = self.T
+        S = np.empty((T + 1, 14))
+        A = np.empty((T, 5))
+        TEN = np.empty((T + 1, 4))
+        PAY = np.empty(T + 1)
+        kinds = {}
+        segs = self.segments(rng)
+        kind, f, wr, cl = next(segs)
+        t_seg, close = 0.0, x[12]
+        v_prev = np.zeros(3)
+
+        def rec(k):
+            S[k] = noise(to_state(m, d, idx))
+            TEN[k] = -d.actuator_force[idx.spool]
+            PAY[k] = m.body_mass[self.pay]
+
+        rec(0)
+        for k in range(T):
+            xe = S[k]
+            v, done = f(xe, t_seg)
+            if done:
+                kinds[kind] = kinds.get(kind, 0) + 1
+                kind, f, wr, cl = next(segs)
+                t_seg = 0.0
+                if cl is not None:
+                    close = cl
+                if rng.random() < 0.35:                    # the payload changes at a segment boundary
+                    on = m.body_mass[self.pay] > 1e-3
+                    m.body_mass[self.pay] = 1e-4 if on else max(1e-4, rng.uniform(0.02, 0.5) * eta["payload_max_kg"] / 0.5)
+                    m.body_inertia[self.pay] = 1e-6
+                v, _ = f(xe, t_seg)
+            # near the floor, descend no faster than the spools can stop: stopping distance v^2 / 2a with a = half the
+            # line acceleration (a 0.35 m/s descent needs ~0.3 m; the first sample put G 23 cm below the floor). The fw
+            # visual servo does the same ("descent speed as a function of how far there is left to fall").
+            G = xe[:3] + self.dG * np.r_[xe[6:8], 1.0]
+            v = v.copy()
+            v[2] = max(v[2], -np.sqrt(2 * 0.5 * eta["line_accel_mps2"] * max(G[2] - 0.04, 0.0)))
+            # keep inside: a command that would leave the reachable box is turned back toward the centre
+            if self.inside_by(xe[:2]) < 0.25 or G[2] < 0.08 or not self.tension_ok(xe[:3], 30.0):
+                c = np.r_[self.poly.mean(0), 1.0]
+                v = 0.15 * (c - xe[:3]) / max(np.linalg.norm(c - xe[:3]), 1e-6)
+            sp = np.linalg.norm(v)
+            v = v * min(1.0, 0.35 / max(sp, 1e-9))
+            a = np.r_[v, wr if t_seg < 3.0 else 0.0, close]
+            A[k] = a
+            pending.append((n_phys + lat_sub, a, xe[:3].copy()))
+            for _ in range(self.sub):
+                while pending and pending[0][0] <= n_phys:
+                    _, applied, p_at_send = pending.popleft()
+                    spools.command(p_at_send, applied)
+                n_phys += 1
+                u = spools.substep(-d.actuator_force[idx.spool], self.h)
+                d.ctrl[idx.spool] = u[:4]
+                d.ctrl[idx.wrist_ctrl], d.ctrl[idx.finger_ctrl] = u[4], u[5]
+                mujoco.mj_step(m, d)
+            if not np.isfinite(d.qpos).all() or np.abs(d.qvel[:6]).max() > 20:
+                return None
+            rec(k + 1)
+            t_seg += DT
+            v_prev = v
+        return {"states": S.astype(np.float32), "actions": A.astype(np.float32), "tensions": TEN.astype(np.float32),
+                "payload": PAY.astype(np.float32), "eta": np.array([eta[k] for k in ETA_NAMES], np.float32), "kinds": kinds,
+                "mounts": self.M.astype(np.float32), "runs": np.asarray(self.cfg["room"]["indirect_run_m"], np.float32)}
+
+
+def _shard_job(args):
+    out, scenario, shard_i, seed0, n, seconds, random_rooms, hand = args
+    gen = Generator(scenario, seconds, random_rooms, hand)
+    rows, rejected, kinds = [], 0, {}
+    t0 = time.perf_counter()
+    for i in range(n):
+        tr = gen.trajectory(seed0 + i)
+        if tr is None:
+            rejected += 1
+            continue
+        for k, v in tr["kinds"].items():
+            kinds[k] = kinds.get(k, 0) + v
+        rows.append(tr)
+    shard = {k: np.stack([r[k] for r in rows]) for k in ("states", "actions", "tensions", "payload", "eta", "mounts", "runs")}
+    np.savez_compressed(Path(out) / f"shard_{shard_i:04d}.npz", **shard, eta_names=np.array(ETA_NAMES), dt=DT)
+    return len(rows), rejected, kinds, time.perf_counter() - t0
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--scenario", default="configs/scenarios/clear_playroom.yaml")
+    ap.add_argument("--n", type=int, default=20)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--seconds", type=float, default=30.0)
+    ap.add_argument("--shard-size", type=int, default=100)
+    ap.add_argument("--workers", type=int, default=1)
+    ap.add_argument("--hand", default=None, help="stringman | so101 (default: configs/stringman.yaml `hand`)")
+    ap.add_argument("--fixed-room", action="store_true", help="the scenario's room for every trajectory (test sets of a real room)")
+    ap.add_argument("--out", default=str(ROOT / "data/cdpr_v0_sample"))
+    args = ap.parse_args()
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    size = min(args.shard_size, args.n)
+    jobs = [(str(out), args.scenario, i, args.seed + i * size, size, args.seconds, not args.fixed_room, args.hand)
+            for i in range(args.n // size)]
+    t0 = time.perf_counter()
+    done, rej, kinds, cpu = 0, 0, {}, 0.0
+    if args.workers > 1:
+        from multiprocessing import Pool
+        with Pool(args.workers) as pool:
+            it = pool.imap_unordered(_shard_job, jobs)
+            for k, (n, r, kd, s) in enumerate(it):
+                done, rej, cpu = done + n, rej + r, cpu + s
+                for a, v in kd.items():
+                    kinds[a] = kinds.get(a, 0) + v
+                print(f"  {k + 1}/{len(jobs)} shards, {done} trajectories, {time.perf_counter() - t0:.0f} s", flush=True)
+    else:
+        for job in jobs:
+            n, r, kd, s = _shard_job(job)
+            done, rej, cpu = done + n, rej + r, cpu + s
+            for a, v in kd.items():
+                kinds[a] = kinds.get(a, 0) + v
+    meta = {"trajectories": done, "rejected": rej, "seconds_each": args.seconds, "rate_hz": 1 / DT,
+            "scenario": args.scenario, "hand": Generator(args.scenario, 1.0, False, args.hand).cfg["hand"],
+            "dG": Generator(args.scenario, 1.0, False, args.hand).dG, "random_rooms": not args.fixed_room, "wall_s": time.perf_counter() - t0, "cpu_s": cpu,
+            "cpu_s_per_trajectory": cpu / max(done, 1), "segments": kinds, "eta_names": ETA_NAMES,
+            "model_state": "states (14): p, v, s, s_dot, wrist, wrist_dot, closure, closure_dot. tensions NOT a model input."}
+    (out / "manifest.json").write_text(json.dumps(meta, indent=2))
+    print(json.dumps(meta, indent=1))
+
+
+if __name__ == "__main__":
+    main()

scripts/import_room.py

@@ -0,0 +1,357 @@
+"""Import a real Stringman room from a naavox LeRobot dataset into the twin: geometry, named places, the floor image.
+
+    hf download naavox/playroom-sep29-2 --repo-type dataset --local-dir data/hf/playroom-sep29-2
+    python scripts/import_room.py --dataset data/hf/playroom-sep29-2 --conf conf_playroom --calibrations <fw>/src/nf_robot/ml/calibrations --name playroom
+    python scripts/import_room.py --dataset data/hf/bedroom-sep6 --conf conf_bedroom_move_clutter_2 --name bedroom
+    uv run python scripts/import_room.py --building commercial_real_estate --office r5 --name cre_r5
+
+A BUILDING (the room layer, milestone R, 2026-10-13): one office cut out of a scanned building
+(~/robot-lab/buildings/<name>/, shared by every robot; see import_building's docstring). Writes configs/rooms/<name>.yaml
+and data/rooms/<name>/ (visual meshes, the fixed map's points; outside git, rebuilt by this command).
+
+Writes configs/rooms/<name>.yaml and assets/rooms/<name>/floor.png. Everything comes from the recording itself, in its
+own room frame (fw ml/calibrations/readme.md: a config is only valid for the sessions it was recorded with):
+  - anchors: the `anchor_poses` feature (datasets from August 2026 on carry it per frame; constant within a session)
+  - named places: observation.state `<place>_bearing` / `_distance`, which are in the GRIPPER frame:
+        place = gripper_pos_xy + distance * (sin(a), cos(a)),  a = bearing + spin
+    (found 2026-10-08 by trying the conventions: this one puts every frame of playroom-sep29-2 on the same point, std
+    0.00 m; the others scatter by 0.6-1.8 m). A place whose solution is the origin is unset.
+  - floor: the median of the episodes' first overhead frames. The overhead camera is the firmware's orthographic floor
+    view (host/floor_view.py: room origin at the image centre, +y up, 5 m across), so it drops onto the twin's floor
+    at its true scale. Static clutter stays in it: it is the room's look, not something to pick.
+  - eyelets (the indirect lines' far corners) are NOT in the recording: taken from the room's calibration file
+    (fw ml/calibrations) through the 2D similarity that maps that file's two anchors onto the recording's, z = the
+    recording's anchor height. APPROXIMATE (that file is an older calibration of the same room).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import sys
+
+import numpy as np
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+# the firmware's calibration files (cranebot3-firmware src/nf_robot/ml/calibrations): --calibrations or $NF_CALIBRATIONS
+FW_CAL = Path(os.environ.get("NF_CALIBRATIONS", "nf_robot/ml/calibrations"))
+PLACES = ("hamper", "toybox", "trashcan", "gamepad", "parking_location")
+EXTENT_M = 5.0          # fw host/floor_view.EXTENT_M
+
+
+def similarity_2d(src: np.ndarray, dst: np.ndarray):
+    """Scale, rotation, translation mapping 2 src points onto 2 dst points (complex-number form)."""
+    s0, s1 = complex(*src[0]), complex(*src[1])
+    d0, d1 = complex(*dst[0]), complex(*dst[1])
+    a = (d1 - d0) / (s1 - s0)
+    b = d0 - a * s0
+    return lambda p: np.array([(a * complex(*p) + b).real, (a * complex(*p) + b).imag]), abs(a)
+
+
+def floor_median(ds: Path, n_max: int = 60) -> np.ndarray:
+    import av
+    import pandas as pd
+    ep = pd.read_parquet(ds / "meta/episodes/chunk-000/file-000.parquet")
+    col = "videos/observation.images.overhead_camera/from_timestamp"
+    fidx = "videos/observation.images.overhead_camera/file_index"
+    ts = sorted(ep.loc[ep[fidx] == 0, col].values[:n_max] + 0.5)
+    c = av.open(str(ds / "videos/observation.images.overhead_camera/chunk-000/file-000.mp4"))
+    s = c.streams.video[0]
+    s.thread_type = "AUTO"
+    out, i = [], 0
+    for f in c.decode(s):
+        t = float(f.pts * s.time_base)
+        while i < len(ts) and t >= ts[i]:
+            out.append(f.to_ndarray(format="rgb24"))
+            i += 1
+        if i >= len(ts):
+            break
+    return np.median(np.stack(out), 0).astype(np.uint8), len(out)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset")
+    ap.add_argument("--conf", help="fw ml/calibrations/<conf>.json for the eyelets")
+    ap.add_argument("--calibrations", help="the firmware's ml/calibrations folder (default $NF_CALIBRATIONS)")
+    ap.add_argument("--building", help="a scanned building (~/robot-lab/buildings/<name>): import one office of it")
+    ap.add_argument("--office", help="the office's id in building.yaml (e.g. r5)")
+    ap.add_argument("--anchor-z", type=float, default=2.65, help="mount height: ceiling 2.85 less the winch block")
+    ap.add_argument("--name", required=True)
+    args = ap.parse_args()
+    if args.building:
+        return import_building(args)
+    import pandas as pd
+    ds = Path(args.dataset)
+    info = json.loads((ds / "meta/info.json").read_text())
+    df = pd.read_parquet(ds / "data/chunk-000/file-000.parquet")
+    names = info["features"]["observation.state"]["names"]
+    S = np.stack(df["observation.state"].values)
+    col = lambda k: S[:, names.index(k)]  # noqa: E731
+    ap_ = np.stack(df["anchor_poses"].values)
+    assert len(np.unique(ap_.round(4), axis=0)) == 1, "anchors moved within the recording"
+    a = ap_[0].reshape(2, 6)                                     # rx, ry, rz, x, y, z per anchor
+    anchors = a[:, 3:6]
+
+    places = {}
+    g = np.c_[col("gripper_pos_x"), col("gripper_pos_y")]
+    for p in PLACES:
+        ang = col(f"{p}_bearing") + col("spin")
+        P = g + col(f"{p}_distance")[:, None] * np.c_[np.sin(ang), np.cos(ang)]
+        med, sd = np.median(P, 0), P.std(0).max()
+        if sd < 0.02 and np.linalg.norm(med) > 0.05:
+            places[p] = [round(float(med[0]), 3), round(float(med[1]), 3)]
+
+    conf = json.loads((Path(args.calibrations or FW_CAL) / f"{args.conf}.json").read_text())
+    ca = np.array([[x["pose"]["position"][k] if "pose" in x else x["position"][k] for k in "xy"] for x in conf["anchors"]])
+    ce = np.array([[x["indirectLine"]["eyeletPos"][k] for k in "xy"] for x in conf["anchors"]])
+    f, scale = similarity_2d(ca, anchors[:, :2])
+    eyelets = np.array([f(e) for e in ce])
+    z = anchors[:, 2]
+    # line order (fw-sim): 0 anchor0 direct, 1 anchor0 indirect via its eyelet, 2 anchor1 direct, 3 anchor1 indirect
+    mounts = [anchors[0, :2], eyelets[0], anchors[1, :2], eyelets[1]]
+    mz = [z[0], z[0], z[1], z[1]]
+    runs = [0.0, float(np.linalg.norm(eyelets[0] - anchors[0, :2])), 0.0, float(np.linalg.norm(eyelets[1] - anchors[1, :2]))]
+
+    img, n = floor_median(ds)
+    out_dir = ROOT / "assets/rooms" / args.name
+    out_dir.mkdir(parents=True, exist_ok=True)
+    from PIL import Image
+    Image.fromarray(img).save(out_dir / "floor.png")
+    gan = np.c_[col("gantry_position_x"), col("gantry_position_y"), col("gantry_position_z")]
+    room = {
+        "source": {"dataset": f"naavox/{ds.name}", "frames": int(len(df)), "conf_for_eyelets": args.conf,
+                   "eyelet_similarity_scale": round(float(scale), 3), "floor_median_of": int(n)},
+        "mounts_xyz": [[round(float(m[0]), 3), round(float(m[1]), 3), round(float(zz), 3)] for m, zz in zip(mounts, mz)],
+        "indirect_run_m": [round(r, 3) for r in runs],
+        "ceiling_m": round(float(z.max()) + 0.13, 3),           # docs: anchors ~13 cm below the ceiling
+        "named_places": places,
+        "floor_image": {"path": f"assets/rooms/{args.name}/floor.png", "extent_m": EXTENT_M, "centre": [0.0, 0.0]},
+        "recorded_gantry_box": [[round(float(gan[:, i].min()), 2), round(float(gan[:, i].max()), 2)] for i in range(3)],
+        "anchor_yaw_rad": [round(float(a[0, 2]), 3), round(float(a[1, 2]), 3)],
+    }
+    path = ROOT / "configs/rooms" / f"{args.name}.yaml"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(f"# Imported by scripts/import_room.py from naavox/{ds.name} (see its docstring for each field's source).\n"
+                    + yaml.safe_dump(room, sort_keys=False))
+    print(path.read_text())
+
+
+# ----------------------------------------------------------------------------------------------- a scanned building
+def floor_field(P, box, fz, cell=0.25):
+    """The scanned floor's height as a smooth field f(x, y): the scan is not flat. r5's floor points wander from -6.7 to
+    +1.0 cm (0.6 m cell medians, 2026-10-13; a RANSAC plane came out 1.05 deg tilted and left the open floor at
+    +1.7 cm median): Polycam drift, not a sloping office. Per 25 cm cell: the median of the points within 4 cm of
+    the cell's 10th percentile (the floor, not a chair leg), cells with < 20 such points filled from the nearest
+    measured ones (under the table), then smoothed (sigma 2 cells). Returns f (callable on (n, 2)), its grid."""
+    from scipy import ndimage
+    from scipy.interpolate import NearestNDInterpolator, RegularGridInterpolator
+    x0, x1, y0, y1 = box
+    Q = P[(P[:, 0] > x0) & (P[:, 0] < x1) & (P[:, 1] > y0) & (P[:, 1] < y1) & (np.abs(P[:, 2] - fz) < 0.12)]
+    nx, ny = int(np.ceil((x1 - x0) / cell)), int(np.ceil((y1 - y0) / cell))
+    ij = np.minimum(((Q[:, :2] - [x0, y0]) / cell).astype(int), [nx - 1, ny - 1])
+    G = np.full((nx, ny), np.nan)
+    key = ij[:, 0] * ny + ij[:, 1]
+    order = np.argsort(key)
+    ks, starts = np.unique(key[order], return_index=True)
+    for k, a, b in zip(ks, starts, np.r_[starts[1:], len(order)]):
+        z = Q[order[a:b], 2]
+        lo = np.percentile(z, 10)
+        z = z[z < lo + 0.04]
+        if len(z) >= 20:
+            G[k // ny, k % ny] = np.median(z)
+    ok = ~np.isnan(G)
+    ii, jj = np.nonzero(ok)
+    fill = NearestNDInterpolator(np.c_[ii, jj], G[ok])
+    ai, aj = np.nonzero(~ok)
+    if len(ai):
+        G[~ok] = fill(np.c_[ai, aj])
+    G = ndimage.gaussian_filter(G, 2.0, mode="nearest")
+    xs, ys = x0 + (np.arange(nx) + 0.5) * cell, y0 + (np.arange(ny) + 0.5) * cell
+    f = RegularGridInterpolator((xs, ys), G, bounds_error=False, fill_value=None)
+    return lambda xy: f(np.clip(xy, [xs[0], ys[0]], [xs[-1], ys[-1]])), G, float(ok.mean())
+
+
+def import_building(args):
+    """One office of a scanned building -> a room for the cable robot.
+
+      - mounts: the office's four corners at anchor height, found from the scan, not typed in: the free space in the
+        band 1.0 m .. anchor_z + 0.15 m (wall points occupy a 4 cm grid; the anchor band alone leaked out of r5
+        through two scan holes in its walls, 2026-10-13), the connected part around the office centre,
+        eroded 5 cm (fw definitions: eyelets 5 cm off the walls); the corner = the free cell furthest along
+        (+-1, +-1). Order as scripts/make_room3d.py (CCW from +x+y; lines 0, 2 direct, 1, 3 via eyelets along a wall).
+      - the room frame: origin on the floor under the mounts' centre, axes = the building's (pose in building.yaml)
+      - the visual mesh: the OBJ's faces in the office box (+30 cm: its walls), the ceiling dropped (the overhead
+        camera hangs under it), one mesh per texture. VISUAL ONLY in the plant (contype 0).
+      - the fixed map's points: the PLY in the same crop (data/rooms/<name>/fixed_points.npy, xyz + rgb).
+      - supports: the floor and each large horizontal surface (upward mesh faces 0.3-1.5 m, clustered by height and
+        place, >= 0.25 m^2): a table top's height and box. The plant gets a thin collision box under each so waste
+        can lie on it (the mesh itself has no contacts).
+      - the bin (named place `hamper`): free floor near a wall, >= 0.6 m inside the mount polygon, nothing of the
+        scan 0.1-1.5 m above within 0.45 m."""
+    from scipy import ndimage
+    from cablepilot.roommap.scan import load_building, load_mtl, load_obj, load_ply, obj_to_frame, write_obj
+    bdir, B = load_building(args.building)
+    off = B["offices"][args.office]
+    x0, x1, y0, y1 = off["box"]
+    fz = float(B["floor_z"])
+    P, C = load_ply(bdir / B["files"]["points"])
+    pad = 0.3
+    near = (P[:, 0] > x0 - pad) & (P[:, 0] < x1 + pad) & (P[:, 1] > y0 - pad) & (P[:, 1] < y1 + pad)
+    # the office's own floor, FOUND (armpilot scan_furniture: RANSAC, "found, not given"): the building's floor_z is
+    # the whole floor's histogram peak, and r5's floor lies 2.2 cm under it (median, 2026-10-13); a level-floor
+    # assumption left a speckle of "obstacle" voxels 2-4 cm up all over the room
+    ffield, G, measured = floor_field(P, (x0 - pad, x1 + pad, y0 - pad, y1 + pad), fz)
+    P = P.copy()
+    P[near, 2] -= ffield(P[near, :2])                        # flatten (the same correction for the mesh below)
+    fz_mean = float(np.mean(G))
+
+    # mounts: free space at anchor height
+    res = 0.04
+    lo = np.array([x0 - pad, y0 - pad])
+    shape = (np.array([x1 - x0, y1 - y0]) + 2 * pad) / res
+    shape = shape.astype(int) + 1
+    band = near & (P[:, 2] > 1.0) & (P[:, 2] < args.anchor_z + 0.15)
+    occ = np.zeros(shape, bool)
+    ij = ((P[band, :2] - lo) / res).astype(int)
+    occ[ij[:, 0], ij[:, 1]] = True
+    occ = ndimage.binary_closing(occ, iterations=2)          # the scan's 2.2 cm points leave pinholes in a wall
+    lab, _ = ndimage.label(~occ)
+    c_ij = ((np.array([(x0 + x1) / 2, (y0 + y1) / 2]) - lo) / res).astype(int)
+    free = ndimage.binary_erosion(lab == lab[tuple(c_ij)], iterations=2)   # 2 cells = 8 cm from a wall point's cell
+    fi, fj = np.nonzero(free)
+    cells = lo + (np.c_[fi, fj] + 0.5) * res
+    M = []
+    for d in ((1, 1), (-1, 1), (-1, -1), (1, -1)):
+        M.append(cells[np.argmax(cells @ np.array(d, float))])
+    M = np.array(M)
+    O = M.mean(0).round(3)                                   # the room frame's origin (floor under the mounts' centre)
+    mounts = np.c_[M - O, np.full(4, args.anchor_z)]
+    runs = [0.0, float(np.linalg.norm(M[1] - M[0])), 0.0, float(np.linalg.norm(M[3] - M[2]))]
+
+    out = ROOT / "data/rooms" / args.name
+    out.mkdir(parents=True, exist_ok=True)
+    keep = near & (P[:, 2] > -0.05) & (P[:, 2] < off["ceiling_m"] - 0.1)
+    pts = np.c_[P[keep] - [*O, 0], C[keep]].astype(np.float32)
+    np.save(out / "fixed_points.npy", pts)
+
+    V, T, Fc, Mt = load_obj(bdir / B["files"]["mesh"])
+    V = obj_to_frame(V)                                      # the mesh shares the PLY's frame (same capture)
+    V[:, 2] -= ffield(V[:, :2])
+    V = V - [*O, 0]
+    A = V[Fc[:, :, 0]]
+    nrm = np.cross(A[:, 1] - A[:, 0], A[:, 2] - A[:, 0])
+    area = np.linalg.norm(nrm, axis=1) / 2
+    up = nrm[:, 2] / (2 * area + 1e-12)
+    cen = A.mean(1)
+    bx0, bx1, by0, by1 = x0 - O[0] - pad, x1 - O[0] + pad, y0 - O[1] - pad, y1 - O[1] + pad
+    inbox = (cen[:, 0] > bx0) & (cen[:, 0] < bx1) & (cen[:, 1] > by0) & (cen[:, 1] < by1)
+    keepF = inbox & ~((cen[:, 2] > off["ceiling_m"] - 0.25) & (up < -0.5))
+    mtl = load_mtl(bdir / B["files"]["mesh"].replace(" ", "_").replace(".obj", ".mtl"))
+    meshes = []
+    for k, mat in enumerate(sorted(set(Mt[keepF]))):
+        sel = keepF & (Mt == mat)
+        n = write_obj(out / f"mesh_{k}.obj", V, T, Fc[sel])
+        from PIL import Image                                 # MuJoCo reads PNG textures, not the scan's JPEGs
+        Image.open(bdir / mtl[mat]).convert("RGB").save(out / f"mesh_{k}.png")
+        meshes.append({"obj": f"mesh_{k}.obj", "texture": f"mesh_{k}.png", "faces": int(n)})
+
+    # supports: large horizontal surfaces above the floor
+    hz = keepF & (up > 0.95) & (cen[:, 2] > 0.3) & (cen[:, 2] < 1.5)
+    supports = [{"name": "floor", "z": 0.0}]
+    g = 0.05
+    zb = np.round(cen[hz, 2] / 0.02).astype(int)
+    for zk in np.unique(zb):
+        s = np.nonzero(hz)[0][np.abs(zb - zk) <= 1]
+        if area[s].sum() < 0.25:
+            continue
+        q = ((cen[s, :2] - [bx0, by0]) / g).astype(int)
+        grid = np.zeros((int((bx1 - bx0) / g) + 1, int((by1 - by0) / g) + 1), bool)
+        grid[q[:, 0], q[:, 1]] = True
+        grid = ndimage.binary_closing(grid, iterations=2)
+        lab, nl = ndimage.label(grid)
+        for L in range(1, nl + 1):
+            mem = lab[q[:, 0], q[:, 1]] == L
+            if area[s[mem]].sum() < 0.25 or any(abs(sp["z"] - np.average(cen[s[mem], 2], weights=area[s[mem]])) < 0.03
+                                                 and sp.get("_l") == (zk, L) for sp in supports):
+                continue
+            xy = cen[s[mem], :2]
+            zz = float(np.average(cen[s[mem], 2], weights=area[s[mem]]))
+            if any(sp["name"] != "floor" and abs(sp["z"] - zz) < 0.03 and np.all(np.abs(np.mean(xy, 0) - np.mean(sp["box"], 1)) < 0.3)
+                   for sp in supports):
+                continue                                      # the same table seen in the neighbouring height bin
+            bxy = np.percentile(xy, [3, 97], axis=0)
+            supports.append({"name": f"top{len(supports)}", "z": round(zz, 3),
+                             "box": [[round(float(bxy[0, 0]), 3), round(float(bxy[1, 0]), 3)],
+                                     [round(float(bxy[0, 1]), 3), round(float(bxy[1, 1]), 3)]],
+                             "area_m2": round(float(area[s[mem]].sum()), 2)})
+
+    # one table, one support: the height bins overlap (r5's table came out three times, 0.710 / 0.717 / 0.718 m,
+    # boxes inside each other, 2026-10-13): merge same-height (3 cm) supports whose boxes overlap into their union
+    tops = [sp for sp in supports if "box" in sp]
+    merged = True
+    while merged:
+        merged = False
+        for i in range(len(tops)):
+            for j in range(i + 1, len(tops)):
+                a, b = tops[i], tops[j]
+                (ax0, ax1), (ay0, ay1) = a["box"]
+                (bx0_, bx1_), (by0_, by1_) = b["box"]
+                if abs(a["z"] - b["z"]) < 0.03 and ax0 < bx1_ and bx0_ < ax1 and ay0 < by1_ and by0_ < ay1:
+                    w = a["area_m2"] + b["area_m2"]
+                    a["z"] = round((a["z"] * a["area_m2"] + b["z"] * b["area_m2"]) / w, 3)
+                    a["box"] = [[min(ax0, bx0_), max(ax1, bx1_)], [min(ay0, by0_), max(ay1, by1_)]]
+                    a["area_m2"] = round(max(a["area_m2"], b["area_m2"]), 2)       # nested bins: the larger, not the sum
+                    tops.pop(j)
+                    merged = True
+                    break
+            if merged:
+                break
+    supports = [supports[0]] + [{**t, "name": f"table{k}"} for k, t in enumerate(tops)]
+
+    # the bin: free floor near a wall
+    from cablepilot.sim.kin import ccw_polygon
+    poly = ccw_polygon(mounts[:, :2])
+    e = np.roll(poly, -1, 0) - poly
+    nr = np.c_[-e[:, 1], e[:, 0]] / np.linalg.norm(e, axis=1)[:, None]
+    tall = pts[(pts[:, 2] > 0.1) & (pts[:, 2] < 1.5), :2]
+    from scipy.spatial import cKDTree
+    tree = cKDTree(tall)
+    best = None
+    for x in np.arange(poly[:, 0].min(), poly[:, 0].max(), 0.05):
+        for y in np.arange(poly[:, 1].min(), poly[:, 1].max(), 0.05):
+            q = np.array([x, y])
+            ins = ((q - poly) * nr).sum(1).min()
+            if ins < 0.6 or tree.query(q)[0] < 0.45:
+                continue
+            if best is None or ins < best[0]:                 # nearest a wall (yet >= 0.6 m in)
+                best = (ins, q)
+    hamper = best[1].round(3).tolist()
+
+    room = {"source": {"building": str(bdir).replace(str(Path.home()), "~"), "office": args.office, "imported_by": "scripts/import_room.py --building",
+                       "scan_points_kept": int(keep.sum())},
+            "floor_flattened": {"note": "scan z - f(x, y), f = the scanned floor's smooth height (floor_field)",
+                                "f_range_m": [round(float(G.min()), 4), round(float(G.max()), 4)],
+                                "cells_measured": round(measured, 2)},
+            "building_pose": {"xyz": [float(O[0]), float(O[1]), round(fz_mean, 4)], "yaw_rad": 0.0,
+                              "note": "room frame = building frame shifted by xyz (floor at z 0); same axes"},
+            "size_m": [round(float(np.ptp(M[:, 0])), 3), round(float(np.ptp(M[:, 1])), 3)],
+            "mounts_xyz": mounts.round(3).tolist(), "indirect_run_m": [round(r, 3) for r in runs],
+            "ceiling_m": float(off["ceiling_m"]),
+            "named_places": {"hamper": hamper},
+            "scan": {"dir": f"data/rooms/{args.name}", "meshes": meshes, "points": "fixed_points.npy",
+                     "box": [[round(float(bx0), 3), round(float(bx1), 3)], [round(float(by0), 3), round(float(by1), 3)]]},
+            "supports": supports}
+    path = ROOT / "configs/rooms" / f"{args.name}.yaml"
+    path.write_text(f"# One office of a scanned building ({B['name']}, office {args.office}), imported by "
+                    f"scripts/import_room.py --building (see import_building's docstring for each field's source).\n"
+                    + yaml.safe_dump(room, sort_keys=False))
+    print(path.read_text())
+
+
+if __name__ == "__main__":
+    main()

scripts/train_cdpr_wm.py

@@ -0,0 +1,358 @@
+"""Train the Stringman SkyJEPA (cablepilot/model/learned.py) on task-free data, then test 1: open-loop prediction.
+(armpilot's scripts/train_arm_wm.py on the cable robot.)
+
+    python scripts/train_cdpr_wm.py --data data/cdpr_v0_playroom --out checkpoints/cdpr_wm_v0.pt
+    python scripts/train_cdpr_wm.py --eval-only --out checkpoints/cdpr_wm_v0.pt
+
+Stage 1 (task-free JEPA): predict the next 2 s of state latents from 1 s of history and the commands,
+loss = MSE(pred, target) + 0.02 SIGReg(pred), as SkyJEPA. Stage 2: the prober on frozen latents, loss = weighted MSE of
+the integrated states (normalised) against the recorded ones, the end of the horizon weighted most. The prober's last
+layer starts at zero: training starts exactly at the hand-written backbone and learns only the correction.
+
+Test 1 (docs/MILESTONES.md M1, the bar set before training): on held-out windows, after 20 steps (2.0 s): grasp point
+error <= 2 cm median (also on payload windows), pole tilt error <= 2 deg median; next to the nominal oracle (MuJoCo, no
+eta, no payload) and the backbone alone (nothing learned).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from cablepilot.model.learned import JEPA, Normalizer, Prober, features, integrate  # noqa: E402
+
+H, L = 10, 20
+L_SWING_DATA = 0.3089  # the data's pendulum (fw, Stringman hand); load() sets it from the manifest's hand
+D_G = -0.5147          # grasp point down the pole; load() sets it from the data's manifest (SO-101 hand: -0.472)
+# the machine the data came from (manifest "machine"; Stringman when absent) and its backbone priors: the person lift's
+# swing runs over a 2.4x range of lengths (empty harness .. a person), its spools ramp at 0.8 m/s^2 (P1, 2026-10-12)
+MACHINE, OMEGA_SPAN, A_MAX0 = "configs/stringman.yaml", 0.3, 0.25
+# Stage-2 error scales per state dim, in METRES / radians: an error of one scale costs 1. In normalised units (v0) a 5 cm
+# position error cost ~0.003 next to the swing and rate terms, and the grasp-point error at 2 s ROSE during stage 2
+# (53 -> 68 mm) while the loss fell; near-still windows came out at 80 mm against 33 mm for "integrate the command"
+# (2026-10-08). p 2 cm, v 5 cm/s, s 0.01 (~0.6 deg), s_dot 0.1 /s, wrist 0.1 rad, wrist rate 0.5, closure 0.05, its rate 0.5.
+E_SCALE = torch.tensor([0.02, 0.02, 0.02, 0.05, 0.05, 0.05, 0.01, 0.01, 0.1, 0.1, 0.1, 0.5, 0.05, 0.5])
+
+
+class SIGReg(nn.Module):
+    """LeJEPA's Sketched Isotropic Gaussian Regularisation (copied from armpilot, from LeDrone/skyjepa)."""
+
+    def __init__(self, n_directions=64, n_knots=17):
+        super().__init__()
+        nodes, weights = np.polynomial.hermite.hermgauss(n_knots)
+        self.n = n_directions
+        self.register_buffer("nodes", torch.tensor(nodes, dtype=torch.float32))
+        self.register_buffer("weights", torch.tensor(weights, dtype=torch.float32))
+        self.register_buffer("gauss_cf", torch.tensor(np.exp(-nodes ** 2 / 2.0), dtype=torch.float32))
+
+    def forward(self, lat):                      # (T, B, D)
+        T, B, D = lat.shape
+        u = torch.randn(self.n, D)
+        u = u / (u.norm(dim=1, keepdim=True) + 1e-8)
+        stat = lat.new_zeros(())
+        for t in range(T):
+            arg = (lat[t] @ u.t()).unsqueeze(-1) * self.nodes.view(1, 1, -1)
+            C, S = torch.cos(arg).mean(0), torch.sin(arg).mean(0)
+            stat = stat + B * (((C - self.gauss_cf) ** 2 + S ** 2) * self.weights).sum(1).mean()
+        return stat / T
+
+
+def load(data):
+    """One dataset directory, or several joined with commas: (X, A, P, M, R, dt). M (N, 4, 3) mounts and R (N, 4) runs
+    per trajectory (shards from a fixed room without them: the scenario's)."""
+    dirs = [Path(d) for d in str(data).split(",")]
+    parts = []
+    for d in dirs:
+        shards = sorted(d.glob("shard_*.npz"))
+        X, A, P, M, R = [], [], [], [], []
+        man = json.loads((d / "manifest.json").read_text())
+        global D_G, L_SWING_DATA, MACHINE, OMEGA_SPAN, A_MAX0
+        D_G = float(man.get("dG", D_G))
+        from cablepilot.sim.scene import load_config as _lc
+        if man.get("machine"):  # another machine (P1: the person lift): its own pendulum and spools
+            MACHINE = man["machine"]
+            mc = _lc(machine=MACHINE)
+            L_SWING_DATA = float(mc["body"]["swing_length_m"])
+            A_MAX0 = float(mc["spool"]["line_accel_mps2"])
+            OMEGA_SPAN = 1.0 if mc.get("hand") == "harness" else 0.3
+        elif man.get("hand"):   # the hand's pendulum, to start the backbone's swing from (Prober l_swing)
+            L_SWING_DATA = float(_lc(hand=man["hand"])["body"]["swing_length_m"])
+        for f in shards:
+            z = np.load(f)
+            X.append(z["states"])
+            A.append(z["actions"])
+            P.append(z["payload"])
+            if "mounts" in z:
+                M.append(z["mounts"])
+                R.append(z["runs"])
+            else:
+                from cablepilot.sim.scene import load_config, mounts
+                c = load_config(machine=MACHINE, scenario=man["scenario"])
+                M.append(np.repeat(mounts(c)[None].astype(np.float32), len(z["states"]), 0))
+                R.append(np.repeat(np.asarray(c["room"]["indirect_run_m"], np.float32)[None], len(z["states"]), 0))
+        parts.append([np.concatenate(v) for v in (X, A, P, M, R)] + [float(np.load(shards[0])["dt"])])
+    if len(parts) == 1:
+        return tuple(parts[0])
+    k = min(len(p[0]) for p in parts)   # interleave so that the held-out tail holds trajectories of every set
+    return tuple(np.stack([p[j][:k] for p in parts], 1).reshape(-1, *parts[0][j].shape[1:]) for j in range(5)) + (parts[0][5],)
+
+
+def windows(X, A, idx, rng, B, M, P=None):
+    i = rng.choice(idx, B)
+    t = rng.integers(0, A.shape[1] - (H + L) + 1, B)
+    ar = np.arange(H + 1 + L)
+    out = [torch.as_tensor(X[i[:, None], t[:, None] + ar]), torch.as_tensor(A[i[:, None], t[:, None] + ar[:-1]]),
+           torch.as_tensor(M[i])]
+    if P is not None:
+        out += [P[i[:, None], t[:, None] + ar], i]
+    return out
+
+
+def lr_at(step, total, peak, final=1e-4, warm=200):
+    if step < warm:
+        return peak * step / warm
+    p = (step - warm) / max(1, total - warm)
+    return final + (peak - final) * 0.5 * (1 + math.cos(math.pi * p))
+
+
+def grasp_point(x):
+    s = x[..., 6:8]
+    z = np.sqrt(np.clip(1 - (s ** 2).sum(-1, keepdims=True), 1e-6, None))
+    return x[..., 0:3] + D_G * np.concatenate([s, z], -1)
+
+
+def train(args):
+    X, A, P, M, R, dt = load(args.data)
+    n = len(X)
+    rng = np.random.default_rng(0)
+    test_idx, train_idx = np.arange(n - args.test, n), np.arange(0, n - args.test)
+    with torch.no_grad():
+        sub = features(torch.as_tensor(X[train_idx[:2000], ::5]), torch.as_tensor(M[train_idx[:2000]])[:, None]).reshape(-1, 28).numpy()
+    asub = A[train_idx[:2000]].reshape(-1, 5)
+    norm = Normalizer(sub.mean(0), sub.std(0) + 1e-3, asub.mean(0), asub.std(0) + 1e-3)
+    cfg = {"latent": 24, "action_latent": 12, "hidden": 48, "prober_hidden": 64, "H": H, "L": L, "dt": dt,
+           "data": str(args.data), "trajectories_train": int(len(train_idx)), "l_swing": L_SWING_DATA,
+           "omega_span": OMEGA_SPAN, "a_max0": A_MAX0, "machine": MACHINE}
+    torch.manual_seed(0)
+    jepa, prober, sig = JEPA(cfg["latent"], cfg["action_latent"], cfg["hidden"]), Prober(cfg["latent"], cfg["prober_hidden"], cfg["l_swing"], cfg["omega_span"], cfg["a_max0"]), SIGReg()
+    n_j, n_p = sum(p.numel() for p in jepa.parameters()), sum(p.numel() for p in prober.parameters())
+    print(f"{n} trajectories ({len(train_idx)} train, {len(test_idx)} test), dt {dt * 1000:.0f} ms; "
+          f"JEPA {n_j} params, prober {n_p}", flush=True)
+    t0 = time.perf_counter()
+    opt = torch.optim.Adam(jepa.parameters(), lr=args.lr, weight_decay=1e-5)
+    if args.stage1_from:                             # reuse stage 1 (frozen latents) from an earlier checkpoint
+        old = torch.load(args.stage1_from, weights_only=False)
+        jepa.load_state_dict(old["jepa"])
+        norm = Normalizer(**old["norm"])
+        print(f"stage 1 from {args.stage1_from}", flush=True)
+    for step in range(0 if args.stage1_from else args.steps1):
+        for g in opt.param_groups:
+            g["lr"] = lr_at(step, args.steps1, args.lr)
+        xs, acts, Mw = windows(X, A, train_idx, rng, args.batch, M)
+        pred, tgt = jepa(norm.s(features(xs, Mw[:, None])), norm.a(acts), H)
+        l_pred = ((pred - tgt) ** 2).mean()
+        l_sig = sig(pred.transpose(0, 1)[::4])
+        loss = l_pred + 0.02 * l_sig
+        opt.zero_grad()
+        loss.backward()
+        nn.utils.clip_grad_norm_(jepa.parameters(), 0.5)
+        opt.step()
+        if step % 250 == 0 or step == args.steps1 - 1:
+            std = pred.detach().reshape(-1, pred.shape[-1]).std(0).min().item()
+            print(f"  stage 1  step {step:5d}  L_pred {l_pred.item():.4f}  L_sig {l_sig.item():.3f}  "
+                  f"latent min std {std:.3f}  {time.perf_counter() - t0:.0f} s", flush=True)
+    t1 = time.perf_counter() - t0
+    jepa.eval()
+    for p in jepa.parameters():
+        p.requires_grad_(False)
+    opt = torch.optim.Adam(prober.parameters(), lr=args.lr2, weight_decay=1e-5)
+    tw = torch.linspace(0.3, 1.0, L)[None, :, None]
+    for step in range(args.steps2):
+        for g in opt.param_groups:
+            g["lr"] = lr_at(step, args.steps2, args.lr2)
+        xs, acts, Mw = windows(X, A, train_idx, rng, args.batch, M)
+        with torch.no_grad():
+            pred, _ = jepa(norm.s(features(xs, Mw[:, None])), norm.a(acts), H)
+        out = integrate(xs[:, H], acts[:, H:], acts[:, H - 1], pred, prober, dt, norm, Mw)
+        err = nn.functional.huber_loss((out - xs[:, H + 1:]) / E_SCALE, torch.zeros_like(out), reduction="none", delta=3.0)
+        loss = (err * tw).mean()
+        opt.zero_grad()
+        loss.backward()
+        nn.utils.clip_grad_norm_(prober.parameters(), 0.5)
+        opt.step()
+        if step % 250 == 0 or step == args.steps2 - 1:
+            g_err = np.linalg.norm(grasp_point(out[:, -1].detach().numpy()) - grasp_point(xs[:, -1].numpy()), axis=-1)
+            print(f"  stage 2  step {step:5d}  loss {loss.item():.4f}  grasp-point error at 2 s median "
+                  f"{1000 * np.median(g_err):.1f} mm  {time.perf_counter() - t0:.0f} s", flush=True)
+    ckpt = {"config": cfg, "jepa": jepa.state_dict(), "prober": prober.state_dict(), "norm": norm.state_dict(),
+            "train_s": time.perf_counter() - t0, "stage1_s": t1, "params": {"jepa": n_j, "prober": n_p}}
+    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+    torch.save(ckpt, args.out)
+    print(f"saved {args.out}  ({time.perf_counter() - t0:.0f} s)")
+    return X, A, P, M, R, test_idx
+
+
+def tilt_angle_err(a, b):
+    def axis(x):
+        s = x[..., 6:8]
+        return np.concatenate([s, np.sqrt(np.clip(1 - (s ** 2).sum(-1, keepdims=True), 1e-6, None))], -1)
+    c = np.clip((axis(a) * axis(b)).sum(-1), -1, 1)
+    return np.degrees(np.arccos(c))
+
+
+def test1(args, data=None, test_idx=None):
+    from cablepilot.model.learned import LearnedCDPRModel
+    from cablepilot.model.oracle import OracleWorldModel
+    from cablepilot.sim.scene import load_config
+    if data is None:
+        data = load(args.data)
+        test_idx = np.arange(len(data[0]) - args.test, len(data[0]))
+    X, A, P, M, R, dt = data
+    manifest = json.loads((Path(str(args.data).split(",")[0]) / "manifest.json").read_text())
+    cfg = load_config(machine=manifest.get("machine", "configs/stringman.yaml"), scenario=manifest["scenario"],
+                      hand=manifest.get("hand"))
+    person = cfg.get("hand") == "harness"
+    ck = torch.load(args.out, weights_only=False)
+    model = LearnedCDPRModel(ck, dt=ck["config"]["dt"])
+    rng = np.random.default_rng(123)
+    xs, acts, Mw, pay, traj = windows(X, A, test_idx, rng, args.n_eval, M, P)
+    xs, acts = xs.numpy(), acts.numpy()
+    payload_w = (pay > 1e-3).any(1)
+    event_w = np.ptp(pay, axis=1) > 1.0                       # the person's weight coming on / going off / shifting
+    t0 = time.perf_counter()
+    learned = []
+    for b in range(len(xs)):
+        model.set_room(M[traj[b]])
+        learned.append(model.predict(xs[b, :H + 1], acts[b, :H], acts[b:b + 1, H:]).numpy())
+    learned = np.concatenate(learned)
+    t_l = (time.perf_counter() - t0) / len(xs)
+    # the person lift's stiff lines need the 2 ms step; its oracle is told 75 kg (the range's middle), never the truth
+    orc = OracleWorldModel(cfg, dt=ck["config"]["dt"], timestep=0.002 if person else 0.01, nthread=4,
+                           payload_kg=75.0 if person else 0.0)
+    t0 = time.perf_counter()
+    oracle, last = [], None
+    for b in range(len(xs)):
+        j = traj[b]
+        if last is None or not np.allclose(M[j], last):       # the oracle in this window's room
+            orc.set_room({"mounts_xyz": M[j].tolist(), "indirect_run_m": R[j].tolist()})
+            last = M[j]
+        oracle.append(orc.rollout(xs[b, H][None], acts[b, H - 1][None], acts[b:b + 1, H:]).numpy())
+    oracle = np.concatenate(oracle)
+    t_o = (time.perf_counter() - t0) / len(xs)
+    fresh = Prober(ck["config"]["latent"], ck["config"]["prober_hidden"], ck["config"].get("l_swing", 0.3089),
+                   ck["config"].get("omega_span", 0.3), ck["config"].get("a_max0", 0.25))   # the hand-written backbone alone
+    with torch.no_grad():
+        bb = integrate(torch.as_tensor(xs[:, H]), torch.as_tensor(acts[:, H:]), torch.as_tensor(acts[:, H - 1]),
+                       torch.zeros(len(xs), L, ck["config"]["latent"]), fresh, ck["config"]["dt"], model.norm,
+                       torch.as_tensor(M[traj])).numpy()
+    truth = xs[:, -1]
+    res = {}
+    for name, pr in (("learned", learned[:, -1]), ("oracle", oracle[:, -1]), ("backbone", bb[:, -1])):
+        e = np.linalg.norm(grasp_point(pr) - grasp_point(truth), axis=-1) * 1000
+        ea = tilt_angle_err(pr, truth)
+        eh = np.linalg.norm(pr[:, 0:3] - truth[:, 0:3], axis=-1) * 1000
+        res[name] = {"g_med_mm": float(np.median(e)), "g_p90_mm": float(np.percentile(e, 90)),
+                     "g_payload_med_mm": float(np.median(e[payload_w])), "tilt_med_deg": float(np.median(ea)),
+                     "tilt_p90_deg": float(np.percentile(ea, 90)),
+                     "hook_med_mm": float(np.median(eh)), "hook_event_med_mm": float(np.median(eh[event_w])) if event_w.any() else None,
+                     "tilt_event_med_deg": float(np.median(ea[event_w])) if event_w.any() else None}
+    print(f"\nTEST 1 · {args.data} · open loop, {len(xs)} held-out windows ({payload_w.sum()} with payload on or changing), "
+          f"{len(set(map(tuple, M[traj].reshape(len(traj), -1).round(3))))} rooms, after {L} steps ({L * ck['config']['dt']:.1f} s)")
+    print("(backbone = hand-written physics alone, nothing learned; oracle = MuJoCo in the same room, nominal physics, no payload)")
+    print(f"{'model':9s} {'grasp pt median':>15s} {'p90':>8s} {'payload median':>15s} {'tilt median':>12s} {'p90':>7s}")
+    for k, r in res.items():
+        print(f"{k:9s} {r['g_med_mm']:12.1f} mm {r['g_p90_mm']:5.1f} mm {r['g_payload_med_mm']:12.1f} mm "
+              f"{r['tilt_med_deg']:9.2f} deg {r['tilt_p90_deg']:4.2f}")
+    r = res["learned"]
+    if person:   # P1 (docs/MILESTONES.md): hook <= 20 mm, also on attach / set-down windows; swing <= 1.5 deg
+        f1 = lambda v: "n/a" if v is None else f"{v:.1f}"
+        print(f"\nP1 · {event_w.sum()} windows where the person's weight changes. At 2 s:")
+        for k, v in res.items():
+            print(f"  {k:9s} hook {v['hook_med_mm']:.1f} mm (events {f1(v['hook_event_med_mm'])}), swing "
+                  f"{v['tilt_med_deg']:.2f} deg (events {f1(v['tilt_event_med_deg'])}), person COM {v['g_med_mm']:.1f} mm")
+        ok = (r["hook_med_mm"] <= 20 and (r["hook_event_med_mm"] is None or r["hook_event_med_mm"] <= 20)
+              and r["tilt_med_deg"] <= 1.5)
+        print(f"P1 model bar (hook <= 20 mm, also on events; swing <= 1.5 deg): {'YES' if ok else 'NO'}")
+        res["weigh"] = weigh_test(args, cfg, test_idx)
+    else:
+        ok = r["g_med_mm"] <= 20 and r["g_payload_med_mm"] <= 20 and r["tilt_med_deg"] <= 2
+        print(f"pass (<= 20 mm, <= 20 mm on payload, <= 2 deg): {'YES' if ok else 'NO'}")
+    print(f"learned {t_l * 1000:.1f} ms per window (S = 1), oracle {t_o * 1000:.1f} ms")
+    Path(args.out).with_suffix(f".test1.{Path(str(args.data).split(',')[0]).name}.json").write_text(json.dumps(res, indent=1))
+
+
+def weigh_test(args, cfg, test_idx):
+    """P1's weighing bar: 1 s after every attach ends in the held-out trajectories, the lines' weighing
+    (perception/weigh.py: mean vertical pull over that second / g - the rig's nominal mass) within 10 % of the person."""
+    from cablepilot.perception.weigh import rig_mass, weigh_kg
+    shards = sorted(Path(str(args.data).split(",")[0]).glob("shard_*.npz"))
+    S, TEN, PAY, MO = [], [], [], []
+    for f in shards:
+        z = np.load(f)
+        S.append(z["states"]), TEN.append(z["tensions"]), PAY.append(z["payload"]), MO.append(z["mounts"])
+    S, TEN, PAY, MO = (np.concatenate(v) for v in (S, TEN, PAY, MO))
+    rig, errs = rig_mass(cfg), []
+    for j in test_idx:
+        p = PAY[j]
+        k = 1
+        while k < len(p):
+            if p[k - 1] < 1.0 <= p[k]:                       # an attach starts
+                e = k
+                while e + 1 < len(p) and abs(p[e + 1] - p[e]) > 1e-3:
+                    e += 1                                    # ... and ends at e
+                # an attach that ENDS with a person on (2026-10-12: one attach in the held-out set was cut off by a
+                # set-down back to 0 kg, and the first run divided by that 0)
+                if e + 10 < len(p) and p[e] >= 1.0 and abs(p[e + 10] - p[e]) < 1e-3:
+                    w = slice(e + 1, e + 11)                  # the second after it ends
+                    est = weigh_kg(TEN[j, w], S[j, w, 0:3], MO[j], rig)
+                    errs.append(abs(est - p[e + 10]) / p[e + 10])
+                k = e + 1
+            k += 1
+    errs = np.array(errs) * 100
+    if not len(errs):
+        print("weighing: no complete attach in the held-out set")
+        return None
+    r = {"attaches": int(len(errs)), "median_pct": float(np.median(errs)), "p90_pct": float(np.percentile(errs, 90)),
+         "max_pct": float(errs.max()), "within_10pct": float((errs <= 10).mean())}
+    print(f"P1 weighing bar (within 10 % 1 s after an attach ends): {r['attaches']} attaches, median {r['median_pct']:.1f} %, "
+          f"p90 {r['p90_pct']:.1f} %, max {r['max_pct']:.1f} %, within 10 %: {100 * r['within_10pct']:.0f} %  "
+          f"{'YES' if r['within_10pct'] == 1.0 else 'NO'}")
+    return r
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--data", default=str(ROOT / "data/cdpr_v0_playroom"))
+    ap.add_argument("--out", default=str(ROOT / "checkpoints/cdpr_wm_v0.pt"))
+    ap.add_argument("--steps1", type=int, default=3000)
+    ap.add_argument("--steps2", type=int, default=3000)
+    ap.add_argument("--batch", type=int, default=256)
+    ap.add_argument("--lr", type=float, default=3e-3)
+    ap.add_argument("--test", type=int, default=500, help="last N trajectories held out")
+    ap.add_argument("--n-eval", type=int, default=500)
+    ap.add_argument("--test-all", action="store_true", help="eval-only: every trajectory of --data is held out (an unseen room)")
+    ap.add_argument("--eval-only", action="store_true")
+    ap.add_argument("--stage1-from", default=None, help="checkpoint whose stage 1 (JEPA, normaliser) is reused")
+    ap.add_argument("--lr2", type=float, default=1e-3)
+    args = ap.parse_args()
+    if args.eval_only:
+        if args.test_all:
+            d = load(args.data)
+            return test1(args, d, np.arange(len(d[0])))
+        return test1(args)
+    X, A, P, M, R, test_idx = train(args)
+    test1(args, (X, A, P, M, R, float(np.load(sorted(Path(str(args.data).split(",")[0]).glob("shard_*.npz"))[0])["dt"])), test_idx)
+
+
+if __name__ == "__main__":
+    main()