Multi-task video release: tasks.json + README + ReactVideoDataset loader

README.md

@@ -10,229 +10,87 @@ tags:
   - gelsight
   - realsense
   - motion-capture
-  - dynamics
   - world-model
   - human-collected
+  - lerobot
 pretty_name: React (Tactile-Visual Manipulation)
 size_categories:
   - 100K<n<1M
-configs:
-  - config_name: episode_metadata
-    data_files:
-      - split: train
-        path: metadata/episodes.parquet
-  - config_name: motherboard
-    data_files:
-      - split: train
-        path: episodes/motherboard/**/episode_*.pt
-  - config_name: motherboard_segments
-    data_files:
-      - split: train
-        path: segments/motherboard/**/episode_*.segment_*.pt
-  - config_name: all
-    data_files:
-      - split: train
-        path: episodes/**/episode_*.pt
 ---
 
-# React
+# React — Multi-Task Tactile-Visual Manipulation
 
-Dense, contact-rich, synchronized multimodal interaction data collected from **human hands holding handheld GelSight tactile sensors — no robot arm involved**. Intended for **tactile-visual dynamics / world-model learning**, *not* a policy / demonstration dataset.
+Dense, contact-rich, synchronized multimodal interaction data collected from **human hands holding handheld GelSight tactile sensors** (no robot arm). Intended for **tactile-visual dynamics / world-model learning**.
 
-![Tactile intensity timeline](figures/contact_intensity_full.png)
+> **133 min · 240 k frames @ 30 Hz · 3× RGB + 2× GelSight + OptiTrack · 2 tasks**
 
-> **106 min of robot-free human-hand multimodal interaction · 190,231 frames @ 30 Hz across 3 × RGB-D + 2 × GelSight + 3-body OptiTrack**
+## Format — LeRobot-style video release
 
-## What's different about this dataset
+Each episode ships as **5 MP4 video streams** (640×480, H.264) + a **per-frame parquet** of poses and contact metrics. This matches how LeRobot / DROID / Open X-Embodiment ship manipulation data: tiny on disk (whole dataset ≈ 4.3 GB vs ~1 TB raw), random-access decodable, training-ready.
 
