examples/play_react_pt.py: episode-aware viewer. Accepts a directory of segments — all same-episode segments concatenate into one playback timeline; N/P switches between episodes. Red border + red trail-plot mark on segment-boundary frames. Also supports --save_video_dir for per-episode batch MP4 export.

examples/README.md

@@ -117,24 +117,41 @@ pre-trim timeline.
 trim_offset = ep["_contact_meta"]["trim_offset"]
 h5_index = pt_index + trim_offset    # only needed when reading raw H5
 ```
+## Visualizing a single .pt or a whole task
 
-
-## Visualizing a single .pt file
-
-If you want to scrub through one recording or segment frame-by-frame (the
-same way `python -m twm.visualize` plays the original H5 archive), use:
+Use `examples/play_react_pt.py` to scrub through React data interactively
+(same key bindings as `python -m twm.visualize` for H5 archives).
 
 ```bash
-# Interactive cv2 window (space / arrows / 1..6 / r / q)
-python examples/play_react_pt.py     processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt
+# Single .pt (mode1_v1 episode or one mode2_v1 segment)
+python examples/play_react_pt.py \
+    processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt
 
-# Headless MP4 export (no display required)
-python examples/play_react_pt.py <pt_path> --save_video out.mp4
+# Whole task: all 27 episodes are discovered; same-source segments are
+# concatenated into one playback timeline. N / P jumps between episodes.
+python examples/play_react_pt.py processed/mode2_v1/motherboard
+
+# Headless: write one MP4 per episode into a directory
+python examples/play_react_pt.py processed/mode2_v1/motherboard \
+    --save_video_dir /tmp/react_mp4s
 ```
 
-The viewer shows: cam0 view | tactile_L raw + diff | tactile_R raw + diff
-on the top row, and OptiTrack pose text + a sliding contact-intensity
-trail plot + the controls cheatsheet on the bottom row. The GelSight diff
-is computed against the `_contact_meta.ref_p01_*` baseline (the
-quietest moment of the recording), so it reads as 'what is currently
-pressing on the gel' rather than 'change since the start of the clip.'
+Controls:
+
+| Key | Action |
+|---|---|
+| `space` | pause / resume |
+| `left / a`, `right / d` | prev / next frame |
+| `1..6` | speed 1x / 2x / 5x / 10x / 25x / 50x |
+| `r` | reset GelSight diff reference to current frame |
+| **`n` / `p`** | **next / previous episode** |
+| `q` | quit |
+
+Panel layout (1280 x 480):
+
+- **Row 1**: cam0 view, tactile_L raw, tactile_L diff, tactile_R raw, tactile_R diff
+- **Row 2**: OT pose text (live x/y/z + quaternion), contact-intensity trail plot, controls cheatsheet
+- **Status bar at top**: episode index, frame index in the concatenated timeline, segment number, source-H5 frame range
+- **Red border for 1 frame** when crossing a segment boundary (visible cue that a bad interval was cut here). Vertical red marks in the trail plot show recent boundaries.
+
+The GelSight diff is computed against `_contact_meta.ref_p01_*` (the quietest frame of the episode), so it reads as the absolute contact on the gel rather than change since the start of the clip.

examples/play_react_pt.py

@@ -1,39 +1,41 @@
-"""Interactive playback for a React `.pt` file — same key bindings as
-`twm.visualize`, but operates on the downsampled, single-camera, cam-aligned
-content that's actually inside the `.pt`. Works for both `mode1_v1/` whole
-recordings and `mode2_v1/` clean segments.
+"""Interactive playback for React data — accepts a single `.pt` OR a
+directory of segments / episodes, concatenates same-episode segments
+into one continuous timeline, and lets you switch between source
+episodes with N / P.
 
 Usage
 -----
-Interactive (cv2 window):
+Single file (mode1_v1 episode OR a single mode2_v1 segment):
     python examples/play_react_pt.py \\
         processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt
 
-Headless export to MP4:
-    python examples/play_react_pt.py <pt_path> --save_video out.mp4
+Whole task — episode-by-episode browser:
+    python examples/play_react_pt.py \\
+        processed/mode2_v1/motherboard
+
+  All segments of `episode_NNN` are concatenated into one playback
+  timeline; N / P jumps to the next / previous source episode.
+
+  Works with mode1_v1 too (each `.pt` is treated as a one-segment
+  episode); N / P then jumps file-to-file.
+
+Headless export (one MP4 per episode):
+    python examples/play_react_pt.py <root> --save_video_dir /tmp/out
 
 Controls
 --------
-    space       — pause / resume
-    → / d       — next frame (works while paused)
-    ← / a       — previous frame
-    1 / 2 / 3 / 4 / 5 / 6 — playback speed 1× / 2× / 5× / 10× / 25× / 50×
-    r           — reset GelSight diff reference to current frame
-    q           — quit
-
-Panel layout (1280 × 480)
--------------------------
-    Row 1 (240 tall):  view | tactile_L_raw | tactile_L_diff | tactile_R_raw | tactile_R_diff
-    Row 2 (240 tall):  OT pose panel | contact-intensity trail plot | controls cheatsheet
-    Status bar at top: episode / segment, frame index, wall-clock t, playback speed
-
-The diff is computed against the per-episode `ref_p01_{left,right}` image
-stored in `_contact_meta` (the "quietest moment of the recording" — the
-same baseline `twm.contact_index` uses), so it reads as "what is *currently*
-pressing on the gel" rather than "what changed since this clip started."
+    space         — pause / resume
+    → / d         — next frame
+    ← / a         — previous frame
+    1..6          — playback speed 1× / 2× / 5× / 10× / 25× / 50×
+    r             — reset GelSight diff reference to current frame
+    n             — next episode
+    p             — previous episode
+    q             — quit
 """
 import argparse
 import collections
+import re
 import sys
 import time
 from pathlib import Path
@@ -42,13 +44,11 @@ import cv2
 import numpy as np
 import torch
 
-# ─── color conventions ──────────────────────────────────────────────────────
-# OT pose-text colors (BGR for cv2 calls)
+# ──────────────────────────────────────────────────────────────────────────────
 TRACKER_COLORS = {
     "sensor_left":  (  0, 255, 120),
     "sensor_right": (  0, 180, 255),
 }
-
 PANEL_W, PANEL_H = 1280, 480
 VIEW_THUMB = (320, 240)
 TAC_THUMB = (240, 240)
@@ -56,28 +56,135 @@ OT_PANEL = (320, 240)
 TRAIL_PANEL = (640, 240)
 CONTROLS_PANEL = (320, 240)
 
+SEGMENT_FNAME_RE = re.compile(r"^(episode_\d+)\.segment_(\d+)\.pt$")
+PLAIN_EPISODE_RE = re.compile(r"^(episode_\d+)\.pt$")
+
 
 def _to_hwc(t):
     return t.permute(1, 2, 0).numpy() if t.ndim == 3 else t.numpy()
 
-
 def _view_to_bgr(view_chw):
-    """`view` is BGR (rs.format.bgr8 → contact_index keeps byte order).
-    cv2.imshow expects BGR, so just permute to HWC."""
     return view_chw.permute(1, 2, 0).numpy()
 
-
 def _tactile_to_bgr(tac_chw):
-    """`tactile_*` is RGB. Convert to BGR for cv2.imshow."""
     rgb = tac_chw.permute(1, 2, 0).numpy()
     return rgb[..., ::-1]
 
-
 def _diff_thumb(frame_bgr, ref_bgr, size):
     diff = np.clip(frame_bgr.astype(np.int16) - ref_bgr.astype(np.int16) + 128, 0, 255).astype(np.uint8)
     return cv2.resize(diff, size, interpolation=cv2.INTER_NEAREST)
 
 
+# ──────────────────────────────────────────────────────────────────────────────
+# Episode discovery
+# ──────────────────────────────────────────────────────────────────────────────
+
+def discover_episodes(root: Path) -> list[dict]:
+    """Walk `root`, group .pt files by source episode key '<date>/episode_NNN',
+    and return one entry per episode with its segment paths sorted.
+
+    Handles both:
+      - mode2_v1: `<root>/<date>/episode_NNN.segment_MM.pt`
+      - mode1_v1: `<root>/<date>/episode_NNN.pt`
+    """
+    pts = sorted(root.rglob("*.pt"))
+    if not pts:
+        raise SystemExit(f"No .pt files under {root}")
+
+    episodes: dict[str, dict] = {}    # key: "<date>/<ep>" → {date, ep_stem, segs: [(seg_idx, path)]}
+    for p in pts:
+        m_seg = SEGMENT_FNAME_RE.match(p.name)
+        m_plain = PLAIN_EPISODE_RE.match(p.name)
+        if m_seg:
+            ep_stem, seg_idx = m_seg.group(1), int(m_seg.group(2))
+        elif m_plain:
+            ep_stem, seg_idx = m_plain.group(1), 0
+        else:
+            continue
+        date = p.parent.name
+        key = f"{date}/{ep_stem}"
+        episodes.setdefault(key, {"date": date, "ep_stem": ep_stem, "segs": []})
+        episodes[key]["segs"].append((seg_idx, p))
+
+    out = []
+    for key in sorted(episodes):
+        ep = episodes[key]
+        ep["segs"].sort(key=lambda x: x[0])
+        out.append({"key": key, **ep})
+    return out
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Episode-load
+# ──────────────────────────────────────────────────────────────────────────────
+
+class LoadedEpisode:
+    """One source episode, with all its segments concatenated for playback.
+
+    Stores:
+      - keys for the 5 image-shaped tensors (view, tactile_*) concatenated
+      - keys for the 5 per-frame scalar/vector tensors
+      - segment_bounds[i] = (start_in_concat, end_in_concat, seg_idx, source_h5_range)
+        for the i-th segment
+      - p01 reference frames pulled from the *first* segment's _contact_meta
+    """
+    PER_FRAME_KEYS = (
+        "view", "tactile_left", "tactile_right",
+        "sensor_left_pose", "sensor_right_pose", "timestamps",
+        "tactile_left_intensity",  "tactile_right_intensity",
+        "tactile_left_mixed",      "tactile_right_mixed",
+    )
+
+    def __init__(self, ep_meta: dict):
+        self.key = ep_meta["key"]
+        self.date = ep_meta["date"]
+        self.ep_stem = ep_meta["ep_stem"]
+        self.segment_paths = [p for _, p in ep_meta["segs"]]
+        print(f"[player] loading episode {self.key}  "
+              f"({len(self.segment_paths)} segment{'s' if len(self.segment_paths) > 1 else ''})...")
+
+        per_seg = [torch.load(p, weights_only=False, map_location="cpu") for p in self.segment_paths]
+        cat = {}
+        for k in self.PER_FRAME_KEYS:
+            if k in per_seg[0]:
+                cat[k] = torch.cat([s[k] for s in per_seg], dim=0)
+        # Boundaries
+        bounds = []
+        cursor = 0
+        for i, s in enumerate(per_seg):
+            n = s["view"].shape[0]
+            meta = s.get("_contact_meta", {})
+            bounds.append({
+                "start_in_concat": cursor,
+                "end_in_concat":   cursor + n - 1,
+                "seg_idx":         int(meta.get("source_segment_idx", i)),
+                "source_h5_range": meta.get("source_h5_frame_range"),
+                "n_frames":        n,
+            })
+            cursor += n
+        self.data = cat
+        self.bounds = bounds
+        self.n_frames = cursor
+        meta0 = per_seg[0].get("_contact_meta", {})
+        # p01 references from the first segment (same per-source-episode)
+        self.ref_L = _tactile_to_bgr(meta0["ref_p01_left"]) if meta0.get("ref_p01_left") is not None else _tactile_to_bgr(per_seg[0]["tactile_left"][0])
+        self.ref_R = _tactile_to_bgr(meta0["ref_p01_right"]) if meta0.get("ref_p01_right") is not None else _tactile_to_bgr(per_seg[0]["tactile_right"][0])
+        print(f"[player]   total {self.n_frames} frames  ({self.n_frames / 30.0:.1f}s)")
+
+    def segment_at(self, frame_idx: int) -> dict:
+        for b in self.bounds:
+            if b["start_in_concat"] <= frame_idx <= b["end_in_concat"]:
+                return b
+        return self.bounds[-1]
+
+    def is_segment_start(self, frame_idx: int) -> bool:
+        return any(frame_idx == b["start_in_concat"] for b in self.bounds[1:])
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Panel renderer
+# ──────────────────────────────────────────────────────────────────────────────
+
 def _make_ot_panel(pose_L, pose_R, t_idx, t_sec, w, h):
     panel = np.zeros((h, w, 3), np.uint8)
     cv2.putText(panel, "OptiTrack (this frame)", (8, 22),
@@ -89,121 +196,97 @@ def _make_ot_panel(pose_L, pose_R, t_idx, t_sec, w, h):
         cv2.putText(panel, name, (8, y), cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 1, cv2.LINE_AA)
         y += 18
         if p is None or all(v == 0 for v in p):
-            cv2.putText(panel, "  no data", (8, y),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.4, (100, 100, 100), 1, cv2.LINE_AA)
-            y += 36
-            continue
+            cv2.putText(panel, "  no data", (8, y), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (100, 100, 100), 1, cv2.LINE_AA)
+            y += 36; continue
         x, yv, z, qx, qy, qz, qw = p
-        cv2.putText(panel, f"  x={x:+.3f} y={yv:+.3f} z={z:+.3f}", (8, y),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.38, (220, 220, 220), 1, cv2.LINE_AA)
+        cv2.putText(panel, f"  x={x:+.3f} y={yv:+.3f} z={z:+.3f}", (8, y), cv2.FONT_HERSHEY_SIMPLEX, 0.38, (220, 220, 220), 1, cv2.LINE_AA)
         y += 16
-        cv2.putText(panel, f"  qx={qx:+.2f} qy={qy:+.2f}", (8, y),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.38, (160, 160, 160), 1, cv2.LINE_AA)
+        cv2.putText(panel, f"  qx={qx:+.2f} qy={qy:+.2f}", (8, y), cv2.FONT_HERSHEY_SIMPLEX, 0.38, (160, 160, 160), 1, cv2.LINE_AA)
         y += 16
-        cv2.putText(panel, f"  qz={qz:+.2f} qw={qw:+.2f}", (8, y),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.38, (160, 160, 160), 1, cv2.LINE_AA)
+        cv2.putText(panel, f"  qz={qz:+.2f} qw={qw:+.2f}", (8, y), cv2.FONT_HERSHEY_SIMPLEX, 0.38, (160, 160, 160), 1, cv2.LINE_AA)
         y += 24
-    cv2.putText(panel, f"t = {t_sec:.2f} s   (frame {t_idx})",
+    cv2.putText(panel, f"t = {t_sec:.2f} s   (concat frame {t_idx})",
                 (8, h - 14), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (200, 200, 200), 1, cv2.LINE_AA)
     return panel
 
 
-def _make_trail_panel(iL_trail, iR_trail, w, h, threshold=0.4):
-    """Plot the last ~N frames of tactile_*_mixed as a paired waveform."""
+def _make_trail_panel(iL_trail, iR_trail, boundary_marks, w, h, threshold=0.4):
     panel = np.zeros((h, w, 3), np.uint8)
-    cv2.putText(panel, "Contact intensity (tactile_*_mixed)  — orange=L  blue=R",
-                (8, 22), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200, 200, 200), 1, cv2.LINE_AA)
+    cv2.putText(panel, "Contact intensity (mixed)  — orange = L  ·  blue = R  ·  red = segment cut",
+                (8, 22), cv2.FONT_HERSHEY_SIMPLEX, 0.48, (200, 200, 200), 1, cv2.LINE_AA)
     cv2.line(panel, (8, 30), (w - 8, 30), (60, 60, 60), 1)
-
-    # Bipolar plot: L above mid, R below mid
     mid_y = h - 26
     max_y = 50
-    plot_top = mid_y - max_y
-    plot_bot = mid_y + max_y
     cv2.line(panel, (8, mid_y), (w - 8, mid_y), (80, 80, 80), 1)
-
     if not iL_trail:
         return panel
     N = len(iL_trail)
-    # Auto-scale by combined max so both stay visible
     smax = max(max(iL_trail), max(iR_trail), float(threshold) * 1.5, 1e-3)
     x_scale = (w - 16) / max(N - 1, 1)
     for i in range(N - 1):
-        x0 = int(8 + i * x_scale)
-        x1 = int(8 + (i + 1) * x_scale)
-        # left = orange #E69F00 in BGR
+        x0 = int(8 + i * x_scale); x1 = int(8 + (i + 1) * x_scale)
         y0L = mid_y - int(min(iL_trail[i],     smax) / smax * max_y)
         y1L = mid_y - int(min(iL_trail[i + 1], smax) / smax * max_y)
         cv2.line(panel, (x0, y0L), (x1, y1L), (0, 159, 230), 1, cv2.LINE_AA)
-        # right = blue #0072B2 in BGR
         y0R = mid_y + int(min(iR_trail[i],     smax) / smax * max_y)
         y1R = mid_y + int(min(iR_trail[i + 1], smax) / smax * max_y)
         cv2.line(panel, (x0, y0R), (x1, y1R), (178, 114, 0), 1, cv2.LINE_AA)
-    # Threshold lines
-    yT_up = mid_y - int(min(threshold, smax) / smax * max_y)
-    yT_dn = mid_y + int(min(threshold, smax) / smax * max_y)
-    cv2.line(panel, (8, yT_up), (w - 8, yT_up), (60, 60, 60), 1, cv2.LINE_AA)
-    cv2.line(panel, (8, yT_dn), (w - 8, yT_dn), (60, 60, 60), 1, cv2.LINE_AA)
-    # Current values readout
-    cv2.putText(panel, f"L = {iL_trail[-1]:.2f}", (10, plot_top + 10),
+    # Segment-cut markers
+    for off in boundary_marks:
+        if 0 <= off < N:
+            x = int(8 + off * x_scale)
+            cv2.line(panel, (x, 35), (x, h - 30), (0, 0, 220), 1, cv2.LINE_AA)
+    cv2.putText(panel, f"L = {iL_trail[-1]:.2f}", (10, 50),
                 cv2.FONT_HERSHEY_SIMPLEX, 0.42, (0, 159, 230), 1, cv2.LINE_AA)
-    cv2.putText(panel, f"R = {iR_trail[-1]:.2f}", (10, plot_bot + 18),
+    cv2.putText(panel, f"R = {iR_trail[-1]:.2f}", (10, h - 8),
                 cv2.FONT_HERSHEY_SIMPLEX, 0.42, (178, 114, 0), 1, cv2.LINE_AA)
-    cv2.putText(panel, f"window: last {N} frames  (threshold = {threshold:.2f})",
-                (w - 280, h - 8), cv2.FONT_HERSHEY_SIMPLEX, 0.38, (140, 140, 140), 1, cv2.LINE_AA)
     return panel
 
 
-def _make_controls_panel(w, h, paused, speed):
+def _make_controls_panel(w, h, paused, speed, ep_idx, n_eps):
     panel = np.zeros((h, w, 3), np.uint8)
     cv2.putText(panel, "Controls", (10, 22),
                 cv2.FONT_HERSHEY_SIMPLEX, 0.55, (200, 200, 200), 1, cv2.LINE_AA)
     cv2.line(panel, (10, 30), (w - 10, 30), (60, 60, 60), 1)
     keys = [
-        ("SPACE",    "pause / resume"),
-        ("← / a",    "previous frame"),
-        ("→ / d",    "next frame"),
-        ("1..6",     "speed 1x/2x/5x/10x/25x/50x"),
-        ("r",        "reset gel-diff ref"),
-        ("q",        "quit"),
+        ("SPACE",  "pause / resume"),
+        ("←  →",   "prev / next frame"),
+        ("1..6",   "speed 1x/2x/5x/10x/25x/50x"),
+        ("n  p",   "next / prev episode"),
+        ("r",      "reset gel-diff ref"),
+        ("q",      "quit"),
     ]
     y = 52
     for k, v in keys:
-        cv2.putText(panel, f"[{k}]", (10, y), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (140, 200, 140), 1, cv2.LINE_AA)
-        cv2.putText(panel, v, (110, y), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (200, 200, 200), 1, cv2.LINE_AA)
+        cv2.putText(panel, f"[{k}]", (10, y),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.42, (140, 200, 140), 1, cv2.LINE_AA)
+        cv2.putText(panel, v, (110, y),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.42, (200, 200, 200), 1, cv2.LINE_AA)
         y += 22
-    # State indicator
     state = "|| PAUSED" if paused else "> PLAYING"
     state_col = (0, 140, 255) if paused else (0, 220, 80)
-    cv2.putText(panel, state, (10, h - 26),
+    cv2.putText(panel, state, (10, h - 50),
                 cv2.FONT_HERSHEY_SIMPLEX, 0.55, state_col, 2, cv2.LINE_AA)
-    cv2.putText(panel, f"speed: {speed}x", (10, h - 8),
+    cv2.putText(panel, f"speed: {speed}x", (10, h - 30),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.45, (180, 180, 180), 1, cv2.LINE_AA)
+    cv2.putText(panel, f"episode {ep_idx + 1} / {n_eps}", (10, h - 10),
                 cv2.FONT_HERSHEY_SIMPLEX, 0.45, (180, 180, 180), 1, cv2.LINE_AA)
     return panel
 
 
-def _episode_label(meta: dict, fallback: str) -> str:
-    """Pretty label for header. mode2_v1 segments expose source_episode; older mode1_v1 doesn't."""
-    src = meta.get("source_episode")
-    seg = meta.get("source_segment_idx")
-    if src and seg is not None:
-        return f"{src} / seg{int(seg):02d}"
-    return fallback
-
-
-def build_panel(ep, frame_idx, ref_L_bgr, ref_R_bgr, iL_trail, iR_trail,
-                ep_label, paused, speed, n_frames):
-    view_bgr  = _view_to_bgr(ep["view"][frame_idx])
-    tac_L_bgr = _tactile_to_bgr(ep["tactile_left"][frame_idx])
-    tac_R_bgr = _tactile_to_bgr(ep["tactile_right"][frame_idx])
+def build_panel(ep: LoadedEpisode, frame_idx: int, ref_L_bgr, ref_R_bgr,
+                iL_trail, iR_trail, boundary_marks_local,
+                paused: bool, speed: int,
+                ep_idx: int, n_eps: int):
+    view_bgr  = _view_to_bgr(ep.data["view"][frame_idx])
+    tac_L_bgr = _tactile_to_bgr(ep.data["tactile_left"][frame_idx])
+    tac_R_bgr = _tactile_to_bgr(ep.data["tactile_right"][frame_idx])
 
     view_thumb  = cv2.resize(view_bgr,  VIEW_THUMB, interpolation=cv2.INTER_NEAREST)
     tac_L_thumb = cv2.resize(tac_L_bgr, TAC_THUMB,  interpolation=cv2.INTER_NEAREST)
     tac_R_thumb = cv2.resize(tac_R_bgr, TAC_THUMB,  interpolation=cv2.INTER_NEAREST)
     tac_L_diff  = _diff_thumb(tac_L_bgr, ref_L_bgr, TAC_THUMB)
     tac_R_diff  = _diff_thumb(tac_R_bgr, ref_R_bgr, TAC_THUMB)
-
-    # Tile-label headers
     for img, label in [(view_thumb, "cam0 / view"),
                        (tac_L_thumb, "tactile_left"),
                        (tac_L_diff,  "tac_L diff (vs p01)"),
@@ -211,140 +294,191 @@ def build_panel(ep, frame_idx, ref_L_bgr, ref_R_bgr, iL_trail, iR_trail,
                        (tac_R_diff,  "tac_R diff (vs p01)")]:
         cv2.putText(img, label, (6, 14),
                     cv2.FONT_HERSHEY_SIMPLEX, 0.4, (220, 220, 220), 1, cv2.LINE_AA)
-
     row1 = np.hstack([view_thumb, tac_L_thumb, tac_L_diff, tac_R_thumb, tac_R_diff])
 
-    pose_L = ep["sensor_left_pose"][frame_idx].tolist()
-    pose_R = ep["sensor_right_pose"][frame_idx].tolist()
-    t_sec  = float(ep["timestamps"][frame_idx] - ep["timestamps"][0])
+    pose_L = ep.data["sensor_left_pose"][frame_idx].tolist()
+    pose_R = ep.data["sensor_right_pose"][frame_idx].tolist()
+    t_sec  = float(ep.data["timestamps"][frame_idx] - ep.data["timestamps"][0])
     ot_panel       = _make_ot_panel(pose_L, pose_R, frame_idx, t_sec, *OT_PANEL)
-    trail_panel    = _make_trail_panel(list(iL_trail), list(iR_trail), *TRAIL_PANEL)
-    controls_panel = _make_controls_panel(*CONTROLS_PANEL, paused=paused, speed=speed)
-
+    trail_panel    = _make_trail_panel(list(iL_trail), list(iR_trail),
+                                        boundary_marks_local, *TRAIL_PANEL)
+    controls_panel = _make_controls_panel(*CONTROLS_PANEL, paused=paused, speed=speed,
+                                           ep_idx=ep_idx, n_eps=n_eps)
     row2 = np.hstack([ot_panel, trail_panel, controls_panel])
     panel = np.vstack([row1, row2])
 
-    # Top status bar (orange, on a dark band so it's legible over the cams)
+    # Top status bar
     cv2.rectangle(panel, (0, 0), (PANEL_W, 22), (30, 30, 30), -1)
     state = "PAUSED" if paused else "PLAYING"
-    status = (f"[{state}]  {ep_label}  ·  frame {frame_idx + 1}/{n_frames}  "
-              f"·  t = {t_sec:.2f}s  ·  {speed}x")
+    seg = ep.segment_at(frame_idx)
+    h5r = seg["source_h5_range"]
+    seg_label = f"seg {seg['seg_idx']:02d}"
+    if h5r:
+        seg_label += f"  H5[{h5r[0]}..{h5r[1]}]"
+    status = (f"[{state}]  ep {ep_idx + 1}/{n_eps}  {ep.key}  ·  "
+              f"frame {frame_idx + 1}/{ep.n_frames}  ·  t={t_sec:.2f}s  ·  "
+              f"{seg_label}  ·  {speed}x")
     cv2.putText(panel, status, (10, 16),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.48, (0, 200, 255), 1, cv2.LINE_AA)
+                cv2.FONT_HERSHEY_SIMPLEX, 0.46, (0, 200, 255), 1, cv2.LINE_AA)
+
+    # Segment-cut flash: red border for the first 2 frames of a non-first segment
+    if ep.is_segment_start(frame_idx):
+        cv2.rectangle(panel, (0, 22), (PANEL_W - 1, PANEL_H - 1), (0, 0, 220), 3)
+
     return panel
 
 
+# ──────────────────────────────────────────────────────────────────────────────
+# Main
+# ──────────────────────────────────────────────────────────────────────────────
+
 def main():
-    ap = argparse.ArgumentParser(description="Interactive playback of a React .pt file.")
-    ap.add_argument("pt_path", help="path to a .pt under processed/mode{1,2}_v1/.../")
+    ap = argparse.ArgumentParser(description="Interactive React .pt player.")
+    ap.add_argument("path", help="A single .pt file OR a directory of episodes/segments.")
     ap.add_argument("--save_video", default=None,
-                    help="Path to write an MP4 instead of opening a window (headless mode).")
-    ap.add_argument("--fps", type=float, default=30.0, help="Playback / output fps.")
-    ap.add_argument("--trail_frames", type=int, default=120,
-                    help="How many recent frames to plot in the contact-intensity trail (default 120 = 4s).")
+                    help="When `path` is a single .pt: write that one episode as MP4 here.")
+    ap.add_argument("--save_video_dir", default=None,
+                    help="When `path` is a directory: write one MP4 per episode into this dir.")
+    ap.add_argument("--fps", type=float, default=30.0)
+    ap.add_argument("--trail_frames", type=int, default=120)
     args = ap.parse_args()
 
-    pt_path = Path(args.pt_path)
-    if not pt_path.is_file():
-        print(f"Not a file: {pt_path}", file=sys.stderr); sys.exit(1)
-
-    print(f"Loading {pt_path}...")
-    ep = torch.load(pt_path, weights_only=False, map_location="cpu")
-    n_frames = ep["view"].shape[0]
-    meta = ep.get("_contact_meta", {})
-    ep_label = _episode_label(meta, fallback=pt_path.stem)
-    print(f"  {ep_label}: {n_frames} frames  ({n_frames / args.fps:.1f}s @ {args.fps:.0f} fps)")
-
-    # Initial GelSight diff reference — use the per-episode p01 frame stored
-    # in _contact_meta (cleanest "no contact" baseline). Fall back to frame 0
-    # if the .pt was produced before that field existed.
-    def _ref_from_meta_or_first(side):
-        key = f"ref_p01_{side}"
-        if key in meta and meta[key] is not None:
-            ref = meta[key]
-            if hasattr(ref, "permute"):
-                return _tactile_to_bgr(ref)
-        return _tactile_to_bgr(ep[f"tactile_{side}"][0])
-    ref_L = _ref_from_meta_or_first("left")
-    ref_R = _ref_from_meta_or_first("right")
-
-    iL = ep["tactile_left_mixed"].numpy()
-    iR = ep["tactile_right_mixed"].numpy()
-
-    paused, speed, frame_idx = False, 1, 0
-    SPEEDS = {ord('1'): 1, ord('2'): 2, ord('3'): 5,
-              ord('4'): 10, ord('5'): 25, ord('6'): 50}
+    in_path = Path(args.path)
+    if not in_path.exists():
+        print(f"Not found: {in_path}", file=sys.stderr); sys.exit(1)
+
+    if in_path.is_file():
+        # Single .pt → one-episode mode (use parent dir for discovery to enable n/p)
+        parent_root = in_path.parent.parent  # <root>/<date>/file.pt → <root>
+        episodes = discover_episodes(parent_root)
+        # Find the episode that contains this exact file
+        target_path = in_path.resolve()
+        start_idx = 0
+        for i, ep_meta in enumerate(episodes):
+            if any(p.resolve() == target_path for _, p in ep_meta["segs"]):
+                start_idx = i; break
+    else:
+        episodes = discover_episodes(in_path)
+        start_idx = 0
+    print(f"[player] discovered {len(episodes)} episode(s) under {in_path}")
+
+    headless_dir = Path(args.save_video_dir) if args.save_video_dir else None
+    headless_single = args.save_video
+
+    if headless_single and len(episodes) > 1 and in_path.is_dir():
+        print("--save_video accepts a single output path; for a directory pass --save_video_dir instead.", file=sys.stderr)
+        sys.exit(1)
+
+    headless = headless_single is not None or headless_dir is not None
 
-    headless = args.save_video is not None
     if headless:
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        writer = cv2.VideoWriter(args.save_video, fourcc, args.fps, (PANEL_W, PANEL_H))
-        if not writer.isOpened():
-            print(f"Could not open {args.save_video} for writing.", file=sys.stderr); sys.exit(1)
-        print(f"Headless: writing {args.save_video}  ({n_frames} frames at {args.fps} fps)")
-    else:
-        cv2.namedWindow(ep_label, cv2.WINDOW_AUTOSIZE)
-        cv2.createTrackbar("Frame", ep_label, 0, max(1, n_frames - 1), lambda v: None)
-        print("Controls:  space / ←→ / 1..6 / r / q")
+        if headless_dir:
+            headless_dir.mkdir(parents=True, exist_ok=True)
+        for ep_idx in range(start_idx, len(episodes)):
+            ep = LoadedEpisode(episodes[ep_idx])
+            out_path = (Path(headless_single)
+                        if headless_single else
+                        (headless_dir / f"{ep.date}_{ep.ep_stem}.mp4"))
+            fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+            writer = cv2.VideoWriter(str(out_path), fourcc, args.fps, (PANEL_W, PANEL_H))
+            iL_trail = collections.deque(maxlen=args.trail_frames)
+            iR_trail = collections.deque(maxlen=args.trail_frames)
+            print(f"  → {out_path}")
+            for f in range(ep.n_frames):
+                iL_trail.append(float(ep.data["tactile_left_mixed"][f]))
+                iR_trail.append(float(ep.data["tactile_right_mixed"][f]))
+                local_boundary_marks = [
+                    args.trail_frames - 1 - (f - b["start_in_concat"])
+                    for b in ep.bounds[1:]
+                    if b["start_in_concat"] <= f and (f - b["start_in_concat"]) < args.trail_frames
+                ]
+                panel = build_panel(ep, f, ep.ref_L, ep.ref_R,
+                                    iL_trail, iR_trail, local_boundary_marks,
+                                    paused=False, speed=1,
+                                    ep_idx=ep_idx, n_eps=len(episodes))
+                writer.write(panel)
+            writer.release()
+            if headless_single:
+                break
+        return
 
-    iL_trail = collections.deque(maxlen=args.trail_frames)
-    iR_trail = collections.deque(maxlen=args.trail_frames)
-    last_drawn = -1
+    # Interactive
+    paused, speed = False, 1
+    SPEEDS = {ord('1'): 1, ord('2'): 2, ord('3'): 5,
+              ord('4'): 10, ord('5'): 25, ord('6'): 50}
 
-    try:
-        while True:
-            frame_idx = max(0, min(frame_idx, n_frames - 1))
-            if not headless:
-                pos = cv2.getTrackbarPos("Frame", ep_label)
-                if pos != frame_idx and pos != last_drawn:
-                    frame_idx = pos
-                    paused = True
+    ep_idx = start_idx
+    while 0 <= ep_idx < len(episodes):
+        ep = LoadedEpisode(episodes[ep_idx])
+        WIN = "React .pt player"
+        cv2.namedWindow(WIN, cv2.WINDOW_AUTOSIZE)
+        cv2.createTrackbar("Frame", WIN, 0, max(1, ep.n_frames - 1), lambda v: None)
+        ref_L, ref_R = ep.ref_L, ep.ref_R
+        iL_trail = collections.deque(maxlen=args.trail_frames)
+        iR_trail = collections.deque(maxlen=args.trail_frames)
+        frame_idx = 0
+        last_drawn = -1
+        action = "stay"     # 'next' | 'prev' | 'quit' | 'stay'
 
-            iL_trail.append(float(iL[frame_idx]))
-            iR_trail.append(float(iR[frame_idx]))
+        while True:
+            frame_idx = max(0, min(frame_idx, ep.n_frames - 1))
+            pos = cv2.getTrackbarPos("Frame", WIN)
+            if pos != frame_idx and pos != last_drawn:
+                frame_idx = pos; paused = True
+
+            iL_trail.append(float(ep.data["tactile_left_mixed"][frame_idx]))
+            iR_trail.append(float(ep.data["tactile_right_mixed"][frame_idx]))
+            boundary_marks = [
+                args.trail_frames - 1 - (frame_idx - b["start_in_concat"])
+                for b in ep.bounds[1:]
+                if b["start_in_concat"] <= frame_idx and (frame_idx - b["start_in_concat"]) < args.trail_frames
+            ]
 
             panel = build_panel(ep, frame_idx, ref_L, ref_R,
-                                iL_trail, iR_trail, ep_label, paused, speed, n_frames)
-
-            if headless:
-                writer.write(panel)
-                if frame_idx % 30 == 0:
-                    print(f"  wrote frame {frame_idx + 1}/{n_frames}")
-                if frame_idx >= n_frames - 1:
-                    break
-                frame_idx += 1
-                continue
-
-            cv2.imshow(ep_label, panel)
-            if cv2.getTrackbarPos("Frame", ep_label) != frame_idx:
-                cv2.setTrackbarPos("Frame", ep_label, frame_idx)
+                                iL_trail, iR_trail, boundary_marks,
+                                paused=paused, speed=speed,
+                                ep_idx=ep_idx, n_eps=len(episodes))
+            cv2.imshow(WIN, panel)
+            if cv2.getTrackbarPos("Frame", WIN) != frame_idx:
+                cv2.setTrackbarPos("Frame", WIN, frame_idx)
             last_drawn = frame_idx
 
             key = cv2.waitKey(1) & 0xFF
-            if   key == ord('q'): break
+            if   key == ord('q'): action = "quit"; break
             elif key == ord(' '): paused = not paused
             elif key in (81, ord('a')): paused = True; frame_idx -= 1
             elif key in (83, ord('d')): paused = True; frame_idx += 1
             elif key in SPEEDS:   speed = SPEEDS[key]
             elif key == ord('r'):
-                ref_L = _tactile_to_bgr(ep["tactile_left"][frame_idx])
-                ref_R = _tactile_to_bgr(ep["tactile_right"][frame_idx])
+                ref_L = _tactile_to_bgr(ep.data["tactile_left"][frame_idx])
+                ref_R = _tactile_to_bgr(ep.data["tactile_right"][frame_idx])
                 print(f"  diff ref reset to frame {frame_idx}")
+            elif key == ord('n'):
+                action = "next"; break
+            elif key == ord('p'):
+                action = "prev"; break
 
             if not paused:
                 frame_idx += speed
-                if frame_idx >= n_frames:
-                    frame_idx = n_frames - 1
+                if frame_idx >= ep.n_frames:
+                    print(f"End of episode {ep.key}.")
                     paused = True
-                    print("End of file.")
+                    frame_idx = ep.n_frames - 1
                 time.sleep(max(0.0, 1.0 / (args.fps * speed) - 0.001))
 
-    finally:
-        if headless:
-            writer.release()
-            print(f"Wrote {args.save_video}")
+        cv2.destroyAllWindows()
+        if action == "quit": return
+        if action == "next":
+            ep_idx = min(ep_idx + 1, len(episodes) - 1)
+            if ep_idx == len(episodes) - 1 and episodes[ep_idx]["key"] == ep.key:
+                print("Already at last episode.")
+        elif action == "prev":
+            ep_idx = max(ep_idx - 1, 0)
+            if ep_idx == 0 and episodes[ep_idx]["key"] == ep.key:
+                print("Already at first episode.")
         else:
-            cv2.destroyAllWindows()
+            # natural end of an episode — pause; wait for explicit action
+            paused = True
 
 
 if __name__ == "__main__":