chess-sim/code/sim/grasp_trace.py

"""Grasp traces and repeatability of a policy in the settings profile's scene.

repeat  Runs a few identical episodes several times under three conditions and reports
        whether, where and why repeats diverge:
          same_process   one process, the episodes repeated back to back
          separate       one process per repeat, running in parallel (as eval_policy does)
          deterministic  like separate, with torch deterministic algorithms, TF32 off and
                         a fixed cuBLAS workspace
        Each run builds a fresh simulator and pins the episode (seed, move, the expert's
        plan), the policy's sampling seed and the simulator reset exactly as eval_policy
        does. Per frame it keeps a hash of the images the policy saw and the commanded and
        actual joints, so the first divergence can be attributed to the inputs (simulation,
        rendering) or to the policy (same inputs, different outputs).

trace   Runs episodes and records every frame: commanded and actual joints; the jaw's
        pinch point relative to where the marked piece stands now, along and across the
        jaw's actual closing direction; the jaw yaw against the expert's; the gripper's
        lean; the physical fingertip gap (mm, from the jaw geometry) commanded and actual;
        the piece's pose and tilt; action-chunk boundaries. Every physics substep: the first
        contact of the arm with the marked piece (before or after closing began), of the arm
        with another piece, and of the marked piece with another piece; the first tilt past
        5 and 45 degrees. A fingertip touch at the grasp (within 3 mm of the grasp height
        and 2.5 mm sideways) before closing is the intended contact, recorded separately.
        Closing begins where the gripper command starts its ramp down within 20 mm above
        the grasp point. Failures are classified by what happened first (see classify),
        and slow (4x) replays of pawn failures are written with the measurements overlaid.

Run:  MUJOCO_GL=egl PHASE2_PROFILE=baseline .venv/bin/python sim/grasp_trace.py repeat \
          --policy models/baseline --indices 3,7,12 --repeats 5 --out sim/reports/grasp_trace/repeat
      MUJOCO_GL=egl PHASE2_PROFILE=baseline .venv/bin/python sim/grasp_trace.py trace \
          --policy models/baseline --episodes 40 --workers 6 --seed 8000003 --out sim/reports/grasp_trace/trace
"""
from __future__ import annotations

import argparse
import hashlib
import io
import json
import multiprocessing as mp
import os
import sys
import time
from collections import Counter, defaultdict
from pathlib import Path
from queue import Empty

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
OPEN, CLOSING = 4.0, 3.0          # gripper command, LeRobot 0-100 units (see eval_policy)


# ---------------------------------------------------------------------------- setup
def set_deterministic():
    """Deterministic torch/CUDA settings; call before torch touches CUDA."""
    os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8")
    import torch

    torch.use_deterministic_algorithms(True, warn_only=True)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False
    torch.backends.cuda.matmul.allow_tf32 = False
    torch.backends.cudnn.allow_tf32 = False


def episode(runner, seed: int, i: int):
    """Episode i of `seed` exactly as eval_policy sets it up: the move (checked doable by
    the expert), the expert's own grasp plan, and the policy's sampling seed."""
    import mujoco
    import numpy as np

    erng = np.random.default_rng([seed, i])
    for _ in range(20):
        ep_seed = int(erng.integers(2**62))
        task = runner.setup(np.random.default_rng(ep_seed))
        if runner.run(task, ep_seed).success:
            break
    task = runner.setup(np.random.default_rng(ep_seed))
    d = runner.d
    saved = (d.qpos.copy(), d.qvel.copy(), d.act.copy(), d.ctrl.copy(), d.time)
    plan = runner.expert.plan_pick(d, task.target, np.random.default_rng(ep_seed))
    d.qpos[:], d.qvel[:], d.act[:], d.ctrl[:] = saved[:4]
    d.time = saved[4]
    mujoco.mj_forward(runner.m, d)
    return task, ep_seed, int(erng.integers(2**31)), plan


