Datasets:

rshift8
/

sim_ep_03

This export is sim_ep_03: clutter-only state-feedback pick/place. See TASK.json for task semantics. The upstream obstruction-task examples below describe a different dataset; the timing, camera and training interfaces apply.

# UR5e obstruction-removal training data

The current run lives in `runs/pi05_15hz_3variants_20261023/`. It requests
**171 episodes and 513 camera videos**, if every generation passes. Capture,
measured-state sampling and held-action commands are **15 Hz**; physics and
contact logging are **300 Hz**. Each sample spans exactly 20 physics steps.
The plan retains ten historical obstacle scenes for originals 0, 10, 16, 27,
and 36, plus the ten scenes already generated for original 1. Each of the
remaining 37 originals has **three** obstacle variations with surrounding
clutter. Failed attempts never count as accepted episodes.

Existing 25 Hz captures remain in `runs/pi05_430_three_camera_20261022/`.
They are not relabeled or interpolated to 15 Hz. Scene specifications and
controllers are reused, followed by fresh physical execution and all three
camera captures. The old camera-repair queue and separate 46-scene supplemental
queue are superseded. The new pilot covers a detour, historical removal and
new destination-blocking removal, including a held-out source, before scaling.

Use the repository `Makefile` and `config/pi05_generation.json`; see
[reproduction instructions](PI05_GENERATION.md). `make start` runs the pilot,
full two-GPU queue, export, and actual openpi loader validation in order.

Read the current run's `generation_plan.json`,
`manifest.json`, `physics_status.json`, `render_status.json`, and export reports
for actual progress and accepted/failed counts. The presence of a video or an
older `task_success` flag does **not** make an episode eligible for training.

## Verified training interface

On 2026-10-22, the upstream openpi checkout was pinned to
`215abfb217dbac7d5f1273282331b9b1866c0479`. Its `pyproject.toml` pins LeRobot to
`0cf864870cf29f4738d3ade893e6fd13fbd7cdb5`, whose dataset format is **v2.1**.
This is deliberately not an export to the latest, incompatible LeRobot layout.
The exporter also requires `datasets==3.6.0` from openpi's lockfile. Version 4
changes column access and Parquet feature metadata and fails the pinned loader.