-| | |
-|---|---|
-| **Robot-arm-free** | Recorded directly from a human operator holding two GelSight Mini sensors. No robot kinematics, no embodiment bias, no robot occluding the scene. |
-| **Tactile + RGB-D + mocap, simultaneous** | Most manipulation datasets ship one of these. React ships all three, synchronized to a common 30 Hz clock. |
-| **Contact-dense** | **64 % of post-trim frames** have confirmed tactile contact on at least one sensor — see [`figures/contact_intensity_full.png`](figures/contact_intensity_full.png). |
-| **Long, continuous interaction** | Recordings are minutes long, not seconds. Median recording duration is 4 min; longest 19 min. Good for short-window sampling of dynamics, not for action-conditioned policy learning. |
-
-![Comparison with other manipulation datasets](figures/dataset_figures/F7_comparison_table.png)
-
-## At a glance
-
-| | |
-|---|---|
-| Embodiment | **Human hands (no robot)** — handheld GelSight sensors with motion-capture rigid bodies |
-| Intended use | Dynamics / world-model learning over short multimodal windows. Sample short trajectories (1 s – 10 s); recording-file boundaries are not action boundaries. |
-| Total synchronized duration | **105.7 min** at 30 Hz (190,231 multimodal frames, post-trim) |
-| Bimanual tactile-contact time | **64.3 % of post-trim frames** (3,302 contact events, median 0.73 s; see [`figures/dataset_figures/F2_contact_event_duration_histogram.png`](figures/dataset_figures/F2_contact_event_duration_histogram.png) and [`metadata/episodes.parquet`](metadata/episodes.parquet) for per-file numbers) |
-| Cameras | 3× Intel RealSense D415 (color + depth), 480×640, 30 FPS |
-| Tactile | 2× GelSight Mini (left, right), handheld |
-| Motion capture | OptiTrack VRPN, 3 rigid bodies, ~120 Hz |
-| Tasks | `motherboard` (more coming) |
-| License | CC-BY-4.0 |
-
-## Recording sessions
-
-| Date | Kind | Active sensors | Notes |
-|---|---|---|---|
-| 2026-05-10 | session | left + right | First full bimanual session. |
-| 2026-05-11 | session | left + right | Largest session. A handful of GelSight LED-flicker frames + one mocap teleport; see [`bad_frames.json`](bad_frames.json). |
-
-| 2026-05-19 | session | left + right | New session, multi-cam (`view_left/middle/right`) end-to-end. Curation via reproducible `detect_bad_intervals.py` ruleset (see [`docs/curation_pipeline.md`](docs/curation_pipeline.md)). |
-
-See [`tasks.json`](tasks.json) for the machine-readable registry (per-date `active_sensors`, etc.).
-
-**OT-uninitialized prefixes trimmed.** Three episodes had OptiTrack offline at the start of recording (1–11 min each); those prefixes have been cut from the published `.pt` files (`_contact_meta.trim_offset` per file). Future recordings use an OT watchdog that refuses to start an episode unless mocap is streaming. Full story: [`docs/caveats.md`](docs/caveats.md).
-
-
-
-## Data quality
-
-| Mode | Frames | % | Files | Cause |
-|---|---:|---:|---:|---|
-| GelSight LED flicker | 56 | 0.029 % | 5 | Single-frame LED dropout, recovers next frame |
-| OptiTrack pose teleport | 56 | 0.029 % | 3 | Solver flip (translation > 5 m/s or angular > 15 rad/s) |
-| OptiTrack track loss | 1,680 | 0.883 % | 6 | Marker briefly left mocap-volume / camera FOV mid-episode |
-| **Total (union)** | **1,768** | **0.929 %** | **11** | |
-
-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 layouts: `episodes/` vs `segments/`
-
-The same recordings are shipped two ways depending on what your code
-wants to do:
-
-- **`episodes/<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`. Each file carries all three RealSense views
-  (`view_left`, `view_middle`, `view_right`) plus both GelSights.
-- **`segments/<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 layouts have identical content (same source recordings, same
-frame data); only the file boundaries differ.
-
-## Quick start
-
-```python
-# Load by task with `datasets`
-from datasets import load_dataset
-ds = load_dataset("yxma/React", "motherboard", split="train")
 ```
-
-Or grab a single recording file directly:
-
-```python
-import torch
-from huggingface_hub import hf_hub_download
-
-path = hf_hub_download(
-    repo_id="yxma/React", repo_type="dataset",
-    filename="episodes/motherboard/2026-05-11/episode_003.pt",
-)
-ep = torch.load(path, weights_only=False)
-# ep["view"]                                 (T, 3, 128, 128) uint8 — overhead cam
-# ep["tactile_left"], ep["tactile_right"]    (T, 3, 128, 128) uint8
-# ep["sensor_left_pose"], ep["sensor_right_pose"]
-#                                            (T, 7) float32 — xyz + quaternion
-# ep["timestamps"]                           (T,)  float64
-# Plus per-frame contact metrics:            tactile_{side}_{intensity, area, mixed}
+data/<task>/
+├── calibration/                     # OptiTrack→camera extrinsics for this task
+│   ├── T_mocap_to_cam_{left,middle,right}.json
+│   ├── T_gel_to_rigid_{left,right}.json
+│   └── calibration.json             # epoch, applies-to dates, RMSE, chain
+├── videos/<date>/episode_NNN/
+│   ├── view_left.mp4  view_middle.mp4  view_right.mp4    # 640×480 RGB
+│   └── tactile_left.mp4  tactile_right.mp4               # 640×480 GelSight
+├── meta/<date>/episode_NNN.parquet  # one row per frame (see below)
+├── episodes.jsonl                   # one row per episode
+├── segments.json                    # clean-segment index (no bad frames)
+├── bad_frames.json                  # quality intervals per episode
+└── previews/<date>/episode_NNN.mp4  # 1280×480 viewer-layout preview
 ```
 
-Sampling short windows for dynamics learning — **drop windows that overlap any flagged interval**:
-
-```python
-import json
-
-with open("bad_frames.json") as f:
-    bad = json.load(f)["episodes"]   # frame indices are TRIMMED-pt coordinates
-
-def is_clean_window(episode_key, t_start, t_end):
-    """True iff [t_start, t_end] doesn't intersect any flagged span."""
-    bf = bad[episode_key]
-    intervals = (bf["intensity_spikes"]
-                 + bf["pose_teleports_L"] + bf["pose_teleports_R"]
-                 + bf["ot_loss_L"] + bf["ot_loss_R"])
-    return all(not (s <= t_end and e >= t_start) for s, e in intervals)
-```
+### parquet columns (per frame, aligned to video frame `i`)
+| Column | Type | Meaning |
+|---|---|---|
+| `frame_idx` | int | 0…T-1, matches MP4 frame index |
+| `timestamp` | float64 | camera clock (s) |
+| `sensor_left_pose`, `sensor_right_pose` | list[7] | OptiTrack world pose (xyz + quat wxyz) |
+| `tactile_{L,R}_{intensity,area,mixed}` | float32 | contact metrics (computed at full 640×480) |
+| `source_h5_frame` | int | index into the original recording |
 
-Currently 1,768 / 190,231 frames (0.93 %) are flagged across 11 of 27 files — see [`docs/quality.md`](docs/quality.md) for the per-mode breakdown and more filtering recipes. The example dataloader below does this filtering for you when `skip_bad_frames=True`.
-
-## Example dataloader — short contact-rich windows
-
-A reference PyTorch `Dataset` is shipped under [`examples/react_window_dataset.py`](examples/react_window_dataset.py). It scans the processed `.pt` files, applies the contact filter, drops windows that overlap [`bad_frames.json`](bad_frames.json), and respects the per-date `active_sensors` field from [`tasks.json`](tasks.json).
-
-```python
-from examples.react_window_dataset import ReactWindowDataset
-from torch.utils.data import DataLoader
-
-ds = ReactWindowDataset(
-    data_root="episodes/motherboard",
-    bad_frames_path="bad_frames.json",
-    tasks_json_path="tasks.json",
-    window_length=16,            # frames per window
-    stride=1,                    # within-window stride (1 = consecutive)
-    window_step=16,              # step between window starts (overlap control)
-    contact_metric="mixed",      # "intensity" | "area" | "mixed"
-    tactile_threshold=0.4,
-    min_contact_fraction=0.6,    # ≥ 60 % of window frames must have contact
-    which_sensors="any",         # "any" | "both" | "left" | "right"
-    skip_bad_frames=True,
-    respect_active_sensors=True,
-)
-print(len(ds), "windows")
-loader = DataLoader(ds, batch_size=8, shuffle=True, num_workers=2)
-```
+**Decoded frames are RGB** (standard decoder convention) for all five streams.
 
-With the defaults shown above, the dataset assembles **~9.2 k contact-rich 16-frame windows** across the 27 recordings. Each sample is a dict of `(T, …)` tensors plus metadata (`episode`, `frame_start`, `active_sensors`, …).
+## Tasks
 
-### Example output
+| Task | Episodes | Dates | Duration | Clean segments | Calibration |
+|---|---|---|---|---|---|
+| **motherboard** | 32 | 2026-05-10/11/19 | 108 min | 76 (107 min) | **May-12** (RMSE ~5 mm) |
+| **pushT** | 4 | 2026-06-18 | 25 min | 17 (25 min) | **June-26** (RMSE ~0.6 px) |
 
-Four random windows, time runs left→right; each cell is `view | tactile_left | tactile_right` with sensor frame axes (X red, Y green, Z blue-ish) projected onto the view:
+See [`tasks.json`](tasks.json) for the machine-readable registry (per-task dates, sensors, calibration epoch, world-frame offsets).
 
-![dataloader sample grid](figures/dataloader_examples/sample_grid.png)
+### Calibration epochs
+Cameras were **recalibrated between tasks**. Each task points to the calibration valid for its recordings:
+- `motherboard` → **May-12** extrinsics (`data/motherboard/calibration/`)
+- `pushT` → **June-26** extrinsics (`data/pushT/calibration/`)
 
-One window played frame-by-frame with the sensor-frame overlay:
+Camera extrinsics are used only for the projection overlay; **stored poses are OptiTrack world-frame** and independent of calibration. The 2026-05-19 motherboard session had a redefined world origin; an offset `(0.23, 0, 0.175) m` is already baked into its poses so all dates share one frame (recorded in `episodes.jsonl`).
 
-![dataloader sample GIF](figures/dataloader_examples/sample_window.gif)
+## Loading
 
-Full demo script: [`examples/demo_react_window.py`](examples/demo_react_window.py).
-
-## Recording-file previews
-
-Per-episode previews live under [`figures/episode_previews/`](figures/episode_previews/) as inline-renderable MP4s. **Browse all 32 episodes (collapsed by default) on [](figures/episode_previews/index.md) — click any row to preview that episode inline.** Each shows 60 frames evenly sampled across the episode in the recording-viewer layout: 3 RealSense cameras with projected GelSight axes, GelSight raw + diff thumbs, OptiTrack pose text panel. (The on-disk recording unit is called an "episode" purely for file naming — these boundaries don't carry semantic / action meaning for this dataset.)
-
-## Repository layout
+```python
+from examples.react_video_dataset import ReactVideoDataset
 