def gap_table(expert, heights_mm=(2.0, 10.0)):
    """Gripper angle -> physical gap (mm) between the fixed and moving fingertips, averaged
    over heights_mm above the fingertip (from the expert's jaw geometry)."""
    import numpy as np

    jaws = expert.jaws
    rel = np.linspace(heights_mm[0], heights_mm[1], 5) / 1000
    fixed = np.interp(rel, jaws.heights, jaws.fixed_inner)
    qs = np.linspace(-0.3, 1.3, 161)
    gaps = []
    for q in qs:
        inner, _ = jaws.moving_profile(q, rel)
        gaps.append(float(np.nanmean(inner - fixed)) * 1000 if np.any(~np.isnan(inner)) else np.nan)
    return qs, np.array(gaps)


class JpegFrames(list):
    """Frames kept as JPEG bytes (drive() appends the images the policy saw)."""

    def append(self, img):
        from PIL import Image

        buf = io.BytesIO()
        Image.fromarray(img).save(buf, "JPEG", quality=85)
        super().append(buf.getvalue())


class HashFrames(list):
    """Frames kept as an md5 of their bytes (for repeatability)."""

    def append(self, img):
        import numpy as np

        super().append(hashlib.md5(np.ascontiguousarray(img).tobytes()).hexdigest())


