Add mode2_v1 schema — 73 pre-sliced clean segments from 27 source episodes (104.7 min, bad intervals excluded by construction). New ReactSegmentDataset + demo. No bad_frames.json filtering needed at the dataloader; data is constructively clean. mode1_v1 stays for backward compatibility. See segments.json + new README section.

README.md

@@ -25,6 +25,10 @@ configs:
     data_files:
       - split: train
         path: processed/mode1_v1/motherboard/**/episode_*.pt
+  - config_name: motherboard_segments
+    data_files:
+      - split: train
+        path: processed/mode2_v1/motherboard/**/episode_*.segment_*.pt
   - config_name: all
     data_files:
       - split: train
@@ -86,6 +90,15 @@ See [`tasks.json`](tasks.json) for the machine-readable registry (per-date `acti
 
 Every flagged interval is in [`bad_frames.json`](bad_frames.json) keyed by `episode/episode_*` with TRIMMED-pt frame indices. A richer per-event view (with cross-modal motion + OT-gap + angular-velocity stats) lives in [`freeze_intervals.json`](freeze_intervals.json). Skip-list usage is shown below and in [`docs/quality.md`](docs/quality.md). Long start-of-episode OT-uninitialized prefixes (the dominant problem in the raw recordings) have already been trimmed from the published `.pt` files — see [`docs/caveats.md`](docs/caveats.md).
 
+## Two schemas: mode1_v1 vs mode2_v1
+
+The same recordings are shipped two ways depending on what your code wants to do:
+
+- **`processed/mode1_v1/<task>/<date>/episode_*.pt`** — one file per recording. Includes bad intervals (LED flicker, pose teleport, OT track loss) inside; downstream code is expected to filter them out using `bad_frames.json`. This is what the example `ReactWindowDataset` consumes.
+- **`processed/mode2_v1/<task>/<date>/episode_*.segment_*.pt`** — same recordings, but **pre-sliced into contiguous clean segments at every bad-frames boundary**. No `bad_frames.json` lookup needed; the data is clean by construction. Index lookup via [`segments.json`](segments.json). Each segment's `_contact_meta.source_h5_frame_range` maps it back to the original recording. The example `ReactSegmentDataset` ([`examples/react_segment_dataset.py`](examples/react_segment_dataset.py)) consumes these.
+
+Both schemas have identical content (same source recordings, same frame data); only the file boundaries differ. `mode2_v1` produces 73 segments from 27 source episodes; **104.7 min total** (vs. mode1_v1's 105.7 min — the 1-min delta is the bad frames cut at segment boundaries).
+
 ## Quick start
 
 ```python

examples/demo_react_segment.py

@@ -0,0 +1,222 @@
+"""End-to-end usage example for `ReactSegmentDataset` (the mode2_v1 schema).
+
+Run against a local checkout of the React HF dataset:
+
+  python examples/demo_react_segment.py \\
+      --segments_root processed/mode2_v1/motherboard \\
+      --tasks_json tasks.json \\
+      --n_samples 4 \\
+      --out_dir /tmp/react_segment_demo_out
+
+What this does
+--------------
+1. Builds `ReactSegmentDataset` — same window-enumeration / filtering API
+   as `ReactWindowDataset` but operates over pre-sliced clean segments
+   (no `bad_frames.json` lookup; data is clean by construction).
+2. Prints how many contact-rich windows were sampled + how many were
+   rejected by the contact / motion filters.
+3. Renders a static PNG grid of `--n_samples` random windows.
+4. For each picked window also writes an H.264 MP4 clip
+   (`sample_window_NN.mp4`) so you can visually inspect motion.
+
+Self-contained: numpy + torch + Pillow + cv2 (ffmpeg if available, falls
+back to cv2.VideoWriter otherwise).
+"""
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).parent))
+from react_segment_dataset import ReactSegmentDataset
+
+
+def _to_hwc(t):
+    return t.permute(1, 2, 0).numpy() if t.ndim == 3 else t.numpy()
+
+
+def _view_to_rgb(view_chw_uint8):
+    return view_chw_uint8.permute(1, 2, 0).numpy()[..., ::-1].copy()
+
+
+def make_static_grid(ds, sample_indices, out_path: Path, *,
+                     n_cols: int = 6, cell_scale: int = 3) -> None:
+    rows = []
+    for idx in sample_indices:
+        s = ds[idx]
+        T = s["view"].shape[0]
+        pick = np.linspace(0, T - 1, n_cols).astype(int)
+        cells = []
+        for t in pick:
+            view  = _view_to_rgb(s["view"][t]).astype(np.uint8)
+            tac_L = _to_hwc(s["tactile_left"][t]).astype(np.uint8)
+            tac_R = _to_hwc(s["tactile_right"][t]).astype(np.uint8)
+            triplet = np.concatenate([view, tac_L, tac_R], axis=1)
+            triplet = cv2.resize(
+                triplet,
+                (triplet.shape[1] * cell_scale, triplet.shape[0] * cell_scale),
+                interpolation=cv2.INTER_NEAREST,
+            )
+            cells.append(triplet)
+        rows.append(np.concatenate(cells, axis=1))
+
+    H_row = rows[0].shape[0]
+    W_row = rows[0].shape[1]
+    label_h = 88
+    pad_y = 16
+    canvas_h = 60 + len(rows) * (H_row + label_h + pad_y)
+    canvas = np.full((canvas_h, W_row + 20, 3), 245, np.uint8)
+    cv2.putText(canvas, f"ReactSegmentDataset — {n_cols} evenly-spaced frames per sample (time runs left → right)",
+                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (50, 50, 50), 2, cv2.LINE_AA)
+
+    cell_w = W_row // n_cols
+    for r, idx in enumerate(sample_indices):
+        s = ds[idx]
+        y0 = 60 + r * (H_row + label_h + pad_y)
+        dur_s = float(s["timestamps"][-1] - s["timestamps"][0])
+        mL = float(s["tactile_left_mixed"].max())
+        mR = float(s["tactile_right_mixed"].max())
+        h5a = s.get("h5_frame_start", "—")
+        cv2.putText(
+            canvas,
+            (f"sample #{idx}  ·  {s['source_episode']}/seg{int(s['source_segment_idx']):02d}  ·  "
+             f"H5 frame {h5a}  ·  ({dur_s:.2f}s)  ·  active: {','.join(s['active_sensors'])}  ·  "
+             f"peak mixed L={mL:.2f}  R={mR:.2f}"),
+            (10, y0 + 24), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (40, 40, 40), 1, cv2.LINE_AA,
+        )
+        T = s["view"].shape[0]
+        pick = np.linspace(0, T - 1, n_cols).astype(int)
+        for c, t in enumerate(pick):
+            cv2.putText(canvas, f"t = {int(t)}",
+                        (10 + c * cell_w + 8, y0 + 56),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.45, (90, 90, 90), 1, cv2.LINE_AA)
+        cv2.putText(canvas, "view  |  tactile_left  |  tactile_right",
+                    (10, y0 + 76), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (130, 130, 130), 1, cv2.LINE_AA)
+        canvas[y0 + label_h:y0 + label_h + H_row, 10:10 + W_row] = rows[r]
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    Image.fromarray(canvas).save(out_path)
+    print(f"  grid -> {out_path}  ({out_path.stat().st_size / 1024:.1f} KB)")
+
+
+def _write_mp4_h264(frames_rgb, out_path: Path, fps: float = 15.0) -> None:
+    H, W = frames_rgb[0].shape[:2]
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    if shutil.which("ffmpeg") is not None:
+        cmd = ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
+               "-f", "rawvideo", "-pix_fmt", "rgb24",
+               "-s", f"{W}x{H}", "-r", f"{fps:.3f}",
+               "-i", "-",
+               "-c:v", "libx264", "-pix_fmt", "yuv420p",
+               "-preset", "medium", "-crf", "20",
+               "-movflags", "+faststart",
+               "-an", str(out_path)]
+        proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+        for f in frames_rgb:
+            assert f.shape == (H, W, 3) and f.dtype == np.uint8
+            proc.stdin.write(f.tobytes())
+        proc.stdin.close()
+        if proc.wait() != 0:
+            raise RuntimeError("ffmpeg failed")
+        return
+    vw = cv2.VideoWriter(str(out_path),
+                         cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H))
+    for f in frames_rgb:
+        vw.write(cv2.cvtColor(f, cv2.COLOR_RGB2BGR))
+    vw.release()
+
+
+def make_window_mp4(ds, sample_idx: int, out_path: Path,
+                    *, scale: int = 3, fps: float = 15.0) -> None:
+    s = ds[sample_idx]
+    T = s["view"].shape[0]
+    h5a = s.get("h5_frame_start", "—")
+    frames = []
+    for t in range(T):
+        view  = _view_to_rgb(s["view"][t]).astype(np.uint8)
+        tac_L = _to_hwc(s["tactile_left"][t]).astype(np.uint8)
+        tac_R = _to_hwc(s["tactile_right"][t]).astype(np.uint8)
+        triplet = np.concatenate([view, tac_L, tac_R], axis=1)
+        triplet = cv2.resize(triplet,
+                             (triplet.shape[1] * scale, triplet.shape[0] * scale),
+                             interpolation=cv2.INTER_NEAREST)
+        H, W, _ = triplet.shape
+        header = np.full((28, W, 3), 235, np.uint8)
+        cv2.putText(
+            header,
+            f"#{sample_idx}  {s['source_episode']}/seg{int(s['source_segment_idx']):02d}  "
+            f"H5 frame {h5a}+{t}  ({t+1}/{T})  view | tactile_L | tactile_R",
+            (8, 19), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (40, 40, 40), 1, cv2.LINE_AA,
+        )
+        frames.append(np.concatenate([header, triplet], axis=0))
+    _write_mp4_h264(frames, out_path, fps=fps)
+    print(f"  mp4  -> {out_path.name}  ({out_path.stat().st_size / 1024:.1f} KB)")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--segments_root", required=True,
+                    help="processed/mode2_v1/motherboard")
+    ap.add_argument("--tasks_json", default="tasks.json")
+    ap.add_argument("--n_samples", type=int, default=4)
+    ap.add_argument("--out_dir", default="/tmp/react_segment_demo_out")
+    ap.add_argument("--window_length", type=int, default=16)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--mp4_fps", type=float, default=15.0)
+    ap.add_argument("--no_mp4", action="store_true")
+    ap.add_argument("--no_motion_filter", action="store_true")
+    args = ap.parse_args()
+
+    print("=== Building dataset (segments are clean by construction) ===")
+    ds = ReactSegmentDataset(
+        segments_root  = args.segments_root,
+        tasks_json_path= args.tasks_json,
+        window_length  = args.window_length,
+        stride         = 1,
+        window_step    = max(1, args.window_length // 2),
+        contact_metric        = "mixed",
+        tactile_threshold     = 0.4,
+        min_contact_fraction  = 0.5,
+        which_sensors         = "both",
+        respect_active_sensors= True,
+        require_motion        = not args.no_motion_filter,
+        min_motion_mps        = 0.01,
+        min_motion_fraction   = 0.25,
+        which_sensors_must_move = "all_active",
+    )
+
+    if len(ds) == 0:
+        print("No windows passed the filters. Lower thresholds or disable a filter.")
+        return
+
+    rng = np.random.default_rng(args.seed)
+    pick = rng.choice(len(ds), min(args.n_samples, len(ds)), replace=False)
+
+    print(f"\n=== One sample's structure (#{int(pick[0])}) ===")
+    s0 = ds[int(pick[0])]
+    for k, v in s0.items():
+        if isinstance(v, torch.Tensor):
+            print(f"  {k:30s} {tuple(v.shape)}  {v.dtype}")
+        else:
+            print(f"  {k:30s} {v!r}")
+
+    out_dir = Path(args.out_dir)
+    print(f"\n=== Static grid of {len(pick)} random windows ===")
+    make_static_grid(ds, pick, out_dir / "sample_grid.png")
+
+    if not args.no_mp4:
+        print(f"\n=== Per-window MP4 clips ({len(pick)} files, H.264) ===")
+        for i, idx in enumerate(pick):
+            make_window_mp4(ds, int(idx),
+                             out_dir / f"sample_window_{i:02d}.mp4",
+                             fps=args.mp4_fps)
+
+
+if __name__ == "__main__":
+    main()

examples/react_segment_dataset.py

@@ -0,0 +1,373 @@
+"""React: short-horizon contact-rich window dataset over pre-sliced segments.
+
+This is the `mode2_v1/` companion to `react_window_dataset.py`. The
+difference is purely architectural:
+
+- `ReactWindowDataset` operates on `processed/mode1_v1/<task>/<date>/episode_*.pt`,
+  which include bad intervals (LED flicker, pose teleports, OT track loss),
+  and uses `bad_frames.json` to skip windows that overlap a flagged span.
+
+- `ReactSegmentDataset` (this file) operates on
+  `processed/mode2_v1/<task>/<date>/episode_*.segment_*.pt`, where every
+  `.pt` is already a contiguous clean span. No `bad_frames.json` lookup is
+  needed; the data is *constructively* clean.
+
+Filters that remain (these are about what kind of window you want, not
+whether the data is good):
+
+  1. `respect_active_sensors`  — ignore inactive sensors per `tasks.json`
+  2. `min_contact_fraction`    — drop windows below the contact threshold
+  3. `require_motion`          — drop "operator paused" windows
+
+The per-segment `_contact_meta.source_h5_frame_range` lets you map any
+window back to its position in the original H5 recording, e.g. for
+inspection in `twm.visualize` or for cross-referencing with the original
+H5 archive.
+
+Usage
+-----
+```python
+from react_segment_dataset import ReactSegmentDataset
+from torch.utils.data import DataLoader
+
+ds = ReactSegmentDataset(
+    segments_root  = "processed/mode2_v1/motherboard",
+    tasks_json_path= "tasks.json",
+    window_length  = 16,
+    stride         = 1,
+    window_step    = 8,
+    # contact filter
+    contact_metric        = "mixed",
+    tactile_threshold     = 0.4,
+    min_contact_fraction  = 0.5,
+    which_sensors         = "both",
+    # motion filter (recommended for dynamics learning)
+    require_motion              = True,
+    min_motion_mps              = 0.01,
+    min_motion_fraction         = 0.25,
+    which_sensors_must_move     = "all_active",
+)
+loader = DataLoader(ds, batch_size=8, shuffle=True, num_workers=2)
+```
+
+Each sample is the same dict as `ReactWindowDataset`, plus the segment
+provenance (`source_episode`, `source_segment_idx`, `source_h5_frame_range`).
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+CONTACT_METRICS = ("intensity", "area", "mixed")
+
+
+def _per_frame_speed_mps(pose7: np.ndarray, fps: float = 30.0) -> np.ndarray:
+    if pose7.shape[0] < 2:
+        return np.zeros(pose7.shape[0], dtype=np.float64)
+    d = np.linalg.norm(np.diff(pose7[:, :3], axis=0), axis=1) * fps
+    out = np.empty(pose7.shape[0], dtype=np.float64)
+    out[0] = d[0]
+    out[1:] = d
+    return out
+
+
+class ReactSegmentDataset(Dataset):
+    """Per-window dataset over the pre-sliced React segments.
+
+    Parameters
+    ----------
+    segments_root : path
+        Directory containing `<task>/<date>/episode_*.segment_*.pt`
+        (searched recursively). e.g. `processed/mode2_v1/motherboard`.
+    tasks_json_path : optional path
+        Path to `tasks.json`. Used for the `respect_active_sensors` mode.
+
+    window_length, stride, window_step : window enumeration
+    contact_metric, tactile_threshold, min_contact_fraction, which_sensors :
+        contact filter parameters
+    respect_active_sensors : bool, default True
+    require_motion, min_motion_mps, min_motion_fraction,
+    which_sensors_must_move : motion filter parameters
+
+    tasks, dates : optional iterables of str
+        Restrict to specific task / date strings.
+
+    fps : float, default 30
+    """
+
+    def __init__(
+        self,
+        segments_root: str | Path,
+        tasks_json_path: str | Path | None = None,
+        *,
+        window_length: int = 16,
+        stride: int = 1,
+        window_step: int | None = None,
+        contact_metric: str = "mixed",
+        tactile_threshold: float = 0.4,
+        min_contact_fraction: float = 0.5,
+        which_sensors: str = "both",
+        tasks: Iterable[str] | None = None,
+        dates: Iterable[str] | None = None,
+        respect_active_sensors: bool = True,
+        require_motion: bool = False,
+        min_motion_mps: float = 0.01,
+        min_motion_fraction: float = 0.25,
+        which_sensors_must_move: str = "all_active",
+        fps: float = 30.0,
+    ):
+        if contact_metric not in CONTACT_METRICS:
+            raise ValueError(f"contact_metric must be one of {CONTACT_METRICS}")
+        if which_sensors not in ("any", "both", "left", "right"):
+            raise ValueError("which_sensors must be 'any' | 'both' | 'left' | 'right'")
+        if which_sensors_must_move not in ("any", "all_active"):
+            raise ValueError("which_sensors_must_move must be 'any' | 'all_active'")
+        if window_length < 1 or stride < 1:
+            raise ValueError("window_length and stride must be ≥ 1")
+
+        self.segments_root = Path(segments_root)
+        self.window_length = int(window_length)
+        self.stride = int(stride)
+        self.window_step = int(window_step) if window_step is not None else max(1, window_length // 2)
+        self.contact_metric = contact_metric
+        self.tactile_threshold = float(tactile_threshold)
+        self.min_contact_fraction = float(min_contact_fraction)
+        self.which_sensors = which_sensors
+        self.respect_active_sensors = bool(respect_active_sensors)
+        self.require_motion = bool(require_motion)
+        self.min_motion_mps = float(min_motion_mps)
+        self.min_motion_fraction = float(min_motion_fraction)
+        self.which_sensors_must_move = which_sensors_must_move
+        self.fps = float(fps)
+
+        # Per-date active-sensor info
+        self.per_date = {}
+        if tasks_json_path is not None and Path(tasks_json_path).is_file():
+            tj = json.loads(Path(tasks_json_path).read_text())
+            for tk, td in tj.get("tasks", {}).items():
+                for d, info in td.get("per_date_notes", {}).items():
+                    self.per_date[d] = info
+
+        # Discover segments
+        pt_files = sorted(self.segments_root.rglob("episode_*.segment_*.pt"))
+        if not pt_files:
+            raise RuntimeError(f"No segment .pt files under {self.segments_root}")
+        tasks_set = set(tasks) if tasks is not None else None
+        dates_set = set(dates) if dates is not None else None
+
+        self.segments: list[dict] = []          # cached .pt dicts
+        self.segment_paths: list[Path] = []
+        self.segment_meta: list[dict] = []      # source_episode, segment_idx, etc.
+        self.segment_active: list[list[str]] = []
+        self.windows: list[tuple[int, int]] = []   # (seg_idx, t_start)
+
+        span = (self.window_length - 1) * self.stride + 1
+
+        n_total_candidates = 0
+        n_drop_contact = 0
+        n_drop_motion = 0
+
+        for pt in pt_files:
+            rel = pt.relative_to(self.segments_root)
+            # rel.parts == (<task>, <date>, "episode_NNN.segment_MM.pt") OR (<date>, ...)
+            if len(rel.parts) == 3:
+                task, date, _ = rel.parts
+            elif len(rel.parts) == 2:
+                task, date = None, rel.parts[0]
+            else:
+                task, date = None, None
+            if tasks_set is not None and task not in tasks_set:
+                continue
+            if dates_set is not None and date not in dates_set:
+                continue
+
+            d = torch.load(pt, weights_only=False, map_location="cpu")
+            meta = d.get("_contact_meta", {})
+            src_ep = meta.get("source_episode") or rel.stem.split(".")[0]
+            seg_idx = int(meta.get("source_segment_idx", 0))
+            active = ["left", "right"]
+            if self.respect_active_sensors and date in self.per_date:
+                active = list(self.per_date[date].get("active_sensors", active))
+
+            mL = d[f"tactile_left_{self.contact_metric}"].numpy()
+            mR = d[f"tactile_right_{self.contact_metric}"].numpy()
+            T = mL.shape[0]
+            if T < span:
+                continue   # segment too short to host any window
+
+            # Contact predicate
+            cL = mL > self.tactile_threshold
+            cR = mR > self.tactile_threshold
+            if "left"  not in active: cL[:] = False
+            if "right" not in active: cR[:] = False
+            req = self.which_sensors
+            if   req == "any":   contact_frame = cL | cR
+            elif req == "both":  contact_frame = cL & cR
+            elif req == "left":  contact_frame = cL
+            else:                contact_frame = cR
+
+            # Per-frame motion mask
+            if self.require_motion:
+                speed_L = _per_frame_speed_mps(d["sensor_left_pose"].numpy(), self.fps)
+                speed_R = _per_frame_speed_mps(d["sensor_right_pose"].numpy(), self.fps)
+                moving_L = speed_L >= self.min_motion_mps
+                moving_R = speed_R >= self.min_motion_mps
+            else:
+                moving_L = moving_R = None
+
+            seg_id = len(self.segments)
+            self.segments.append(d)
+            self.segment_paths.append(pt)
+            self.segment_meta.append({
+                "source_episode":          src_ep,
+                "source_segment_idx":      seg_idx,
+                "source_h5_frame_range":   meta.get("source_h5_frame_range"),
+                "source_pt_frame_range":   meta.get("source_pt_frame_range"),
+            })
+            self.segment_active.append(active)
+
+            kept = 0
+            for t_start in range(0, T - span + 1, self.window_step):
+                n_total_candidates += 1
+                t_end = t_start + span - 1
+                frame_idx = np.arange(t_start, t_start + span, self.stride)
+                if contact_frame[frame_idx].mean() < self.min_contact_fraction:
+                    n_drop_contact += 1
+                    continue
+                if self.require_motion:
+                    passed = []
+                    for side, mov in [("left", moving_L), ("right", moving_R)]:
+                        if side not in active:
+                            continue
+                        passed.append(mov[frame_idx].mean() >= self.min_motion_fraction)
+                    if self.which_sensors_must_move == "all_active":
+                        ok = bool(passed) and all(passed)
+                    else:
+                        ok = any(passed)
+                    if not ok:
+                        n_drop_motion += 1
+                        continue
+                self.windows.append((seg_id, t_start))
+                kept += 1
+            # Compact per-segment print so noisy episodes don't drown the summary
+            if kept > 0 or T >= span:
+                print(f"[ReactSegmentDataset] {src_ep}/seg{seg_idx:02d}  "
+                      f"T={T:>5d}  kept={kept:>3d} windows")
+
+        self.stats = {
+            "n_source_episodes":      len({m["source_episode"] for m in self.segment_meta}),
+            "n_segments_loaded":      len(self.segments),
+            "n_candidates":           n_total_candidates,
+            "n_dropped_contact":      n_drop_contact,
+            "n_dropped_motion":       n_drop_motion,
+            "n_contact_rich_windows": len(self.windows),
+            "window_length":          self.window_length,
+            "stride":                 self.stride,
+            "window_step":            self.window_step,
+            "min_contact_fraction":   self.min_contact_fraction,
+            "tactile_threshold":      self.tactile_threshold,
+            "contact_metric":         self.contact_metric,
+            "which_sensors":          self.which_sensors,
+            "require_motion":         self.require_motion,
+            "min_motion_mps":         self.min_motion_mps,
+            "min_motion_fraction":    self.min_motion_fraction,
+            "which_sensors_must_move":self.which_sensors_must_move,
+        }
+        pct = 100.0 * len(self.windows) / max(1, n_total_candidates)
+        print()
+        print(f"[ReactSegmentDataset] =================================")
+        print(f"[ReactSegmentDataset]   Contact-rich windows sampled: {len(self.windows):,}")
+        print(f"[ReactSegmentDataset]   ({pct:.1f}% of {n_total_candidates:,} sliding-window candidates)")
+        print(f"[ReactSegmentDataset] =================================")
+        print(f"[ReactSegmentDataset] From {self.stats['n_segments_loaded']} segments across "
+              f"{self.stats['n_source_episodes']} source episodes.")
+        print(f"[ReactSegmentDataset] Window spec: length={self.window_length}, "
+              f"stride={self.stride}, step={self.window_step}  "
+              f"(≈{self.window_length / self.fps:.2f}s @ {self.fps:.0f} fps)")
+        print(f"[ReactSegmentDataset] Rejected by filter:")
+        print(f"[ReactSegmentDataset]   contact (< {self.min_contact_fraction:.0%} of frames in tactile contact):  {n_drop_contact:,}")
+        print(f"[ReactSegmentDataset]   motion  ({'enabled' if self.require_motion else 'disabled'}):  {n_drop_motion:,}")
+        print(f"[ReactSegmentDataset] (No bad_frames filter — segments are already clean by construction.)")
+
+    def __len__(self) -> int:
+        return len(self.windows)
+
+    def __getitem__(self, idx: int) -> dict:
+        seg_id, t_start = self.windows[idx]
+        seg = self.segments[seg_id]
+        meta = self.segment_meta[seg_id]
+        frame_idx = torch.arange(t_start, t_start + self.window_length * self.stride, self.stride)
+        sample = {
+            "view":          seg["view"][frame_idx],
+            "tactile_left":  seg["tactile_left"][frame_idx],
+            "tactile_right": seg["tactile_right"][frame_idx],
+            "sensor_left_pose":  seg["sensor_left_pose"][frame_idx],
+            "sensor_right_pose": seg["sensor_right_pose"][frame_idx],
+            "timestamps":    seg["timestamps"][frame_idx],
+            "tactile_left_intensity":  seg["tactile_left_intensity"][frame_idx],
+            "tactile_right_intensity": seg["tactile_right_intensity"][frame_idx],
+            "tactile_left_mixed":   seg["tactile_left_mixed"][frame_idx],
+            "tactile_right_mixed":  seg["tactile_right_mixed"][frame_idx],
+        }
+        sample["segment_path"]         = str(self.segment_paths[seg_id])
+        sample["source_episode"]       = meta["source_episode"]
+        sample["source_segment_idx"]   = int(meta["source_segment_idx"])
+        sample["source_h5_frame_range"]= meta["source_h5_frame_range"]
+        sample["frame_start"]          = int(t_start)
+        sample["frame_end"]            = int(frame_idx[-1].item())
+        sample["active_sensors"]       = list(self.segment_active[seg_id])
+        # H5 frame index of the first frame in this window (useful for cross-ref)
+        h5_range = meta["source_h5_frame_range"]
+        if h5_range is not None:
+            sample["h5_frame_start"] = int(h5_range[0]) + int(t_start)
+            sample["h5_frame_end"]   = int(h5_range[0]) + int(frame_idx[-1].item())
+        return sample
+
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--segments_root", required=True,
+                    help="processed/mode2_v1/motherboard (relative to dataset root)")
+    ap.add_argument("--tasks_json", default="tasks.json")
+    ap.add_argument("--window_length", type=int, default=16)
+    ap.add_argument("--stride", type=int, default=1)
+    ap.add_argument("--window_step", type=int, default=None)
+    ap.add_argument("--tactile_threshold", type=float, default=0.4)
+    ap.add_argument("--min_contact_fraction", type=float, default=0.5)
+    ap.add_argument("--contact_metric", default="mixed", choices=CONTACT_METRICS)
+    ap.add_argument("--which_sensors", default="both", choices=["any", "both", "left", "right"])
+    ap.add_argument("--require_motion", action="store_true")
+    ap.add_argument("--min_motion_mps", type=float, default=0.01)
+    ap.add_argument("--min_motion_fraction", type=float, default=0.25)
+    ap.add_argument("--which_sensors_must_move", default="all_active",
+                    choices=["any", "all_active"])
+    args = ap.parse_args()
+    ds = ReactSegmentDataset(
+        segments_root=args.segments_root,
+        tasks_json_path=args.tasks_json,
+        window_length=args.window_length,
+        stride=args.stride,
+        window_step=args.window_step,
+        contact_metric=args.contact_metric,
+        tactile_threshold=args.tactile_threshold,
+        min_contact_fraction=args.min_contact_fraction,
+        which_sensors=args.which_sensors,
+        require_motion=args.require_motion,
+        min_motion_mps=args.min_motion_mps,
+        min_motion_fraction=args.min_motion_fraction,
+        which_sensors_must_move=args.which_sensors_must_move,
+    )
+    print(f"\nlen(ds) = {len(ds)}")
+    if len(ds):
+        sample = ds[0]
+        for k, v in sample.items():
+            if isinstance(v, torch.Tensor):
+                print(f"  {k:30s} {tuple(v.shape)}  {v.dtype}")
+            else:
+                print(f"  {k:30s} {v!r}")

processed/mode2_v1/motherboard/2026-05-10/episode_000.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14dbcb0538c9dd38ff34be703ab89f968fe84ce186c44deea6989bda9523ee5b
+size 1016781053

processed/mode2_v1/motherboard/2026-05-10/episode_001.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e87c9e839b76baeeb0901482728c9a89bce9b610ee619893de52fd89be4ee922
+size 812137725

processed/mode2_v1/motherboard/2026-05-10/episode_001.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23bf6d6bcc797c705b3869af71b3c850848745b58e76d1f432c58473edab41f9
+size 228600893

processed/mode2_v1/motherboard/2026-05-10/episode_001.segment_02.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a667b410e1651f2f73f5f4f92d8bdeabaeda769f889eed6a4d65f879e00aabc
+size 69106045

processed/mode2_v1/motherboard/2026-05-10/episode_002.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:984fe336e8a834b1b52a85f170603f006370b079ecc47d31d248296bb5ff4ae0
+size 1409395901

processed/mode2_v1/motherboard/2026-05-10/episode_002.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:abd2e08d178c244559cc94002a6ce392dea4feca55dff4918756fc5d03eb63a7
+size 16728125

processed/mode2_v1/motherboard/2026-05-10/episode_002.segment_02.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8345acf2488695f989bb13fdb1dfe9a773d2ece83141538945462b72c074bac
+size 93450749

processed/mode2_v1/motherboard/2026-05-10/episode_002.segment_03.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5da6ad10cde4f96a3536e47e2210f0b665e6bb9d493efa753c923bba770ddaa0
+size 23219709

processed/mode2_v1/motherboard/2026-05-10/episode_003.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca2e9e3fc030e4b5347346194dd857c4b43aad31ed8eea631f0204ce7243d0b1
+size 1366755645

processed/mode2_v1/motherboard/2026-05-10/episode_004.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd216cb4ce8788b7c9d4580f37e8d19e146e03aaf0f4a8e41dcc679845b5119b
+size 355193789

processed/mode2_v1/motherboard/2026-05-10/episode_005.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92bb6a8bf6330bc3b42e9205d7f4de0d03f87b72af12338e83fbd328032b9108
+size 112779005

processed/mode2_v1/motherboard/2026-05-10/episode_006.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ecdf92b0be6be6b7c1c24d4427e467dcc4db56d6faf79d80075da7c57841365
+size 579313213

processed/mode2_v1/motherboard/2026-05-10/episode_007.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cf48ff081b45744ded13b5868ef73e96f6353b6b6771361d11e1bba5c29895e
+size 284520317

processed/mode2_v1/motherboard/2026-05-10/episode_008.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcf65af751bab982780ba85652b535355e231ac6f3b872fd1954d23144ca03b1
+size 192747837

processed/mode2_v1/motherboard/2026-05-10/episode_009.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ead38d1e22f3a82b5be23a66cd6de5c5d06a115f25cf73279879c0017b431292
+size 269175869

processed/mode2_v1/motherboard/2026-05-10/episode_010.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff67066044ade94cea048c5b3c32a96681250cc2b9fab951672f414259bf907b
+size 152910909

processed/mode2_v1/motherboard/2026-05-10/episode_011.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4051c0bee29c38b660c10e30b97a107a45bd2b03671c684d17c32884362a2294
+size 324947325

processed/mode2_v1/motherboard/2026-05-11/episode_003.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:382adf884ff5a48b17a7588192a3096f57a56d4049f754b755d0923a6dc91403
+size 38859389

processed/mode2_v1/motherboard/2026-05-11/episode_003.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b580aedc2068641d84fb385c104301828b43b4996ad057bc7f3a1af6332049b
+size 1228801853

processed/mode2_v1/motherboard/2026-05-11/episode_003.segment_02.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:939da2f48ff22aba139524effc427b47bd87b6a6e3756835c3431d955ee17524
+size 210305789

processed/mode2_v1/motherboard/2026-05-11/episode_004.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:093c532c962fbd4e4776ddaa7a98b0849b65f0f934f839a95cd1f07a864d8e21
+size 389424253

processed/mode2_v1/motherboard/2026-05-11/episode_005.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7c294f34148ff952a32d0a959cbe3c35100cb6e37a49c8d8b88f5d520628e0b
+size 382932285

processed/mode2_v1/motherboard/2026-05-11/episode_005.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2dc0e657a169bae07b4a312404fca93d370fbcdfbc608c719ee86ab73714de9
+size 1505004285

processed/mode2_v1/motherboard/2026-05-11/episode_005.segment_02.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb01c348654ab42bc3b3e673a2c68e7f16a1474a0fafc738d2306ed7eb83cf8e
+size 245568829

processed/mode2_v1/motherboard/2026-05-11/episode_006.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:573641bd2a33181e444a1d7e492808a886351a3b701cc38732bbdee37ea01c8a
+size 1769255421

processed/mode2_v1/motherboard/2026-05-11/episode_007.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df9969cd9a3b4020cb82213394301260f52ca3f7e86c76bf28b044b92aba1c6d
+size 824678845

processed/mode2_v1/motherboard/2026-05-11/episode_007.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ed930c16dce24d15fa2ae716f117f5a17b357d5ac0516184473d73f1f844988
+size 193633341

processed/mode2_v1/motherboard/2026-05-11/episode_008.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be4b91faaf624e7b08d43d4548bcd21775894c0347d058dcb5abbe2ad8d67038
+size 321996413

processed/mode2_v1/motherboard/2026-05-11/episode_008.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d45d25d005e67c2f132f8c1437fde65a73499f53cb0e6e4b43fce66d058d6c69
+size 1399362621

processed/mode2_v1/motherboard/2026-05-11/episode_008.segment_02.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb1bd2c3845409386f3fce18756598a8f092ce0d174ee1528ad7832b4defe6c0
+size 298536829

processed/mode2_v1/motherboard/2026-05-11/episode_009.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c2a7a63bb49df1fef3c3ea31d3d22a70986a9c2e168eabc527cec2ad865d211
+size 644380221

processed/mode2_v1/motherboard/2026-05-11/episode_010.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0db9b9d6c54f7060d3114417b8943a895a0b76d3c3a9f407eda57e0edb321a3e
+size 1007633277

processed/mode2_v1/motherboard/2026-05-11/episode_011.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66808dfa6f0acef0f6437f6a77d246e087d18e0ba84def449930a0c0bfff5f86
+size 629330557

processed/mode2_v1/motherboard/2026-05-11/episode_011.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a07f93d27cf3c3fe307f9825dc843ef63d5badccb1932f68f7d1708ca6b3006
+size 446671293

processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a0896417348e0a66bd5db7f8fe85e9de9de5b21acf66dead6b4bc50a9192fd6
+size 2187985277

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ab514bfdaec8a5e3893a46d74d4f6a5ff5c7a08cebd97fbfc2a90d1d5a109f4
+size 850794109

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_01.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9846e12af37206521ee20c6b23e1bb04e1d711e06f397636f22acfa4ca78b437
+size 11121085

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_02.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d47edca6ff9db5f90200a4653c341f59a5d94cb54a373e46163d6e5237ed806e
+size 3153789

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_03.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00359eb4bd548de6583b5221a0e8522953e7aa5612ac01c66d73703a96709194
+size 23662589

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_04.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b89cb794685ccb934cc0ffcf87b9e2cb1c8f9ffb82bb9aaa391e09c489c187b0
+size 15547453

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_05.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0aeae827a42dd2af6c8287ab11bb578b3626f36fd874fecb346d68e57d5c4661
+size 205584381

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_06.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5a88f88c01f9ca1f7800eeeb22e2cee76cf664357ff7bcd109b9bcae8bfbae2
+size 7285245

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_07.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce89dfc49804f0dd9c5940011b4d6eb94f517a3c426f2e1abc0002daa0842a31
+size 53761341

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_08.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1351acc9d830d572a463110da9f95feec92ed5a4bc67e744f94044836f84624
+size 213551485

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_09.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:469f92a4aeafd7834fffe15c9c62924972e77e7a730184553ceb762871c50bd7
+size 2858877

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_10.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0834aa838355a867ca53fa240e2c1d8d63869f0cfa95f66beeb75d9797ff3f8
+size 47564669

processed/mode2_v1/motherboard/2026-05-11/episode_013.segment_11.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b8eecc56eab4e1cadc342af5abbba9d2f4dcc30d99934e76683262c0cea539f
+size 172681981