+ds = ReactVideoDataset("data/motherboard", window_length=16, mode="segment")
+sample = ds[0]
+# sample["view_middle"]:       (16, 480, 640, 3) uint8 RGB
+# sample["tactile_left"]:      (16, 480, 640, 3) uint8 RGB
+# sample["sensor_left_pose"]:  (16, 7) float32
 ```
-README.md                                        # this file
-tasks.json                                       # task / session registry
-bad_frames.json                                  # data-quality skip-list
-episodes/<task>/<date>/episode_*.pt    # per-file tensors
-figures/                                         # previews + analysis figures
-docs/                                            # extended documentation
-```
+`mode="segment"` iterates clean spans (no bad frames by construction); `mode="window"` slides over whole episodes and skips `bad_frames.json` intervals. Backend: PyAV (install `decord` for faster random access).
 
-## More documentation
+## Data quality
+Per-task `bad_frames.json` flags `intensity_spikes`, `pose_teleports_{L,R}`, `ot_loss_{L,R}` (OptiTrack track loss). Overall flagged: motherboard 0.90 %, pushT 0.67 %. `segments.json` already excludes them.
 
-| File | Contents |
-|---|---|
-| [`docs/recording.md`](docs/recording.md) | Hardware setup, camera serials, sensor + mocap layout, robot-free collection method |
-| [`docs/schema.md`](docs/schema.md) | Full `.pt` field reference and contact-metric definitions |
-| [`docs/quality.md`](docs/quality.md) | Data-quality breakdown (per-mode), `bad_frames.json` schema, dataloader recipe, inspection figures |
-| [`docs/figures.md`](docs/figures.md) | Dataset statistics + analysis gallery (F1–F8) |
-| [`docs/caveats.md`](docs/caveats.md) | Known caveats and roadmap |
+## Notes
+- **Depth** is available in the source recordings and will be added under `data/<task>/depth/` in a later upload.
+- One pushT source recording (`episode_004`) was corrupt and excluded.
+- The previous single-task `.pt` release (`episodes/`, `segments/`) is superseded by this video format.
 
 ## License