# ---------------------------------------------------------------------------- tracing
class Tracer:
    def __init__(self, runner, task, plan, policy, capture=False):
        import mujoco
        import numpy as np

        self.r, self.task, self.plan, self.policy = runner, task, plan, policy
        m, d, w, ex = runner.m, runner.d, runner.w, runner.expert
        self.target = task.target
        self.others = set(task.squares.values()) - {task.target}
        self.base0 = w.base_pos(d, task.target).copy()
        self.grasp_rel = plan.grasp_point - self.base0
        self.hand = {m.body("gripper").id, m.body("moving_jaw_so101_v1").id}
        self.qs, self.gaps = gap_table(ex)
        self.n_steps = policy.config.n_action_steps
        self.rows, self.events, self.parts = [], {}, {}
        self.open_max, self.closing = 0.0, False
        self.cmd_hist = []
        self.capture = capture
        self.side = []
        if capture:
            self.cam = mujoco.MjvCamera()
            self.cam.type = mujoco.mjtCamera.mjCAMERA_FREE
            self.cam.lookat[:] = plan.grasp_point
            self.cam.distance = 0.16
            self.cam.azimuth = float(np.degrees(plan.yaw)) + 90.0       # looking across the closing direction
            self.cam.elevation = -12.0
            self.side_renderer = mujoco.Renderer(m, 240, 320)

    def close(self):
        if self.capture:
            self.side_renderer.close()

    def _event(self, key, t, part=None):
        if key not in self.events:
            self.events[key] = t
            if part is not None:
                self.parts[key] = part

    def _at_grasp(self):
        """Pinch point within 3 mm of the grasp height and 2.5 mm sideways of the piece."""
        import numpy as np

        r, d, ex = self.r, self.r.d, self.r.expert
        pinch, _ = ex.kin.pose(d.qpos[ex.kin.qadr].copy(), self.plan.offset)
        err = pinch - (r.w.base_pos(d, self.target) + self.grasp_rel)
        return abs(err[2]) < 0.003 and np.linalg.norm(err[:2]) < 0.0025

    def on_substep(self, f, k):
        r, d = self.r, self.r.d
        m = r.m
        t = f + (k + 1) / r.n_sub
        for c in d.contact[:d.ncon]:
            for a, b in ((c.geom1, c.geom2), (c.geom2, c.geom1)):
                pb = r.piece_of_geom.get(b)
                if pb is None:
                    continue
                if a in r.arm_geoms:
                    part = "finger" if m.geom_bodyid[a] in self.hand else m.body(m.geom_bodyid[a]).name
                    if pb == self.target:
                        if self.closing:
                            self._event("arm_target_closing", t, part)
                        elif part == "finger" and self._at_grasp():
                            self._event("finger_touch_at_grasp", t, part)     # the intended contact (fixed finger 0.8 mm off)
                        else:
                            self._event("arm_target_open", t, part)
                    elif pb in self.others:
                        self._event("arm_neighbour", t, f"{part}->{pb}")
                elif r.piece_of_geom.get(a) == self.target and pb in self.others:
                    self._event("target_neighbour", t, pb)
        tilt = r.w.tilt_deg(d, self.target)
        if tilt > 5:
            self._event("tilt5", t)
        if tilt > 45:
            self._event("tilt45", t)

    def on_frame(self, f, a):
        import numpy as np

        r, d, w, ex, plan = self.r, self.r.d, self.r.w, self.r.expert, self.plan
        a = np.asarray(a, float)
        q = d.qpos[ex.kin.qadr].copy()
        pinch, R = ex.kin.pose(q, plan.offset)
        grasp_now_ = w.base_pos(d, self.target) + self.grasp_rel
        # Closing begins where the command starts its ramp down near the piece (within 20 mm
        # above the grasp point): 1 unit below its maximum of the last half second. The
        # approach also lowers the command (rest ~10 to open ~6), but higher up.
        self.cmd_hist.append(a[5])
        self.open_max = max(self.open_max, a[5])
        if (not self.closing and self.open_max > OPEN and pinch[2] - grasp_now_[2] < 0.020
                and a[5] < max(self.cmd_hist[-15:]) - 1.0):
            self.closing = True
            self._event("close_start", float(f))
        if a[5] < CLOSING:
            self._event("close_cmd3", float(f))              # eval_policy's close marker
        pinch_cmd, _ = ex.kin.pose(np.radians(a[:5]), plan.offset)
        lo, hi = r.grip_range
        gq = float(d.qpos[r.grip_qadr])
        gq_cmd = lo + np.clip(a[5], 0, 100) / 100 * (hi - lo)
        base = w.base_pos(d, self.target)
        grasp_now = base + self.grasp_rel
        err = pinch - grasp_now
        xj = np.r_[R[:2, 0], 0.0]
        xj /= max(np.linalg.norm(xj), 1e-9)
        yj = np.array([-xj[1], xj[0], 0.0])
        yaw = float(np.arctan2(R[1, 0], R[0, 0]))
        dyaw = np.degrees(yaw - plan.yaw)
        self.rows.append(dict(
            f=f, cmd=a.copy(), act=r.to_lerobot(d.qpos[r.qadr]).astype(float), pinch=pinch.copy(),
            track_mm=1000 * float(np.linalg.norm(pinch_cmd - pinch)),
            lat_mm=1000 * float(np.linalg.norm(err[:2])), along_mm=1000 * float(err @ xj),
            across_mm=1000 * float(err @ yj), height_mm=1000 * float(err[2]),
            yaw=yaw, yaw_err180=float((dyaw + 90) % 180 - 90), yaw_err360=float((dyaw + 180) % 360 - 180),
            lean_deg=float(np.degrees(np.arccos(np.clip(R[2, 2], -1, 1)))),
            gap_mm=float(np.interp(gq, self.qs, self.gaps)), gap_cmd_mm=float(np.interp(gq_cmd, self.qs, self.gaps)),
            piece=base.copy(), piece_moved_mm=1000 * float(np.linalg.norm(base[:2] - self.base0[:2])),
            tilt=float(w.tilt_deg(d, self.target)),
            new_chunk=len(self.policy._queues["action"]) == self.n_steps - 1,
            closing=self.closing))
        if self.capture:
            self.side_renderer.update_scene(d, camera=self.cam, scene_option=r.scene_option)
            buf = io.BytesIO()
            from PIL import Image

            Image.fromarray(self.side_renderer.render()).save(buf, "JPEG", quality=85)
            self.side.append(buf.getvalue())
        return False

    def arrays(self):
        import numpy as np

        keys = self.rows[0].keys()
        return {k: np.array([row[k] for row in self.rows]) for k in keys}