References: [openpi custom-data instructions](https://github.com/Physical-Intelligence/openpi/blob/215abfb217dbac7d5f1273282331b9b1866c0479/README.md),
[dependency pin](https://github.com/Physical-Intelligence/openpi/blob/215abfb217dbac7d5f1273282331b9b1866c0479/pyproject.toml),
[model/data transforms](https://github.com/Physical-Intelligence/openpi/blob/215abfb217dbac7d5f1273282331b9b1866c0479/src/openpi/training/config.py).

Use **pi05_base**, not the Franka/DROID expert or DROID normalization. The
UR5e is a different embodiment. `policies/pi05_ur5e.py` defines the custom
adapter and config. The model retains action dimension 32 and action horizon
50; seven real channels are padded only inside the model preprocessing.
## State, actions, and time
The seven-channel state and action order is:
1. `shoulder_pan_joint`
2. `shoulder_lift_joint`
3. `elbow_joint`
4. `wrist_1_joint`
5. `wrist_2_joint`
6. `wrist_3_joint`
7. `gripper_open_fraction`
Arm positions are absolute radians in the imported UR5e URDF convention;
velocities are radians/second. State is measured from PhysX, independently of
commanded joint targets. This is a single-arm seven-channel dataset, not the
historical padded 14-channel RoboPRO contract.
Gripper opening is `1 - native_position / 255` (1 open, 0 closed).
Commanded opening uses the requested native actuator position. Measured opening
uses the finger-joint-to-native calibration map; it is **not** a measured jaw
aperture or a force measurement. The mapping, raw native measurement/request,
finger angle, and all articulation joint positions/order are preserved in each
raw `synchronized.hdf5`. The gripper response retains the inherited latency and
rate model. Finger-drive effort is a simulator actuator setting, not calibrated
physical squeezing force.

Physics runs at 300 Hz; actions and image observations run at **15 Hz**.
Each sample has measured state and all three camera images at simulation time `t`.
Its absolute target is then issued and held over `[t, t + 1/15)`.
Velocity feedforward is the difference between consecutive commanded positions
divided by 1/15, held throughout that control interval. Gripper command latency
is part of the simulated plant. `action_end_timestamp` records the actual end.
Rendering freezes physics, so sequential camera readbacks share the same
simulation timestamp. There is no pairing of cached images with later joints.
Wall-clock rendering duration is unrelated to action duration.

## Cameras and model mapping

All three streams are RGB uint8, 640 × 480, with calibration in `scene_spec.json`:

| Export feature | Source HDF5 role | openpi input |
| --- | --- | --- |
| `observation.images.wall` | `countertop_camera` | `base_0_rgb` |
| `observation.images.wrist` | `left_camera`, attached to flange | `left_wrist_0_rgb` |
| `observation.images.body_forward` | `right_camera`, base-mounted | `right_wrist_0_rgb` |

All three model image masks are true. The model's fixed third slot is named
`right_wrist_0_rgb`; its physical camera in this dataset is the base-mounted
body-forward camera, not a second wrist camera. Physical roles and calibration
remain explicit in exported feature names and scene metadata.
Openpi resizes with its standard 224 × 224 image transform. No arbitrary flips
are applied. Camera poses use OpenCV optical axes in the scene specification.
Stored flange/object poses are xyz in meters followed by quaternion **wxyz**.
The wrist extrinsic is relative to the flange, whose measured pose is retained.

Raw PNGs remain available. LeRobot contains separate MP4 streams and Parquet
numeric samples with identical frame counts. The exporter decodes every video
and checks presentation timestamps against the 15 Hz sample grid.

### Earlier two-camera completion method (archived 25 Hz run)

The following method applied to the archived 25 Hz run, not the new 15 Hz run.
Compatible completed two-camera episodes could fill variation zero of their
original recording by rendering only `body_forward`. The existing wall/wrist
PNGs are reused unchanged. Their measured joint, action, gripper, phase, and
timestamp datasets are copied bit-for-bit to a new HDF5 file; the original
files remain untouched. The third view uses every saved articulation DOF
(including measured gripper mimic joints) and object poses logged at the same
simulation timestamp. It never interpolates states or executes new dynamics.
The reconstructed flange must agree with the recorded flange within 2 mm and
0.01 rad at every frame. This is visual replay of an already validated physical
execution, not a newly executed demonstration. The new camera's exposure time
is the original simulation time, not its later wall-clock render time.

`third_camera_status.json` records progress and `third_camera_completion.json`
records provenance, timestamp error, flange error, source checksum, and exact
preservation of existing numeric datasets. A separate complete episode must
pass rendering, export, and the real openpi loader before this method scales.
If later episodes fail completion, the normal batch falls back to fresh capture.
These reused episodes occupy existing slots in the reduced plan; they do
not increase the count or displace the 50 historical obstacle variations.

### October 23 camera identity correction

The initial multi-camera capture had a viewport/readback timing defect: the
wrist stream often repeated the wall view. All 73 previously accepted captures
were withheld after image comparison, and their previous export gates were
invalidated. File counts, time alignment, and successful loader decoding alone
did not establish correct camera identity.

Capture now uses a fixed render-camera prim with the requested calibrated pose
and intrinsics, and at least 16 rendered frames before each readback. The
requested/render-product binding and pose are checked at every exposure.
`camera_poses_base_opencv` and `camera_identity_version` are recorded; acceptance
checks those poses against wall/body calibration and measured flange × wrist
extrinsic, and rejects near-duplicate camera views at distributed samples.

`analysis.pi05_camera_recovery` first repairs episode 31 and exports it through
the actual openpi loader. It then repairs the remaining completed captures.
Reference images are rendered at evenly spaced frames and every task-phase
transition to determine which streams need replacement. Correct streams are
retained, while faulty streams are rendered from the original physical states.
All existing robot numeric datasets must remain bit-for-bit equal. Corrected
training captures live in `camera_repaired_v1/`; prior `videos/` addresses point
to the corrected videos once their replacement passes, with old videos saved
under `videos_before_camera_repair/`. Original raw captures remain for audit.
`camera_repair_status.json` reports actual repaired counts. These repairs belong to the archived 25 Hz run. The current 15 Hz pipeline uses
the corrected capture implementation and has its own pilot gate.

### Parallel execution on both GPUs

The current coordinator is `analysis.pi05_parallel`: two persistent Isaac
processes, one per RTX 4080 SUPER. Each process uses explicit CUDA-index renderer
selection (`active_cuda_gpus`), the matching physics GPU setting, a separate
portable Kit directory, and a GPU-specific lock. Workers render offscreen;
GPU 1 cannot present a window through the desktop display attached to GPU 0.
The GPU 1 offscreen preview passed the same camera-identity comparisons.

Each worker owns a different episode/variation output directory and writes an
isolated result file. Only the coordinator updates aggregate progress and
records accepted videos. It schedules fresh physical generation and
three-camera capture, followed by unified export and openpi validation.
Existing 25 Hz captures remain separate. Physical failures remain reported;
parallel execution does not relabel them successful. Two workers do not imply twice the measured throughput: CPU physics,
PNG writes, and encoding can leave a GPU briefly idle.

Monitor `parallel/status.json`, `parallel/gpu0/current.json`,
`parallel/gpu1/current.json`, and the per-GPU worker logs. Each completed job
records elapsed time in `parallel/results/`. The coordinator can be launched
with `make start` when no coordinator/workers are running. Use `make status`
and `make estimate` for progress and an updated timing estimate.

## Splitting and normalization

Validation original recording IDs are **7, 14, 21, 28, 35**; the remaining 38
IDs are training sources. All attempts and future augmentations of a recording
inherit that assignment. Failed sources are reported, never silently replaced
by a source from the other split.

Training and validation are separate local repositories:
`local/ur5e_obstacles_15hz_train` and `local/ur5e_obstacles_15hz_validation`.
This prevents openpi's default all-episode LeRobot loader from accidentally
training on held-out recordings. Set `HF_LEROBOT_HOME` to the export root.

Stored actions remain absolute. The adapter converts the six arm channels in
each 50-step (3.333-second) action chunk to deltas relative to the **first measured
state in that chunk**. The gripper remains absolute. At episode ends, actions
repeat the final command according to LeRobot's padding convention; chunks
never cross episode boundaries. Openpi's action padding mask is available from
LeRobot; the standard training transform uses endpoint repetition.

`assets/ur5e/norm_stats.json` is calculated only from accepted training sources,
after that same action conversion, including chunk endpoint padding. It stores
mean, standard deviation, and exact 1st/99th percentiles. Pi0.5 uses quantile
normalization; validation reuses training statistics. The loader smoke test
checks the normalization/delta inverse against stored commands.

## Acceptance and provenance

For newly sampled removal tasks, the obstruction occupies the original destination measured from the real
final image. The controller must physically pick it, move it to a clear table
location, release it, then grasp and place the original target. During physical
execution objects stay dynamic, with no attachment, teleportation, or
object-pose playback. Adding a missing camera later uses the saved physical
trajectory as described above, while retaining its original validation.
Planner revision 2 centers the obstruction between nearby rack pegs while
checking that it still overlaps the observed destination. It can shift the
target's planned placement by at most 13 mm toward that gap; acceptance always
compares against the unchanged observed destination with the original 15 mm
tolerance. This avoids spawning a blocking cup tipped over a peg.
Surrounding props use existing textured meshes with explicit mass, friction,
scale, and source metadata. Layout seeds and rejected attempts are retained.

Acceptance requires target grasp/lift, correct rack placement within 15 mm in
horizontal position and height, sustained rack support and release, and
terminal speed below 0.02 m/s. The obstruction must have a two-finger grasp,
rise over 70 mm, finish within 40 mm of its clearing point, be released, and
settle. Unplanned robot-object/table/rack contacts and obstruction-clutter
contacts above 0.05 N are rejected. Surrounding bodies must move less than
10 mm. Contact evidence is sampled at the 300 Hz physics rate. These checks
cover reported PhysX actor contacts; they are not a hardware safety proof.
The inherited robot articulation disables self-collision. These checks therefore
cover robot contact with objects, rack, and table, plus unintended prop contacts;
they do not certify clearance between the robot's own links.

`training_validation.json` adds numeric finiteness, joint ordering, initial
robot state, action timing, gripper convention, camera synchronization, and
image-count checks. Raw HDF5, full contact traces, summaries, source identities,
instructions, specs, and failure files remain alongside each generation.
The original tar archive is read-only throughout; its SHA-256 is retained.

Reconstruction uses calibrated RGB silhouettes and wrist-depth table fits.
Overlay reviews and fit quality are retained per original recording. Mass,
friction, gripper response, and rigid plastic geometry remain simulator priors;
the photographic table/background projections do not constitute a full room
reconstruction. This dataset is simulation training data, not validated
real-robot transfer data.

## Running and checking

The current batch script refuses to scale until `pilot_export/openpi_loader_validation.json`
records successful three-camera end-to-end pilots covering new removal,
historical removal, and historical detour. Run simulator commands under
the shared `/tmp/real2sim_isaac.lock` when using the old serial runner. The
parallel coordinator instead uses `/tmp/real2sim_isaac_gpu0.lock` and
`/tmp/real2sim_isaac_gpu1.lock`; never run the serial and parallel runners together.

```bash
make doctor
make start
make status
make estimate
```

Use the pinned openpi and LeRobot source directories on `PYTHONPATH` for export
and `analysis.pi05_openpi`. The isolated data-validation environment is under
the run's `deps/venv`; its exact package versions are recorded with the run.
`openpi_loader_validation.json` establishes actual video decoding, action
chunking, tokenizer/preprocessing, normalization inversion, and minibatch
construction. It does not claim that an optimizer step or policy fine-tuning
has been performed. No automatic upload is part of this workflow.

The local TorchCodec runtime additionally uses the Ubuntu FFmpeg 4 shared
libraries extracted into `deps/ffmpeg4/usr/lib/x86_64-linux-gnu`. Include that
directory in `LD_LIBRARY_PATH`; no system packages were changed. The durable
orchestrator supplies this and the pinned source imports automatically:

```bash
make run
```

Generation stages resume using their per-source/per-variation status files.
Each accepted render writes three viewing MP4s under its `videos/` directory
alongside raw synchronized HDF5 and PNGs. These viewing files precede the final
LeRobot export; training readiness requires the export and loader checks.
The final exporter preserves original recording and variation IDs. Failed
attempts are not counted as successful variations or silently filled by duplicates.
Export requires a
new output directory; preserve an interrupted export before restarting that stage.

## Reusing the historical obstacle videos

`analysis.pi05_legacy_audit` audits the canonical 50 obstacle entries in the old
video inventory, verifies their video checksums, and extracts logged joints to
`legacy_obstacle_reuse/episodeXXXX/obstacle_YY/logged_joints.hdf5`. These files
preserve 50 Hz measured arm states, commanded targets, calibrated gripper state,
camera exposure times, and the old MP4 resampling map. Their seven-channel order
matches this contract, but they are explicitly **not training-ready episodes**.
Old camera captures were typically 72 ms apart; some have no joint measurement
within 8 ms. Old videos repeat captures on a 15 fps presentation grid and can
display an image up to 72 ms old. They also lack the wrist stream. No interpolated
state is relabeled as an exact measured observation.

The audit found 46 eligible scene/trajectory candidates: 29 clearing and 17
detour variants. Four old runs fail the stricter screen (two move the rack more
than 10 mm and two have unintended robot contacts). The old artifacts are
preserved. Reuse means new physical execution and synchronous 15 Hz capture
from the saved scenes/plans, with fresh acceptance checks on every rollout.

The former `analysis.pi05_legacy_reuse` supplemental queue is cancelled. The
current settings-driven coordinator includes **all 50** source scenes,
adds surrounding clutter while retaining their obstacle/task, and retries fresh
physical execution. Its pilot covers clearing and detour tasks through all
three cameras, export, and openpi loading before scaling. It records failures
rather than treating old acceptance as proof of new success. Detours retain avoidance instructions and
the `legacy_detour` profile; old source/route-clearing demonstrations use
`legacy_clearance`. Neither supplemental profile claims that the original
destination was occupied, and neither relaxes the main `required_clearance`
profile. Both retain the new timing, grasp/release, settling, destination, and
unintended-contact requirements as applicable to the labeled task.

The unified export uses `local/ur5e_obstacles_15hz_{train,validation}` and computes
normalization using only its training rows. Original IDs 0, 10, 16, 27, 36 are all training
sources under the fixed split; their augmentations never enter validation.
The adapter reads the dataset name from `export_report.json`. Monitor
the current run's per-variant `physics_status.json`, `render_status.json`,
`failed_generations.json`, and `manifest.json` for actual results; preparation is not acceptance.

	This export is sim_ep_03: clutter-only state-feedback pick/place. See TASK.json for task semantics. The upstream obstruction-task examples below describe a different dataset; the timing, camera and training interfaces apply.

	# UR5e obstruction-removal training data

	The current run lives in `runs/pi05_15hz_3variants_20261023/`. It requests
	171 episodes and 513 camera videos, if every generation passes. Capture,
	measured-state sampling and held-action commands are 15 Hz; physics and
	contact logging are 300 Hz. Each sample spans exactly 20 physics steps.
	The plan retains ten historical obstacle scenes for originals 0, 10, 16, 27,
	and 36, plus the ten scenes already generated for original 1. Each of the
	remaining 37 originals has three obstacle variations with surrounding
	clutter. Failed attempts never count as accepted episodes.

	Existing 25 Hz captures remain in `runs/pi05_430_three_camera_20261022/`.
	They are not relabeled or interpolated to 15 Hz. Scene specifications and
	controllers are reused, followed by fresh physical execution and all three
	camera captures. The old camera-repair queue and separate 46-scene supplemental
	queue are superseded. The new pilot covers a detour, historical removal and
	new destination-blocking removal, including a held-out source, before scaling.

	Use the repository `Makefile` and `config/pi05_generation.json`; see
	[reproduction instructions](PI05_GENERATION.md). `make start` runs the pilot,
	full two-GPU queue, export, and actual openpi loader validation in order.

	Read the current run's `generation_plan.json`,
	`manifest.json`, `physics_status.json`, `render_status.json`, and export reports
	for actual progress and accepted/failed counts. The presence of a video or an
	older `task_success` flag does not make an episode eligible for training.

	## Verified training interface

	On 2026-10-22, the upstream openpi checkout was pinned to
	`215abfb217dbac7d5f1273282331b9b1866c0479`. Its `pyproject.toml` pins LeRobot to
	`0cf864870cf29f4738d3ade893e6fd13fbd7cdb5`, whose dataset format is v2.1.
	This is deliberately not an export to the latest, incompatible LeRobot layout.
	The exporter also requires `datasets==3.6.0` from openpi's lockfile. Version 4
	changes column access and Parquet feature metadata and fails the pinned loader.

	References: [openpi custom-data instructions](https://github.com/Physical-Intelligence/openpi/blob/215abfb217dbac7d5f1273282331b9b1866c0479/README.md),
	[dependency pin](https://github.com/Physical-Intelligence/openpi/blob/215abfb217dbac7d5f1273282331b9b1866c0479/pyproject.toml),
	[model/data transforms](https://github.com/Physical-Intelligence/openpi/blob/215abfb217dbac7d5f1273282331b9b1866c0479/src/openpi/training/config.py).

	Use pi05_base, not the Franka/DROID expert or DROID normalization. The
	UR5e is a different embodiment. `policies/pi05_ur5e.py` defines the custom
	adapter and config. The model retains action dimension 32 and action horizon
	50; seven real channels are padded only inside the model preprocessing.

	## State, actions, and time

	The seven-channel state and action order is:

	1. `shoulder_pan_joint`
	2. `shoulder_lift_joint`
	3. `elbow_joint`
	4. `wrist_1_joint`
	5. `wrist_2_joint`
	6. `wrist_3_joint`
	7. `gripper_open_fraction`

	Arm positions are absolute radians in the imported UR5e URDF convention;
	velocities are radians/second. State is measured from PhysX, independently of
	commanded joint targets. This is a single-arm seven-channel dataset, not the
	historical padded 14-channel RoboPRO contract.

	Gripper opening is `1 - native_position / 255` (1 open, 0 closed).
	Commanded opening uses the requested native actuator position. Measured opening
	uses the finger-joint-to-native calibration map; it is not a measured jaw
	aperture or a force measurement. The mapping, raw native measurement/request,
	finger angle, and all articulation joint positions/order are preserved in each
	raw `synchronized.hdf5`. The gripper response retains the inherited latency and
	rate model. Finger-drive effort is a simulator actuator setting, not calibrated
	physical squeezing force.

	Physics runs at 300 Hz; actions and image observations run at 15 Hz.
	Each sample has measured state and all three camera images at simulation time `t`.
	Its absolute target is then issued and held over `[t, t + 1/15)`.
	Velocity feedforward is the difference between consecutive commanded positions
	divided by 1/15, held throughout that control interval. Gripper command latency
	is part of the simulated plant. `action_end_timestamp` records the actual end.
	Rendering freezes physics, so sequential camera readbacks share the same
	simulation timestamp. There is no pairing of cached images with later joints.
	Wall-clock rendering duration is unrelated to action duration.

	## Cameras and model mapping

	All three streams are RGB uint8, 640 × 480, with calibration in `scene_spec.json`:

	\| Export feature \| Source HDF5 role \| openpi input \|
	\| --- \| --- \| --- \|
	\| `observation.images.wall` \| `countertop_camera` \| `base_0_rgb` \|
	\| `observation.images.wrist` \| `left_camera`, attached to flange \| `left_wrist_0_rgb` \|
	\| `observation.images.body_forward` \| `right_camera`, base-mounted \| `right_wrist_0_rgb` \|

	All three model image masks are true. The model's fixed third slot is named
	`right_wrist_0_rgb`; its physical camera in this dataset is the base-mounted
	body-forward camera, not a second wrist camera. Physical roles and calibration
	remain explicit in exported feature names and scene metadata.
	Openpi resizes with its standard 224 × 224 image transform. No arbitrary flips
	are applied. Camera poses use OpenCV optical axes in the scene specification.
	Stored flange/object poses are xyz in meters followed by quaternion wxyz.
	The wrist extrinsic is relative to the flange, whose measured pose is retained.

	Raw PNGs remain available. LeRobot contains separate MP4 streams and Parquet
	numeric samples with identical frame counts. The exporter decodes every video
	and checks presentation timestamps against the 15 Hz sample grid.

	### Earlier two-camera completion method (archived 25 Hz run)

	The following method applied to the archived 25 Hz run, not the new 15 Hz run.
	Compatible completed two-camera episodes could fill variation zero of their
	original recording by rendering only `body_forward`. The existing wall/wrist
	PNGs are reused unchanged. Their measured joint, action, gripper, phase, and
	timestamp datasets are copied bit-for-bit to a new HDF5 file; the original
	files remain untouched. The third view uses every saved articulation DOF
	(including measured gripper mimic joints) and object poses logged at the same
	simulation timestamp. It never interpolates states or executes new dynamics.
	The reconstructed flange must agree with the recorded flange within 2 mm and
	0.01 rad at every frame. This is visual replay of an already validated physical
	execution, not a newly executed demonstration. The new camera's exposure time
	is the original simulation time, not its later wall-clock render time.

	`third_camera_status.json` records progress and `third_camera_completion.json`
	records provenance, timestamp error, flange error, source checksum, and exact
	preservation of existing numeric datasets. A separate complete episode must
	pass rendering, export, and the real openpi loader before this method scales.
	If later episodes fail completion, the normal batch falls back to fresh capture.
	These reused episodes occupy existing slots in the reduced plan; they do
	not increase the count or displace the 50 historical obstacle variations.

	### October 23 camera identity correction

	The initial multi-camera capture had a viewport/readback timing defect: the
	wrist stream often repeated the wall view. All 73 previously accepted captures
	were withheld after image comparison, and their previous export gates were
	invalidated. File counts, time alignment, and successful loader decoding alone
	did not establish correct camera identity.

	Capture now uses a fixed render-camera prim with the requested calibrated pose
	and intrinsics, and at least 16 rendered frames before each readback. The
	requested/render-product binding and pose are checked at every exposure.
	`camera_poses_base_opencv` and `camera_identity_version` are recorded; acceptance
	checks those poses against wall/body calibration and measured flange × wrist
	extrinsic, and rejects near-duplicate camera views at distributed samples.

	`analysis.pi05_camera_recovery` first repairs episode 31 and exports it through
	the actual openpi loader. It then repairs the remaining completed captures.
	Reference images are rendered at evenly spaced frames and every task-phase
	transition to determine which streams need replacement. Correct streams are
	retained, while faulty streams are rendered from the original physical states.
	All existing robot numeric datasets must remain bit-for-bit equal. Corrected
	training captures live in `camera_repaired_v1/`; prior `videos/` addresses point
	to the corrected videos once their replacement passes, with old videos saved
	under `videos_before_camera_repair/`. Original raw captures remain for audit.
	`camera_repair_status.json` reports actual repaired counts. These repairs belong to the archived 25 Hz run. The current 15 Hz pipeline uses
	the corrected capture implementation and has its own pilot gate.

	### Parallel execution on both GPUs

	The current coordinator is `analysis.pi05_parallel`: two persistent Isaac
	processes, one per RTX 4080 SUPER. Each process uses explicit CUDA-index renderer
	selection (`active_cuda_gpus`), the matching physics GPU setting, a separate
	portable Kit directory, and a GPU-specific lock. Workers render offscreen;
	GPU 1 cannot present a window through the desktop display attached to GPU 0.
	The GPU 1 offscreen preview passed the same camera-identity comparisons.

	Each worker owns a different episode/variation output directory and writes an
	isolated result file. Only the coordinator updates aggregate progress and
	records accepted videos. It schedules fresh physical generation and
	three-camera capture, followed by unified export and openpi validation.
	Existing 25 Hz captures remain separate. Physical failures remain reported;
	parallel execution does not relabel them successful. Two workers do not imply twice the measured throughput: CPU physics,
	PNG writes, and encoding can leave a GPU briefly idle.

	Monitor `parallel/status.json`, `parallel/gpu0/current.json`,
	`parallel/gpu1/current.json`, and the per-GPU worker logs. Each completed job
	records elapsed time in `parallel/results/`. The coordinator can be launched
	with `make start` when no coordinator/workers are running. Use `make status`
	and `make estimate` for progress and an updated timing estimate.

	## Splitting and normalization

	Validation original recording IDs are 7, 14, 21, 28, 35; the remaining 38
	IDs are training sources. All attempts and future augmentations of a recording
	inherit that assignment. Failed sources are reported, never silently replaced
	by a source from the other split.

	Training and validation are separate local repositories:
	`local/ur5e_obstacles_15hz_train` and `local/ur5e_obstacles_15hz_validation`.
	This prevents openpi's default all-episode LeRobot loader from accidentally
	training on held-out recordings. Set `HF_LEROBOT_HOME` to the export root.

	Stored actions remain absolute. The adapter converts the six arm channels in
	each 50-step (3.333-second) action chunk to deltas relative to the **first measured
	state in that chunk**. The gripper remains absolute. At episode ends, actions
	repeat the final command according to LeRobot's padding convention; chunks
	never cross episode boundaries. Openpi's action padding mask is available from
	LeRobot; the standard training transform uses endpoint repetition.

	`assets/ur5e/norm_stats.json` is calculated only from accepted training sources,
	after that same action conversion, including chunk endpoint padding. It stores
	mean, standard deviation, and exact 1st/99th percentiles. Pi0.5 uses quantile
	normalization; validation reuses training statistics. The loader smoke test
	checks the normalization/delta inverse against stored commands.

	## Acceptance and provenance

	For newly sampled removal tasks, the obstruction occupies the original destination measured from the real
	final image. The controller must physically pick it, move it to a clear table
	location, release it, then grasp and place the original target. During physical
	execution objects stay dynamic, with no attachment, teleportation, or
	object-pose playback. Adding a missing camera later uses the saved physical
	trajectory as described above, while retaining its original validation.
	Planner revision 2 centers the obstruction between nearby rack pegs while
	checking that it still overlaps the observed destination. It can shift the
	target's planned placement by at most 13 mm toward that gap; acceptance always
	compares against the unchanged observed destination with the original 15 mm
	tolerance. This avoids spawning a blocking cup tipped over a peg.
	Surrounding props use existing textured meshes with explicit mass, friction,
	scale, and source metadata. Layout seeds and rejected attempts are retained.

	Acceptance requires target grasp/lift, correct rack placement within 15 mm in
	horizontal position and height, sustained rack support and release, and
	terminal speed below 0.02 m/s. The obstruction must have a two-finger grasp,
	rise over 70 mm, finish within 40 mm of its clearing point, be released, and
	settle. Unplanned robot-object/table/rack contacts and obstruction-clutter
	contacts above 0.05 N are rejected. Surrounding bodies must move less than
	10 mm. Contact evidence is sampled at the 300 Hz physics rate. These checks
	cover reported PhysX actor contacts; they are not a hardware safety proof.
	The inherited robot articulation disables self-collision. These checks therefore
	cover robot contact with objects, rack, and table, plus unintended prop contacts;
	they do not certify clearance between the robot's own links.

	`training_validation.json` adds numeric finiteness, joint ordering, initial
	robot state, action timing, gripper convention, camera synchronization, and
	image-count checks. Raw HDF5, full contact traces, summaries, source identities,
	instructions, specs, and failure files remain alongside each generation.
	The original tar archive is read-only throughout; its SHA-256 is retained.

	Reconstruction uses calibrated RGB silhouettes and wrist-depth table fits.
	Overlay reviews and fit quality are retained per original recording. Mass,
	friction, gripper response, and rigid plastic geometry remain simulator priors;
	the photographic table/background projections do not constitute a full room
	reconstruction. This dataset is simulation training data, not validated
	real-robot transfer data.

	## Running and checking

	The current batch script refuses to scale until `pilot_export/openpi_loader_validation.json`
	records successful three-camera end-to-end pilots covering new removal,
	historical removal, and historical detour. Run simulator commands under
	the shared `/tmp/real2sim_isaac.lock` when using the old serial runner. The
	parallel coordinator instead uses `/tmp/real2sim_isaac_gpu0.lock` and
	`/tmp/real2sim_isaac_gpu1.lock`; never run the serial and parallel runners together.

	```bash
	make doctor
	make start
	make status
	make estimate
	```

	Use the pinned openpi and LeRobot source directories on `PYTHONPATH` for export
	and `analysis.pi05_openpi`. The isolated data-validation environment is under
	the run's `deps/venv`; its exact package versions are recorded with the run.
	`openpi_loader_validation.json` establishes actual video decoding, action
	chunking, tokenizer/preprocessing, normalization inversion, and minibatch
	construction. It does not claim that an optimizer step or policy fine-tuning
	has been performed. No automatic upload is part of this workflow.

	The local TorchCodec runtime additionally uses the Ubuntu FFmpeg 4 shared
	libraries extracted into `deps/ffmpeg4/usr/lib/x86_64-linux-gnu`. Include that
	directory in `LD_LIBRARY_PATH`; no system packages were changed. The durable
	orchestrator supplies this and the pinned source imports automatically:

	```bash
	make run
	```

	Generation stages resume using their per-source/per-variation status files.
	Each accepted render writes three viewing MP4s under its `videos/` directory
	alongside raw synchronized HDF5 and PNGs. These viewing files precede the final
	LeRobot export; training readiness requires the export and loader checks.
	The final exporter preserves original recording and variation IDs. Failed
	attempts are not counted as successful variations or silently filled by duplicates.
	Export requires a
	new output directory; preserve an interrupted export before restarting that stage.

	## Reusing the historical obstacle videos

	`analysis.pi05_legacy_audit` audits the canonical 50 obstacle entries in the old
	video inventory, verifies their video checksums, and extracts logged joints to
	`legacy_obstacle_reuse/episodeXXXX/obstacle_YY/logged_joints.hdf5`. These files
	preserve 50 Hz measured arm states, commanded targets, calibrated gripper state,
	camera exposure times, and the old MP4 resampling map. Their seven-channel order
	matches this contract, but they are explicitly not training-ready episodes.
	Old camera captures were typically 72 ms apart; some have no joint measurement
	within 8 ms. Old videos repeat captures on a 15 fps presentation grid and can
	display an image up to 72 ms old. They also lack the wrist stream. No interpolated
	state is relabeled as an exact measured observation.

	The audit found 46 eligible scene/trajectory candidates: 29 clearing and 17
	detour variants. Four old runs fail the stricter screen (two move the rack more
	than 10 mm and two have unintended robot contacts). The old artifacts are
	preserved. Reuse means new physical execution and synchronous 15 Hz capture
	from the saved scenes/plans, with fresh acceptance checks on every rollout.

	The former `analysis.pi05_legacy_reuse` supplemental queue is cancelled. The
	current settings-driven coordinator includes all 50 source scenes,
	adds surrounding clutter while retaining their obstacle/task, and retries fresh
	physical execution. Its pilot covers clearing and detour tasks through all
	three cameras, export, and openpi loading before scaling. It records failures
	rather than treating old acceptance as proof of new success. Detours retain avoidance instructions and
	the `legacy_detour` profile; old source/route-clearing demonstrations use
	`legacy_clearance`. Neither supplemental profile claims that the original
	destination was occupied, and neither relaxes the main `required_clearance`
	profile. Both retain the new timing, grasp/release, settling, destination, and
	unintended-contact requirements as applicable to the labeled task.

	The unified export uses `local/ur5e_obstacles_15hz_{train,validation}` and computes
	normalization using only its training rows. Original IDs 0, 10, 16, 27, 36 are all training
	sources under the fixed split; their augmentations never enter validation.
	The adapter reads the dataset name from `export_report.json`. Monitor
	the current run's per-variant `physics_status.json`, `render_status.json`,
	`failed_generations.json`, and `manifest.json` for actual results; preparation is not acceptance.