-
-Released under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/) (CC-BY-4.0).
-
-## Citation
-
-If you use this dataset, please cite (TODO: add bibtex).
-
+[CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/).

examples/react_video_dataset.py

@@ -0,0 +1,167 @@
+"""ReactVideoDataset — load the React multi-task video-format release.
+
+Layout consumed (per task):
+    data/<task>/videos/<date>/episode_NNN/{view_left,view_middle,view_right,
+                                           tactile_left,tactile_right}.mp4
+    data/<task>/meta/<date>/episode_NNN.parquet   # per-frame pose/scalar
+    data/<task>/segments.json                     # clean-segment index
+    data/<task>/bad_frames.json                   # quality intervals
+    data/<task>/episodes.jsonl                    # per-episode summary
+    data/<task>/calibration/                      # extrinsics (May-12 / June-26)
+
+Decoded frames are returned as RGB uint8 (H, W, 3) — standard video-decoder
+convention. (cv2 users: this is already RGB, do NOT re-swap.)
+
+Two sampling modes:
+    mode="segment": iterate clean segments from segments.json (no bad frames
+                    by construction). RECOMMENDED.
+    mode="window":  sliding windows over whole episodes; windows overlapping
+                    bad_frames.json intervals are skipped when skip_bad=True.
+
+Decoder backend: PyAV (`av`) by default; falls back to OpenCV. Install
+`decord` for fastest random access.
+
+Example
+-------
+    ds = ReactVideoDataset("data/motherboard", window_length=16, mode="segment")
+    sample = ds[0]
+    # sample["view_middle"]: (T, H, W, 3) uint8 RGB
+    # sample["sensor_left_pose"]: (T, 7) float32
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+
+try:
+    import av
+    _BACKEND = "av"
+except Exception:
+    import cv2
+    _BACKEND = "cv2"
+
+VIEW_STREAMS = ("view_left", "view_middle", "view_right")
+TACTILE_STREAMS = ("tactile_left", "tactile_right")
+ALL_STREAMS = VIEW_STREAMS + TACTILE_STREAMS
+
+
+def _decode_frames(mp4_path: Path, frame_indices):
+    """Return (N, H, W, 3) uint8 RGB for the requested frame indices."""
+    want = list(frame_indices)
+    if _BACKEND == "av":
+        container = av.open(str(mp4_path))
+        stream = container.streams.video[0]
+        out, wantset, got = {}, set(want), 0
+        for fi, frame in enumerate(container.decode(stream)):
+            if fi in wantset:
+                out[fi] = frame.to_ndarray(format="rgb24")
+                got += 1
+                if got == len(wantset):
+                    break
+        container.close()
+        return np.stack([out[i] for i in want])
+    else:  # cv2 fallback (BGR -> RGB)
+        cap = cv2.VideoCapture(str(mp4_path))
+        frames = []
+        for i in want:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, i)
+            ok, fr = cap.read()
+            frames.append(fr[..., ::-1] if ok else np.zeros((480, 640, 3), np.uint8))
+        cap.release()
+        return np.stack(frames)
+
+
+class ReactVideoDataset:
+    def __init__(self, task_root, window_length=16, stride=1, window_step=None,
+                 mode="segment", streams=ALL_STREAMS, skip_bad=True,
+                 which_sensors="any"):
+        self.root = Path(task_root)
+        self.W = window_length
+        self.stride = stride
+        self.step = window_step or window_length
+        self.mode = mode
+        self.streams = tuple(streams)
+        self.skip_bad = skip_bad
+        self.which = which_sensors
+
+        self.segments = json.loads((self.root / "segments.json").read_text())["segments"]
+        self.bad = json.loads((self.root / "bad_frames.json").read_text())["episodes"]
+        self.index = self._build_index()
+
+    def _video_dir(self, ep_key):
+        date, ep = ep_key.split("/")
+        return self.root / "videos" / date / ep
+
+    def _parquet(self, ep_key):
+        date, ep = ep_key.split("/")
+        return self.root / "meta" / date / f"{ep}.parquet"
+
+    def _bad_mask(self, ep_key, T):
+        m = np.zeros(T, bool)
+        e = self.bad.get(ep_key, {})
+        for k in ("intensity_spikes", "pose_teleports_L", "pose_teleports_R",
+                  "ot_loss_L", "ot_loss_R"):
+            for a, b in e.get(k, []):
+                m[max(0, a):min(T, b + 1)] = True
+        return m
+
+    def _build_index(self):
+        items = []
+        span = (self.W - 1) * self.stride + 1
+        if self.mode == "segment":
+            for s in self.segments:
+                ek, a, b = s["source_episode"], s["frame_range"][0], s["frame_range"][1]
+                start = a
+                while start + span - 1 <= b:
+                    items.append((ek, start))
+                    start += self.step
+        else:  # window over whole episode
+            for s in self.segments:  # reuse episode list via segments' episodes
+                pass
+            eps = sorted({s["source_episode"] for s in self.segments})
+            for ek in eps:
+                T = self.bad.get(ek, {}).get("n_frames", 0)
+                bad = self._bad_mask(ek, T) if self.skip_bad else np.zeros(T, bool)
+                start = 0
+                while start + span - 1 < T:
+                    idx = range(start, start + span, self.stride)
+                    if not (self.skip_bad and bad[list(idx)].any()):
+                        items.append((ek, start))
+                    start += self.step
+        return items
+
+    def __len__(self):
+        return len(self.index)
+
+    def __getitem__(self, i):
+        ek, start = self.index[i]
+        idx = list(range(start, start + (self.W - 1) * self.stride + 1, self.stride))
+        vd = self._video_dir(ek)
+        out = {s: _decode_frames(vd / f"{s}.mp4", idx) for s in self.streams}
+        tbl = pq.read_table(self._parquet(ek)).slice(start, idx[-1] - start + 1)
+        # subsample by stride
+        rows = [r - start for r in idx]
+        pl = np.array(tbl.column("sensor_left_pose").to_pylist(), np.float32)[rows]
+        pr = np.array(tbl.column("sensor_right_pose").to_pylist(), np.float32)[rows]
+        out["sensor_left_pose"] = pl
+        out["sensor_right_pose"] = pr
+        for c in ("tactile_left_intensity", "tactile_right_intensity",
+                  "tactile_left_mixed", "tactile_right_mixed"):
+            out[c] = np.array(tbl.column(c).to_pylist(), np.float32)[rows]
+        out["episode"] = ek
+        out["frame_start"] = start
+        return out
+
+
+if __name__ == "__main__":
+    import sys
+    root = sys.argv[1] if len(sys.argv) > 1 else "data/motherboard"
+    ds = ReactVideoDataset(root, window_length=8, mode="segment")
+    print(f"backend={_BACKEND}  {len(ds)} windows")
+    s = ds[0]
+    for k, v in s.items():
+        shape = getattr(v, "shape", v)
+        print(f"  {k}: {shape}")

tasks.json

@@ -1,62 +1,74 @@
 {
+  "dataset": "React",
+  "format": "video (LeRobot-style: per-camera MP4 + per-episode parquet)",
+  "resolution": "640x480",
+  "fps": 30,
+  "video_streams": [
+    "view_left",
+    "view_middle",
+    "view_right",
+    "tactile_left",
+    "tactile_right"
+  ],
+  "parquet_columns": [
+    "frame_idx",
+    "timestamp",
+    "sensor_left_pose",
+    "sensor_right_pose",
+    "tactile_{L,R}_{intensity,area,mixed}",
+    "source_h5_frame"
+  ],
+  "decoded_color": "RGB (standard video-decoder convention)",
   "tasks": {
     "motherboard": {
-      "language": "Bimanual manipulation of components on a computer motherboard.",
-      "purpose": "Dense, contact-rich, synchronized multimodal interaction data for tactile-visual dynamics / world-model learning. Not a policy-learning / demonstration dataset.",
-      "operator": "human hands (handheld GelSight Mini sensors with motion-capture rigid bodies; no robot arm involved)",
-      "embodiment": "human",
+      "n_episodes": 32,
       "dates": [
         "2026-05-10",
-        "2026-05-11"
+        "2026-05-11",
+        "2026-05-19"
       ],
-      "per_date_notes": {
-        "2026-05-10": {
-          "kind": "session",
-          "active_sensors": [
-            "left",
-            "right"
-          ],
-          "note": "First full bimanual recording session."
-        },
-        "2026-05-11": {
-          "kind": "session",
-          "active_sensors": [
-            "left",
-            "right"
-          ],
-          "note": "Largest session. 3 episodes had OptiTrack offline at recording start (ep_005/012/017); those prefixes (~17 min total) have been trimmed from the published .pt files \u2014 see `trim_offsets` and `_contact_meta.trim_offset` per .pt. Mid-episode flagged frames: 9 of 15 files have \u2265 1 flagged frame (intensity spike, pose teleport, or ot_loss) \u2014 see bad_frames.json."
-        },
-        "2026-05-19": {
-          "kind": "session",
-          "active_sensors": [
-            "left",
-            "right"
-          ],
-          "note": "Recorded with all 3 RealSense views and both GelSight sensors. OptiTrack world origin was redefined on 2026-05-19 relative to earlier sessions; an offset of (dx=0.230, dy=0.000, dz=0.175) m has been added to sensor_{left,right}_pose translation columns of every .pt (and to OT samples during preview rendering) so all 32 episodes share one world frame. See _contact_meta.world_frame_offset_applied in each 2026-05-19 .pt for the per-file record.",
-          "world_frame_offset_applied": [
-            0.23,
-            0.0,
-            0.175
-          ]
-        }
-      },
-      "n_episode_files": 27,
-      "notes": "2026-05-11/episode_001 was lost at recording time (HDF5 superblock not finalized). 2026-05-11/episodes 000 and 002 were short test recordings with no tactile contact and were dropped.",
-      "trim_offsets": {
-        "2026-05-11/episode_005": 2429,
-        "2026-05-11/episode_012": 9719,
-        "2026-05-11/episode_017": 19228
+      "n_frames": 194445,
+      "duration_min": 108.0,
+      "n_segments": 76,
+      "clean_min": 107.04,
+      "bad_fraction": 0.009,
+      "active_sensors": [
+        "left",
+        "right"
+      ],
+      "calibration_id": "may-12",
+      "calibration_created": "2026-05-12",
+      "calibration_rmse_unit": "mm",
+      "world_frame_offset_dates": {
+        "2026-05-19": [
+          0.23,
+          0.0,
+          0.175
+        ]
       },
-      "trim_note": "Per-episode prefix that has already been cut from the published .pt. Episodes not listed have trim_offset = 0 (no trim needed)."
+      "gelsight_left_serial": "2BGLKZNT/2DUPB53G",
+      "note": "Bimanual handheld tactile-visual interaction. 05-19 has a redefined OptiTrack world origin; an offset (0.23,0,0.175)m is baked into its poses so all dates share one frame."
+    },
+    "pushT": {
+      "n_episodes": 4,
+      "dates": [
+        "2026-06-18"
+      ],
+      "n_frames": 45595,
+      "duration_min": 25.3,
+      "n_segments": 17,
+      "clean_min": 25.16,
+      "bad_fraction": 0.0067,
+      "active_sensors": [
+        "left",
+        "right"
+      ],
+      "calibration_id": "june-26",
+      "calibration_created": "2026-06-26",
+      "calibration_rmse_unit": "px",
+      "world_frame_offset_dates": {},
+      "gelsight_left_serial": "2DUPB53G",
+      "note": "Push-T manipulation. Recalibrated cameras (June-26). One source H5 (episode_004) was corrupt and excluded."
     }
-  },
-  "schema_version": "mode1_v1",
-  "layout": "processed/mode1_v1/<task>/<date>/episode_*.{pt,contact.json}  (raw with bad intervals)  OR  processed/mode2_v1/<task>/<date>/episode_*.segment_*.pt  (pre-sliced clean segments; see segments.json)",
-  "mode2_v1": {
-    "description": "Same recordings as mode1_v1 but sliced at every bad-frames boundary into contiguous clean segments. Use with examples/react_segment_dataset.py.",
-    "n_segments": 73,
-    "total_frames": 188442,
-    "total_duration_min": 104.69,
-    "manifest": "segments.json"
   }
 }