def classify(A: dict, events: dict, parts: dict, fps: int = 30) -> dict:
    """What happened first, and the signals around it.

    The onset is the earliest of: the arm touching the marked piece before the jaws began
    closing, the arm touching another piece, the marked piece touching another piece, or
    the marked piece tilting past 5 deg, all before closing began. If none happened, it is
    the start of closing. Signals in the half second up to the onset:
    - rotating: the jaw turned faster than 45 deg/s while the pinch point was within 30 mm
      of the grasp point;
    - sideways: at the onset the pinch point moved sideways more than twice as fast as
      vertically, and faster than 10 mm/s;
    - lag: the pinch point of the commanded joints was more than 3 mm from the actual one;
    - offset: when closing began, the pinch point was more than 2 mm (sideways) from the
      grasp point on the piece where it stands.
    """
    import numpy as np

    close = events.get("close_start")
    pre = [(events[k], k) for k in ("arm_target_open", "arm_neighbour", "target_neighbour", "tilt5")
           if k in events and (close is None or events[k] < close)]
    if pre:
        t0, first = min(pre)
        stage = "before closing"
    elif close is not None:
        t0, first, stage = close, "close_start", "at closing"
    else:
        return dict(onset="never closed, nothing touched", first=None, t0=None, flags={})
    n = len(A["f"])
    f0 = min(int(t0), n - 1)
    lo = max(0, f0 - fps // 2)
    yaw = np.unwrap(A["yaw"])
    rate = np.abs(np.diff(yaw, prepend=yaw[0])) * fps
    dist = np.hypot(A["lat_mm"], A["height_mm"])
    near = dist[lo:f0 + 1] < 30
    rotating = bool(np.any(np.degrees(rate[lo:f0 + 1])[near] > 45)) if near.any() else False
    v = np.diff(A["pinch"], axis=0, prepend=A["pinch"][:1]) * fps
    k0 = max(1, f0 - 2)
    h_speed = float(np.mean(np.linalg.norm(v[k0:f0 + 1, :2], axis=1)))
    v_speed = float(np.mean(np.abs(v[k0:f0 + 1, 2])))
    sideways = h_speed > 2 * v_speed and h_speed > 0.010
    lag = bool(A["track_mm"][f0] > 3.0)
    fc = min(int(close), n - 1) if close is not None else None
    lat_close = float(A["lat_mm"][fc]) if fc is not None else None
    offset = lat_close is not None and lat_close > 2.0
    if stage == "before closing":
        if rotating:
            onset = "wrist rotates near the piece"
        elif sideways:
            onset = "hand approaches sideways"
        else:
            onset = "descends onto the piece off-centre"
    else:
        onset = "jaws close around an offset piece" if offset else "closed centred; failed later"
    chunks = np.flatnonzero(A["new_chunk"])
    near_chunk = bool(np.any(np.abs(chunks - f0) <= 5)) if len(chunks) else False
    return dict(onset=onset, first=first, first_part=parts.get(first), t0_s=round(t0 / fps, 2), stage=stage,
                flags=dict(rotating=rotating, sideways=sideways, lag=lag, offset=offset),
                h_speed_mm_s=round(1000 * h_speed, 1), v_speed_mm_s=round(1000 * v_speed, 1),
                track_mm_at_onset=round(float(A["track_mm"][f0]), 2),
                lat_mm_at_onset=round(float(A["lat_mm"][f0]), 2), height_mm_at_onset=round(float(A["height_mm"][f0]), 1),
                yaw_err180_at_onset=round(float(A["yaw_err180"][f0]), 1),
                gap_mm_at_onset=round(float(A["gap_mm"][f0]), 1), lat_mm_at_close=None if lat_close is None else round(lat_close, 2),
                chunk_within_5_frames=near_chunk)


def write_replay(path, policy_frames, side_frames, A, events, info, f0, fps=30, slow=4, before=60, after=60):
    """Slow replay around frame f0: the images the policy saw (overhead, wrist), a close-up
    side view, and the measurements of each frame."""
    import av
    import numpy as np
    from PIL import Image, ImageDraw

    n = min(len(side_frames), len(A["f"]), len(policy_frames))
    lo, hi = max(0, f0 - before), min(n, f0 + after)
    ev_frames = {k: int(v) for k, v in events.items()}
    with av.open(str(path), "w") as container:
        stream = container.add_stream("libx264", rate=fps)
        stream.width, stream.height, stream.pix_fmt = 960, 360, "yuv420p"
        stream.options = {"crf": "23"}
        for f in range(lo, hi):
            top = np.asarray(Image.open(io.BytesIO(policy_frames[f])).convert("RGB"))    # 240 x 640 (overhead | wrist)
            side = np.asarray(Image.open(io.BytesIO(side_frames[f])).convert("RGB"))     # 240 x 320
            canvas = Image.new("RGB", (960, 360), (18, 18, 18))
            canvas.paste(Image.fromarray(top), (0, 0))
            canvas.paste(Image.fromarray(side), (640, 0))
            pen = ImageDraw.Draw(canvas)
            lines = [f"{info}   t={f / fps:5.2f}s  frame {f}{'   NEW CHUNK' if A['new_chunk'][f] else ''}",
                     f"pinch vs piece: sideways {A['lat_mm'][f]:5.1f} mm (along {A['along_mm'][f]:+5.1f}, across {A['across_mm'][f]:+5.1f}),"
                     f" height {A['height_mm'][f]:+6.1f} mm   jaw yaw err {A['yaw_err360'][f]:+6.1f} deg   lean {A['lean_deg'][f]:4.1f} deg",
                     f"gap {A['gap_mm'][f]:5.1f} mm (commanded {A['gap_cmd_mm'][f]:5.1f})   command-vs-actual {A['track_mm'][f]:4.1f} mm"
                     f"   piece moved {A['piece_moved_mm'][f]:5.1f} mm, tilt {A['tilt'][f]:5.1f} deg",
                     "events: " + ", ".join(f"{k} @{v / fps:.2f}s" for k, v in sorted(events.items(), key=lambda x: x[1])
                                           if ev_frames[k] <= f) or "events: none yet"]
            for j, line in enumerate(lines):
                pen.text((8, 248 + 26 * j), line, fill=(255, 235, 120) if j == 3 else (230, 230, 230))
            if any(ev_frames[k] == f for k in events):
                pen.rectangle([0, 0, 959, 239], outline=(255, 60, 60), width=4)
            frame = av.VideoFrame.from_ndarray(np.asarray(canvas), format="rgb24")
            for _ in range(slow):
                for packet in stream.encode(frame):
                    container.mux(packet)
        for packet in stream.encode():
            container.mux(packet)


# ---------------------------------------------------------------------------- workers
def run_one(runner, cfg, bundle, seed, i, seconds, capture=False, hashes=False):
    import numpy as np
    import torch

    from eval_policy import drive

    policy, pre, post, device = bundle
    task, ep_seed, torch_seed, plan = episode(runner, seed, i)
    tr = Tracer(runner, task, plan, policy, capture=capture)
    frames = HashFrames() if hashes else (JpegFrames() if capture else None)
    torch.manual_seed(torch_seed)
    res, met = drive(runner, task, policy, pre, post, device, cfg, seconds, ep_seed ^ 0x5EED, frames,
                     on_frame=tr.on_frame, on_substep=tr.on_substep)
    tr.close()
    A = tr.arrays()
    head = dict(index=i, ep_seed=ep_seed, torch_seed=torch_seed, move=f"{task.source}-{task.dest.square}",
                piece=runner.w.kind[task.target], plan_yaw_deg=round(float(np.degrees(plan.yaw)), 1),
                plan_grasp_mm=[round(1000 * float(x), 3) for x in plan.grasp_point], success=bool(res.success),
                reason=res.reason, frames=res.frames, lifted=bool(met["lifted"]))
    return head, A, tr, frames


def repeat_worker(condition, reps, args, indices, queue):
    if condition == "deterministic":
        set_deterministic()
    import warnings

    warnings.filterwarnings("ignore")
    import numpy as np
    import torch

    from episode import EpisodeRunner, load_config
    from eval_policy import load_policy
    from piece_sets import sample_piece_set

    torch.set_num_threads(2)
    cfg = load_config()
    bundle = load_policy(args.policy)
    out = Path(args.out) / "runs"
    out.mkdir(parents=True, exist_ok=True)
    for rep in reps:
        for i in indices:
            runner = EpisodeRunner(cfg, sample_piece_set(np.random.default_rng([args.seed, 10**9 + i // 5]), cfg, "rep"),
                                   render=True)
            head, A, tr, hashes = run_one(runner, cfg, bundle, args.seed, i, args.seconds, hashes=True)
            runner.close()
            np.savez_compressed(out / f"{condition}_rep{rep}_ep{i:03d}.npz", cmd=A["cmd"], act=A["act"],
                                hashes=np.array(list(hashes)))
            queue.put(dict(condition=condition, rep=rep, pid=os.getpid(), **head, events=tr.events))
    queue.put(None)


def trace_worker(k, n, args, queue):
    import warnings

    warnings.filterwarnings("ignore")
    import numpy as np
    import torch

    from episode import EpisodeRunner, load_config
    from eval_policy import load_policy
    from piece_sets import sample_piece_set

    torch.set_num_threads(2)
    cfg = load_config()
    bundle = load_policy(args.policy)
    out = Path(args.out)
    (out / "traces").mkdir(parents=True, exist_ok=True)
    (out / "replays").mkdir(parents=True, exist_ok=True)
    runner = EpisodeRunner(cfg, sample_piece_set(np.random.default_rng([args.seed, 10**9]), cfg, "trace"), render=True)
    for i in range(k * args.episodes // n, (k + 1) * args.episodes // n):
        head, A, tr, frames = run_one(runner, cfg, bundle, args.seed, i, args.seconds, capture=args.replays)
        c = classify(A, tr.events, tr.parts)
        np.savez_compressed(out / "traces" / f"ep{i:03d}.npz", **A)
        replay = None
        if args.replays and not head["success"] and head["piece"] == "pawn" and c.get("t0_s") is not None:
            replay = f"replays/ep{i:03d}_{head['move']}_{c['onset'].split()[0]}.mp4"
            write_replay(out / replay, frames, tr.side, A, tr.events,
                         f"ep {i} {head['piece']} {head['move']} ({c['onset']})", int(c["t0_s"] * 30))
        queue.put(dict(**head, events={k2: round(v / 30, 3) for k2, v in tr.events.items()}, parts=tr.parts,
                       classification=c, replay=replay))
    runner.close()
    queue.put(None)


def collect(procs, queue, label):
    results, finished = [], 0
    while finished < len(procs):
        try:
            r = queue.get(timeout=120)
        except Empty:
            if not any(p.is_alive() for p in procs):
                print(f"{label}: worker(s) crashed", flush=True)
                break
            continue
        if r is None:
            finished += 1
            continue
        results.append(r)
        print(f"{label}: {r.get('condition', '')} {r.get('rep', '')} ep {r['index']} {r['move']} "
              f"{'ok' if r['success'] else 'fail'} {r.get('classification', {}).get('onset', '')}", flush=True)
    for p in procs:
        p.join()
    return results


# ---------------------------------------------------------------------------- reports
def repeat_report(args, results):
    import numpy as np

    runs = Path(args.out) / "runs"
    load = lambda c, rep, i: np.load(runs / f"{c}_rep{rep}_ep{i:03d}.npz")
    by = defaultdict(dict)
    for r in results:
        by[(r["condition"], r["index"])][r["rep"]] = r
    rows = []
    for (cond, i), reps in sorted(by.items()):
        ref = load(cond, min(reps), i)
        for rep, r in sorted(reps.items()):
            x = load(cond, rep, i)
            n = min(len(x["cmd"]), len(ref["cmd"]))
            dcmd = np.abs(x["cmd"][:n] - ref["cmd"][:n]).max(axis=1)
            hn = min(len(x["hashes"]), len(ref["hashes"]))
            hdiff = np.flatnonzero(x["hashes"][:hn] != ref["hashes"][:hn])
            cdiff = np.flatnonzero(dcmd > 1e-4)
            rows.append(dict(condition=cond, index=i, rep=rep, move=r["move"], success=r["success"],
                             same_episode=(r["ep_seed"], r["torch_seed"], r["plan_grasp_mm"]) ==
                                          (reps[min(reps)]["ep_seed"], reps[min(reps)]["torch_seed"], reps[min(reps)]["plan_grasp_mm"]),
                             first_input_diff=int(hdiff[0]) if len(hdiff) else None,
                             first_action_diff=int(cdiff[0]) if len(cdiff) else None,
                             action_diff_at_first=float(dcmd[cdiff[0]]) if len(cdiff) else 0.0,
                             max_action_diff=float(dcmd.max()) if n else 0.0))
    # Across conditions: each repeat against same_process repeat 0.
    cross = []
    for (cond, i), reps in sorted(by.items()):
        if cond == "same_process" or ("same_process", i) not in by:
            continue
        ref = load("same_process", 0, i)
        for rep in sorted(reps):
            x = load(cond, rep, i)
            n = min(len(x["cmd"]), len(ref["cmd"]))
            cd = np.flatnonzero(np.abs(x["cmd"][:n] - ref["cmd"][:n]).max(axis=1) > 1e-4)
            hn = min(len(x["hashes"]), len(ref["hashes"]))
            hd = np.flatnonzero(x["hashes"][:hn] != ref["hashes"][:hn])
            cross.append(dict(condition=cond, index=i, rep=rep, first_input_diff=int(hd[0]) if len(hd) else None,
                              first_action_diff=int(cd[0]) if len(cd) else None))
    (Path(args.out) / "repeat_results.json").write_text(json.dumps(dict(results=results, rows=rows, cross=cross), indent=1, default=str))
    lines = ["# Repeatability", "",
             f"Policy `{args.policy}`, episodes {args.indices} of seed {args.seed}, {args.repeats} repeats per condition. "
             "Each run builds a fresh simulator and pins the episode seed, move, expert plan and the policy's sampling "
             "seed as eval_policy does. `first input diff`: first frame whose policy images differ from repeat 0 "
             "(md5 of the downsampled images); `first action diff`: first frame whose commanded joints differ by more "
             "than 1e-4 (degrees or gripper units).", "",
             "| condition | episode | move | outcomes (repeat 0..n) | identical episode setup | first input diff (frames) | first action diff (frames) | max action diff |",
             "|---|---|---|---|---|---|---|---|"]
    grouped = defaultdict(list)
    for row in rows:
        grouped[(row["condition"], row["index"])].append(row)
    for (cond, i), rs in grouped.items():
        rs = sorted(rs, key=lambda x: x["rep"])
        lines.append(f"| {cond} | {i} | {rs[0]['move']} | {''.join('S' if x['success'] else 'F' for x in rs)} | "
                     f"{all(x['same_episode'] for x in rs)} | {[x['first_input_diff'] for x in rs[1:]]} | "
                     f"{[x['first_action_diff'] for x in rs[1:]]} | {max(x['max_action_diff'] for x in rs):.3g} |")
    if cross:
        lines += ["", "## Against `same_process` repeat 0", "",
                  "| condition | episode | repeat | first input diff | first action diff |", "|---|---|---|---|---|"]
        lines += [f"| {c['condition']} | {c['index']} | {c['rep']} | {c['first_input_diff']} | {c['first_action_diff']} |" for c in cross]
    (Path(args.out) / "repeat_report.md").write_text("\n".join(lines) + "\n")
    print("\n".join(lines))


def trace_report(args, results):
    import numpy as np

    out = Path(args.out)
    results.sort(key=lambda r: r["index"])
    (out / "trace_results.json").write_text(json.dumps(results, indent=1, default=str))
    fails = [r for r in results if not r["success"]]
    oks = [r for r in results if r["success"]]
    lines = ["# Grasp traces", "",
             f"Policy `{args.policy}`, {len(results)} episodes of seed {args.seed} (not the development or final sets). "
             f"{len(oks)} succeeded, {len(fails)} failed.", "",
             "Onset = what happened first (see `classify` in `sim/grasp_trace.py`): the arm touching the marked piece "
             "before the jaws began closing, touching another piece, the marked piece touching another piece, or tilting "
             "past 5 deg, before closing began; otherwise the start of closing. Contacts are checked every physics step.", "",
             "## Failures by onset", "", "| onset | pawn | knight | total |", "|---|---|---|---|"]
    onsets = Counter((r["classification"]["onset"], r["piece"]) for r in fails)
    for o in sorted({k[0] for k in onsets}):
        lines.append(f"| {o} | {onsets[(o, 'pawn')]} | {onsets[(o, 'knight')]} | {onsets[(o, 'pawn')] + onsets[(o, 'knight')]} |")
    firsts = Counter((r["classification"].get("first"), r["classification"].get("first_part")) for r in fails)
    lines += ["", "First event of each failure (event, part that touched):", ""]
    lines += [f"- {k[0]} ({k[1]}): {v}" for k, v in firsts.most_common()]
    flag = lambda rs, k: sum(r["classification"].get("flags", {}).get(k, False) for r in rs)
    lines += ["", "## Signals", "", "| signal | failures | successes |", "|---|---|---|"]
    for k, label in (("rotating", "jaw turning > 45 deg/s within 30 mm of the grasp point, up to the onset"),
                     ("sideways", "pinch point moving mostly sideways at the onset"),
                     ("lag", "commanded vs actual pinch point > 3 mm at the onset"),
                     ("offset", "> 2 mm sideways from the piece when closing began")):
        lines.append(f"| {label} | {flag(fails, k)}/{len(fails)} | {flag(oks, k)}/{len(oks)} |")
    med = lambda rs, key: round(float(np.median([r["classification"][key] for r in rs
                                                  if r["classification"].get(key) is not None])), 2) if rs else None
    lines += ["", "| measure | failures (median) | successes (median) |", "|---|---|---|"]
    for key, label in (("lat_mm_at_close", "sideways error when closing began (mm)"),
                       ("track_mm_at_onset", "command vs actual at the onset (mm)"),
                       ("lat_mm_at_onset", "sideways error at the onset (mm)"),
                       ("height_mm_at_onset", "height above the grasp point at the onset (mm)"),
                       ("yaw_err180_at_onset", "jaw yaw vs the expert's, mod 180, at the onset (deg)"),
                       ("gap_mm_at_onset", "fingertip gap at the onset (mm)"),
                       ("h_speed_mm_s", "sideways speed at the onset (mm/s)"),
                       ("v_speed_mm_s", "vertical speed at the onset (mm/s)")):
        lines.append(f"| {label} | {med(fails, key)} | {med(oks, key)} |")
    near = sum(r["classification"].get("chunk_within_5_frames", False) for r in fails)
    lines += ["", f"A new action chunk started within 5 frames of the onset in {near}/{len(fails)} failures "
              "(by chance about 11/50 = 22% with 50-step chunks).", "",
              "## Episodes", "", "| # | move | result | onset | first event | at (s) | sideways at close (mm) | replay |",
              "|---|---|---|---|---|---|---|---|"]
    for r in results:
        c = r["classification"]
        lines.append(f"| {r['index']} | {r['piece']} {r['move']} | {'ok' if r['success'] else 'fail'} | {c['onset']} | "
                     f"{c.get('first')} ({c.get('first_part')}) | {c.get('t0_s')} | {c.get('lat_mm_at_close')} | "
                     f"{r['replay'] or ''} |")
    (out / "trace_report.md").write_text("\n".join(lines) + "\n")
    print("\n".join(lines))


def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("mode", choices=["repeat", "trace"])
    ap.add_argument("--policy", required=True)
    ap.add_argument("--seed", type=int, default=8_000_003)
    ap.add_argument("--seconds", type=float, default=20.0)
    ap.add_argument("--out", required=True)
    ap.add_argument("--indices", default="", help="repeat: episode indices of --seed")
    ap.add_argument("--repeats", type=int, default=5, help="repeat: processes for separate and deterministic")
    ap.add_argument("--same-repeats", type=int, default=3, help="repeat: back-to-back repeats in one process")
    ap.add_argument("--conditions", default="same_process,separate,deterministic")
    ap.add_argument("--episodes", type=int, default=40)
    ap.add_argument("--workers", type=int, default=6)
    ap.add_argument("--replays", action="store_true")
    args = ap.parse_args()
    Path(args.out).mkdir(parents=True, exist_ok=True)
    ctx = mp.get_context("spawn")
    t0 = time.time()
    if args.mode == "repeat":
        indices = [int(x) for x in args.indices.split(",")]
        conds = args.conditions.split(",")
        results = []
        # same_process runs alongside separate; deterministic after (GPU memory: 1 + repeats processes at a time).
        batches = [[c for c in conds if c in ("same_process", "separate")], [c for c in conds if c == "deterministic"]]
        for batch in batches:
            if not batch:
                continue
            queue = ctx.Queue()
            procs = []
            for cond in batch:
                if cond == "same_process":
                    procs.append(ctx.Process(target=repeat_worker, args=(cond, list(range(args.same_repeats)), args, indices, queue)))
                else:
                    procs += [ctx.Process(target=repeat_worker, args=(cond, [rep], args, indices, queue))
                              for rep in range(args.repeats)]
            for p in procs:
                p.start()
            results += collect(procs, queue, "repeat")
        repeat_report(args, results)
    else:
        queue = ctx.Queue()
        procs = [ctx.Process(target=trace_worker, args=(k, args.workers, args, queue)) for k in range(args.workers)]
        for p in procs:
            p.start()
        trace_report(args, collect(procs, queue, "trace"))
    print(f"done in {(time.time() - t0) / 60:.1f} min")


if __name__ == "__main__":
    main()