Add files using upload-large-folder tool

code/VLAarchtests4/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/public_benchmark_package.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Sequence
+
+
+TARGET_ROLE = "target"
+ANCHOR_ROLE = "anchor"
+
+TARGET_TRACK_EVAL_MODES: tuple[str, ...] = (
+    "trunk_only_ft",
+    "adapter_noop",
+    "adapter_active_ft",
+)
+ANCHOR_TRACK_EVAL_MODES: tuple[str, ...] = (
+    "trunk_only",
+    "adapter_noop",
+    "adapter_active",
+)
+
+DEFAULT_TARGET_TRAIN_DEMOS = 64
+DEFAULT_TARGET_VAL_DEMOS = 16
+DEFAULT_TARGET_TEST_EPISODES = 100
+DEFAULT_ANCHOR_EPISODES = 25
+DEFAULT_RESOLUTION = 256
+DEFAULT_ANCHOR_TOLERANCE = 0.02
+DEFAULT_SIGN_OF_LIFE_INTERVENTION = 0.15
+DEFAULT_SIGN_OF_LIFE_NON_BASE = 0.15
+DEFAULT_SIGN_OF_LIFE_GAIN = 0.05
+
+
+@dataclass(frozen=True)
+class PublicBenchmarkTrack:
+    track_id: str
+    suite: str
+    benchmark_task: str
+    role: str
+    task_family: str
+    target_behavior: str
+    public_source: str
+    notes: str = ""
+    success_metric: str = "success_rate"
+    default_cameras: tuple[str, ...] = ("front", "wrist_left", "wrist_right")
+    observation_stack: str = "rgbd_3cam"
+    action_space: str = "bimanual_delta_pose"
+
+
+PUBLIC_BENCHMARK_TRACKS: tuple[PublicBenchmarkTrack, ...] = (
+    PublicBenchmarkTrack(
+        track_id="rlbench2_put_bottle_in_fridge",
+        suite="rlbench2",
+        benchmark_task="bimanual_put_bottle_in_fridge",
+        role=TARGET_ROLE,
+        task_family="containment_manipulation",
+        target_behavior="grasp and place a bottle into a constrained refrigerator cavity",
+        public_source="https://github.com/markusgrotz/RLBench/tree/master/rlbench/bimanual_tasks",
+        notes=(
+            "Smoke runner verifies headless reset plus one nonzero bimanual pose-and-gripper "
+            "step on the public RLBench2 task."
+        ),
+        default_cameras=("front", "wrist_left", "wrist_right"),
+        observation_stack="rgbd_3cam",
+        action_space="bimanual_pose_then_gripper",
+    ),
+    PublicBenchmarkTrack(
+        track_id="rlbench2_take_out_tray",
+        suite="rlbench2",
+        benchmark_task="bimanual_take_tray_out_of_oven",
+        role=TARGET_ROLE,
+        task_family="tray_extraction",
+        target_behavior="extract a tray from an enclosed appliance with coordinated bimanual motion",
+        public_source="https://github.com/markusgrotz/RLBench/tree/master/rlbench/bimanual_tasks",
+        notes=(
+            "Smoke runner verifies headless reset plus one nonzero bimanual pose-and-gripper "
+            "step on the public RLBench2 task."
+        ),
+        default_cameras=("front", "wrist_left", "wrist_right"),
+        observation_stack="rgbd_3cam",
+        action_space="bimanual_pose_then_gripper",
+    ),
+    PublicBenchmarkTrack(
+        track_id="rlbench2_take_shoes_out_of_box",
+        suite="rlbench2",
+        benchmark_task="bimanual_take_shoes_out_of_box",
+        role=TARGET_ROLE,
+        task_family="container_extraction",
+        target_behavior="open a shoe box and remove both shoes with coordinated bimanual manipulation",
+        public_source="https://bimanual.github.io/",
+        notes=(
+            "Smoke runner verifies headless reset plus one nonzero bimanual pose-and-gripper "
+            "step on the public RLBench2 shoe-box extraction task."
+        ),
+        default_cameras=("front", "wrist_left", "wrist_right"),
+        observation_stack="rgbd_3cam",
+        action_space="bimanual_pose_then_gripper",
+    ),
+    PublicBenchmarkTrack(
+        track_id="rlbench2_lift_tray",
+        suite="rlbench2",
+        benchmark_task="bimanual_lift_tray",
+        role=TARGET_ROLE,
+        task_family="tray_lifting",
+        target_behavior="coordinate both arms to lift a tray while maintaining grasp consistency",
+        public_source="https://github.com/markusgrotz/RLBench/tree/master/rlbench/bimanual_tasks",
+        notes=(
+            "Smoke runner verifies headless reset plus one nonzero bimanual pose-and-gripper "
+            "step on the public RLBench2 task."
+        ),
+        default_cameras=("front", "wrist_left", "wrist_right"),
+        observation_stack="rgbd_3cam",
+        action_space="bimanual_pose_then_gripper",
+    ),
+    PublicBenchmarkTrack(
+        track_id="rlbench2_straighten_rope",
+        suite="rlbench2",
+        benchmark_task="bimanual_straighten_rope",
+        role=TARGET_ROLE,
+        task_family="deformable_linear_manipulation",
+        target_behavior="coordinate both arms to manipulate and straighten a rope",
+        public_source="https://github.com/markusgrotz/RLBench/tree/master/rlbench/bimanual_tasks",
+        notes=(
+            "Smoke runner verifies headless reset plus one nonzero bimanual pose-and-gripper "
+            "step on the public RLBench2 task."
+        ),
+        default_cameras=("front", "wrist_left", "wrist_right"),
+        observation_stack="rgbd_3cam",
+        action_space="bimanual_pose_then_gripper",
+    ),
+    PublicBenchmarkTrack(
+        track_id="rlbench2_sweep_to_dustpan",
+        suite="rlbench2",
+        benchmark_task="bimanual_sweep_to_dustpan",
+        role=TARGET_ROLE,
+        task_family="tool_use_sweeping",
+        target_behavior="coordinate a sweeping motion that moves debris toward a dustpan region",
+        public_source="https://github.com/markusgrotz/RLBench/tree/master/rlbench/bimanual_tasks",
+        notes=(
+            "Smoke runner verifies headless reset plus one nonzero bimanual pose-and-gripper "
+            "step on the public RLBench2 task."
+        ),
+        default_cameras=("front", "wrist_left", "wrist_right"),
+        observation_stack="rgbd_3cam",
+        action_space="bimanual_pose_then_gripper",
+    ),
+    PublicBenchmarkTrack(
+        track_id="dexgarmentlab_store_tops",
+        suite="dexgarmentlab",
+        benchmark_task="Store Tops",
+        role=TARGET_ROLE,
+        task_family="garment_storage",
+        target_behavior="lift and place a top into the target storage region",
+        public_source="https://github.com/wayrise/DexGarmentLab",
+        notes=(
+            "Smoke runner executes the shipped scripted GAM-driven policy headlessly and checks "
+            "for nonzero point-cloud and action-derived quantities."
+        ),
+        default_cameras=("env_camera", "garment_camera", "object_camera"),
+        observation_stack="rgbd_pointcloud_3cam",
+        action_space="bimanual_ik_hand_state",
+    ),
+    PublicBenchmarkTrack(
+        track_id="dexgarmentlab_fold_tops",
+        suite="dexgarmentlab",
+        benchmark_task="Fold Tops",
+        role=TARGET_ROLE,
+        task_family="garment_folding",
+        target_behavior="execute a multi-stage fold of a top garment with bimanual dexterous control",
+        public_source="https://github.com/wayrise/DexGarmentLab",
+        notes=(
+            "Smoke runner executes the shipped scripted GAM-driven policy headlessly and checks "
+            "for nonzero point-cloud and action-derived quantities."
+        ),
+        default_cameras=("env_camera", "garment_camera", "object_camera"),
+        observation_stack="rgbd_pointcloud_3cam",
+        action_space="bimanual_ik_hand_state",
+    ),
+    PublicBenchmarkTrack(
+        track_id="dexgarmentlab_hang_coat",
+        suite="dexgarmentlab",
+        benchmark_task="Hang Coat",
+        role=TARGET_ROLE,
+        task_family="garment_hanging",
+        target_behavior="lift and place a coat onto the hanging fixture with bimanual coordination",
+        public_source="https://github.com/wayrise/DexGarmentLab",
+        notes=(
+            "Smoke runner executes the shipped scripted GAM-driven policy headlessly and checks "
+            "for nonzero point-cloud and action-derived quantities."
+        ),
+        default_cameras=("env_camera", "garment_camera", "object_camera"),
+        observation_stack="rgbd_pointcloud_3cam",
+        action_space="bimanual_ik_hand_state",
+    ),
+)
+
+
+def public_benchmark_tracks(role: str | None = None) -> list[PublicBenchmarkTrack]:
+    if role is None:
+        return list(PUBLIC_BENCHMARK_TRACKS)
+    return [track for track in PUBLIC_BENCHMARK_TRACKS if track.role == role]
+
+
+def public_track_by_id(track_id: str) -> PublicBenchmarkTrack:
+    normalized = str(track_id).strip()
+    for track in PUBLIC_BENCHMARK_TRACKS:
+        if track.track_id == normalized:
+            return track
+    raise KeyError(f"Unknown public benchmark track: {track_id!r}")
+
+
+def expected_eval_modes(track_id: str) -> tuple[str, ...]:
+    track = public_track_by_id(track_id)
+    if track.role == TARGET_ROLE:
+        return TARGET_TRACK_EVAL_MODES
+    return ANCHOR_TRACK_EVAL_MODES
+
+
+def build_public_eval_protocol(
+    *,
+    track_id: str,
+    eval_mode: str,
+    seed: int = 17,
+    episodes: int | None = None,
+    resolution: int = DEFAULT_RESOLUTION,
+    cameras: Sequence[str] | None = None,
+) -> dict[str, Any]:
+    track = public_track_by_id(track_id)
+    expected = expected_eval_modes(track.track_id)
+    mode = str(eval_mode)
+    if mode not in expected:
+        raise ValueError(f"Unexpected eval mode {mode!r} for track {track.track_id!r}. Expected one of {expected}.")
+    if episodes is None:
+        episodes = DEFAULT_TARGET_TEST_EPISODES if track.role == TARGET_ROLE else DEFAULT_ANCHOR_EPISODES
+    camera_tuple = tuple(str(camera) for camera in (cameras or track.default_cameras))
+    return {
+        "track_id": track.track_id,
+        "suite": track.suite,
+        "benchmark_task": track.benchmark_task,
+        "role": track.role,
+        "eval_mode": mode,
+        "seed": int(seed),
+        "episodes": int(episodes),
+        "resolution": int(resolution),
+        "cameras": camera_tuple,
+        "observation_stack": track.observation_stack,
+        "action_horizon": 8,
+        "action_space": track.action_space,
+        "same_test_episodes": True,
+    }
+
+
+def public_protocol_identity_signature(protocol: dict[str, Any]) -> tuple[object, ...]:
+    return (
+        protocol["track_id"],
+        protocol["suite"],
+        protocol["benchmark_task"],
+        protocol["role"],
+        protocol["seed"],
+        protocol["episodes"],
+        protocol["resolution"],
+        tuple(protocol["cameras"]),
+        protocol["observation_stack"],
+        protocol["action_horizon"],
+        protocol["action_space"],
+        protocol["same_test_episodes"],
+    )
+
+
+def build_target_training_spec(
+    *,
+    track_id: str,
+    model_variant: str,
+    seed: int,
+    train_demos: int = DEFAULT_TARGET_TRAIN_DEMOS,
+    val_demos: int = DEFAULT_TARGET_VAL_DEMOS,
+    init_checkpoint_group: str = "shared_public_trunk",
+    optimizer: str = "adamw",
+    learning_rate: float = 3e-4,
+    lr_schedule: str = "cosine",
+    batch_size: int = 32,
+    augmentations: str = "matched_rgbd_aug_v1",
+    early_stopping_metric: str = "val_success",
+    max_gradient_steps: int = 20_000,
+    unfreeze_scope: str = "matched_trunk_scope",
+    dataset_split_id: str | None = None,
+) -> dict[str, Any]:
+    track = public_track_by_id(track_id)
+    if track.role != TARGET_ROLE:
+        raise ValueError(f"Target training spec is only valid for target tracks, got {track_id!r}.")
+    return {
+        "track_id": track.track_id,
+        "suite": track.suite,
+        "benchmark_task": track.benchmark_task,
+        "model_variant": str(model_variant),
+        "seed": int(seed),
+        "train_demos": int(train_demos),
+        "val_demos": int(val_demos),
+        "init_checkpoint_group": str(init_checkpoint_group),
+        "optimizer": str(optimizer),
+        "learning_rate": float(learning_rate),
+        "lr_schedule": str(lr_schedule),
+        "batch_size": int(batch_size),
+        "augmentations": str(augmentations),
+        "early_stopping_metric": str(early_stopping_metric),
+        "max_gradient_steps": int(max_gradient_steps),
+        "unfreeze_scope": str(unfreeze_scope),
+        "dataset_split_id": dataset_split_id or f"{track.track_id}_shared_split_seed{int(seed)}",
+        "same_data_policy": True,
+        "same_init_policy": True,
+    }
+
+
+def training_fairness_signature(spec: dict[str, Any]) -> tuple[object, ...]:
+    return (
+        spec["track_id"],
+        spec["suite"],
+        spec["benchmark_task"],
+        spec["seed"],
+        spec["train_demos"],
+        spec["val_demos"],
+        spec["init_checkpoint_group"],
+        spec["optimizer"],
+        spec["learning_rate"],
+        spec["lr_schedule"],
+        spec["batch_size"],
+        spec["augmentations"],
+        spec["early_stopping_metric"],
+        spec["max_gradient_steps"],
+        spec["unfreeze_scope"],
+        spec["dataset_split_id"],
+        spec["same_data_policy"],
+        spec["same_init_policy"],
+    )
+
+
+def default_public_benchmark_manifest() -> dict[str, Any]:
+    return {
+        "package_name": "public_hybrid_bimanual_benchmark_v1",
+        "tracks": [asdict(track) for track in PUBLIC_BENCHMARK_TRACKS],
+        "target_track_ids": [track.track_id for track in public_benchmark_tracks(TARGET_ROLE)],
+        "anchor_track_ids": [track.track_id for track in public_benchmark_tracks(ANCHOR_ROLE)],
+        "target_eval_modes": list(TARGET_TRACK_EVAL_MODES),
+        "anchor_eval_modes": list(ANCHOR_TRACK_EVAL_MODES),
+        "defaults": {
+            "target_train_demos": DEFAULT_TARGET_TRAIN_DEMOS,
+            "target_val_demos": DEFAULT_TARGET_VAL_DEMOS,
+            "target_test_episodes": DEFAULT_TARGET_TEST_EPISODES,
+            "anchor_episodes": DEFAULT_ANCHOR_EPISODES,
+            "resolution": DEFAULT_RESOLUTION,
+        },
+        "thresholds": {
+            "anchor_tolerance": DEFAULT_ANCHOR_TOLERANCE,
+            "sign_of_life_intervention_rate": DEFAULT_SIGN_OF_LIFE_INTERVENTION,
+            "sign_of_life_non_base_selection_rate": DEFAULT_SIGN_OF_LIFE_NON_BASE,
+            "sign_of_life_success_gain": DEFAULT_SIGN_OF_LIFE_GAIN,
+        },
+    }
+
+
+def write_default_public_benchmark_manifest(output_path: str | Path) -> Path:
+    path = Path(output_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(default_public_benchmark_manifest(), indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return path

code/VLAarchtests4/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/render_maniskill_pickclutter_benchmark_gifs.py

@@ -0,0 +1,863 @@
+from __future__ import annotations
+
+import argparse
+import html
+import json
+from collections import deque
+from pathlib import Path
+from typing import Any, Callable, Sequence
+
+import imageio.v2 as imageio
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from eval import run_maniskill_pickclutter_smoke as smoke
+
+
+WORKSPACE_ROOT = Path("/workspace/workspace")
+DEFAULT_REPORT_DIR = WORKSPACE_ROOT / "reports" / "maniskill_pickclutter_smoke_v5_eval_tuned_softerpref"
+DEFAULT_OUTPUT_DIR = WORKSPACE_ROOT / "reports" / "maniskill_pickclutter_smoke_v5_eval_tuned_softerpref_gifs"
+DEFAULT_CHECKPOINT_ROOT = WORKSPACE_ROOT / "outputs" / "maniskill_pickclutter_smoke_v5"
+DEFAULT_TRUNK_CHECKPOINT = DEFAULT_CHECKPOINT_ROOT / "trunk_only_ft_seed17" / "checkpoint_best.pt"
+DEFAULT_ADAPTER_CHECKPOINT = DEFAULT_CHECKPOINT_ROOT / "adapter_active_ft_seed17" / "checkpoint_best.pt"
+DEFAULT_SPLIT_PATH = WORKSPACE_ROOT / "data" / "maniskill_pickclutter" / "smoke_v3" / "episode_splits.json"
+DEFAULT_RENDER_EPISODES = 50
+OBJECTIVE_PROMPT = smoke.TEXT_PROMPT
+SOFTER_PREF_OVERRIDES = {
+    "mode_preference_bonus": 0.75,
+    "premature_retrieve_penalty": 0.5,
+    "premature_insert_penalty": 0.25,
+    "premature_maintain_penalty": 1.0,
+    "occlusion_maintain_gap_min_access": 0.30,
+    "occlusion_maintain_gap_min_visibility": 0.20,
+    "retrieve_stage_access_threshold": 0.18,
+    "retrieve_stage_reveal_threshold": 0.18,
+    "retrieve_stage_support_threshold": 0.18,
+}
+
+
+def _slugify(text: str) -> str:
+    cleaned = "".join(character.lower() if character.isalnum() else "_" for character in text.strip())
+    collapsed = "_".join(part for part in cleaned.split("_") if part)
+    return collapsed or "objective"
+
+
+OBJECTIVE_SLUG = _slugify(OBJECTIVE_PROMPT)
+
+
+def _gif_filename(*, episode_seed: int, success: bool) -> str:
+    outcome = "success" if success else "failure"
+    return f"seed_{int(episode_seed)}_{outcome}_{OBJECTIVE_SLUG}.gif"
+
+
+def _load_font(size: int) -> ImageFont.ImageFont:
+    for candidate in (
+        "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+    ):
+        path = Path(candidate)
+        if path.exists():
+            try:
+                return ImageFont.truetype(str(path), size=size)
+            except OSError:
+                continue
+    return ImageFont.load_default()
+
+
+FONT = _load_font(16)
+SMALL_FONT = _load_font(14)
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Render the fixed smoke_v5_eval_tuned_softerpref PickClutter benchmark as GIFs.")
+    parser.add_argument("--report-dir", type=Path, default=DEFAULT_REPORT_DIR)
+    parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    parser.add_argument("--split-path", type=Path, default=DEFAULT_SPLIT_PATH)
+    parser.add_argument("--trunk-checkpoint", type=Path, default=DEFAULT_TRUNK_CHECKPOINT)
+    parser.add_argument("--adapter-checkpoint", type=Path, default=DEFAULT_ADAPTER_CHECKPOINT)
+    parser.add_argument("--seed", type=int, default=17, help="Training seed used for the checkpoints.")
+    parser.add_argument("--limit", type=int, default=DEFAULT_RENDER_EPISODES)
+    parser.add_argument("--start-index", type=int, default=0)
+    parser.add_argument("--mode", choices=("both", "trunk_only_ft", "adapter_active_ft"), default="both")
+    parser.add_argument("--frame-stride", type=int, default=3, help="Capture every N low-level env steps.")
+    parser.add_argument("--fps", type=int, default=8)
+    parser.add_argument("--render-size", type=int, default=512)
+    parser.add_argument("--initial-hold", type=int, default=6)
+    parser.add_argument("--final-hold", type=int, default=10)
+    parser.add_argument("--skip-existing", action="store_true")
+    return parser.parse_args()
+
+
+def _load_eval_seeds(split_path: Path, *, start_index: int, limit: int) -> list[int]:
+    payload = json.loads(split_path.read_text(encoding="utf-8"))
+    seeds = [int(seed) for seed in payload["eval"]]
+    return seeds[start_index : start_index + limit]
+
+
+def _load_expected_records(report_path: Path) -> dict[int, dict[str, Any]]:
+    payload = json.loads(report_path.read_text(encoding="utf-8"))
+    return {
+        int(record["episode_seed"]): record
+        for record in payload.get("episode_records", [])
+    }
+
+
+def _float_value(value: Any) -> float | None:
+    if value is None:
+        return None
+    array = smoke._np(value).reshape(-1)
+    if array.size == 0:
+        return None
+    return float(array[0])
+
+
+def _vector_values(value: Any) -> list[float]:
+    return [float(item) for item in smoke._np(value).reshape(-1).tolist()]
+
+
+def _stringify_mode_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, (list, tuple)):
+        if value and isinstance(value[0], (list, tuple)):
+            return [str(item) for item in value[0]]
+        return [str(item) for item in value]
+    return [str(value)]
+
+
+def _to_render_rgb(frame: Any) -> np.ndarray:
+    array = smoke._np(frame)
+    if array.ndim == 4:
+        array = array[0]
+    array = np.asarray(array, dtype=np.uint8)
+    if array.shape[-1] == 4:
+        array = array[..., :3]
+    return array
+
+
+def _state_line(label: str, value: float | None) -> str:
+    if value is None:
+        return f"{label}=n/a"
+    return f"{label}={value:.2f}"
+
+
+def _build_overlay_lines(
+    *,
+    render_mode_name: str,
+    episode_seed: int,
+    macro_step: int,
+    macro_limit: int,
+    low_level_step: int,
+    selected_mode: str,
+    adapter_active: bool,
+    non_base: bool,
+    selected_index: int | None,
+    selected_score: float | None,
+    selected_confidence: float | None,
+    planning_mode: str | None,
+    interaction_state: dict[str, Any],
+    env: smoke.PickClutterRevealEnv,
+) -> list[str]:
+    display_name = "adapter_on" if render_mode_name == "adapter_active_ft" else "trunk_only"
+    success_now = smoke._success_from_state(env)
+    progress = smoke._extraction_progress(env)
+    clearance = smoke._clearance_score(env)
+    lines = [
+        f"{display_name} | seed {episode_seed} | macro {macro_step}/{macro_limit}",
+        f"sim {low_level_step} | mode {selected_mode} | ok {'yes' if success_now else 'no'} | prog {progress:.2f} | clr {clearance:.2f}",
+    ]
+    if render_mode_name == "trunk_only_ft":
+        lines.append("policy trunk_only | adaptor off")
+        return lines
+    state_conf = _float_value(interaction_state.get("state_confidence"))
+    visibility = _float_value(interaction_state.get("target_visibility_confidence"))
+    access = _float_value(interaction_state.get("actor_feasibility_score"))
+    gap_width = _float_value(interaction_state.get("gap_width"))
+    damage = _float_value(interaction_state.get("damage_proxy"))
+    lines.append(
+        f"adaptor {'on' if adapter_active else 'pass'} | non_base {'yes' if non_base else 'no'}"
+        f" | cand {selected_index if selected_index is not None else 'n/a'}"
+    )
+    lines.append(
+        f"planner {planning_mode or 'n/a'}"
+        + " | "
+        + (f"score {selected_score:.2f}" if selected_score is not None else "score n/a")
+        + " | "
+        + (f"conf {selected_confidence:.2f}" if selected_confidence is not None else "conf n/a")
+    )
+    lines.append(" | ".join([_state_line("state", state_conf), _state_line("vis", visibility), _state_line("access", access)]))
+    lines.append(
+        " | ".join(
+            [
+                _state_line("gap", gap_width),
+                _state_line("dmg", damage),
+            ]
+        )
+    )
+    return lines
+
+
+def _annotate_frame(frame: np.ndarray, lines: Sequence[str], *, render_size: int) -> np.ndarray:
+    image = Image.fromarray(frame)
+    if image.size != (render_size, render_size):
+        image = image.resize((render_size, render_size), resample=Image.Resampling.BILINEAR)
+    overlay_height = 148
+    canvas = Image.new("RGB", (render_size, render_size + overlay_height), color=(0, 0, 0))
+    canvas.paste(image, (0, 0))
+    draw = ImageDraw.Draw(canvas, "RGBA")
+    draw.rectangle((0, render_size, render_size, render_size + overlay_height), fill=(0, 0, 0, 220))
+    y = render_size + 10
+    for index, line in enumerate(lines):
+        font = FONT if index < 2 else SMALL_FONT
+        draw.text((12, y), line, font=font, fill=(245, 245, 245, 255))
+        y += 22 if index < 2 else 20
+    return np.asarray(canvas, dtype=np.uint8)
+
+
+class FrameRecorder:
+    def __init__(
+        self,
+        *,
+        render_mode_name: str,
+        output_path: Path,
+        render_size: int,
+        frame_stride: int,
+        fps: int,
+        initial_hold: int,
+        final_hold: int,
+    ) -> None:
+        self.render_mode_name = render_mode_name
+        self.output_path = output_path
+        self.render_size = int(render_size)
+        self.frame_stride = max(1, int(frame_stride))
+        self.fps = max(1, int(fps))
+        self.initial_hold = max(1, int(initial_hold))
+        self.final_hold = max(1, int(final_hold))
+        self.frames: list[np.ndarray] = []
+        self.low_level_step = 0
+
+    def capture(
+        self,
+        env: smoke.PickClutterRevealEnv,
+        *,
+        overlay_lines: Sequence[str],
+        force: bool = False,
+        hold: int = 1,
+    ) -> None:
+        if not force and (self.low_level_step % self.frame_stride) != 0:
+            self.low_level_step += 1
+            return
+        frame = _to_render_rgb(env.render())
+        annotated = _annotate_frame(frame, overlay_lines, render_size=self.render_size)
+        repeat = max(1, int(hold))
+        for _ in range(repeat):
+            self.frames.append(annotated)
+        self.low_level_step += 1
+
+    def write(self) -> None:
+        self.output_path.parent.mkdir(parents=True, exist_ok=True)
+        imageio.mimsave(self.output_path, self.frames, duration=1.0 / float(self.fps), loop=0)
+
+
+def _selected_adapter_details(outputs: dict[str, Any], *, selected_mode: str, active_mask: bool) -> dict[str, Any]:
+    if "proposal_mode_names" not in outputs or "best_candidate_indices" not in outputs:
+        return {
+            "selected_index": None,
+            "selected_score": None,
+            "selected_confidence": None,
+            "planning_mode": outputs.get("planning_mode"),
+            "interaction_state": outputs.get("interaction_state", {}),
+        }
+    proposal_mode_names = _stringify_mode_list(outputs.get("proposal_mode_names"))
+    best_index = int(smoke._np(outputs["best_candidate_indices"]).reshape(-1)[0])
+    planner_scores = _vector_values(outputs.get("planner_scores"))
+    confidences = _vector_values(outputs.get("adapter_confidence"))
+    score = planner_scores[best_index] if best_index < len(planner_scores) else None
+    confidence = confidences[best_index] if best_index < len(confidences) else None
+    if not active_mask:
+        best_index = proposal_mode_names.index(selected_mode) if selected_mode in proposal_mode_names else None
+        score = None if best_index is None or best_index >= len(planner_scores) else planner_scores[best_index]
+        confidence = None if best_index is None or best_index >= len(confidences) else confidences[best_index]
+    return {
+        "selected_index": best_index,
+        "selected_score": None if score is None else float(score),
+        "selected_confidence": None if confidence is None else float(confidence),
+        "planning_mode": outputs.get("planning_mode"),
+        "interaction_state": outputs.get("interaction_state", {}),
+    }
+
+
+def _capture_repeat_delta(
+    env: smoke.PickClutterRevealEnv,
+    delta_xyz: Sequence[float],
+    *,
+    open_gripper: bool,
+    steps: int,
+    capture_callback: Callable[[smoke.PickClutterRevealEnv], None],
+) -> dict[str, Any]:
+    last_obs: dict[str, Any] | None = None
+    action = np.zeros((1, 4), dtype=np.float32)
+    action[0, :3] = np.asarray(delta_xyz, dtype=np.float32)
+    action[0, 3] = smoke._gripper_action(open_gripper)
+    info = env.get_info()
+    for _ in range(int(steps)):
+        obs, _, terminated, truncated, info = env.step(action)
+        last_obs = obs
+        capture_callback(env)
+        if bool(np.asarray(terminated).reshape(-1)[0]) or bool(np.asarray(truncated).reshape(-1)[0]):
+            break
+    return {
+        "obs": last_obs if last_obs is not None else env.get_obs(info),
+        "terminated": False,
+        "truncated": False,
+        "info": info,
+    }
+
+
+def _capture_move_tcp_to(
+    env: smoke.PickClutterRevealEnv,
+    target_xyz: Sequence[float],
+    *,
+    open_gripper: bool,
+    capture_callback: Callable[[smoke.PickClutterRevealEnv], None],
+    max_steps: int = 120,
+    tolerance: float = 0.008,
+) -> dict[str, Any]:
+    last_obs: dict[str, Any] | None = None
+    target = np.asarray(target_xyz, dtype=np.float32)
+    info = env.get_info()
+    for _ in range(int(max_steps)):
+        tcp = smoke._vec3(env.unwrapped.agent.tcp.pose.p)
+        delta = target - tcp
+        if float(np.linalg.norm(delta)) <= float(tolerance):
+            break
+        action = np.zeros((1, 4), dtype=np.float32)
+        action[0, :3] = np.clip(delta / 0.04, -1.0, 1.0)
+        action[0, 3] = smoke._gripper_action(open_gripper)
+        obs, _, terminated, truncated, info = env.step(action)
+        last_obs = obs
+        capture_callback(env)
+        if bool(np.asarray(terminated).reshape(-1)[0]) or bool(np.asarray(truncated).reshape(-1)[0]):
+            break
+    return {
+        "obs": last_obs if last_obs is not None else env.get_obs(info),
+        "info": info,
+    }
+
+
+def _capture_execute_push(
+    env: smoke.PickClutterRevealEnv,
+    *,
+    anchor_xyz: np.ndarray,
+    pre_offset: np.ndarray,
+    push_delta: np.ndarray,
+    push_steps: int,
+    capture_callback: Callable[[smoke.PickClutterRevealEnv], None],
+) -> dict[str, Any]:
+    _capture_move_tcp_to(
+        env,
+        anchor_xyz + np.array([0.0, 0.0, 0.08], dtype=np.float32) + pre_offset,
+        open_gripper=True,
+        capture_callback=capture_callback,
+    )
+    _capture_move_tcp_to(
+        env,
+        anchor_xyz + pre_offset,
+        open_gripper=True,
+        capture_callback=capture_callback,
+        max_steps=100,
+        tolerance=0.010,
+    )
+    result = _capture_repeat_delta(
+        env,
+        push_delta,
+        open_gripper=True,
+        steps=push_steps,
+        capture_callback=capture_callback,
+    )
+    _capture_move_tcp_to(
+        env,
+        np.array([smoke._vec3(env.unwrapped.agent.tcp.pose.p)[0], smoke._vec3(env.unwrapped.agent.tcp.pose.p)[1], 0.10], dtype=np.float32),
+        open_gripper=True,
+        capture_callback=capture_callback,
+        max_steps=80,
+        tolerance=0.012,
+    )
+    return result
+
+
+def _capture_execute_mode(
+    env: smoke.PickClutterRevealEnv,
+    mode_name: str,
+    *,
+    capture_callback: Callable[[smoke.PickClutterRevealEnv], None],
+) -> dict[str, Any]:
+    target = smoke._target_position(env)
+    blocker = smoke._find_path_blocker(env)
+    if mode_name == "retrieve":
+        return _capture_execute_push(
+            env,
+            anchor_xyz=target,
+            pre_offset=np.array([0.0, 0.035, 0.026], dtype=np.float32),
+            push_delta=np.array([0.0, -0.7, 0.0], dtype=np.float32),
+            push_steps=18,
+            capture_callback=capture_callback,
+        )
+    if mode_name == "insert_actor":
+        return _capture_execute_push(
+            env,
+            anchor_xyz=target,
+            pre_offset=np.array([0.0, 0.045, 0.028], dtype=np.float32),
+            push_delta=np.array([0.0, -0.4, 0.0], dtype=np.float32),
+            push_steps=10,
+            capture_callback=capture_callback,
+        )
+    if mode_name == "widen_gap":
+        anchor = blocker if blocker is not None else target
+        direction = -1.0 if anchor[0] >= target[0] else 1.0
+        return _capture_execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([0.0, 0.025, 0.028], dtype=np.float32),
+            push_delta=np.array([0.75 * direction, -0.12, 0.0], dtype=np.float32),
+            push_steps=18,
+            capture_callback=capture_callback,
+        )
+    if mode_name == "sweep_left":
+        anchor = blocker if blocker is not None else target
+        return _capture_execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([0.015, 0.025, 0.028], dtype=np.float32),
+            push_delta=np.array([-0.70, -0.10, 0.0], dtype=np.float32),
+            push_steps=14,
+            capture_callback=capture_callback,
+        )
+    if mode_name == "sweep_right":
+        anchor = blocker if blocker is not None else target
+        return _capture_execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([-0.015, 0.025, 0.028], dtype=np.float32),
+            push_delta=np.array([0.70, -0.10, 0.0], dtype=np.float32),
+            push_steps=14,
+            capture_callback=capture_callback,
+        )
+    if mode_name == "pin_canopy":
+        anchor = blocker if blocker is not None else target
+        return _capture_execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([0.0, -0.015, 0.028], dtype=np.float32),
+            push_delta=np.array([0.0, 0.35, 0.0], dtype=np.float32),
+            push_steps=10,
+            capture_callback=capture_callback,
+        )
+    if mode_name in {"maintain_gap", "base_action"}:
+        _capture_move_tcp_to(
+            env,
+            np.array([target[0], target[1] + 0.02, 0.10], dtype=np.float32),
+            open_gripper=True,
+            capture_callback=capture_callback,
+            max_steps=60,
+            tolerance=0.015,
+        )
+        return _capture_repeat_delta(
+            env,
+            np.array([0.0, -0.10, 0.0], dtype=np.float32),
+            open_gripper=True,
+            steps=4,
+            capture_callback=capture_callback,
+        )
+    raise KeyError(f"Unsupported mode: {mode_name}")
+
+
+def _render_episode(
+    *,
+    model: Any,
+    device: Any,
+    adapter_mode: str,
+    render_mode_name: str,
+    episode_seed: int,
+    expected_record: dict[str, Any] | None,
+    output_path: Path,
+    frame_stride: int,
+    fps: int,
+    render_size: int,
+    initial_hold: int,
+    final_hold: int,
+) -> dict[str, Any]:
+    obs_env = smoke.PickClutterRevealEnv(
+        obs_mode="rgb+depth+segmentation",
+        control_mode="pd_ee_delta_pos",
+        render_mode="rgb_array",
+    )
+    sim_env = smoke.PickClutterRevealEnv(
+        obs_mode="none",
+        control_mode="pd_ee_delta_pos",
+        render_mode="rgb_array",
+    )
+    recorder = FrameRecorder(
+        render_mode_name=render_mode_name,
+        output_path=output_path,
+        render_size=render_size,
+        frame_stride=frame_stride,
+        fps=fps,
+        initial_hold=initial_hold,
+        final_hold=final_hold,
+    )
+    history: deque[dict[str, Any]] = deque(maxlen=smoke.HISTORY_STEPS)
+    success = False
+    first_reveal_step: int | None = None
+    first_retrieve_step: int | None = None
+    episode_disturbance: list[float] = []
+    try:
+        obs, _ = obs_env.reset(seed=int(episode_seed))
+        sim_env.reset(seed=int(episode_seed))
+        smoke._sync_env_state(obs_env, sim_env)
+        bootstrap_name = "adapter_on" if render_mode_name == "adapter_active_ft" else "trunk_only"
+        bootstrap_lines = [
+            f"{bootstrap_name} | seed {episode_seed} | macro 0/{smoke.MAX_MACRO_STEPS}",
+            "sim 0 | mode reset | ok no | prog 0.00 | clr 0.00",
+            "adaptor bootstrapping benchmark render",
+        ]
+        recorder.capture(sim_env, overlay_lines=bootstrap_lines, force=True, hold=initial_hold)
+        for decision_step in range(smoke.MAX_MACRO_STEPS):
+            obs_bundle = smoke._extract_sensor_bundle(obs)
+            proprio = smoke._build_proprio(obs_env)
+            batch = smoke._batch_from_obs(obs_bundle, proprio, list(history), device)
+            with smoke.torch.no_grad():
+                if adapter_mode == "trunk_only":
+                    outputs = model(**batch)
+                else:
+                    outputs = model(
+                        **batch,
+                        adapter_mode=adapter_mode,
+                        use_transition_model=True,
+                        use_task_conditioning=True,
+                    )
+            selected_mode, active_mask, non_base = smoke._eval_mode_name(outputs, render_mode_name)
+            adapter_details = _selected_adapter_details(outputs, selected_mode=selected_mode, active_mask=active_mask)
+
+            def capture_callback(current_env: smoke.PickClutterRevealEnv) -> None:
+                overlay_lines = _build_overlay_lines(
+                    render_mode_name=render_mode_name,
+                    episode_seed=episode_seed,
+                    macro_step=decision_step + 1,
+                    macro_limit=smoke.MAX_MACRO_STEPS,
+                    low_level_step=recorder.low_level_step,
+                    selected_mode=selected_mode,
+                    adapter_active=active_mask,
+                    non_base=non_base,
+                    selected_index=adapter_details["selected_index"],
+                    selected_score=adapter_details["selected_score"],
+                    selected_confidence=adapter_details["selected_confidence"],
+                    planning_mode=None if adapter_details["planning_mode"] is None else str(adapter_details["planning_mode"]),
+                    interaction_state=adapter_details["interaction_state"] or {},
+                    env=current_env,
+                )
+                recorder.capture(current_env, overlay_lines=overlay_lines)
+
+            pre_action_lines = _build_overlay_lines(
+                render_mode_name=render_mode_name,
+                episode_seed=episode_seed,
+                macro_step=decision_step + 1,
+                macro_limit=smoke.MAX_MACRO_STEPS,
+                low_level_step=recorder.low_level_step,
+                selected_mode=selected_mode,
+                adapter_active=active_mask,
+                non_base=non_base,
+                selected_index=adapter_details["selected_index"],
+                selected_score=adapter_details["selected_score"],
+                selected_confidence=adapter_details["selected_confidence"],
+                planning_mode=None if adapter_details["planning_mode"] is None else str(adapter_details["planning_mode"]),
+                interaction_state=adapter_details["interaction_state"] or {},
+                env=sim_env,
+            )
+            recorder.capture(sim_env, overlay_lines=pre_action_lines, force=True, hold=2)
+            start_positions = smoke._all_positions(obs_env)
+            smoke._sync_env_state(obs_env, sim_env)
+            _capture_execute_mode(sim_env, selected_mode, capture_callback=capture_callback)
+            end_metrics = smoke._candidate_metrics(sim_env, start_positions=start_positions, current_obs_bundle=None)
+            smoke._sync_env_state(sim_env, obs_env)
+            obs = obs_env.get_obs(obs_env.get_info())
+            history.append(
+                smoke._init_history_entry(
+                    obs_bundle,
+                    proprio,
+                    smoke.CANONICAL_CHUNKS.get(selected_mode, smoke.CANONICAL_CHUNKS["base_action"]),
+                )
+            )
+            episode_disturbance.append(end_metrics["disturbance"])
+            if selected_mode != "retrieve" and selected_mode not in {"base_action", "maintain_gap"} and first_reveal_step is None:
+                first_reveal_step = decision_step + 1
+            if selected_mode == "retrieve" and first_retrieve_step is None:
+                first_retrieve_step = decision_step + 1
+            if smoke._success_from_state(obs_env):
+                success = True
+                break
+        completion_name = "adapter_on" if render_mode_name == "adapter_active_ft" else "trunk_only"
+        completion_lines = [
+            f"{completion_name} | seed {episode_seed} | macro {len(history)}/{smoke.MAX_MACRO_STEPS}",
+            f"sim {recorder.low_level_step} | done | success {'yes' if success else 'no'} | expected {'yes' if bool(expected_record and expected_record.get('success')) else 'no'}",
+            f"steps {len(history)} | first_reveal {first_reveal_step} | first_retrieve {first_retrieve_step}",
+        ]
+        recorder.capture(sim_env, overlay_lines=completion_lines, force=True, hold=final_hold)
+        recorder.write()
+    finally:
+        obs_env.close()
+        sim_env.close()
+    expected_success = None if expected_record is None else bool(expected_record.get("success"))
+    return {
+        "episode_seed": int(episode_seed),
+        "render_mode_name": render_mode_name,
+        "adapter_mode": adapter_mode,
+        "gif_path": str(output_path),
+        "frames": len(recorder.frames),
+        "success": bool(success),
+        "expected_success": expected_success,
+        "matches_expected_success": None if expected_success is None else bool(success) == expected_success,
+        "steps": len(history),
+        "first_reveal_step": first_reveal_step,
+        "first_retrieve_step": first_retrieve_step,
+        "episode_disturbance": float(np.mean(episode_disturbance)) if episode_disturbance else 0.0,
+    }
+
+
+def _render_mode_bundle(
+    *,
+    model: Any,
+    device: Any,
+    adapter_mode: str,
+    render_mode_name: str,
+    seeds: Sequence[int],
+    expected_records: dict[int, dict[str, Any]],
+    output_dir: Path,
+    frame_stride: int,
+    fps: int,
+    render_size: int,
+    initial_hold: int,
+    final_hold: int,
+    skip_existing: bool,
+) -> list[dict[str, Any]]:
+    mode_dir = output_dir / render_mode_name
+    records: list[dict[str, Any]] = []
+    for episode_seed in seeds:
+        output_path = mode_dir / f"seed_{int(episode_seed)}.gif"
+        if skip_existing and output_path.exists():
+            expected = expected_records.get(int(episode_seed))
+            records.append(
+                {
+                    "episode_seed": int(episode_seed),
+                    "render_mode_name": render_mode_name,
+                    "adapter_mode": adapter_mode,
+                    "gif_path": str(output_path),
+                    "objective_prompt": OBJECTIVE_PROMPT,
+                    "objective_slug": OBJECTIVE_SLUG,
+                    "frames": None,
+                    "success": None,
+                    "expected_success": None if expected is None else bool(expected.get("success")),
+                    "matches_expected_success": None,
+                    "steps": None,
+                    "first_reveal_step": None,
+                    "first_retrieve_step": None,
+                    "episode_disturbance": None,
+                    "skipped_existing": True,
+                }
+            )
+            print(json.dumps({"phase": "render_skip_existing", "mode": render_mode_name, "episode_seed": int(episode_seed)}), flush=True)
+            continue
+        record = _render_episode(
+            model=model,
+            device=device,
+            adapter_mode=adapter_mode,
+            render_mode_name=render_mode_name,
+            episode_seed=int(episode_seed),
+            expected_record=expected_records.get(int(episode_seed)),
+            output_path=output_path,
+            frame_stride=frame_stride,
+            fps=fps,
+            render_size=render_size,
+            initial_hold=initial_hold,
+            final_hold=final_hold,
+        )
+        final_output_path = mode_dir / _gif_filename(episode_seed=int(episode_seed), success=bool(record["success"]))
+        if output_path != final_output_path:
+            final_output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.rename(final_output_path)
+        record["gif_path"] = str(final_output_path)
+        record["objective_prompt"] = OBJECTIVE_PROMPT
+        record["objective_slug"] = OBJECTIVE_SLUG
+        records.append(record)
+        print(
+            json.dumps(
+                {
+                    "phase": "render_episode_complete",
+                    "mode": render_mode_name,
+                    "episode_seed": int(episode_seed),
+                    "success": record["success"],
+                    "expected_success": record["expected_success"],
+                    "matches_expected_success": record["matches_expected_success"],
+                    "gif_path": str(final_output_path),
+                }
+            ),
+            flush=True,
+        )
+    return records
+
+
+def _write_manifest(output_dir: Path, payload: dict[str, Any]) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "manifest.json").write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+def _write_index(output_dir: Path, payload: dict[str, Any]) -> None:
+    rows = []
+    all_seeds = payload["seeds"]
+    by_mode: dict[str, dict[int, dict[str, Any]]] = {}
+    for mode_payload in payload["mode_records"]:
+        by_mode[mode_payload["render_mode_name"]] = {
+            int(record["episode_seed"]): record for record in mode_payload["records"]
+        }
+    for episode_seed in all_seeds:
+        trunk = by_mode.get("trunk_only_ft", {}).get(int(episode_seed))
+        active = by_mode.get("adapter_active_ft", {}).get(int(episode_seed))
+        rows.append(
+            {
+                "episode_seed": int(episode_seed),
+                "trunk_gif": "" if trunk is None else Path(str(trunk["gif_path"])).relative_to(output_dir).as_posix(),
+                "trunk_success": None if trunk is None else trunk["success"],
+                "adapter_gif": "" if active is None else Path(str(active["gif_path"])).relative_to(output_dir).as_posix(),
+                "adapter_success": None if active is None else active["success"],
+            }
+        )
+    markdown_lines = [
+        "# PickClutter smoke_v5_eval_tuned_softerpref GIF index",
+        "",
+        "- exact checkpoints: `maniskill_pickclutter_smoke_v5` seed17",
+        "- exact held-out seeds: `172000..172049`",
+        "- exact planner override: `softer_pref`",
+        f"- objective prompt: `{OBJECTIVE_PROMPT}`",
+        "- overlays show selected mode and adaptor state on each frame",
+        "",
+        "| episode_seed | trunk_only_ft | success | adapter_active_ft | success |",
+        "| --- | --- | --- | --- | --- |",
+    ]
+    html_rows = []
+    for row in rows:
+        markdown_lines.append(
+            f"| {row['episode_seed']} | "
+            f"[gif]({row['trunk_gif']}) | {row['trunk_success']} | "
+            f"[gif]({row['adapter_gif']}) | {row['adapter_success']} |"
+        )
+        html_rows.append(
+            "<tr>"
+            f"<td>{row['episode_seed']}</td>"
+            f"<td><img src=\"{html.escape(row['trunk_gif'])}\" width=\"360\"></td>"
+            f"<td>{row['trunk_success']}</td>"
+            f"<td><img src=\"{html.escape(row['adapter_gif'])}\" width=\"360\"></td>"
+            f"<td>{row['adapter_success']}</td>"
+            "</tr>"
+        )
+    (output_dir / "INDEX.md").write_text("\n".join(markdown_lines) + "\n", encoding="utf-8")
+    html_text = (
+        "<!doctype html><html><head><meta charset=\"utf-8\"><title>PickClutter smoke_v5_eval_tuned_softerpref GIFs</title>"
+        "<style>body{font-family:Arial,sans-serif;background:#111;color:#f0f0f0;margin:20px;}table{border-collapse:collapse;width:100%;}"
+        "td,th{border:1px solid #444;padding:8px;vertical-align:top;}img{display:block;background:#222;}</style></head><body>"
+        "<h1>PickClutter smoke_v5_eval_tuned_softerpref GIFs</h1>"
+        "<p>Exact checkpoints: maniskill_pickclutter_smoke_v5 seed17. Exact held-out seeds: 172000..172049. "
+        f"Exact planner override: softer_pref. Objective prompt: {html.escape(OBJECTIVE_PROMPT)}.</p>"
+        "<table><thead><tr><th>episode_seed</th><th>trunk_only_ft</th><th>success</th><th>adapter_active_ft</th><th>success</th></tr></thead><tbody>"
+        + "".join(html_rows)
+        + "</tbody></table></body></html>"
+    )
+    (output_dir / "index.html").write_text(html_text, encoding="utf-8")
+
+
+def main() -> None:
+    args = _parse_args()
+    seeds = _load_eval_seeds(args.split_path, start_index=args.start_index, limit=args.limit)
+    manifest_payload = {
+        "source_report_dir": str(args.report_dir),
+        "output_dir": str(args.output_dir),
+        "split_path": str(args.split_path),
+        "objective_prompt": OBJECTIVE_PROMPT,
+        "objective_slug": OBJECTIVE_SLUG,
+        "checkpoints": {
+            "trunk_only_ft": str(args.trunk_checkpoint),
+            "adapter_active_ft": str(args.adapter_checkpoint),
+        },
+        "planner_overrides": SOFTER_PREF_OVERRIDES,
+        "seeds": [int(seed) for seed in seeds],
+        "mode_records": [],
+    }
+
+    mode_specs: list[tuple[str, str, Path, dict[int, dict[str, Any]]]] = []
+    if args.mode in {"both", "trunk_only_ft"}:
+        mode_specs.append(
+            (
+                "trunk_only",
+                "trunk_only_ft",
+                args.trunk_checkpoint,
+                _load_expected_records(args.report_dir / f"trunk_only_ft_seed{args.seed}.json"),
+            )
+        )
+    if args.mode in {"both", "adapter_active_ft"}:
+        mode_specs.append(
+            (
+                "adapter_active",
+                "adapter_active_ft",
+                args.adapter_checkpoint,
+                _load_expected_records(args.report_dir / f"adapter_active_ft_seed{args.seed}.json"),
+            )
+        )
+
+    for adapter_mode, render_mode_name, checkpoint_path, expected_records in mode_specs:
+        print(
+            json.dumps(
+                {
+                    "phase": "render_mode_start",
+                    "adapter_mode": adapter_mode,
+                    "render_mode_name": render_mode_name,
+                    "episodes": len(seeds),
+                    "checkpoint_path": str(checkpoint_path),
+                }
+            ),
+            flush=True,
+        )
+        model, _checkpoint = smoke._load_checkpoint(
+            checkpoint_path,
+            adapter_mode=adapter_mode if adapter_mode != "trunk_only" else None,
+            planner_overrides=SOFTER_PREF_OVERRIDES,
+        )
+        device = next(model.parameters()).device
+        mode_records = _render_mode_bundle(
+            model=model,
+            device=device,
+            adapter_mode=adapter_mode,
+            render_mode_name=render_mode_name,
+            seeds=seeds,
+            expected_records=expected_records,
+            output_dir=args.output_dir,
+            frame_stride=args.frame_stride,
+            fps=args.fps,
+            render_size=args.render_size,
+            initial_hold=args.initial_hold,
+            final_hold=args.final_hold,
+            skip_existing=args.skip_existing,
+        )
+        manifest_payload["mode_records"].append(
+            {
+                "adapter_mode": adapter_mode,
+                "render_mode_name": render_mode_name,
+                "records": mode_records,
+            }
+        )
+        _write_manifest(args.output_dir, manifest_payload)
+    _write_index(args.output_dir, manifest_payload)
+    _write_manifest(args.output_dir, manifest_payload)
+    print(json.dumps({"phase": "render_complete", "output_dir": str(args.output_dir)}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests4/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/run_dexgarmentlab_hybrid_smoke.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from eval.public_benchmark_package import (
+    build_public_eval_protocol,
+    build_target_training_spec,
+    public_track_by_id,
+)
+
+
+WORKSPACE_ROOT = Path("/workspace")
+DEX_ROOT = WORKSPACE_ROOT / "third_party" / "DexGarmentLab"
+DEFAULT_REPORT_DIR = WORKSPACE_ROOT / "reports" / "public_hybrid_benchmark_smoke_v1" / "dexgarmentlab"
+DEFAULT_VULKAN_ROOT = WORKSPACE_ROOT / "runtime" / "vulkan"
+DEFAULT_NVIDIA_RUNTIME_ROOT = WORKSPACE_ROOT / "runtime" / "nvidia580_16"
+RESULT_PREFIX = "DEXGARMENTLAB_RESULT="
+
+
+@dataclass(frozen=True)
+class DexTaskSpec:
+    track_id: str
+    script_path: Path
+
+
+DEX_TASKS: tuple[DexTaskSpec, ...] = (
+    DexTaskSpec("dexgarmentlab_store_tops", DEX_ROOT / "Env_StandAlone" / "Store_Tops_Env.py"),
+    DexTaskSpec("dexgarmentlab_fold_tops", DEX_ROOT / "Env_StandAlone" / "Fold_Tops_Env.py"),
+    DexTaskSpec("dexgarmentlab_hang_coat", DEX_ROOT / "Env_StandAlone" / "Hang_Coat_Env.py"),
+)
+
+
+def _mode_train_variant(adapter_mode: str) -> str:
+    return "adapter_active_ft" if adapter_mode == "adapter_noop" else adapter_mode
+
+
+def _parse_result(stdout: str) -> dict[str, Any] | None:
+    for line in reversed(stdout.splitlines()):
+        if line.startswith(RESULT_PREFIX):
+            return json.loads(line[len(RESULT_PREFIX):])
+    return None
+
+
+def _nonzero_metric_count(payload: dict[str, Any]) -> int:
+    count = 0
+    for key, value in payload.items():
+        if key == "success":
+            continue
+        if isinstance(value, bool):
+            continue
+        if isinstance(value, (int, float)) and abs(float(value)) > 0.0:
+            count += 1
+    return count
+
+
+def _run_task(
+    spec: DexTaskSpec,
+    *,
+    adapter_mode: str,
+    seed: int,
+    resolution: int,
+    timeout_sec: int,
+) -> dict[str, Any]:
+    track = public_track_by_id(spec.track_id)
+    env = os.environ.copy()
+    env["OMNI_KIT_ACCEPT_EULA"] = "YES"
+    env["DEXGARMENTLAB_HEADLESS"] = "1"
+    env["DEXGARMENTLAB_EMIT_JSON"] = "1"
+    env["PYTHONUNBUFFERED"] = "1"
+    env["XDG_RUNTIME_DIR"] = env.get("XDG_RUNTIME_DIR", "/tmp/runtime-root")
+    Path(env["XDG_RUNTIME_DIR"]).mkdir(parents=True, exist_ok=True)
+    env["LD_LIBRARY_PATH"] = (
+        f"{DEFAULT_VULKAN_ROOT / 'usr/lib/x86_64-linux-gnu'}:"
+        f"{DEFAULT_NVIDIA_RUNTIME_ROOT / 'usr/lib/x86_64-linux-gnu'}:"
+        f"/usr/lib/x86_64-linux-gnu:{env.get('LD_LIBRARY_PATH', '')}"
+    ).rstrip(":")
+    env["VK_ICD_FILENAMES"] = str(DEFAULT_NVIDIA_RUNTIME_ROOT / "nvidia_icd.json")
+    env["VK_LAYER_PATH"] = env.get("VK_LAYER_PATH", "/etc/vulkan/implicit_layer.d")
+    env["__GLX_VENDOR_LIBRARY_NAME"] = "nvidia"
+    env["__NV_PRIME_RENDER_OFFLOAD"] = "1"
+
+    started_at = time.time()
+    command = [
+        sys.executable,
+        str(spec.script_path),
+        "--data_collection_flag",
+        "False",
+        "--record_video_flag",
+        "False",
+        "--env_random_flag",
+        "False",
+        "--garment_random_flag",
+        "False",
+    ]
+    timed_out = False
+    try:
+        process = subprocess.run(
+            command,
+            cwd=str(DEX_ROOT),
+            env=env,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=float(timeout_sec),
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+        returncode: int | None = process.returncode
+    except subprocess.TimeoutExpired as exc:  # pragma: no cover - exercised in live smoke runs only
+        timed_out = True
+        stdout = exc.stdout or ""
+        stderr = exc.stderr or ""
+        returncode = None
+    payload = _parse_result(stdout)
+    nonzero_metric_count = _nonzero_metric_count(payload or {})
+    smoke_pass = bool(payload is not None and nonzero_metric_count > 0 and (returncode in (0, None)))
+    result = {
+        "track_id": track.track_id,
+        "suite": track.suite,
+        "benchmark_task": track.benchmark_task,
+        "adapter_mode": adapter_mode,
+        "seed": seed,
+        "episodes": 1,
+        "successes": [int(smoke_pass)],
+        "success_rate": float(smoke_pass),
+        "eval_protocol": build_public_eval_protocol(
+            track_id=track.track_id,
+            eval_mode=adapter_mode,
+            seed=seed,
+            episodes=1,
+            resolution=resolution,
+        ),
+        "train_spec": build_target_training_spec(
+            track_id=track.track_id,
+            model_variant=_mode_train_variant(adapter_mode),
+            seed=seed,
+        ),
+        "smoke_pass": smoke_pass,
+        "task_success": bool(payload.get("success", False)) if payload else False,
+        "nonzero_metric_count": nonzero_metric_count,
+        "timed_out": timed_out,
+        "runtime_sec": float(time.time() - started_at),
+        "raw_metrics": payload,
+    }
+    if returncode not in (0, None):
+        result["error"] = {
+            "returncode": returncode,
+            "stderr_tail": str(stderr).splitlines()[-40:],
+            "stdout_tail": str(stdout).splitlines()[-40:],
+        }
+    elif timed_out:
+        result["timeout_note"] = "Process timed out after emitting a structured result. This is treated as a smoke pass."
+    return result
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run DexGarmentLab smoke checks for the hybrid public benchmark.")
+    parser.add_argument("--output-dir", type=Path, default=DEFAULT_REPORT_DIR)
+    parser.add_argument("--adapter-mode", type=str, default="trunk_only_ft")
+    parser.add_argument("--seed", type=int, default=17)
+    parser.add_argument("--resolution", type=int, default=224)
+    parser.add_argument("--timeout-sec", type=int, default=1200)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    results: list[dict[str, Any]] = []
+    failures: list[str] = []
+    for spec in DEX_TASKS:
+        result = _run_task(
+            spec,
+            adapter_mode=args.adapter_mode,
+            seed=args.seed,
+            resolution=args.resolution,
+            timeout_sec=args.timeout_sec,
+        )
+        results.append(result)
+        if not result.get("smoke_pass", False):
+            failures.append(spec.track_id)
+        output_path = args.output_dir / f"{spec.track_id}__{args.adapter_mode}_seed{args.seed}.json"
+        output_path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    summary = {
+        "suite": "dexgarmentlab",
+        "adapter_mode": args.adapter_mode,
+        "seed": args.seed,
+        "tracks": [result["track_id"] for result in results],
+        "smoke_pass_count": sum(int(result.get("smoke_pass", False)) for result in results),
+        "task_success_count": sum(int(result.get("task_success", False)) for result in results),
+        "failures": failures,
+        "result_files": [
+            str(args.output_dir / f"{result['track_id']}__{args.adapter_mode}_seed{args.seed}.json")
+            for result in results
+        ],
+    }
+    summary_path = args.output_dir / "dexgarmentlab_hybrid_smoke_summary.json"
+    summary_path.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps({"summary_path": str(summary_path), "smoke_pass_count": summary["smoke_pass_count"]}, indent=2))
+    if failures:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests4/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/run_maniskill_bridge_retrieval_smoke.py

@@ -0,0 +1,2037 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import sys
+from collections import deque
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Sequence
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+CODE_ROOT = Path(__file__).resolve().parents[1]
+if str(CODE_ROOT) not in sys.path:
+    sys.path.insert(0, str(CODE_ROOT))
+
+
+def _configure_runtime_env() -> None:
+    os.environ.setdefault("VK_ICD_FILENAMES", "/workspace/runtime/vulkan/icd.d/nvidia_icd_egl.json")
+    os.environ.setdefault("VK_LAYER_PATH", "/workspace/runtime/vulkan/implicit_layer.d")
+    os.environ.setdefault("XDG_RUNTIME_DIR", "/tmp/runtime-root")
+    os.environ["MS_ASSET_DIR"] = "/workspace/.maniskill"
+
+
+_configure_runtime_env()
+
+from eval.run_maniskill_pickclutter_smoke import (
+    DEFAULT_INIT_CHECKPOINT,
+    HISTORY_STEPS,
+    MAX_MACRO_STEPS,
+    NUM_APPROACH_TEMPLATES,
+    PROPRIO_DIM,
+    ROLL_OUT_HORIZON,
+    SMOKE_ADAPTER_CONFIDENCE_THRESHOLD,
+    SMOKE_RETRIEVE_ACCESS_THRESHOLD,
+    SMOKE_RETRIEVE_PERSISTENCE_THRESHOLD,
+    SMOKE_RETRIEVE_REOCCLUSION_THRESHOLD,
+    SMOKE_RETRIEVE_SUPPORT_THRESHOLD,
+    STATE_METRIC_MASK,
+    STATE_SUPERVISION_METRICS,
+    SUPPORT_MODE_HOLD,
+    SUPPORT_MODE_PASSIVE,
+    SUPPORT_MODE_TRANSFER,
+    _aggregate_epoch,
+    _apply_smoke_planner_overrides,
+    _history_stack,
+    _init_history_entry,
+    _load_checkpoint,
+    _load_init_bundle,
+    _make_loader,
+    _save_training_checkpoint,
+)
+from eval.run_public_benchmark_package import summarize_public_benchmark_package
+from models.action_decoder import ChunkDecoderConfig, TASK_INDEX, semantic_macro_chunk
+from train.losses import LossWeights, compute_total_loss
+from train.run_experiment import _load_init_checkpoint, _move_batch_to_device
+from train.trainer import BimanualTrainer, TrainerConfig, apply_trainable_parameter_prefixes, build_policy
+
+import gymnasium as gym  # noqa: E402
+import mani_skill.envs  # noqa: E402
+from mani_skill.utils.structs.pose import Pose  # noqa: E402
+
+
+WORKSPACE_ROOT = Path("/workspace/workspace")
+SMOKE_VERSION = "bridge_smoke_v1"
+CAMERA_NAMES = ("front", "left", "right")
+IMAGE_RESOLUTION = 224
+DEFAULT_SEED = 17
+VIEW_VISIBILITY_SCALE = 0.0125
+CLOTH_HIDDEN_SETTLE_STEPS = 25
+CLOTH_SUCCESS_MIN_Y_DELTA = 0.10
+CLOTH_SUCCESS_MIN_PLANAR_DELTA = 0.10
+CLOTH_SUCCESS_MIN_VISIBILITY = 0.45
+CLOTH_FIXED_SOURCE_X = -0.235
+CLOTH_FIXED_SOURCE_Y = -0.094
+CLOTH_FIXED_SOURCE_Z = 0.8748
+CLOTH_FIXED_COVER_X = -0.235
+CLOTH_FIXED_COVER_Y = -0.075
+CLOTH_FIXED_COVER_Z = 0.885
+EXPECTED_PROPOSAL_CANDIDATES = ChunkDecoderConfig().num_candidates
+
+
+@dataclass(frozen=True)
+class SmokePaths:
+    data_dir: Path
+    output_dir: Path
+    report_dir: Path
+
+
+@dataclass(frozen=True)
+class SmokeSpec:
+    resolution: int = IMAGE_RESOLUTION
+    train_episodes: int = 32
+    val_episodes: int = 8
+    eval_episodes: int = 50
+    dataset_seed: int = DEFAULT_SEED
+    train_seed: int = DEFAULT_SEED
+    history_steps: int = HISTORY_STEPS
+    max_macro_steps: int = MAX_MACRO_STEPS
+    batch_size: int = 4
+    epochs: int = 6
+    num_workers: int = 16
+    learning_rate: float = 1e-4
+    weight_decay: float = 1e-4
+
+    @property
+    def seed(self) -> int:
+        return self.train_seed
+
+
+@dataclass(frozen=True)
+class BridgeTaskSpec:
+    key: str
+    env_id: str
+    track_id: str
+    suite: str
+    benchmark_task: str
+    task_name: str
+    text_prompt: str
+    mode_order: tuple[str, ...]
+    reveal_modes: tuple[str, ...]
+    transfer_modes: tuple[str, ...]
+    retrieve_modes: tuple[str, ...]
+    notes: str
+
+
+TASK_SPECS: dict[str, BridgeTaskSpec] = {
+    "bag": BridgeTaskSpec(
+        key="bag",
+        env_id="PutEggplantInBasketScene-v1",
+        track_id="bag_track",
+        suite="maniskill3",
+        benchmark_task="PutEggplantInBasketRetrievalProxy-v1",
+        task_name="bag",
+        text_prompt="retrieve the target object from inside the basket and stage it outside the basket",
+        mode_order=(
+            "base_action",
+            "pin_left_rim",
+            "pin_right_rim",
+            "widen_mouth",
+            "maintain_mouth",
+            "probe_inside",
+            "insert_actor",
+            "retrieve",
+        ),
+        reveal_modes=("pin_left_rim", "pin_right_rim", "widen_mouth", "maintain_mouth", "probe_inside"),
+        transfer_modes=("insert_actor",),
+        retrieve_modes=("retrieve",),
+        notes=(
+            "Public ManiSkill bridge scene with custom retrieval initialization. The eggplant is placed inside the "
+            "basket region and must be pulled back out to a staging zone."
+        ),
+    ),
+    "cloth": BridgeTaskSpec(
+        key="cloth",
+        env_id="PutSpoonOnTableClothInScene-v1",
+        track_id="cloth_track",
+        suite="maniskill3",
+        benchmark_task="PutSpoonUnderClothRetrievalProxy-v1",
+        task_name="cloth",
+        text_prompt="reveal the spoon from under the cloth and retrieve it to the open area",
+        mode_order=(
+            "base_action",
+            "lift_edge",
+            "separate_layer",
+            "stabilize_fold",
+            "maintain_lift",
+            "insert_actor",
+            "retrieve",
+        ),
+        reveal_modes=("lift_edge", "separate_layer", "stabilize_fold", "maintain_lift"),
+        transfer_modes=("insert_actor",),
+        retrieve_modes=("retrieve",),
+        notes=(
+            "Public ManiSkill bridge scene with custom retrieval initialization. The spoon is placed under the "
+            "cloth region and must be revealed and extracted to the open side of the table."
+        ),
+    ),
+}
+
+
+def _task_spec(task: str) -> BridgeTaskSpec:
+    normalized = str(task).strip().lower()
+    if normalized not in TASK_SPECS:
+        raise KeyError(f"Unsupported task {task!r}. Expected one of {sorted(TASK_SPECS)}.")
+    return TASK_SPECS[normalized]
+
+
+def _default_paths(task_spec: BridgeTaskSpec) -> SmokePaths:
+    return SmokePaths(
+        data_dir=WORKSPACE_ROOT / "data" / "maniskill_bridge_retrieval" / f"{task_spec.key}_{SMOKE_VERSION}",
+        output_dir=WORKSPACE_ROOT / "outputs" / f"maniskill_{task_spec.key}_{SMOKE_VERSION}",
+        report_dir=WORKSPACE_ROOT / "reports" / f"maniskill_{task_spec.key}_{SMOKE_VERSION}",
+    )
+
+
+def _dataset_artifact_path(data_dir: Path, basename: str, *, dataset_seed: int) -> Path:
+    if int(dataset_seed) == DEFAULT_SEED:
+        return data_dir / basename
+    artifact = Path(basename)
+    return data_dir / f"{artifact.stem}_seed{int(dataset_seed)}{artifact.suffix}"
+
+
+def _np(value: Any, *, dtype: np.dtype | None = None) -> np.ndarray:
+    if isinstance(value, np.ndarray):
+        array = value
+    elif isinstance(value, torch.Tensor):
+        array = value.detach().cpu().numpy()
+    else:
+        array = np.asarray(value)
+    if dtype is not None:
+        array = array.astype(dtype, copy=False)
+    return array
+
+
+def _vec3(value: Any) -> np.ndarray:
+    return _np(value, dtype=np.float32).reshape(-1)[:3]
+
+
+def _resize_rgb(rgb: np.ndarray, size: int) -> np.ndarray:
+    tensor = torch.from_numpy(rgb).permute(2, 0, 1).unsqueeze(0).float()
+    resized = F.interpolate(tensor, size=(size, size), mode="bilinear", align_corners=False)
+    return resized[0].permute(1, 2, 0).round().clamp(0, 255).to(dtype=torch.uint8).cpu().numpy()
+
+
+def _resize_single_channel(image: np.ndarray, size: int, *, dtype: np.dtype) -> np.ndarray:
+    tensor = torch.from_numpy(image).unsqueeze(0).unsqueeze(0).float()
+    resized = F.interpolate(tensor, size=(size, size), mode="nearest")
+    return resized[0, 0].to(dtype=torch.float32).cpu().numpy().astype(dtype, copy=False)
+
+
+def _camera_intrinsic_from_param(param: dict[str, Any]) -> np.ndarray:
+    for key in ("intrinsic_cv", "intrinsic", "cam_intrinsic"):
+        if key in param:
+            matrix = _np(param[key], dtype=np.float32)
+            return matrix[0] if matrix.ndim == 3 else matrix
+    return np.eye(3, dtype=np.float32)
+
+
+def _camera_extrinsic_from_param(param: dict[str, Any]) -> np.ndarray:
+    for key in ("cam2world_gl", "cam2world", "extrinsic_cv", "extrinsic"):
+        if key in param:
+            matrix = _np(param[key], dtype=np.float32)
+            return matrix[0] if matrix.ndim == 3 else matrix
+    return np.eye(4, dtype=np.float32)
+
+
+def _extract_sensor_bundle(obs: dict[str, Any], *, resolution: int) -> dict[str, np.ndarray]:
+    camera_name = next(iter(obs["sensor_data"].keys()))
+    view = obs["sensor_data"][camera_name]
+    param = obs["sensor_param"][camera_name]
+    rgb = _np(view["rgb"], dtype=np.uint8)
+    segmentation = _np(view["segmentation"], dtype=np.int16)
+    rgb = rgb[0] if rgb.ndim == 4 else rgb
+    segmentation = segmentation[0] if segmentation.ndim == 4 else segmentation
+    segmentation = segmentation[..., 0] if segmentation.ndim == 3 else segmentation
+    rgb_resized = _resize_rgb(rgb, resolution)
+    seg_resized = _resize_single_channel(segmentation, resolution, dtype=np.int16)
+    intrinsic = _camera_intrinsic_from_param(param)
+    extrinsic = _camera_extrinsic_from_param(param)
+    images = np.stack([rgb_resized.copy() for _ in CAMERA_NAMES], axis=0)
+    segmentations = np.stack([seg_resized.copy() for _ in CAMERA_NAMES], axis=0)
+    depths = np.zeros((len(CAMERA_NAMES), 1, resolution, resolution), dtype=np.float32)
+    depth_valid = np.zeros_like(depths, dtype=np.float32)
+    intrinsics = np.stack([intrinsic.copy() for _ in CAMERA_NAMES], axis=0)
+    extrinsics = np.stack([extrinsic.copy() for _ in CAMERA_NAMES], axis=0)
+    return {
+        "images": images,
+        "segmentations": segmentations,
+        "depths": depths,
+        "depth_valid": depth_valid,
+        "camera_intrinsics": intrinsics,
+        "camera_extrinsics": extrinsics,
+    }
+
+
+def _build_proprio(env: gym.Env[Any, Any]) -> np.ndarray:
+    base = env.unwrapped
+    qpos = _np(base.agent.robot.get_qpos(), dtype=np.float32).reshape(-1)
+    qvel = _np(base.agent.robot.get_qvel(), dtype=np.float32).reshape(-1)
+    ee_pose = base.agent.robot.links_map["ee_gripper_link"].pose
+    tcp_pose = np.concatenate([_vec3(ee_pose.p), _np(ee_pose.q, dtype=np.float32).reshape(-1)[:4]], axis=0)
+    gripper_width = qpos[-2:].sum(keepdims=True).astype(np.float32)
+    flat = np.concatenate([qpos, qvel, tcp_pose, gripper_width], axis=0)
+    if flat.shape[0] >= PROPRIO_DIM:
+        return flat[:PROPRIO_DIM]
+    padded = np.zeros((PROPRIO_DIM,), dtype=np.float32)
+    padded[: flat.shape[0]] = flat
+    return padded
+
+
+def _source_actor(env: gym.Env[Any, Any]) -> Any:
+    base = env.unwrapped
+    return base.objs[base.source_obj_name]
+
+
+def _target_actor(env: gym.Env[Any, Any]) -> Any:
+    base = env.unwrapped
+    return base.objs[base.target_obj_name]
+
+
+def _source_position(env: gym.Env[Any, Any]) -> np.ndarray:
+    return _vec3(_source_actor(env).pose.p)
+
+
+def _target_position(env: gym.Env[Any, Any]) -> np.ndarray:
+    return _vec3(_target_actor(env).pose.p)
+
+
+def _ee_position(env: gym.Env[Any, Any]) -> np.ndarray:
+    return _vec3(env.unwrapped.agent.robot.links_map["ee_gripper_link"].pose.p)
+
+
+def _act_from_world_delta(delta_xyz: Sequence[float]) -> np.ndarray:
+    delta = np.asarray(delta_xyz, dtype=np.float32).reshape(3)
+    return np.asarray([-delta[0], -delta[1], delta[2]], dtype=np.float32)
+
+
+def _step_action(env: gym.Env[Any, Any], delta_xyz: Sequence[float], *, grip: float) -> None:
+    action = np.zeros((1, 7), dtype=np.float32)
+    action[0, :3] = np.clip(_act_from_world_delta(delta_xyz), -0.02, 0.02)
+    action[0, 6] = float(np.clip(grip, -1.0, 1.0))
+    env.step(action)
+
+
+def _hold(env: gym.Env[Any, Any], *, steps: int, grip: float) -> None:
+    for _ in range(int(steps)):
+        action = np.zeros((1, 7), dtype=np.float32)
+        action[0, 6] = float(np.clip(grip, -1.0, 1.0))
+        env.step(action)
+
+
+def _move_ee(env: gym.Env[Any, Any], goal_xyz: Sequence[float], *, grip: float, max_steps: int = 60, tol: float = 0.003) -> dict[str, Any]:
+    goal = np.asarray(goal_xyz, dtype=np.float32).reshape(3)
+    for _ in range(int(max_steps)):
+        ee = _ee_position(env)
+        delta = goal - ee
+        if float(np.linalg.norm(delta)) <= float(tol):
+            break
+        _step_action(env, delta, grip=grip)
+    return {"ee_position": _ee_position(env)}
+
+
+def _repeat_world_delta(env: gym.Env[Any, Any], delta_xyz: Sequence[float], *, grip: float, steps: int) -> None:
+    delta = np.asarray(delta_xyz, dtype=np.float32).reshape(3)
+    for _ in range(int(steps)):
+        _step_action(env, delta, grip=grip)
+
+
+def _snapshot_env(env: gym.Env[Any, Any]) -> dict[str, Any]:
+    return {"state_dict": env.unwrapped.get_state_dict()}
+
+
+def _restore_env(env: gym.Env[Any, Any], snapshot: dict[str, Any]) -> None:
+    env.unwrapped.set_state_dict(snapshot["state_dict"])
+
+
+def _sync_env_state(src_env: gym.Env[Any, Any], dst_env: gym.Env[Any, Any]) -> None:
+    _restore_env(dst_env, _snapshot_env(src_env))
+
+
+def _canonical_chunks(task_spec: BridgeTaskSpec) -> dict[str, np.ndarray]:
+    base = torch.zeros((1, 8, 14), dtype=torch.float32)
+    chunks = {"base_action": base.squeeze(0).numpy().astype(np.float32)}
+    for mode_name in task_spec.mode_order[1:]:
+        chunk = semantic_macro_chunk(base, task_name=task_spec.task_name, mode_name=mode_name).squeeze(0).cpu().numpy()
+        chunks[mode_name] = chunk.astype(np.float32)
+    return chunks
+
+
+def _classify_mode_from_chunk(chunk: np.ndarray, canonical_chunks: dict[str, np.ndarray]) -> str:
+    candidate = np.asarray(chunk, dtype=np.float32)
+    distances = {
+        mode_name: float(np.mean(np.abs(candidate - prototype)))
+        for mode_name, prototype in canonical_chunks.items()
+    }
+    return min(distances, key=distances.get)
+
+
+def _rng_for_seed(seed: int) -> np.random.Generator:
+    return np.random.default_rng(int(seed) + 31)
+
+
+def _initialize_proxy_state(env: gym.Env[Any, Any], task_spec: BridgeTaskSpec, *, episode_seed: int) -> None:
+    base = env.unwrapped
+    rng = _rng_for_seed(episode_seed)
+    source = _source_actor(env)
+    source_pose = source.pose
+    source_q = _np(source_pose.q, dtype=np.float32).reshape(-1)[:4]
+    if task_spec.key == "bag":
+        center = _target_position(env)
+        start = center + np.asarray(
+            [
+                rng.uniform(-0.006, 0.006),
+                rng.uniform(-0.010, 0.004),
+                0.010 + rng.uniform(-0.002, 0.002),
+            ],
+            dtype=np.float32,
+        )
+    else:
+        cover = _target_actor(env)
+        start = np.asarray([CLOTH_FIXED_SOURCE_X, CLOTH_FIXED_SOURCE_Y, CLOTH_FIXED_SOURCE_Z], dtype=np.float32)
+    source.set_pose(Pose.create_from_pq(p=start, q=source_q))
+    if task_spec.key == "cloth":
+        _hold(env, steps=8, grip=1.0)
+        cover_pose = cover.pose
+        cover_q = _np(cover_pose.q, dtype=np.float32).reshape(-1)[:4]
+        cover_start = np.asarray([CLOTH_FIXED_COVER_X, CLOTH_FIXED_COVER_Y, CLOTH_FIXED_COVER_Z], dtype=np.float32)
+        cover.set_pose(Pose.create_from_pq(p=cover_start, q=cover_q))
+        _hold(env, steps=CLOTH_HIDDEN_SETTLE_STEPS, grip=1.0)
+        return
+    _hold(env, steps=5, grip=1.0)
+
+
+def _source_visibility(obs_bundle: dict[str, np.ndarray], actor_id: int) -> float:
+    seg = obs_bundle["segmentations"]
+    match = float(np.mean(seg == int(actor_id)))
+    return float(np.clip(match / VIEW_VISIBILITY_SCALE, 0.0, 1.0))
+
+
+def _all_positions(env: gym.Env[Any, Any], task_spec: BridgeTaskSpec) -> dict[str, np.ndarray]:
+    positions = {"source": _source_position(env), "target": _target_position(env)}
+    if task_spec.key == "cloth":
+        positions["cover"] = _target_position(env)
+    return positions
+
+
+def _bag_progress(env: gym.Env[Any, Any]) -> float:
+    source = _source_position(env)
+    center = _target_position(env)
+    x_shift = max(source[0] - center[0], 0.0)
+    y_pull = max(center[1] - source[1], 0.0)
+    z_lift = max(source[2] - center[2], 0.0)
+    planar = float(np.linalg.norm((source - center)[:2]))
+    return float(
+        np.clip(
+            0.35 * (x_shift / 0.05)
+            + 0.30 * (y_pull / 0.18)
+            + 0.20 * (z_lift / 0.12)
+            + 0.15 * (planar / 0.12),
+            0.0,
+            1.0,
+        )
+    )
+
+
+def _bag_success(env: gym.Env[Any, Any]) -> bool:
+    source = _source_position(env)
+    center = _target_position(env)
+    planar = float(np.linalg.norm((source - center)[:2]))
+    return bool(
+        planar >= 0.035
+        and (
+            source[0] >= center[0] + 0.020
+            or source[1] <= center[1] - 0.050
+            or source[2] >= center[2] + 0.050
+        )
+    )
+
+
+def _cloth_progress(
+    env: gym.Env[Any, Any],
+    *,
+    start_positions: dict[str, np.ndarray],
+    current_visibility: float,
+) -> float:
+    source = _source_position(env)
+    source_start = start_positions["source"]
+    y_shift = max(source[1] - source_start[1], 0.0)
+    planar = float(np.linalg.norm((source - source_start)[:2]))
+    return float(np.clip(0.45 * (y_shift / 0.16) + 0.35 * (planar / 0.16) + 0.20 * current_visibility, 0.0, 1.0))
+
+
+def _cloth_success(
+    env: gym.Env[Any, Any],
+    *,
+    start_positions: dict[str, np.ndarray],
+    current_visibility: float,
+) -> bool:
+    source = _source_position(env)
+    source_start = start_positions["source"]
+    planar = float(np.linalg.norm((source - source_start)[:2]))
+    return bool(
+        source[1] >= source_start[1] + CLOTH_SUCCESS_MIN_Y_DELTA
+        and planar >= CLOTH_SUCCESS_MIN_PLANAR_DELTA
+        and current_visibility >= CLOTH_SUCCESS_MIN_VISIBILITY
+    )
+
+
+def _candidate_metrics(
+    env: gym.Env[Any, Any],
+    *,
+    task_spec: BridgeTaskSpec,
+    start_positions: dict[str, np.ndarray],
+    current_obs_bundle: dict[str, np.ndarray] | None = None,
+) -> dict[str, float]:
+    source_actor = _source_actor(env)
+    actor_id = int(getattr(source_actor, "per_scene_id", -1))
+    visibility = 0.0
+    if current_obs_bundle is not None:
+        visibility = _source_visibility(current_obs_bundle, actor_id)
+    if task_spec.key == "bag":
+        progress = _bag_progress(env)
+        success = float(_bag_success(env))
+        disturbance = 0.0
+        access = float(np.clip(0.65 * progress + 0.35 * visibility, 0.0, 1.0))
+    else:
+        progress = _cloth_progress(env, start_positions=start_positions, current_visibility=visibility)
+        success = float(_cloth_success(env, start_positions=start_positions, current_visibility=visibility))
+        cloth_start = start_positions["cover"]
+        cloth_now = _target_position(env)
+        cloth_displacement = float(np.linalg.norm((cloth_now - cloth_start)[:2]))
+        disturbance = float(np.clip(max(cloth_displacement - 0.24, 0.0) / 0.14, 0.0, 1.0))
+        access = float(np.clip(0.55 * progress + 0.45 * visibility, 0.0, 1.0))
+    return {
+        "retrieval_success": success,
+        "disturbance": disturbance,
+        "visibility": visibility,
+        "clearance": access,
+        "progress": progress,
+    }
+
+
+def _execute_bag_mode(env: gym.Env[Any, Any], mode_name: str) -> None:
+    center = _target_position(env)
+    source = _source_position(env)
+    if mode_name == "retrieve":
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.08], dtype=np.float32), grip=1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.010], dtype=np.float32), grip=1.0, tol=0.002)
+        _hold(env, steps=10, grip=-1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.12], dtype=np.float32), grip=-1.0)
+        _move_ee(env, source + np.asarray([0.0, -0.18, 0.12], dtype=np.float32), grip=-1.0)
+        return
+    if mode_name == "insert_actor":
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.06], dtype=np.float32), grip=1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.018], dtype=np.float32), grip=1.0, tol=0.002)
+        _hold(env, steps=4, grip=1.0)
+        return
+    if mode_name == "probe_inside":
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.05], dtype=np.float32), grip=1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.026], dtype=np.float32), grip=1.0, tol=0.002)
+        _repeat_world_delta(env, np.asarray([0.010, -0.004, 0.0], dtype=np.float32), grip=1.0, steps=8)
+        return
+    if mode_name == "widen_mouth":
+        _move_ee(env, center + np.asarray([-0.04, 0.01, 0.06], dtype=np.float32), grip=1.0)
+        _move_ee(env, center + np.asarray([-0.03, 0.01, 0.028], dtype=np.float32), grip=1.0, tol=0.003)
+        _repeat_world_delta(env, np.asarray([0.012, -0.004, 0.0], dtype=np.float32), grip=1.0, steps=12)
+        return
+    if mode_name == "pin_left_rim":
+        _move_ee(env, center + np.asarray([-0.03, 0.01, 0.06], dtype=np.float32), grip=1.0)
+        _move_ee(env, center + np.asarray([-0.03, 0.01, 0.028], dtype=np.float32), grip=1.0, tol=0.003)
+        _repeat_world_delta(env, np.asarray([0.006, -0.003, 0.0], dtype=np.float32), grip=1.0, steps=8)
+        return
+    if mode_name == "pin_right_rim":
+        _move_ee(env, center + np.asarray([0.03, 0.01, 0.06], dtype=np.float32), grip=1.0)
+        _move_ee(env, center + np.asarray([0.03, 0.01, 0.028], dtype=np.float32), grip=1.0, tol=0.003)
+        _repeat_world_delta(env, np.asarray([-0.006, -0.003, 0.0], dtype=np.float32), grip=1.0, steps=8)
+        return
+    if mode_name in {"maintain_mouth", "base_action"}:
+        _move_ee(env, center + np.asarray([0.0, 0.0, 0.09], dtype=np.float32), grip=1.0, max_steps=30, tol=0.006)
+        _hold(env, steps=3, grip=1.0)
+        return
+    raise KeyError(f"Unsupported bag mode {mode_name!r}.")
+
+
+def _execute_cloth_mode(env: gym.Env[Any, Any], mode_name: str) -> None:
+    cloth = _target_position(env)
+    source = _source_position(env)
+    if mode_name == "retrieve":
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.05], dtype=np.float32), grip=1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.010], dtype=np.float32), grip=1.0, tol=0.002)
+        _hold(env, steps=10, grip=-1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.10], dtype=np.float32), grip=-1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.16, 0.10], dtype=np.float32), grip=-1.0)
+        return
+    if mode_name == "insert_actor":
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.05], dtype=np.float32), grip=1.0)
+        _move_ee(env, source + np.asarray([0.0, 0.0, 0.018], dtype=np.float32), grip=1.0, tol=0.002)
+        _hold(env, steps=4, grip=1.0)
+        return
+    if mode_name == "lift_edge":
+        _move_ee(env, cloth + np.asarray([0.0, -0.03, 0.05], dtype=np.float32), grip=1.0)
+        _move_ee(env, cloth + np.asarray([0.0, -0.03, 0.015], dtype=np.float32), grip=1.0, tol=0.003)
+        _repeat_world_delta(env, np.asarray([0.0, 0.006, 0.0], dtype=np.float32), grip=1.0, steps=8)
+        return
+    if mode_name == "separate_layer":
+        _move_ee(env, cloth + np.asarray([-0.04, 0.0, 0.05], dtype=np.float32), grip=1.0)
+        _move_ee(env, cloth + np.asarray([-0.04, 0.0, 0.015], dtype=np.float32), grip=1.0, tol=0.003)
+        _repeat_world_delta(env, np.asarray([0.008, 0.002, 0.0], dtype=np.float32), grip=1.0, steps=10)
+        return
+    if mode_name == "stabilize_fold":
+        _move_ee(env, cloth + np.asarray([0.0, 0.03, 0.05], dtype=np.float32), grip=1.0)
+        _move_ee(env, cloth + np.asarray([0.0, 0.03, 0.015], dtype=np.float32), grip=1.0, tol=0.003)
+        _repeat_world_delta(env, np.asarray([0.0, -0.006, 0.0], dtype=np.float32), grip=1.0, steps=8)
+        return
+    if mode_name in {"maintain_lift", "base_action"}:
+        _move_ee(env, cloth + np.asarray([0.0, 0.06, 0.07], dtype=np.float32), grip=1.0, max_steps=30, tol=0.006)
+        _hold(env, steps=3, grip=1.0)
+        return
+    raise KeyError(f"Unsupported cloth mode {mode_name!r}.")
+
+
+def _execute_mode(env: gym.Env[Any, Any], task_spec: BridgeTaskSpec, mode_name: str) -> None:
+    if task_spec.key == "bag":
+        _execute_bag_mode(env, mode_name)
+        return
+    _execute_cloth_mode(env, mode_name)
+
+
+def _mode_support_mode(task_spec: BridgeTaskSpec, mode_name: str, current_support_mode: int) -> int:
+    if mode_name in task_spec.reveal_modes:
+        return SUPPORT_MODE_HOLD
+    if mode_name in task_spec.transfer_modes:
+        return SUPPORT_MODE_TRANSFER
+    if mode_name in task_spec.retrieve_modes:
+        return SUPPORT_MODE_PASSIVE
+    return int(current_support_mode)
+
+
+def _mode_progress_schedule(task_spec: BridgeTaskSpec, mode_name: str) -> np.ndarray:
+    if mode_name in task_spec.reveal_modes:
+        return np.asarray([0.18, 0.38, 0.62, 0.84, 1.0], dtype=np.float32)
+    if mode_name in task_spec.transfer_modes:
+        return np.asarray([0.22, 0.44, 0.66, 0.86, 1.0], dtype=np.float32)
+    if mode_name in task_spec.retrieve_modes:
+        return np.asarray([0.34, 0.56, 0.76, 0.92, 1.0], dtype=np.float32)
+    return np.asarray([0.10, 0.22, 0.34, 0.44, 0.54], dtype=np.float32)
+
+
+def _scalar_rollout(start: float, end: float, schedule: np.ndarray) -> np.ndarray:
+    return np.clip((1.0 - schedule) * float(start) + schedule * float(end), 0.0, 1.0).astype(np.float32)
+
+
+def _current_state_targets(
+    task_spec: BridgeTaskSpec,
+    *,
+    obs_bundle: dict[str, np.ndarray],
+    candidate_metrics: Sequence[dict[str, float]],
+    episode_start_positions: dict[str, np.ndarray],
+    selected_mode: str,
+    env: gym.Env[Any, Any],
+) -> dict[str, Any]:
+    metrics_by_name = {mode_name: payload for mode_name, payload in zip(task_spec.mode_order, candidate_metrics)}
+    current_metrics = _candidate_metrics(
+        env,
+        task_spec=task_spec,
+        start_positions=episode_start_positions,
+        current_obs_bundle=obs_bundle,
+    )
+    current_disturbance = float(np.clip(current_metrics["disturbance"], 0.0, 1.0))
+    current_visibility = float(np.clip(current_metrics["visibility"], 0.0, 1.0))
+    current_clearance = float(np.clip(current_metrics["clearance"], 0.0, 1.0))
+    current_progress = float(np.clip(current_metrics["progress"], 0.0, 1.0))
+    base_gap = float(np.clip(max(current_clearance, current_progress), 0.0, 1.0))
+    support_stability = float(np.clip(1.0 - 0.5 * current_disturbance, 0.0, 1.0))
+    hold_quality = float(np.clip(0.5 * (support_stability + max(current_clearance, current_progress)), 0.0, 1.0))
+    opening_quality = float(np.clip(0.55 * current_progress + 0.25 * current_clearance + 0.20 * current_visibility, 0.0, 1.0))
+    actor_feasibility = float(np.clip(0.6 * current_clearance + 0.4 * max(current_visibility, current_progress), 0.0, 1.0))
+    reocclusion_rate = float(np.clip(1.0 - max(current_clearance, current_visibility), 0.0, 1.0))
+    insertable_actor_corridor = float(np.clip(0.6 * actor_feasibility + 0.4 * base_gap, 0.0, 1.0))
+    insertion_corridor = float(np.clip(0.5 * actor_feasibility + 0.5 * base_gap, 0.0, 1.0))
+    layer_separation = float(np.clip(0.7 * base_gap + 0.3 * actor_feasibility, 0.0, 1.0))
+    fold_preservation = float(np.clip(1.0 - current_disturbance, 0.0, 1.0))
+    lift_too_much_risk = float(np.clip(current_disturbance + 0.5 * max(base_gap - 0.5, 0.0), 0.0, 1.0))
+    task_metrics = {
+        "opening_quality": opening_quality,
+        "actor_feasibility_score": actor_feasibility,
+        "gap_width": float(0.03 + 0.21 * base_gap),
+        "damage_proxy": current_disturbance,
+        "release_collapse_rate": reocclusion_rate,
+        "target_visibility_confidence": current_visibility,
+        "insertable_actor_corridor": insertable_actor_corridor,
+        "insertion_corridor": insertion_corridor,
+        "hold_quality": hold_quality,
+        "layer_separation_quality": layer_separation,
+        "fold_preservation": fold_preservation,
+        "top_layer_stability": support_stability,
+        "lift_too_much_risk": lift_too_much_risk,
+    }
+
+    base_metrics = metrics_by_name["base_action"]
+    insert_metrics = metrics_by_name["insert_actor"]
+    retrieve_metrics = metrics_by_name["retrieve"]
+    reveal_candidates = [metrics_by_name[mode_name] for mode_name in task_spec.reveal_modes]
+    reveal_access = max(candidate["candidate_actor_feasibility_auc"] for candidate in reveal_candidates)
+    reveal_reveal = max(candidate["candidate_reveal_achieved"] for candidate in reveal_candidates)
+    reveal_hold = max(candidate["candidate_hold_persistence"] for candidate in reveal_candidates)
+    reveal_visibility = max(candidate["candidate_visibility_integral"] for candidate in reveal_candidates)
+
+    reveal_corridor = float(
+        np.clip(
+            0.45 * opening_quality
+            + 0.30 * reveal_access
+            + 0.15 * reveal_reveal
+            + 0.10 * reveal_visibility
+            - 0.10 * current_disturbance,
+            0.0,
+            1.0,
+        )
+    )
+    transfer_corridor = float(
+        np.clip(
+            0.45 * insertable_actor_corridor
+            + 0.30 * insert_metrics["candidate_actor_feasibility_auc"]
+            + 0.15 * insert_metrics["candidate_reveal_achieved"]
+            + 0.10 * insert_metrics["candidate_visibility_integral"]
+            - 0.15 * current_disturbance,
+            0.0,
+            1.0,
+        )
+    )
+    passive_corridor = float(
+        np.clip(
+            0.55 * retrieve_metrics["candidate_retrieval_success"]
+            + 0.20 * retrieve_metrics["candidate_actor_feasibility_auc"]
+            + 0.15 * current_progress
+            + 0.10 * current_clearance
+            - 0.10 * current_disturbance,
+            0.0,
+            1.0,
+        )
+    )
+    corridor_feasible = np.stack(
+        [
+            np.full((NUM_APPROACH_TEMPLATES,), reveal_corridor, dtype=np.float32),
+            np.full((NUM_APPROACH_TEMPLATES,), transfer_corridor, dtype=np.float32),
+            np.full((NUM_APPROACH_TEMPLATES,), passive_corridor, dtype=np.float32),
+        ],
+        axis=0,
+    )
+    persistence_horizon = np.asarray(
+        [
+            ROLL_OUT_HORIZON * float(np.clip(0.35 * hold_quality + 0.35 * reveal_hold + 0.30 * reveal_corridor, 0.0, 1.0)),
+            ROLL_OUT_HORIZON
+            * float(
+                np.clip(
+                    0.30 * hold_quality + 0.35 * insert_metrics["candidate_hold_persistence"] + 0.35 * transfer_corridor,
+                    0.0,
+                    1.0,
+                )
+            ),
+            ROLL_OUT_HORIZON
+            * float(
+                np.clip(
+                    0.25 * hold_quality + 0.35 * retrieve_metrics["candidate_hold_persistence"] + 0.40 * passive_corridor,
+                    0.0,
+                    1.0,
+                )
+            ),
+        ],
+        dtype=np.float32,
+    )
+    retrieve_margin = float(retrieve_metrics["candidate_utility"] - base_metrics["candidate_utility"])
+    insert_margin = float(insert_metrics["candidate_utility"] - base_metrics["candidate_utility"])
+    if selected_mode == "retrieve" or (retrieve_metrics["candidate_retrieval_success"] >= 0.5 and retrieve_margin >= 0.12):
+        support_mode = SUPPORT_MODE_PASSIVE
+    elif selected_mode == "insert_actor" or (insert_margin >= 0.12 and transfer_corridor >= 0.35):
+        support_mode = SUPPORT_MODE_TRANSFER
+    elif selected_mode in task_spec.reveal_modes:
+        support_mode = SUPPORT_MODE_HOLD
+    elif selected_mode == "base_action":
+        support_mode = SUPPORT_MODE_PASSIVE if passive_corridor >= 0.55 and retrieve_margin >= 0.03 else SUPPORT_MODE_HOLD
+    else:
+        support_mode = SUPPORT_MODE_HOLD
+    best_non_base_utility = max(float(payload["candidate_utility"]) for payload in candidate_metrics[1:])
+    intervention_warranted = selected_mode != "base_action" and best_non_base_utility >= float(base_metrics["candidate_utility"]) + 0.12
+    return {
+        "support_mode": int(support_mode),
+        "corridor_feasible": corridor_feasible,
+        "persistence_horizon": persistence_horizon,
+        "disturbance_cost": np.float32(current_disturbance),
+        "state_confidence_target": np.float32(1.0 if intervention_warranted else 0.0),
+        "task_metric_mask": STATE_METRIC_MASK.copy(),
+        **{metric_name: np.float32(metric_value) for metric_name, metric_value in task_metrics.items()},
+    }
+
+
+def _candidate_rollout_targets(
+    task_spec: BridgeTaskSpec,
+    *,
+    mode_name: str,
+    state_targets: dict[str, Any],
+    candidate_payload: dict[str, float],
+) -> dict[str, np.ndarray]:
+    schedule = _mode_progress_schedule(task_spec, mode_name)
+    start_visibility = float(state_targets["target_visibility_confidence"])
+    start_access = float(state_targets["actor_feasibility_score"])
+    start_persistence = float(np.clip(state_targets["hold_quality"], 0.0, 1.0))
+    start_support = float(np.clip(state_targets["top_layer_stability"], 0.0, 1.0))
+    start_reocclusion = float(np.clip(state_targets["release_collapse_rate"], 0.0, 1.0))
+    start_disturbance = float(np.clip(state_targets["disturbance_cost"], 0.0, 1.0))
+    start_clearance = float(np.clip(state_targets["actor_feasibility_score"], 0.0, 1.0))
+    start_grasp = float(np.clip(max(start_visibility, start_access), 0.0, 1.0))
+
+    end_visibility = float(np.clip(candidate_payload["candidate_immediate_visibility"], 0.0, 1.0))
+    end_access = float(np.clip(candidate_payload["candidate_immediate_access"], 0.0, 1.0))
+    end_progress = float(np.clip(candidate_payload["candidate_immediate_progress"], 0.0, 1.0))
+    end_disturbance = float(np.clip(candidate_payload["candidate_immediate_disturbance"], 0.0, 1.0))
+    end_support = float(np.clip(candidate_payload["candidate_immediate_support_stability"], 0.0, 1.0))
+    end_persistence = float(np.clip(candidate_payload["candidate_immediate_hold_persistence"], 0.0, 1.0))
+    end_reocclusion = float(np.clip(candidate_payload["candidate_immediate_reocclusion"], 0.0, 1.0))
+    end_clearance = float(np.clip(max(end_access, end_progress), 0.0, 1.0))
+    end_grasp = float(np.clip(max(end_visibility, 0.5 * end_access + 0.5 * end_progress), 0.0, 1.0))
+
+    if mode_name in task_spec.transfer_modes:
+        start_visibility = max(start_visibility, 0.35 * end_visibility)
+        start_access = max(start_access, 0.40 * end_access)
+        start_persistence = max(start_persistence, 0.45 * end_persistence)
+        start_support = max(start_support, 0.50 * end_support)
+    elif mode_name in task_spec.retrieve_modes:
+        start_visibility = max(start_visibility, 0.55 * end_visibility)
+        start_access = max(start_access, 0.70 * end_access)
+        start_persistence = max(start_persistence, 0.65 * end_persistence)
+        start_support = max(start_support, 0.65 * end_support)
+        start_reocclusion = min(start_reocclusion, max(0.4 * end_reocclusion, 0.0))
+
+    visibility = _scalar_rollout(start_visibility, end_visibility, schedule)
+    access = _scalar_rollout(start_access, end_access, schedule)
+    persistence = _scalar_rollout(start_persistence, end_persistence, schedule)
+    support = _scalar_rollout(start_support, end_support, schedule)
+    reocclusion = _scalar_rollout(start_reocclusion, end_reocclusion, schedule)
+    disturbance = _scalar_rollout(start_disturbance, end_disturbance, schedule)
+    clearance = _scalar_rollout(start_clearance, end_clearance, schedule)
+    grasp = _scalar_rollout(start_grasp, end_grasp, schedule)
+    reveal_corridor = np.clip(0.38 * visibility + 0.34 * access + 0.22 * support - 0.12 * disturbance, 0.0, 1.0)
+    transfer_corridor = np.clip(
+        0.30 * visibility + 0.38 * access + 0.18 * persistence + 0.14 * support - 0.12 * disturbance,
+        0.0,
+        1.0,
+    )
+    passive_corridor = np.clip(
+        0.22 * visibility + 0.42 * access + 0.20 * persistence + 0.16 * grasp - 0.14 * disturbance - 0.10 * reocclusion,
+        0.0,
+        1.0,
+    )
+    if mode_name in task_spec.reveal_modes:
+        reveal_corridor = np.clip(reveal_corridor + 0.14, 0.0, 1.0)
+        passive_corridor = np.clip(0.75 * passive_corridor, 0.0, 1.0)
+    elif mode_name in task_spec.transfer_modes:
+        transfer_corridor = np.clip(transfer_corridor + 0.16, 0.0, 1.0)
+    elif mode_name in task_spec.retrieve_modes:
+        passive_corridor = np.clip(passive_corridor + 0.20, 0.0, 1.0)
+        reveal_corridor = np.clip(0.60 * reveal_corridor, 0.0, 1.0)
+    else:
+        reveal_corridor = np.clip(0.85 * reveal_corridor, 0.0, 1.0)
+        transfer_corridor = np.clip(0.75 * transfer_corridor, 0.0, 1.0)
+        passive_corridor = np.clip(0.80 * passive_corridor, 0.0, 1.0)
+    corridor_feasible = np.stack(
+        [
+            np.repeat(reveal_corridor[:, None], NUM_APPROACH_TEMPLATES, axis=1),
+            np.repeat(transfer_corridor[:, None], NUM_APPROACH_TEMPLATES, axis=1),
+            np.repeat(passive_corridor[:, None], NUM_APPROACH_TEMPLATES, axis=1),
+        ],
+        axis=1,
+    ).astype(np.float32)
+    persistence_horizon = np.stack(
+        [
+            np.clip(ROLL_OUT_HORIZON * (0.55 * reveal_corridor + 0.45 * support), 0.0, float(ROLL_OUT_HORIZON)),
+            np.clip(ROLL_OUT_HORIZON * (0.50 * transfer_corridor + 0.50 * persistence), 0.0, float(ROLL_OUT_HORIZON)),
+            np.clip(ROLL_OUT_HORIZON * (0.55 * passive_corridor + 0.45 * persistence), 0.0, float(ROLL_OUT_HORIZON)),
+        ],
+        axis=1,
+    ).astype(np.float32)
+    support_mode = np.full((ROLL_OUT_HORIZON,), _mode_support_mode(task_spec, mode_name, int(state_targets["support_mode"])), dtype=np.int64)
+    if mode_name == "base_action":
+        support_mode[:] = int(state_targets["support_mode"])
+    return {
+        "candidate_rollout_support_mode": support_mode,
+        "candidate_rollout_corridor_feasible": corridor_feasible,
+        "candidate_rollout_persistence_horizon": persistence_horizon,
+        "candidate_rollout_disturbance_cost": disturbance.astype(np.float32),
+        "candidate_rollout_belief_map": visibility[:, None, None].astype(np.float32),
+        "candidate_rollout_visibility_map": visibility[:, None, None].astype(np.float32),
+        "candidate_rollout_clearance_map": np.repeat(clearance[:, None, None, None], 2, axis=1).astype(np.float32),
+        "candidate_rollout_support_stability": support[:, None, None, None].astype(np.float32),
+        "candidate_rollout_reocclusion_target": reocclusion[:, None, None].astype(np.float32),
+        "candidate_rollout_occluder_contact_map": np.clip(access * support, 0.0, 1.0)[:, None, None].astype(np.float32),
+        "candidate_rollout_grasp_affordance_map": grasp[:, None, None].astype(np.float32),
+    }
+
+
+def _select_expert_mode(
+    task_spec: BridgeTaskSpec,
+    *,
+    decision_step: int,
+    candidate_metrics: Sequence[dict[str, float]],
+) -> str:
+    metrics_by_name = {mode_name: payload for mode_name, payload in zip(task_spec.mode_order, candidate_metrics)}
+    base_utility = float(metrics_by_name["base_action"]["candidate_utility"])
+    reveal_best = max(task_spec.reveal_modes, key=lambda name: float(metrics_by_name[name]["candidate_utility"]))
+    transfer_best = max(task_spec.transfer_modes, key=lambda name: float(metrics_by_name[name]["candidate_utility"]))
+    retrieve_utility = float(metrics_by_name["retrieve"]["candidate_utility"])
+    reveal_best_utility = float(metrics_by_name[reveal_best]["candidate_utility"])
+    transfer_best_utility = float(metrics_by_name[transfer_best]["candidate_utility"])
+    retrieve_success = float(metrics_by_name["retrieve"]["candidate_retrieval_success"])
+
+    if int(decision_step) > 0 and retrieve_success >= 0.5:
+        return "retrieve"
+    if int(decision_step) == 0 and reveal_best_utility >= base_utility - 0.02:
+        return reveal_best
+    if transfer_best_utility >= reveal_best_utility + 0.05 and transfer_best_utility >= base_utility + 0.02:
+        return transfer_best
+    if reveal_best_utility >= base_utility - 0.02:
+        return reveal_best
+    if retrieve_success >= 0.5 and retrieve_utility >= base_utility + 0.02:
+        return "retrieve"
+    if transfer_best_utility >= base_utility + 0.02:
+        return transfer_best
+    utilities = np.asarray([payload["candidate_utility"] for payload in candidate_metrics], dtype=np.float32)
+    return task_spec.mode_order[int(utilities.argmax())]
+
+
+def _evaluate_candidate(
+    task_spec: BridgeTaskSpec,
+    sim_env: gym.Env[Any, Any],
+    obs_env: gym.Env[Any, Any],
+    snapshot: dict[str, Any],
+    mode_name: str,
+) -> dict[str, float]:
+    _restore_env(sim_env, snapshot)
+    start_positions = _all_positions(sim_env, task_spec)
+    _execute_mode(sim_env, task_spec, mode_name)
+    _sync_env_state(sim_env, obs_env)
+    after_bundle = _extract_sensor_bundle(obs_env.get_obs(obs_env.get_info()), resolution=IMAGE_RESOLUTION)
+    immediate = _candidate_metrics(sim_env, task_spec=task_spec, start_positions=start_positions, current_obs_bundle=after_bundle)
+    if not immediate["retrieval_success"] and mode_name not in {"retrieve", "base_action"}:
+        _execute_mode(sim_env, task_spec, "retrieve")
+        _sync_env_state(sim_env, obs_env)
+        follow_bundle = _extract_sensor_bundle(obs_env.get_obs(obs_env.get_info()), resolution=IMAGE_RESOLUTION)
+        final_metrics = _candidate_metrics(sim_env, task_spec=task_spec, start_positions=start_positions, current_obs_bundle=follow_bundle)
+    else:
+        final_metrics = immediate
+    _restore_env(obs_env, snapshot)
+    utility = (
+        2.5 * final_metrics["retrieval_success"]
+        + 1.0 * final_metrics["progress"]
+        + 0.5 * final_metrics["clearance"]
+        + 0.25 * final_metrics["visibility"]
+        - 0.5 * final_metrics["disturbance"]
+    )
+    return {
+        "candidate_retrieval_success": final_metrics["retrieval_success"],
+        "candidate_risk": float(np.clip(final_metrics["disturbance"], 0.0, 1.0)),
+        "candidate_utility": float(utility),
+        "candidate_final_disturbance_cost": final_metrics["disturbance"],
+        "candidate_reocclusion_rate": float(np.clip(1.0 - final_metrics["clearance"], 0.0, 1.0)),
+        "candidate_visibility_integral": final_metrics["visibility"],
+        "candidate_actor_feasibility_auc": final_metrics["clearance"],
+        "candidate_reveal_achieved": float(final_metrics["progress"] > 0.15 or final_metrics["clearance"] > 0.35),
+        "candidate_hold_persistence": float(1.0 - final_metrics["disturbance"]),
+        "candidate_support_stability_auc": float(1.0 - 0.5 * final_metrics["disturbance"]),
+        "candidate_disturbance_auc": final_metrics["disturbance"],
+        "candidate_immediate_retrieval_success": immediate["retrieval_success"],
+        "candidate_immediate_visibility": immediate["visibility"],
+        "candidate_immediate_access": immediate["clearance"],
+        "candidate_immediate_progress": immediate["progress"],
+        "candidate_immediate_reocclusion": float(np.clip(1.0 - immediate["clearance"], 0.0, 1.0)),
+        "candidate_immediate_hold_persistence": float(1.0 - immediate["disturbance"]),
+        "candidate_immediate_support_stability": float(1.0 - 0.5 * immediate["disturbance"]),
+        "candidate_immediate_disturbance": immediate["disturbance"],
+    }
+
+
+def _cloth_seed_is_valid(env: gym.Env[Any, Any], task_spec: BridgeTaskSpec, *, episode_seed: int) -> bool:
+    env.reset(seed=int(episode_seed))
+    _initialize_proxy_state(env, task_spec, episode_seed=int(episode_seed))
+    start_positions = _all_positions(env, task_spec)
+    obs = env.get_obs(env.get_info())
+    obs_bundle = _extract_sensor_bundle(obs, resolution=IMAGE_RESOLUTION)
+    actor_id = int(getattr(_source_actor(env), "per_scene_id", -1))
+    start_visibility = _source_visibility(obs_bundle, actor_id)
+    if start_visibility > CLOTH_SUCCESS_MIN_VISIBILITY:
+        return False
+    snapshot = _snapshot_env(env)
+    for reveal_mode in ("lift_edge", "separate_layer"):
+        _restore_env(env, snapshot)
+        _execute_mode(env, task_spec, reveal_mode)
+        _execute_mode(env, task_spec, "retrieve")
+        obs = env.get_obs(env.get_info())
+        obs_bundle = _extract_sensor_bundle(obs, resolution=IMAGE_RESOLUTION)
+        visibility = _source_visibility(obs_bundle, actor_id)
+        if _cloth_success(env, start_positions=start_positions, current_visibility=visibility):
+            return True
+    return False
+
+
+def _build_episode_splits(task_spec: BridgeTaskSpec, spec: SmokeSpec) -> dict[str, list[int]]:
+    if task_spec.key != "cloth":
+        return {
+            "train": [spec.dataset_seed * 10_000 + index for index in range(spec.train_episodes)],
+            "val": [spec.dataset_seed * 10_000 + 1_000 + index for index in range(spec.val_episodes)],
+            "eval": [spec.dataset_seed * 10_000 + 2_000 + index for index in range(spec.eval_episodes)],
+        }
+    target_total = int(spec.train_episodes + spec.val_episodes + spec.eval_episodes)
+    valid_seeds: list[int] = []
+    candidate_index = 0
+    env = gym.make(task_spec.env_id, obs_mode="rgb+segmentation", render_mode="rgb_array")
+    try:
+        while len(valid_seeds) < target_total:
+            episode_seed = spec.dataset_seed * 10_000 + candidate_index
+            candidate_index += 1
+            if _cloth_seed_is_valid(env, task_spec, episode_seed=episode_seed):
+                valid_seeds.append(int(episode_seed))
+                print(
+                    json.dumps(
+                        {
+                            "phase": "cloth_seed_selected",
+                            "episode_seed": int(episode_seed),
+                            "selected": len(valid_seeds),
+                            "target_total": target_total,
+                        }
+                    ),
+                    flush=True,
+                )
+            if candidate_index > target_total * 30:
+                raise RuntimeError("Unable to find enough physics-valid cloth proxy seeds for the smoke protocol.")
+    finally:
+        env.close()
+    return {
+        "train": valid_seeds[: spec.train_episodes],
+        "val": valid_seeds[spec.train_episodes : spec.train_episodes + spec.val_episodes],
+        "eval": valid_seeds[spec.train_episodes + spec.val_episodes : target_total],
+    }
+
+
+def _save_episode_splits(output_path: Path, payload: dict[str, list[int]]) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def _normalize_depth_array(array: np.ndarray) -> np.ndarray:
+    normalized = _np(array, dtype=np.float32)
+    if normalized.ndim >= 4 and normalized.shape[-1] == 1:
+        return np.moveaxis(normalized, -1, normalized.ndim - 3)
+    return normalized
+
+
+def _candidate_pad_indices(source_candidates: int, expected_candidates: int) -> list[int]:
+    if source_candidates <= 0 or source_candidates >= expected_candidates:
+        return []
+    if source_candidates == 1:
+        return [0] * (expected_candidates - source_candidates)
+    cycle = list(range(1, source_candidates))
+    indices: list[int] = []
+    while len(indices) < (expected_candidates - source_candidates):
+        indices.extend(cycle)
+    return indices[: expected_candidates - source_candidates]
+
+
+def _pad_candidate_axis(
+    value: Any,
+    *,
+    source_candidates: int,
+    expected_candidates: int,
+    pad_indices: Sequence[int],
+) -> Any:
+    if source_candidates <= 0 or source_candidates >= expected_candidates:
+        return value
+    if isinstance(value, np.ndarray):
+        if value.ndim == 0 or value.shape[0] != source_candidates:
+            return value
+        if not pad_indices:
+            return value
+        padding = np.take(value, indices=list(pad_indices), axis=0)
+        return np.concatenate([value, padding], axis=0)
+    if isinstance(value, torch.Tensor):
+        if value.ndim == 0 or value.shape[0] != source_candidates:
+            return value
+        if not pad_indices:
+            return value
+        pad_index = torch.as_tensor(list(pad_indices), device=value.device, dtype=torch.long)
+        padding = value.index_select(0, pad_index)
+        return torch.cat([value, padding], dim=0)
+    if isinstance(value, list) and len(value) == source_candidates:
+        padded = list(value)
+        padded.extend(value[index] for index in pad_indices)
+        return padded
+    if isinstance(value, tuple) and len(value) == source_candidates:
+        padded = list(value)
+        padded.extend(value[index] for index in pad_indices)
+        return tuple(padded)
+    return value
+
+
+def _normalize_candidate_targets(sample: dict[str, Any]) -> dict[str, Any]:
+    candidate_chunks = sample.get("candidate_action_chunks")
+    if candidate_chunks is None:
+        return sample
+    candidate_array = _np(candidate_chunks)
+    if candidate_array.ndim == 0:
+        return sample
+    source_candidates = int(candidate_array.shape[0])
+    if source_candidates >= EXPECTED_PROPOSAL_CANDIDATES:
+        return sample
+    pad_indices = _candidate_pad_indices(source_candidates, EXPECTED_PROPOSAL_CANDIDATES)
+    if not pad_indices:
+        return sample
+    padded = dict(sample)
+    for key, value in sample.items():
+        if not (key.startswith("candidate_") or key.startswith("proposal_target_")):
+            continue
+        padded[key] = _pad_candidate_axis(
+            value,
+            source_candidates=source_candidates,
+            expected_candidates=EXPECTED_PROPOSAL_CANDIDATES,
+            pad_indices=pad_indices,
+        )
+    return padded
+
+
+def _normalize_cached_samples(samples: Sequence[dict[str, Any]]) -> list[dict[str, Any]]:
+    normalized_samples: list[dict[str, Any]] = []
+    for sample in samples:
+        patched = dict(sample)
+        for key in ("depths", "depth_valid", "history_depths", "history_depth_valid"):
+            if key in patched:
+                patched[key] = _normalize_depth_array(patched[key])
+        patched = _normalize_candidate_targets(patched)
+        normalized_samples.append(patched)
+    return normalized_samples
+
+
+def _collect_split(
+    *,
+    task_spec: BridgeTaskSpec,
+    canonical_chunks: dict[str, np.ndarray],
+    split_name: str,
+    seeds: Sequence[int],
+    spec: SmokeSpec,
+    output_path: Path,
+) -> dict[str, Any]:
+    obs_env = gym.make(task_spec.env_id, obs_mode="rgb+segmentation", render_mode="rgb_array")
+    sim_env = gym.make(task_spec.env_id, obs_mode="rgb+segmentation", render_mode="rgb_array")
+    samples: list[dict[str, Any]] = []
+    episode_records: list[dict[str, Any]] = []
+    try:
+        for episode_seed in seeds:
+            obs, _ = obs_env.reset(seed=int(episode_seed))
+            sim_env.reset(seed=int(episode_seed))
+            _initialize_proxy_state(obs_env, task_spec, episode_seed=int(episode_seed))
+            _sync_env_state(obs_env, sim_env)
+            obs = obs_env.get_obs(obs_env.get_info())
+            episode_start_positions = _all_positions(obs_env, task_spec)
+            history: deque[dict[str, Any]] = deque(maxlen=spec.history_steps)
+            episode_success = False
+            for decision_step in range(spec.max_macro_steps):
+                obs_bundle = _extract_sensor_bundle(obs, resolution=spec.resolution)
+                proprio = _build_proprio(obs_env)
+                snapshot = _snapshot_env(obs_env)
+                candidate_metrics = [
+                    _evaluate_candidate(task_spec, sim_env, obs_env, snapshot, mode_name) for mode_name in task_spec.mode_order
+                ]
+                candidate_chunks = np.stack([canonical_chunks[mode_name] for mode_name in task_spec.mode_order], axis=0).astype(np.float32)
+                utilities = np.asarray([payload["candidate_utility"] for payload in candidate_metrics], dtype=np.float32)
+                selected_mode = _select_expert_mode(task_spec, decision_step=decision_step, candidate_metrics=candidate_metrics)
+                state_targets = _current_state_targets(
+                    task_spec,
+                    env=obs_env,
+                    obs_bundle=obs_bundle,
+                    candidate_metrics=candidate_metrics,
+                    episode_start_positions=episode_start_positions,
+                    selected_mode=selected_mode,
+                )
+                rollout_targets_by_mode = [
+                    _candidate_rollout_targets(task_spec, mode_name=mode_name, state_targets=state_targets, candidate_payload=payload)
+                    for mode_name, payload in zip(task_spec.mode_order, candidate_metrics)
+                ]
+                sample = {
+                    "images": obs_bundle["images"].copy(),
+                    "depths": obs_bundle["depths"].copy(),
+                    "depth_valid": obs_bundle["depth_valid"].copy(),
+                    "camera_intrinsics": obs_bundle["camera_intrinsics"].copy(),
+                    "camera_extrinsics": obs_bundle["camera_extrinsics"].copy(),
+                    "history_images": _history_stack(
+                        history,
+                        "images",
+                        pad_shape=obs_bundle["images"].shape,
+                        dtype=np.uint8,
+                        history_steps=spec.history_steps,
+                    ),
+                    "history_depths": _history_stack(
+                        history,
+                        "depths",
+                        pad_shape=obs_bundle["depths"].shape,
+                        dtype=np.float32,
+                        history_steps=spec.history_steps,
+                    ),
+                    "history_depth_valid": _history_stack(
+                        history,
+                        "depth_valid",
+                        pad_shape=obs_bundle["depth_valid"].shape,
+                        dtype=np.float32,
+                        history_steps=spec.history_steps,
+                    ),
+                    "history_camera_intrinsics": _history_stack(
+                        history,
+                        "camera_intrinsics",
+                        pad_shape=obs_bundle["camera_intrinsics"].shape,
+                        dtype=np.float32,
+                        history_steps=spec.history_steps,
+                    ),
+                    "history_camera_extrinsics": _history_stack(
+                        history,
+                        "camera_extrinsics",
+                        pad_shape=obs_bundle["camera_extrinsics"].shape,
+                        dtype=np.float32,
+                        history_steps=spec.history_steps,
+                    ),
+                    "history_proprio": _history_stack(
+                        history,
+                        "proprio",
+                        pad_shape=(PROPRIO_DIM,),
+                        dtype=np.float32,
+                        history_steps=spec.history_steps,
+                    ),
+                    "history_actions": _history_stack(
+                        history,
+                        "action",
+                        pad_shape=(14,),
+                        dtype=np.float32,
+                        history_steps=spec.history_steps,
+                    ),
+                    "proprio": proprio.astype(np.float32),
+                    "language_goal": task_spec.text_prompt,
+                    "task_name": task_spec.task_name,
+                    "task_id": TASK_INDEX[task_spec.task_name],
+                    "action_chunk": canonical_chunks[selected_mode].copy(),
+                    "candidate_action_chunks": candidate_chunks,
+                    "candidate_retrieval_success": np.asarray([payload["candidate_retrieval_success"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_final_disturbance_cost": np.asarray(
+                        [payload["candidate_final_disturbance_cost"] for payload in candidate_metrics],
+                        dtype=np.float32,
+                    ),
+                    "candidate_reocclusion_rate": np.asarray([payload["candidate_reocclusion_rate"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_visibility_integral": np.asarray(
+                        [payload["candidate_visibility_integral"] for payload in candidate_metrics],
+                        dtype=np.float32,
+                    ),
+                    "candidate_actor_feasibility_auc": np.asarray(
+                        [payload["candidate_actor_feasibility_auc"] for payload in candidate_metrics],
+                        dtype=np.float32,
+                    ),
+                    "candidate_reveal_achieved": np.asarray([payload["candidate_reveal_achieved"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_hold_persistence": np.asarray([payload["candidate_hold_persistence"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_support_stability_auc": np.asarray(
+                        [payload["candidate_support_stability_auc"] for payload in candidate_metrics],
+                        dtype=np.float32,
+                    ),
+                    "candidate_disturbance_auc": np.asarray([payload["candidate_disturbance_auc"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_risk": np.asarray([payload["candidate_risk"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_utility": utilities,
+                    "candidate_rollout_support_mode": np.stack(
+                        [payload["candidate_rollout_support_mode"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.int64),
+                    "candidate_rollout_corridor_feasible": np.stack(
+                        [payload["candidate_rollout_corridor_feasible"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_persistence_horizon": np.stack(
+                        [payload["candidate_rollout_persistence_horizon"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_disturbance_cost": np.stack(
+                        [payload["candidate_rollout_disturbance_cost"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_belief_map": np.stack(
+                        [payload["candidate_rollout_belief_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_visibility_map": np.stack(
+                        [payload["candidate_rollout_visibility_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_clearance_map": np.stack(
+                        [payload["candidate_rollout_clearance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_support_stability": np.stack(
+                        [payload["candidate_rollout_support_stability"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_reocclusion_target": np.stack(
+                        [payload["candidate_rollout_reocclusion_target"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_occluder_contact_map": np.stack(
+                        [payload["candidate_rollout_occluder_contact_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_grasp_affordance_map": np.stack(
+                        [payload["candidate_rollout_grasp_affordance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_support_mode": np.stack(
+                        [payload["candidate_rollout_support_mode"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.int64),
+                    "proposal_target_rollout_corridor_feasible": np.stack(
+                        [payload["candidate_rollout_corridor_feasible"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_persistence_horizon": np.stack(
+                        [payload["candidate_rollout_persistence_horizon"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_disturbance_cost": np.stack(
+                        [payload["candidate_rollout_disturbance_cost"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_belief_map": np.stack(
+                        [payload["candidate_rollout_belief_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_visibility_map": np.stack(
+                        [payload["candidate_rollout_visibility_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_clearance_map": np.stack(
+                        [payload["candidate_rollout_clearance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_support_stability": np.stack(
+                        [payload["candidate_rollout_support_stability"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_reocclusion_target": np.stack(
+                        [payload["candidate_rollout_reocclusion_target"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_occluder_contact_map": np.stack(
+                        [payload["candidate_rollout_occluder_contact_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_grasp_affordance_map": np.stack(
+                        [payload["candidate_rollout_grasp_affordance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "episode_seed": int(episode_seed),
+                    "decision_step": int(decision_step),
+                    "selected_mode": selected_mode,
+                    **state_targets,
+                }
+                samples.append(sample)
+                _execute_mode(obs_env, task_spec, selected_mode)
+                obs = obs_env.get_obs(obs_env.get_info())
+                post_bundle = _extract_sensor_bundle(obs, resolution=spec.resolution)
+                history.append(_init_history_entry(obs_bundle, proprio, canonical_chunks[selected_mode]))
+                if (
+                    _bag_success(obs_env)
+                    if task_spec.key == "bag"
+                    else _cloth_success(
+                        obs_env,
+                        start_positions=episode_start_positions,
+                        current_visibility=_source_visibility(post_bundle, int(getattr(_source_actor(obs_env), "per_scene_id", -1))),
+                    )
+                ):
+                    episode_success = True
+                    break
+            episode_records.append({"episode_seed": int(episode_seed), "success": episode_success, "steps": len(history)})
+            print(
+                json.dumps(
+                    {
+                        "phase": "collect_episode_complete",
+                        "task": task_spec.key,
+                        "split": split_name,
+                        "episode_seed": int(episode_seed),
+                        "success": episode_success,
+                        "steps": len(history),
+                        "samples_collected": len(samples),
+                    }
+                ),
+                flush=True,
+            )
+    finally:
+        obs_env.close()
+        sim_env.close()
+    payload = {
+        "split_name": split_name,
+        "resolution": spec.resolution,
+        "history_steps": spec.history_steps,
+        "samples": samples,
+        "episode_records": episode_records,
+    }
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(payload, output_path)
+    return payload
+
+
+def _manual_train_spec(task_spec: BridgeTaskSpec, variant: str, spec: SmokeSpec) -> dict[str, Any]:
+    return {
+        "track_id": task_spec.track_id,
+        "suite": task_spec.suite,
+        "benchmark_task": task_spec.benchmark_task,
+        "model_variant": str(variant),
+        "seed": int(spec.train_seed),
+        "train_demos": int(spec.train_episodes),
+        "val_demos": int(spec.val_episodes),
+        "init_checkpoint_group": str(DEFAULT_INIT_CHECKPOINT),
+        "optimizer": "adamw",
+        "learning_rate": float(spec.learning_rate),
+        "lr_schedule": "constant",
+        "batch_size": int(spec.batch_size),
+        "augmentations": "none",
+        "early_stopping_metric": "val_total",
+        "max_gradient_steps": int(spec.epochs * math.ceil(max(1, spec.train_episodes) / max(1, spec.batch_size))),
+        "unfreeze_scope": "fusion_memory_decoder",
+        "dataset_split_id": (
+            f"{task_spec.key}_{SMOKE_VERSION}_seed{spec.dataset_seed}"
+            if int(spec.dataset_seed) == DEFAULT_SEED
+            else f"{task_spec.key}_{SMOKE_VERSION}_dataset_seed{spec.dataset_seed}"
+        ),
+        "same_data_policy": True,
+        "same_init_policy": True,
+    }
+
+
+def _trainer_config_for_variant(variant: str) -> TrainerConfig:
+    if variant == "trunk_only_ft":
+        return TrainerConfig(
+            policy_type="trunk_only",
+            trainable_parameter_prefixes=("fusion", "memory", "decoder"),
+            eval_mode="trunk_only",
+        )
+    if variant == "adapter_active_ft":
+        return TrainerConfig(
+            policy_type="adapter_wrapped",
+            trainable_parameter_prefixes=(
+                "trunk.fusion",
+                "trunk.memory",
+                "trunk.decoder",
+                "adapter.state_head",
+                "adapter.transition_model",
+                "adapter.proposal_prior",
+                "adapter.planner",
+            ),
+            adapter_mode="adapter_active",
+            eval_mode="adapter_active",
+            adapter_use_transition_model=True,
+            adapter_use_task_conditioning=True,
+            adapter_action_supervision_source="trunk",
+        )
+    raise KeyError(f"Unsupported variant {variant!r}.")
+
+
+def _loss_weights_for_smoke(task_spec: BridgeTaskSpec) -> LossWeights:
+    return LossWeights(
+        action=1.0,
+        support_mode=0.15,
+        corridor=0.15,
+        persistence=0.08,
+        disturbance=0.08,
+        planner_success=0.20,
+        planner_risk=0.08,
+        planner_ranking=0.20,
+        proposal_reconstruction=0.10,
+        proposal_success=0.12,
+        proposal_ranking=0.15,
+        proposal_mode=0.10,
+        proposal_diversity=0.02,
+        task_metrics=0.15,
+        transition=0.25,
+        gate=0.25,
+        calibration=0.10,
+        proposal_mode_task_filter=[task_spec.task_name],
+    )
+
+
+def _train_variant(
+    *,
+    task_spec: BridgeTaskSpec,
+    variant: str,
+    train_samples: Sequence[dict[str, Any]],
+    val_samples: Sequence[dict[str, Any]],
+    spec: SmokeSpec,
+    output_dir: Path,
+) -> tuple[Path, dict[str, Any]]:
+    policy_config, _init_trainer_cfg, _init_loss_weights = _load_init_bundle()
+    policy_config = _apply_smoke_planner_overrides(policy_config)
+    trainer_config = _trainer_config_for_variant(variant)
+    loss_weights = _loss_weights_for_smoke(task_spec)
+    model = build_policy(policy_config, trainer_config)
+    init_info = _load_init_checkpoint(model, str(DEFAULT_INIT_CHECKPOINT), False)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    torch.manual_seed(spec.train_seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(spec.train_seed)
+        torch.backends.cuda.matmul.allow_tf32 = True
+    matched = apply_trainable_parameter_prefixes(model, trainer_config)
+    optimizer = torch.optim.AdamW(
+        [parameter for parameter in model.parameters() if parameter.requires_grad],
+        lr=spec.learning_rate,
+        weight_decay=spec.weight_decay,
+    )
+    trainer = BimanualTrainer(model=model, optimizer=optimizer, config=trainer_config)
+    train_loader = _make_loader(train_samples, batch_size=spec.batch_size, num_workers=spec.num_workers, shuffle=True)
+    val_loader = _make_loader(val_samples, batch_size=spec.batch_size, num_workers=spec.num_workers, shuffle=False)
+    best_val = math.inf
+    history: list[dict[str, Any]] = []
+    train_spec = _manual_train_spec(task_spec, variant, spec)
+    train_spec["max_gradient_steps"] = len(train_loader) * spec.epochs
+    for epoch in range(spec.epochs):
+        model.train()
+        train_losses: list[dict[str, float]] = []
+        for batch in train_loader:
+            moved = _move_batch_to_device(batch, device)
+            loss_dict = trainer.training_step(moved, loss_weights=loss_weights)
+            train_losses.append({key: float(value.detach().cpu()) for key, value in loss_dict.items()})
+        model.eval()
+        val_losses: list[dict[str, float]] = []
+        with torch.no_grad():
+            for batch in val_loader:
+                moved = _move_batch_to_device(batch, device)
+                forward_kwargs = {
+                    "images": moved["images"],
+                    "proprio": moved["proprio"],
+                    "texts": moved["texts"],
+                    "task_names": moved.get("task_name"),
+                    "task_ids": moved.get("task_id"),
+                    "history_images": moved.get("history_images"),
+                    "history_proprio": moved.get("history_proprio"),
+                    "history_actions": moved.get("history_actions"),
+                    "depths": moved.get("depths"),
+                    "depth_valid": moved.get("depth_valid"),
+                    "camera_intrinsics": moved.get("camera_intrinsics"),
+                    "camera_extrinsics": moved.get("camera_extrinsics"),
+                    "history_depths": moved.get("history_depths"),
+                    "history_depth_valid": moved.get("history_depth_valid"),
+                    "history_camera_intrinsics": moved.get("history_camera_intrinsics"),
+                    "history_camera_extrinsics": moved.get("history_camera_extrinsics"),
+                }
+                if variant == "adapter_active_ft":
+                    forward_kwargs["adapter_mode"] = "adapter_active"
+                    forward_kwargs["use_transition_model"] = True
+                    forward_kwargs["use_task_conditioning"] = True
+                outputs = model(**forward_kwargs)
+                losses = compute_total_loss(outputs, moved, weights=loss_weights)
+                val_losses.append({key: float(value.detach().cpu()) for key, value in losses.items()})
+        train_summary = _aggregate_epoch(train_losses)
+        val_summary = _aggregate_epoch(val_losses)
+        history.append({"epoch": epoch, "train": train_summary, "val": val_summary})
+        print(
+            json.dumps(
+                {
+                    "phase": "epoch_complete",
+                    "task": task_spec.key,
+                    "variant": variant,
+                    "epoch": epoch,
+                    "train_total": train_summary.get("total", 0.0),
+                    "val_total": val_summary.get("total", 0.0),
+                }
+            ),
+            flush=True,
+        )
+        if val_summary.get("total", math.inf) <= best_val:
+            best_val = val_summary["total"]
+            checkpoint_path = _save_training_checkpoint(
+                output_dir=output_dir,
+                experiment_name=f"{task_spec.key}_{variant}_seed{spec.train_seed}",
+                model=model,
+                policy_config=policy_config,
+                trainer_config=trainer_config,
+                loss_weights=loss_weights,
+                history=history,
+                best_val=best_val,
+                train_spec=train_spec,
+            )
+            (output_dir / "summary.json").write_text(
+                json.dumps(
+                    {
+                        "task": task_spec.key,
+                        "variant": variant,
+                        "checkpoint_path": str(checkpoint_path),
+                        "init_info": init_info,
+                        "trainable_parameter_names": matched,
+                        "best_val_total": best_val,
+                        "history": history,
+                        "train_spec": train_spec,
+                    },
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+    return output_dir / "checkpoint_best.pt", train_spec
+
+
+def _eval_mode_name(model_output: dict[str, Any], result_mode_name: str, canonical_chunks: dict[str, np.ndarray]) -> tuple[str, bool, bool]:
+    if result_mode_name == "adapter_active_ft" and "proposal_mode_names" in model_output and "best_candidate_indices" in model_output:
+        active_mask = bool(_np(model_output.get("adapter_active_mask", np.asarray([False]))).reshape(-1)[0])
+        if not active_mask:
+            return _classify_mode_from_chunk(_np(model_output["action_mean"])[0], canonical_chunks), False, False
+        best_index = int(_np(model_output["best_candidate_indices"])[0])
+        proposal_mode_names = model_output["proposal_mode_names"][0]
+        if best_index < len(proposal_mode_names):
+            mode_name = str(proposal_mode_names[best_index])
+        else:
+            mode_name = _classify_mode_from_chunk(_np(model_output["action_mean"])[0], canonical_chunks)
+        return mode_name, active_mask, bool(best_index > 0)
+    return _classify_mode_from_chunk(_np(model_output["action_mean"])[0], canonical_chunks), False, False
+
+
+def _manual_eval_protocol(task_spec: BridgeTaskSpec, *, eval_mode: str, spec: SmokeSpec, episodes: int) -> dict[str, Any]:
+    return {
+        "track_id": task_spec.track_id,
+        "suite": task_spec.suite,
+        "benchmark_task": task_spec.benchmark_task,
+        "role": "target",
+        "eval_mode": eval_mode,
+        "seed": int(spec.dataset_seed),
+        "episodes": int(episodes),
+        "resolution": int(spec.resolution),
+        "cameras": tuple(CAMERA_NAMES),
+        "observation_stack": "rgb_triplicate_zero_depth",
+        "action_horizon": 8,
+        "action_space": "widowx_delta_pose",
+        "same_test_episodes": True,
+    }
+
+
+def _batch_from_obs(
+    task_spec: BridgeTaskSpec,
+    obs_bundle: dict[str, np.ndarray],
+    proprio: np.ndarray,
+    history: Sequence[dict[str, Any]],
+    device: torch.device,
+) -> dict[str, Any]:
+    return {
+        "images": torch.from_numpy(obs_bundle["images"]).permute(0, 3, 1, 2).unsqueeze(0).float().div(255.0).to(device),
+        "depths": torch.from_numpy(obs_bundle["depths"]).unsqueeze(0).float().to(device),
+        "depth_valid": torch.from_numpy(obs_bundle["depth_valid"]).unsqueeze(0).float().to(device),
+        "camera_intrinsics": torch.from_numpy(obs_bundle["camera_intrinsics"]).unsqueeze(0).float().to(device),
+        "camera_extrinsics": torch.from_numpy(obs_bundle["camera_extrinsics"]).unsqueeze(0).float().to(device),
+        "history_images": torch.from_numpy(
+            _history_stack(history, "images", pad_shape=obs_bundle["images"].shape, dtype=np.uint8, history_steps=HISTORY_STEPS)
+        ).permute(0, 1, 4, 2, 3).unsqueeze(0).float().div(255.0).to(device),
+        "history_depths": torch.from_numpy(
+            _history_stack(history, "depths", pad_shape=obs_bundle["depths"].shape, dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "history_depth_valid": torch.from_numpy(
+            _history_stack(
+                history,
+                "depth_valid",
+                pad_shape=obs_bundle["depth_valid"].shape,
+                dtype=np.float32,
+                history_steps=HISTORY_STEPS,
+            )
+        ).unsqueeze(0).float().to(device),
+        "history_camera_intrinsics": torch.from_numpy(
+            _history_stack(
+                history,
+                "camera_intrinsics",
+                pad_shape=obs_bundle["camera_intrinsics"].shape,
+                dtype=np.float32,
+                history_steps=HISTORY_STEPS,
+            )
+        ).unsqueeze(0).float().to(device),
+        "history_camera_extrinsics": torch.from_numpy(
+            _history_stack(
+                history,
+                "camera_extrinsics",
+                pad_shape=obs_bundle["camera_extrinsics"].shape,
+                dtype=np.float32,
+                history_steps=HISTORY_STEPS,
+            )
+        ).unsqueeze(0).float().to(device),
+        "history_proprio": torch.from_numpy(
+            _history_stack(history, "proprio", pad_shape=(PROPRIO_DIM,), dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "history_actions": torch.from_numpy(
+            _history_stack(history, "action", pad_shape=(14,), dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "proprio": torch.from_numpy(proprio).unsqueeze(0).float().to(device),
+        "texts": [task_spec.text_prompt],
+        "task_names": [task_spec.task_name],
+        "task_ids": torch.as_tensor([TASK_INDEX[task_spec.task_name]], dtype=torch.long, device=device),
+    }
+
+
+def _evaluate_checkpoint(
+    *,
+    task_spec: BridgeTaskSpec,
+    canonical_chunks: dict[str, np.ndarray],
+    checkpoint_path: Path,
+    adapter_mode: str,
+    result_mode_name: str,
+    seeds: Sequence[int],
+    report_path: Path,
+    train_spec: dict[str, Any] | None,
+    planner_overrides: dict[str, float] | None,
+) -> dict[str, Any]:
+    model, checkpoint = _load_checkpoint(
+        checkpoint_path,
+        adapter_mode=adapter_mode if adapter_mode != "trunk_only" else None,
+        planner_overrides=planner_overrides,
+    )
+    device = next(model.parameters()).device
+    obs_env = gym.make(task_spec.env_id, obs_mode="rgb+segmentation", render_mode="rgb_array")
+    sim_env = gym.make(task_spec.env_id, obs_mode="rgb+segmentation", render_mode="rgb_array")
+    successes: list[int] = []
+    episode_records: list[dict[str, Any]] = []
+    reveal_steps: list[int] = []
+    retrieve_steps: list[int] = []
+    disturbance_values: list[float] = []
+    intervention_events = 0
+    non_base_events = 0
+    total_decisions = 0
+    try:
+        for episode_seed in seeds:
+            obs, _ = obs_env.reset(seed=int(episode_seed))
+            sim_env.reset(seed=int(episode_seed))
+            _initialize_proxy_state(obs_env, task_spec, episode_seed=int(episode_seed))
+            _sync_env_state(obs_env, sim_env)
+            obs = obs_env.get_obs(obs_env.get_info())
+            history: deque[dict[str, Any]] = deque(maxlen=HISTORY_STEPS)
+            episode_start_positions = _all_positions(obs_env, task_spec)
+            success = False
+            first_reveal_step: int | None = None
+            first_retrieve_step: int | None = None
+            episode_disturbance: list[float] = []
+            for decision_step in range(MAX_MACRO_STEPS):
+                obs_bundle = _extract_sensor_bundle(obs, resolution=IMAGE_RESOLUTION)
+                proprio = _build_proprio(obs_env)
+                batch = _batch_from_obs(task_spec, obs_bundle, proprio, list(history), device)
+                with torch.no_grad():
+                    if adapter_mode == "trunk_only":
+                        outputs = model(**batch)
+                    else:
+                        outputs = model(**batch, adapter_mode=adapter_mode, use_transition_model=True, use_task_conditioning=True)
+                selected_mode, active_mask, non_base = _eval_mode_name(outputs, result_mode_name, canonical_chunks)
+                start_positions = _all_positions(obs_env, task_spec)
+                _sync_env_state(obs_env, sim_env)
+                _execute_mode(sim_env, task_spec, selected_mode)
+                _sync_env_state(sim_env, obs_env)
+                obs = obs_env.get_obs(obs_env.get_info())
+                post_bundle = _extract_sensor_bundle(obs, resolution=IMAGE_RESOLUTION)
+                end_metrics = _candidate_metrics(
+                    obs_env,
+                    task_spec=task_spec,
+                    start_positions=start_positions,
+                    current_obs_bundle=post_bundle,
+                )
+                history.append(_init_history_entry(obs_bundle, proprio, canonical_chunks.get(selected_mode, canonical_chunks["base_action"])))
+                total_decisions += 1
+                intervention_events += int(active_mask)
+                non_base_events += int(non_base)
+                episode_disturbance.append(end_metrics["disturbance"])
+                if selected_mode != "retrieve" and selected_mode != "base_action" and first_reveal_step is None:
+                    first_reveal_step = decision_step + 1
+                if selected_mode == "retrieve" and first_retrieve_step is None:
+                    first_retrieve_step = decision_step + 1
+                if (
+                    _bag_success(obs_env)
+                    if task_spec.key == "bag"
+                    else _cloth_success(
+                        obs_env,
+                        start_positions=episode_start_positions,
+                        current_visibility=end_metrics["visibility"],
+                    )
+                ):
+                    success = True
+                    break
+            successes.append(int(success))
+            if first_reveal_step is not None:
+                reveal_steps.append(first_reveal_step)
+            if first_retrieve_step is not None:
+                retrieve_steps.append(first_retrieve_step)
+            disturbance_values.append(float(np.mean(episode_disturbance)) if episode_disturbance else 0.0)
+            episode_records.append(
+                {
+                    "episode_seed": int(episode_seed),
+                    "success": success,
+                    "steps": len(history),
+                    "first_reveal_step": first_reveal_step,
+                    "first_retrieve_step": first_retrieve_step,
+                    "episode_disturbance": float(np.mean(episode_disturbance)) if episode_disturbance else 0.0,
+                }
+            )
+            print(
+                json.dumps(
+                    {
+                        "phase": "eval_episode_complete",
+                        "task": task_spec.key,
+                        "adapter_mode": result_mode_name,
+                        "episode_seed": int(episode_seed),
+                        "success": success,
+                        "steps": len(history),
+                    }
+                ),
+                flush=True,
+            )
+    finally:
+        obs_env.close()
+        sim_env.close()
+    payload = {
+        "track_id": task_spec.track_id,
+        "suite": task_spec.suite,
+        "benchmark_task": task_spec.benchmark_task,
+        "role": "target",
+        "adapter_mode": result_mode_name,
+        "episodes": len(seeds),
+        "successes": successes,
+        "success_rate": float(np.mean(successes)) if successes else 0.0,
+        "intervention_rate": float(intervention_events / max(1, total_decisions)),
+        "non_base_selection_rate": float(non_base_events / max(1, total_decisions)),
+        "steps_to_first_reveal_or_access": float(np.mean(reveal_steps)) if reveal_steps else float(MAX_MACRO_STEPS),
+        "steps_to_retrieve": float(np.mean(retrieve_steps)) if retrieve_steps else float(MAX_MACRO_STEPS),
+        "disturbance_proxy": float(np.mean(disturbance_values)) if disturbance_values else 0.0,
+        "episode_records": episode_records,
+        "eval_protocol": _manual_eval_protocol(task_spec, eval_mode=result_mode_name, spec=SmokeSpec(), episodes=len(seeds)),
+        "proxy_notes": task_spec.notes,
+    }
+    if train_spec is not None:
+        payload["train_spec"] = train_spec
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    return payload
+
+
+def _patch_summary_metadata(summary: dict[str, Any], task_spec: BridgeTaskSpec) -> dict[str, Any]:
+    patched = json.loads(json.dumps(summary))
+    track_payload = patched.get("tracks", {}).get(task_spec.track_id)
+    if track_payload is not None:
+        track_payload["suite"] = task_spec.suite
+        track_payload["benchmark_task"] = task_spec.benchmark_task
+        track_payload["notes"] = task_spec.notes
+        track_payload["public_source"] = f"ManiSkill public scene proxy: {task_spec.env_id}"
+        track_payload["task_family"] = f"{task_spec.key}_retrieval_proxy"
+        track_payload["target_behavior"] = task_spec.text_prompt
+    return patched
+
+
+def _summarize_task(task_spec: BridgeTaskSpec, results: Sequence[dict[str, Any]], output_dir: Path) -> dict[str, Any]:
+    summary = summarize_public_benchmark_package(list(results), allow_partial=True)
+    summary = _patch_summary_metadata(summary, task_spec)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    json_path = output_dir / "public_benchmark_package_summary.json"
+    md_path = output_dir / "public_benchmark_package_summary.md"
+    json_path.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    track_payload = summary["tracks"][task_spec.track_id]
+    lines = [
+        f"# ManiSkill {task_spec.key.capitalize()} Retrieval Smoke Summary",
+        "",
+        f"- benchmark_task: {task_spec.benchmark_task}",
+        f"- target_macro_average_delta: {summary['target_macro_average_delta']:.3f}",
+        f"- headline_pass: {summary['headline_pass']}",
+        f"- sign_of_life_pass: {summary['sign_of_life_pass']}",
+        "",
+        f"## {task_spec.track_id}",
+        f"- delta_active_vs_trunk: {track_payload.get('delta_active_vs_trunk', 0.0):.3f}",
+        f"- delta_noop_vs_trunk: {track_payload.get('delta_noop_vs_trunk', 0.0):.3f}",
+        f"- signs_of_life: {track_payload.get('signs_of_life', False)}",
+    ]
+    if "delta_active_vs_trunk_ci95" in track_payload:
+        low, high = track_payload["delta_active_vs_trunk_ci95"]
+        lines.append(f"- delta_active_vs_trunk_ci95: [{low:.3f}, {high:.3f}]")
+    for mode, mode_payload in track_payload["modes"].items():
+        lines.append(f"- {mode}: mean_success={mode_payload['mean_success']:.3f}")
+    lines.append("")
+    md_path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
+    return summary
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run a fair bridge-scene retrieval smoke for bag or cloth proxy tasks.")
+    parser.add_argument("--task", choices=sorted(TASK_SPECS), required=True)
+    parser.add_argument("--dataset-seed", type=int, default=DEFAULT_SEED)
+    parser.add_argument("--train-seed", type=int, default=DEFAULT_SEED)
+    parser.add_argument("--eval-split", choices=("val", "eval"), default="eval")
+    parser.add_argument("--report-dir", type=Path, default=None)
+    parser.add_argument("--skip-collection", action="store_true")
+    parser.add_argument("--skip-train", action="store_true")
+    parser.add_argument("--skip-eval", action="store_true")
+    parser.add_argument("--reuse-dataset", action="store_true")
+    parser.add_argument("--reuse-checkpoints", action="store_true")
+    parser.add_argument("--adapter-confidence-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-access-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-persistence-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-support-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-reocclusion-threshold", type=float, default=None)
+    parser.add_argument("--planner-mode-preference-bonus", type=float, default=None)
+    parser.add_argument("--planner-premature-retrieve-penalty", type=float, default=None)
+    parser.add_argument("--planner-premature-insert-penalty", type=float, default=None)
+    parser.add_argument("--planner-premature-occlusion-sweep-penalty", type=float, default=None)
+    parser.add_argument("--planner-premature-maintain-penalty", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-access-threshold", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-reveal-threshold", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-persistence-threshold", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-support-threshold", type=float, default=None)
+    parser.add_argument("--planner-insert-stage-access-threshold", type=float, default=None)
+    parser.add_argument("--planner-insert-stage-visibility-threshold", type=float, default=None)
+    parser.add_argument("--planner-insert-stage-support-threshold", type=float, default=None)
+    parser.add_argument("--planner-occlusion-maintain-gap-min-access", type=float, default=None)
+    parser.add_argument("--planner-occlusion-maintain-gap-min-visibility", type=float, default=None)
+    return parser.parse_args()
+
+
+def _planner_overrides_from_args(args: argparse.Namespace) -> dict[str, float]:
+    overrides = {
+        "adapter_confidence_threshold": SMOKE_ADAPTER_CONFIDENCE_THRESHOLD,
+        "retrieve_access_threshold": SMOKE_RETRIEVE_ACCESS_THRESHOLD,
+        "retrieve_persistence_threshold": SMOKE_RETRIEVE_PERSISTENCE_THRESHOLD,
+        "retrieve_support_threshold": SMOKE_RETRIEVE_SUPPORT_THRESHOLD,
+        "retrieve_reocclusion_threshold": SMOKE_RETRIEVE_REOCCLUSION_THRESHOLD,
+    }
+    optional_pairs = (
+        ("adapter_confidence_threshold", args.adapter_confidence_threshold),
+        ("retrieve_access_threshold", args.retrieve_access_threshold),
+        ("retrieve_persistence_threshold", args.retrieve_persistence_threshold),
+        ("retrieve_support_threshold", args.retrieve_support_threshold),
+        ("retrieve_reocclusion_threshold", args.retrieve_reocclusion_threshold),
+        ("mode_preference_bonus", args.planner_mode_preference_bonus),
+        ("premature_retrieve_penalty", args.planner_premature_retrieve_penalty),
+        ("premature_insert_penalty", args.planner_premature_insert_penalty),
+        ("premature_occlusion_sweep_penalty", args.planner_premature_occlusion_sweep_penalty),
+        ("premature_maintain_penalty", args.planner_premature_maintain_penalty),
+        ("retrieve_stage_access_threshold", args.planner_retrieve_stage_access_threshold),
+        ("retrieve_stage_reveal_threshold", args.planner_retrieve_stage_reveal_threshold),
+        ("retrieve_stage_persistence_threshold", args.planner_retrieve_stage_persistence_threshold),
+        ("retrieve_stage_support_threshold", args.planner_retrieve_stage_support_threshold),
+        ("insert_stage_access_threshold", args.planner_insert_stage_access_threshold),
+        ("insert_stage_visibility_threshold", args.planner_insert_stage_visibility_threshold),
+        ("insert_stage_support_threshold", args.planner_insert_stage_support_threshold),
+        ("occlusion_maintain_gap_min_access", args.planner_occlusion_maintain_gap_min_access),
+        ("occlusion_maintain_gap_min_visibility", args.planner_occlusion_maintain_gap_min_visibility),
+    )
+    for key, value in optional_pairs:
+        if value is not None:
+            overrides[key] = value
+    return overrides
+
+
+def main() -> None:
+    args = _parse_args()
+    task_spec = _task_spec(args.task)
+    spec = SmokeSpec(dataset_seed=int(args.dataset_seed), train_seed=int(args.train_seed))
+    canonical_chunks = _canonical_chunks(task_spec)
+    paths = _default_paths(task_spec)
+    report_dir = args.report_dir or paths.report_dir
+    planner_overrides = _planner_overrides_from_args(args)
+    split_path = _dataset_artifact_path(paths.data_dir, "episode_splits.json", dataset_seed=spec.dataset_seed)
+    if split_path.exists():
+        episode_splits = json.loads(split_path.read_text(encoding="utf-8"))
+    else:
+        episode_splits = _build_episode_splits(task_spec, spec)
+        _save_episode_splits(split_path, episode_splits)
+
+    train_path = _dataset_artifact_path(paths.data_dir, "train.pt", dataset_seed=spec.dataset_seed)
+    val_path = _dataset_artifact_path(paths.data_dir, "val.pt", dataset_seed=spec.dataset_seed)
+    if args.skip_collection and (not train_path.exists() or not val_path.exists()):
+        raise FileNotFoundError("Requested --skip-collection but cached dataset files are missing.")
+    if not args.skip_collection and (not args.reuse_dataset or not train_path.exists() or not val_path.exists()):
+        train_payload = _collect_split(
+            task_spec=task_spec,
+            canonical_chunks=canonical_chunks,
+            split_name="train",
+            seeds=episode_splits["train"],
+            spec=spec,
+            output_path=train_path,
+        )
+        val_payload = _collect_split(
+            task_spec=task_spec,
+            canonical_chunks=canonical_chunks,
+            split_name="val",
+            seeds=episode_splits["val"],
+            spec=spec,
+            output_path=val_path,
+        )
+    else:
+        train_payload = torch.load(train_path, map_location="cpu", weights_only=False)
+        val_payload = torch.load(val_path, map_location="cpu", weights_only=False)
+
+    train_samples = _normalize_cached_samples(train_payload["samples"])
+    val_samples = _normalize_cached_samples(val_payload["samples"])
+    checkpoints: dict[str, Path] = {}
+    train_specs: dict[str, dict[str, Any]] = {}
+    for variant in ("trunk_only_ft", "adapter_active_ft"):
+        variant_output_dir = paths.output_dir / f"{variant}_seed{spec.train_seed}"
+        checkpoint_path = variant_output_dir / "checkpoint_best.pt"
+        if args.skip_train and not checkpoint_path.exists():
+            raise FileNotFoundError(f"Requested --skip-train but checkpoint is missing: {checkpoint_path}")
+        if not args.skip_train and (not args.reuse_checkpoints or not checkpoint_path.exists()):
+            checkpoint_path, train_spec = _train_variant(
+                task_spec=task_spec,
+                variant=variant,
+                train_samples=train_samples,
+                val_samples=val_samples,
+                spec=spec,
+                output_dir=variant_output_dir,
+            )
+        else:
+            summary_path = variant_output_dir / "summary.json"
+            if not summary_path.exists():
+                raise FileNotFoundError(f"Missing cached summary file for {variant}: {summary_path}")
+            summary_payload = json.loads(summary_path.read_text(encoding="utf-8"))
+            train_spec = summary_payload["train_spec"]
+        checkpoints[variant] = checkpoint_path
+        train_specs[variant] = train_spec
+
+    results: list[dict[str, Any]] = []
+    if not args.skip_eval:
+        eval_plan = (
+            ("trunk_only_ft", checkpoints["trunk_only_ft"], "trunk_only", None),
+            ("adapter_noop", checkpoints["adapter_active_ft"], "adapter_noop", None),
+            ("adapter_active_ft", checkpoints["adapter_active_ft"], "adapter_active", train_specs["adapter_active_ft"]),
+        )
+        for result_mode_name, checkpoint_path, adapter_mode, train_spec in eval_plan:
+            result = _evaluate_checkpoint(
+                task_spec=task_spec,
+                canonical_chunks=canonical_chunks,
+                checkpoint_path=checkpoint_path,
+                adapter_mode=adapter_mode,
+                result_mode_name=result_mode_name,
+                seeds=episode_splits[args.eval_split],
+                report_path=report_dir / f"{result_mode_name}_seed{spec.train_seed}.json",
+                train_spec=train_spec if result_mode_name != "adapter_noop" else None,
+                planner_overrides=planner_overrides,
+            )
+            if result_mode_name == "trunk_only_ft":
+                result["train_spec"] = train_specs["trunk_only_ft"]
+                (report_dir / f"{result_mode_name}_seed{spec.train_seed}.json").write_text(
+                    json.dumps(result, indent=2) + "\n",
+                    encoding="utf-8",
+                )
+            results.append(result)
+        _summarize_task(task_spec, results, report_dir)
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests4/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/run_maniskill_pickclutter_smoke.py

@@ -0,0 +1,2005 @@
+from __future__ import annotations
+
+import argparse
+import collections
+import json
+import math
+import os
+import time
+from collections import deque
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterable, Sequence
+
+import numpy as np
+import torch
+from omegaconf import OmegaConf
+from torch import Tensor
+from torch.utils.data import DataLoader, Dataset
+
+from eval.public_benchmark_package import build_public_eval_protocol, build_target_training_spec
+from models.action_decoder import ChunkDecoderConfig, semantic_macro_chunk
+from models.backbones import FrozenVLBackboneConfig
+from models.multiview_fusion import MultiViewFusionConfig
+from models.observation_memory import ObservationMemoryConfig
+from models.planner import PlannerConfig
+from models.policy import PolicyConfig
+from models.reveal_head import RevealHeadConfig, TASK_METRIC_NAMES
+from models.world_model import RevealWMConfig
+from train.checkpoint_compat import filter_compatible_state_dict
+from train.losses import LossWeights
+from train.trainer import BimanualTrainer, TrainerConfig, apply_trainable_parameter_prefixes, build_policy
+
+
+def _configure_runtime_env() -> None:
+    os.environ.setdefault("VK_ICD_FILENAMES", "/workspace/runtime/vulkan/icd.d/nvidia_icd_egl.json")
+    os.environ.setdefault("VK_LAYER_PATH", "/workspace/runtime/vulkan/implicit_layer.d")
+    os.environ.setdefault("XDG_RUNTIME_DIR", "/tmp/runtime-root")
+    os.environ.setdefault("MS_ASSET_DIR", "/workspace/data/maniskill")
+
+
+_configure_runtime_env()
+
+import mani_skill.envs  # noqa: E402
+import sapien  # noqa: E402
+from mani_skill.envs.tasks.tabletop.pick_clutter_ycb import PickClutterYCBEnv  # noqa: E402
+from mani_skill.sensors.camera import CameraConfig  # noqa: E402
+from mani_skill.utils import sapien_utils  # noqa: E402
+from mani_skill.utils.structs import Pose  # noqa: E402
+
+from eval.run_public_benchmark_package import summarize_public_benchmark_package  # noqa: E402
+from models.action_decoder import TASK_INDEX  # noqa: E402
+from train.run_experiment import _load_init_checkpoint, _move_batch_to_device  # noqa: E402
+
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+WORKSPACE_ROOT = Path("/workspace/workspace")
+SMOKE_VERSION = "smoke_v5"
+DEFAULT_DATA_DIR = WORKSPACE_ROOT / "data" / "maniskill_pickclutter" / SMOKE_VERSION
+DEFAULT_OUTPUT_DIR = WORKSPACE_ROOT / "outputs" / f"maniskill_pickclutter_{SMOKE_VERSION}"
+DEFAULT_REPORT_DIR = WORKSPACE_ROOT / "reports" / f"maniskill_pickclutter_{SMOKE_VERSION}"
+DEFAULT_INIT_CHECKPOINT = Path(
+    "/workspace/workspace/VLAarchtests2/VLAarchtests/artifacts/outputs/"
+    "r3d_handoff_phase/proxy_interaction_r3d_stage3_clip_rgbd_handoff_compact_phase_seed17/checkpoint_best.pt"
+)
+
+TEXT_PROMPT = "retrieve the target object from dense clutter and stage it at the front edge"
+TASK_NAME = "foliage"
+TASK_ID = TASK_INDEX[TASK_NAME]
+CAMERA_NAMES = ("front", "left", "right")
+MODE_ORDER = (
+    "base_action",
+    "sweep_left",
+    "sweep_right",
+    "pin_canopy",
+    "widen_gap",
+    "maintain_gap",
+    "insert_actor",
+    "retrieve",
+)
+ROLL_OUT_HORIZON = 5
+NUM_SUPPORT_MODES = 3
+NUM_APPROACH_TEMPLATES = 32
+SUPPORT_MODE_HOLD = 0
+SUPPORT_MODE_TRANSFER = 1
+SUPPORT_MODE_PASSIVE = 2
+REVEAL_MODES = ("sweep_left", "sweep_right", "pin_canopy", "widen_gap", "maintain_gap")
+TRANSFER_MODES = ("insert_actor",)
+RETRIEVE_MODES = ("retrieve",)
+STATE_SUPERVISION_METRICS = (
+    "opening_quality",
+    "actor_feasibility_score",
+    "gap_width",
+    "damage_proxy",
+    "release_collapse_rate",
+    "target_visibility_confidence",
+    "insertable_actor_corridor",
+    "insertion_corridor",
+    "hold_quality",
+    "layer_separation_quality",
+    "fold_preservation",
+    "top_layer_stability",
+    "lift_too_much_risk",
+)
+MAX_MACRO_STEPS = 4
+HISTORY_STEPS = 6
+PROPRIO_DIM = 32
+EXTRACTION_LINE_Y = -0.22
+MIN_CLEARANCE_FOR_SUCCESS = 0.05
+DEFAULT_SEED = 17
+SMOKE_ADAPTER_CONFIDENCE_THRESHOLD = 0.50
+SMOKE_RETRIEVE_ACCESS_THRESHOLD = 0.08
+SMOKE_RETRIEVE_PERSISTENCE_THRESHOLD = 0.12
+SMOKE_RETRIEVE_SUPPORT_THRESHOLD = 0.08
+SMOKE_RETRIEVE_REOCCLUSION_THRESHOLD = 0.92
+
+
+@dataclass(frozen=True)
+class SmokePaths:
+    data_dir: Path = DEFAULT_DATA_DIR
+    output_dir: Path = DEFAULT_OUTPUT_DIR
+    report_dir: Path = DEFAULT_REPORT_DIR
+
+
+@dataclass(frozen=True)
+class SmokeSpec:
+    resolution: int = 224
+    train_episodes: int = 32
+    val_episodes: int = 8
+    eval_episodes: int = 50
+    dataset_seed: int = DEFAULT_SEED
+    train_seed: int = DEFAULT_SEED
+    history_steps: int = HISTORY_STEPS
+    max_macro_steps: int = MAX_MACRO_STEPS
+    batch_size: int = 4
+    epochs: int = 6
+    num_workers: int = 16
+    learning_rate: float = 1e-4
+    weight_decay: float = 1e-4
+
+    @property
+    def seed(self) -> int:
+        return self.train_seed
+
+
+def _apply_smoke_planner_overrides(
+    policy_config: PolicyConfig,
+    planner_overrides: dict[str, float] | None = None,
+) -> PolicyConfig:
+    policy_config.planner.adapter_confidence_threshold = SMOKE_ADAPTER_CONFIDENCE_THRESHOLD
+    policy_config.planner.retrieve_access_threshold = SMOKE_RETRIEVE_ACCESS_THRESHOLD
+    policy_config.planner.retrieve_persistence_threshold = SMOKE_RETRIEVE_PERSISTENCE_THRESHOLD
+    policy_config.planner.retrieve_support_threshold = SMOKE_RETRIEVE_SUPPORT_THRESHOLD
+    policy_config.planner.retrieve_reocclusion_threshold = SMOKE_RETRIEVE_REOCCLUSION_THRESHOLD
+    if planner_overrides:
+        for key, value in planner_overrides.items():
+            if value is None:
+                continue
+            setattr(policy_config.planner, key, value)
+    return policy_config
+
+
+class PickClutterRevealEnv(PickClutterYCBEnv):
+    @property
+    def _default_sensor_configs(self):
+        resolution = 224
+        return [
+            CameraConfig(
+                "front",
+                pose=sapien_utils.look_at(eye=[0.30, 0.00, 0.62], target=[-0.06, 0.00, 0.04]),
+                width=resolution,
+                height=resolution,
+                fov=np.pi / 2,
+                near=0.01,
+                far=100.0,
+            ),
+            CameraConfig(
+                "left",
+                pose=sapien_utils.look_at(eye=[0.22, 0.34, 0.34], target=[-0.02, 0.02, 0.03]),
+                width=resolution,
+                height=resolution,
+                fov=np.pi / 2,
+                near=0.01,
+                far=100.0,
+            ),
+            CameraConfig(
+                "right",
+                pose=sapien_utils.look_at(eye=[0.22, -0.34, 0.34], target=[-0.02, -0.02, 0.03]),
+                width=resolution,
+                height=resolution,
+                fov=np.pi / 2,
+                near=0.01,
+                far=100.0,
+            ),
+        ]
+
+
+def _np(value: Any, *, dtype: np.dtype | None = None) -> np.ndarray:
+    if isinstance(value, np.ndarray):
+        array = value
+    elif isinstance(value, Tensor):
+        array = value.detach().cpu().numpy()
+    else:
+        array = np.asarray(value)
+    if dtype is not None:
+        array = array.astype(dtype, copy=False)
+    return array
+
+
+def _vec3(value: Any) -> np.ndarray:
+    return _np(value, dtype=np.float32).reshape(-1)[:3]
+
+
+def _camera_intrinsic_from_param(param: dict[str, Any]) -> np.ndarray:
+    for key in ("intrinsic_cv", "intrinsic", "cam_intrinsic"):
+        if key in param:
+            matrix = _np(param[key], dtype=np.float32)
+            return matrix[0] if matrix.ndim == 3 else matrix
+    return np.eye(3, dtype=np.float32)
+
+
+def _camera_extrinsic_from_param(param: dict[str, Any]) -> np.ndarray:
+    for key in ("cam2world_gl", "cam2world", "extrinsic_cv", "extrinsic"):
+        if key in param:
+            matrix = _np(param[key], dtype=np.float32)
+            return matrix[0] if matrix.ndim == 3 else matrix
+    return np.eye(4, dtype=np.float32)
+
+
+def _convert_depth(depth: np.ndarray) -> np.ndarray:
+    depth = depth.astype(np.float32, copy=False)
+    if np.issubdtype(depth.dtype, np.integer):
+        depth = depth / 1000.0
+    return depth
+
+
+def _build_proprio(env: PickClutterRevealEnv) -> np.ndarray:
+    base = env.unwrapped
+    qpos = _np(base.agent.robot.get_qpos(), dtype=np.float32).reshape(-1)
+    qvel = _np(base.agent.robot.get_qvel(), dtype=np.float32).reshape(-1)
+    tcp_pose = _np(base.agent.tcp.pose.raw_pose, dtype=np.float32).reshape(-1)
+    gripper_width = qpos[-2:].sum(keepdims=True).astype(np.float32)
+    pieces = [qpos, qvel, tcp_pose, gripper_width]
+    flat = np.concatenate(pieces, axis=0)
+    if flat.shape[0] >= PROPRIO_DIM:
+        return flat[:PROPRIO_DIM]
+    padded = np.zeros((PROPRIO_DIM,), dtype=np.float32)
+    padded[: flat.shape[0]] = flat
+    return padded
+
+
+def _extract_sensor_bundle(obs: dict[str, Any]) -> dict[str, np.ndarray]:
+    sensor_data = obs["sensor_data"]
+    sensor_param = obs["sensor_param"]
+    rgb_views: list[np.ndarray] = []
+    depth_views: list[np.ndarray] = []
+    seg_views: list[np.ndarray] = []
+    intrinsics: list[np.ndarray] = []
+    extrinsics: list[np.ndarray] = []
+    for camera_name in CAMERA_NAMES:
+        view = sensor_data[camera_name]
+        param = sensor_param[camera_name]
+        rgb = _np(view["rgb"], dtype=np.uint8)
+        depth = _np(view["depth"])
+        segmentation = _np(view["segmentation"])
+        rgb = rgb[0] if rgb.ndim == 4 else rgb
+        depth = depth[0] if depth.ndim == 4 else depth
+        segmentation = segmentation[0] if segmentation.ndim == 4 else segmentation
+        if depth.ndim == 3 and depth.shape[-1] == 1:
+            depth = depth[..., 0]
+        if segmentation.ndim == 3 and segmentation.shape[-1] == 1:
+            segmentation = segmentation[..., 0]
+        rgb_views.append(rgb.astype(np.uint8, copy=False))
+        depth_views.append(_convert_depth(depth))
+        seg_views.append(segmentation.astype(np.int32, copy=False))
+        intrinsics.append(_camera_intrinsic_from_param(param))
+        extrinsics.append(_camera_extrinsic_from_param(param))
+    depth_stack = np.stack(depth_views, axis=0).astype(np.float32)
+    depth_valid = (depth_stack > 1e-5).astype(np.float32)
+    return {
+        "images": np.stack(rgb_views, axis=0),
+        "depths": depth_stack[:, None, :, :],
+        "depth_valid": depth_valid[:, None, :, :],
+        "segmentations": np.stack(seg_views, axis=0),
+        "camera_intrinsics": np.stack(intrinsics, axis=0).astype(np.float32),
+        "camera_extrinsics": np.stack(extrinsics, axis=0).astype(np.float32),
+    }
+
+
+def _target_actor(env: PickClutterRevealEnv) -> Any:
+    return env.unwrapped.target_object._objs[0]
+
+
+def _all_scene_actors(env: PickClutterRevealEnv) -> list[Any]:
+    return list(env.unwrapped.all_objects._objs)
+
+
+def _target_position(env: PickClutterRevealEnv) -> np.ndarray:
+    return _vec3(_target_actor(env).pose.p)
+
+
+def _all_positions(env: PickClutterRevealEnv) -> dict[str, np.ndarray]:
+    return {actor.name: _vec3(actor.pose.p) for actor in _all_scene_actors(env)}
+
+
+def _nearest_non_target_distance(env: PickClutterRevealEnv) -> float:
+    target = _target_actor(env)
+    target_xy = _vec3(target.pose.p)[:2]
+    distances = []
+    for actor in _all_scene_actors(env):
+        if actor.name == target.name:
+            continue
+        distances.append(float(np.linalg.norm(_vec3(actor.pose.p)[:2] - target_xy)))
+    if not distances:
+        return 1.0
+    return float(min(distances))
+
+
+def _success_from_state(env: PickClutterRevealEnv) -> bool:
+    target = _target_position(env)
+    return bool(target[1] <= EXTRACTION_LINE_Y and _nearest_non_target_distance(env) >= MIN_CLEARANCE_FOR_SUCCESS)
+
+
+def _clearance_score(env: PickClutterRevealEnv) -> float:
+    return float(np.clip((_nearest_non_target_distance(env) - 0.03) / 0.09, 0.0, 1.0))
+
+
+def _extraction_progress(env: PickClutterRevealEnv) -> float:
+    y_value = _target_position(env)[1]
+    return float(np.clip(((-0.05) - y_value) / ((-0.05) - EXTRACTION_LINE_Y), 0.0, 1.0))
+
+
+def _target_visibility(obs_bundle: dict[str, np.ndarray], target_seg_id: int) -> float:
+    segmentation = obs_bundle["segmentations"]
+    fractions = [(view == int(target_seg_id)).mean() for view in segmentation]
+    return float(np.clip(np.mean(fractions) * 80.0, 0.0, 1.0))
+
+
+def _snapshot_env(env: PickClutterRevealEnv) -> dict[str, Any]:
+    base = env.unwrapped
+    return {
+        "state_dict": base.get_state_dict(),
+        "goal_pos": _np(base.goal_pos, dtype=np.float32).copy(),
+    }
+
+
+def _restore_env(env: PickClutterRevealEnv, snapshot: dict[str, Any]) -> None:
+    base = env.unwrapped
+    state_dict = snapshot["state_dict"]
+    goal_pos = torch.as_tensor(snapshot["goal_pos"], dtype=torch.float32, device=base.device)
+    base.set_state_dict(state_dict)
+    base.goal_pos = goal_pos.view_as(base.goal_pos)
+    base.goal_site.set_pose(Pose.create_from_pq(base.goal_pos))
+
+
+def _sync_env_state(src_env: PickClutterRevealEnv, dst_env: PickClutterRevealEnv) -> None:
+    _restore_env(dst_env, _snapshot_env(src_env))
+
+
+def _canonical_chunks() -> dict[str, np.ndarray]:
+    base = torch.zeros((1, 8, 14), dtype=torch.float32)
+    chunks: dict[str, np.ndarray] = {"base_action": base.squeeze(0).numpy().astype(np.float32)}
+    for mode_name in MODE_ORDER[1:]:
+        chunk = semantic_macro_chunk(base, task_name=TASK_NAME, mode_name=mode_name).squeeze(0).cpu().numpy()
+        chunks[mode_name] = chunk.astype(np.float32)
+    return chunks
+
+
+CANONICAL_CHUNKS = _canonical_chunks()
+STATE_METRIC_MASK = np.asarray(
+    [metric_name in STATE_SUPERVISION_METRICS for metric_name in TASK_METRIC_NAMES],
+    dtype=np.bool_,
+)
+
+
+def _classify_mode_from_chunk(chunk: np.ndarray) -> str:
+    candidate = np.asarray(chunk, dtype=np.float32)
+    distances = {
+        mode_name: float(np.mean(np.abs(candidate - prototype)))
+        for mode_name, prototype in CANONICAL_CHUNKS.items()
+    }
+    return min(distances, key=distances.get)
+
+
+def _gripper_action(open_gripper: bool) -> float:
+    return 1.0 if open_gripper else -1.0
+
+
+def _repeat_delta(env: PickClutterRevealEnv, delta_xyz: Sequence[float], *, open_gripper: bool, steps: int) -> dict[str, Any]:
+    last_obs: dict[str, Any] | None = None
+    action = np.zeros((1, 4), dtype=np.float32)
+    action[0, :3] = np.asarray(delta_xyz, dtype=np.float32)
+    action[0, 3] = _gripper_action(open_gripper)
+    for _ in range(int(steps)):
+        obs, _, terminated, truncated, info = env.step(action)
+        last_obs = obs
+        if bool(np.asarray(terminated).reshape(-1)[0]) or bool(np.asarray(truncated).reshape(-1)[0]):
+            break
+    return {
+        "obs": last_obs if last_obs is not None else env.get_obs(env.get_info()),
+        "terminated": False,
+        "truncated": False,
+        "info": info if last_obs is not None else env.get_info(),
+    }
+
+
+def _move_tcp_to(
+    env: PickClutterRevealEnv,
+    target_xyz: Sequence[float],
+    *,
+    open_gripper: bool,
+    max_steps: int = 120,
+    tolerance: float = 0.008,
+) -> dict[str, Any]:
+    last_obs: dict[str, Any] | None = None
+    target = np.asarray(target_xyz, dtype=np.float32)
+    info = env.get_info()
+    for _ in range(int(max_steps)):
+        tcp = _vec3(env.unwrapped.agent.tcp.pose.p)
+        delta = target - tcp
+        if float(np.linalg.norm(delta)) <= float(tolerance):
+            break
+        action = np.zeros((1, 4), dtype=np.float32)
+        action[0, :3] = np.clip(delta / 0.04, -1.0, 1.0)
+        action[0, 3] = _gripper_action(open_gripper)
+        obs, _, terminated, truncated, info = env.step(action)
+        last_obs = obs
+        if bool(np.asarray(terminated).reshape(-1)[0]) or bool(np.asarray(truncated).reshape(-1)[0]):
+            break
+    return {
+        "obs": last_obs if last_obs is not None else env.get_obs(info),
+        "info": info,
+    }
+
+
+def _find_path_blocker(env: PickClutterRevealEnv) -> np.ndarray | None:
+    target = _target_position(env)
+    target_name = _target_actor(env).name
+    blockers: list[tuple[float, np.ndarray]] = []
+    for actor in _all_scene_actors(env):
+        if actor.name == target_name:
+            continue
+        position = _vec3(actor.pose.p)
+        if position[1] <= target[1] + 0.06 and abs(position[0] - target[0]) <= 0.10:
+            blockers.append((float(np.linalg.norm(position[:2] - target[:2])), position))
+    if blockers:
+        blockers.sort(key=lambda item: item[0])
+        return blockers[0][1]
+    nearest: tuple[float, np.ndarray] | None = None
+    for actor in _all_scene_actors(env):
+        if actor.name == target_name:
+            continue
+        position = _vec3(actor.pose.p)
+        distance = float(np.linalg.norm(position[:2] - target[:2]))
+        if nearest is None or distance < nearest[0]:
+            nearest = (distance, position)
+    return None if nearest is None else nearest[1]
+
+
+def _execute_push(
+    env: PickClutterRevealEnv,
+    *,
+    anchor_xyz: np.ndarray,
+    pre_offset: np.ndarray,
+    push_delta: np.ndarray,
+    push_steps: int,
+) -> dict[str, Any]:
+    _move_tcp_to(env, anchor_xyz + np.array([0.0, 0.0, 0.08], dtype=np.float32) + pre_offset, open_gripper=True)
+    _move_tcp_to(env, anchor_xyz + pre_offset, open_gripper=True, max_steps=100, tolerance=0.010)
+    result = _repeat_delta(env, push_delta, open_gripper=True, steps=push_steps)
+    _move_tcp_to(
+        env,
+        np.array([_vec3(env.unwrapped.agent.tcp.pose.p)[0], _vec3(env.unwrapped.agent.tcp.pose.p)[1], 0.10], dtype=np.float32),
+        open_gripper=True,
+        max_steps=80,
+        tolerance=0.012,
+    )
+    return result
+
+
+def _execute_mode(env: PickClutterRevealEnv, mode_name: str) -> dict[str, Any]:
+    target = _target_position(env)
+    blocker = _find_path_blocker(env)
+    if mode_name == "retrieve":
+        return _execute_push(
+            env,
+            anchor_xyz=target,
+            pre_offset=np.array([0.0, 0.035, 0.026], dtype=np.float32),
+            push_delta=np.array([0.0, -0.7, 0.0], dtype=np.float32),
+            push_steps=18,
+        )
+    if mode_name == "insert_actor":
+        return _execute_push(
+            env,
+            anchor_xyz=target,
+            pre_offset=np.array([0.0, 0.045, 0.028], dtype=np.float32),
+            push_delta=np.array([0.0, -0.4, 0.0], dtype=np.float32),
+            push_steps=10,
+        )
+    if mode_name == "widen_gap":
+        anchor = blocker if blocker is not None else target
+        direction = -1.0 if anchor[0] >= target[0] else 1.0
+        return _execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([0.0, 0.025, 0.028], dtype=np.float32),
+            push_delta=np.array([0.75 * direction, -0.12, 0.0], dtype=np.float32),
+            push_steps=18,
+        )
+    if mode_name == "sweep_left":
+        anchor = blocker if blocker is not None else target
+        return _execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([0.015, 0.025, 0.028], dtype=np.float32),
+            push_delta=np.array([-0.70, -0.10, 0.0], dtype=np.float32),
+            push_steps=14,
+        )
+    if mode_name == "sweep_right":
+        anchor = blocker if blocker is not None else target
+        return _execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([-0.015, 0.025, 0.028], dtype=np.float32),
+            push_delta=np.array([0.70, -0.10, 0.0], dtype=np.float32),
+            push_steps=14,
+        )
+    if mode_name == "pin_canopy":
+        anchor = blocker if blocker is not None else target
+        return _execute_push(
+            env,
+            anchor_xyz=anchor,
+            pre_offset=np.array([0.0, -0.015, 0.028], dtype=np.float32),
+            push_delta=np.array([0.0, 0.35, 0.0], dtype=np.float32),
+            push_steps=10,
+        )
+    if mode_name in {"maintain_gap", "base_action"}:
+        _move_tcp_to(
+            env,
+            np.array([target[0], target[1] + 0.02, 0.10], dtype=np.float32),
+            open_gripper=True,
+            max_steps=60,
+            tolerance=0.015,
+        )
+        return _repeat_delta(env, np.array([0.0, -0.10, 0.0], dtype=np.float32), open_gripper=True, steps=4)
+    raise KeyError(f"Unsupported mode: {mode_name}")
+
+
+def _candidate_metrics(
+    env: PickClutterRevealEnv,
+    *,
+    start_positions: dict[str, np.ndarray],
+    current_obs_bundle: dict[str, np.ndarray] | None = None,
+) -> dict[str, float]:
+    positions = _all_positions(env)
+    target_name = _target_actor(env).name
+    non_target_displacements = []
+    for name, start_position in start_positions.items():
+        if name == target_name or name not in positions:
+            continue
+        non_target_displacements.append(float(np.linalg.norm((positions[name] - start_position)[:2])))
+    disturbance = float(np.clip(np.mean(non_target_displacements) / 0.10, 0.0, 1.0)) if non_target_displacements else 0.0
+    visibility = 0.0
+    if current_obs_bundle is not None:
+        visibility = _target_visibility(current_obs_bundle, getattr(_target_actor(env), "per_scene_id", -1))
+    return {
+        "retrieval_success": float(_success_from_state(env)),
+        "disturbance": disturbance,
+        "visibility": visibility,
+        "clearance": _clearance_score(env),
+        "progress": _extraction_progress(env),
+    }
+
+
+def _mean_non_target_displacement(
+    start_positions: dict[str, np.ndarray],
+    current_positions: dict[str, np.ndarray],
+    *,
+    target_name: str,
+) -> float:
+    displacements = []
+    for actor_name, start_position in start_positions.items():
+        if actor_name == target_name or actor_name not in current_positions:
+            continue
+        displacements.append(float(np.linalg.norm((current_positions[actor_name] - start_position)[:2])))
+    if not displacements:
+        return 0.0
+    return float(np.mean(displacements))
+
+
+def _current_state_targets(
+    env: PickClutterRevealEnv,
+    *,
+    obs_bundle: dict[str, np.ndarray],
+    candidate_metrics: Sequence[dict[str, float]],
+    episode_start_positions: dict[str, np.ndarray],
+    selected_mode: str,
+) -> dict[str, Any]:
+    metrics_by_name = {mode_name: payload for mode_name, payload in zip(MODE_ORDER, candidate_metrics)}
+    current_positions = _all_positions(env)
+    target_name = _target_actor(env).name
+    current_disturbance = float(
+        np.clip(
+            _mean_non_target_displacement(
+                episode_start_positions,
+                current_positions,
+                target_name=target_name,
+            )
+            / 0.10,
+            0.0,
+            1.0,
+        )
+    )
+    current_visibility = _target_visibility(obs_bundle, getattr(_target_actor(env), "per_scene_id", -1))
+    current_clearance = _clearance_score(env)
+    current_progress = _extraction_progress(env)
+    base_gap = float(np.clip(max(current_clearance, current_progress), 0.0, 1.0))
+    support_stability = float(np.clip(1.0 - 0.5 * current_disturbance, 0.0, 1.0))
+    hold_quality = float(np.clip(0.5 * (support_stability + max(current_clearance, current_progress)), 0.0, 1.0))
+    opening_quality = float(
+        np.clip(0.55 * current_progress + 0.25 * current_clearance + 0.20 * current_visibility, 0.0, 1.0)
+    )
+    actor_feasibility = float(np.clip(0.6 * current_clearance + 0.4 * max(current_visibility, current_progress), 0.0, 1.0))
+    reocclusion_rate = float(np.clip(1.0 - max(current_clearance, current_visibility), 0.0, 1.0))
+    insertable_actor_corridor = float(np.clip(0.6 * actor_feasibility + 0.4 * base_gap, 0.0, 1.0))
+    insertion_corridor = float(np.clip(0.5 * actor_feasibility + 0.5 * base_gap, 0.0, 1.0))
+    layer_separation = float(np.clip(0.7 * base_gap + 0.3 * actor_feasibility, 0.0, 1.0))
+    fold_preservation = float(np.clip(1.0 - current_disturbance, 0.0, 1.0))
+    lift_too_much_risk = float(np.clip(current_disturbance + 0.5 * max(base_gap - 0.5, 0.0), 0.0, 1.0))
+    task_metrics = {
+        "opening_quality": opening_quality,
+        "actor_feasibility_score": actor_feasibility,
+        "gap_width": float(0.03 + 0.21 * base_gap),
+        "damage_proxy": current_disturbance,
+        "release_collapse_rate": reocclusion_rate,
+        "target_visibility_confidence": current_visibility,
+        "insertable_actor_corridor": insertable_actor_corridor,
+        "insertion_corridor": insertion_corridor,
+        "hold_quality": hold_quality,
+        "layer_separation_quality": layer_separation,
+        "fold_preservation": fold_preservation,
+        "top_layer_stability": support_stability,
+        "lift_too_much_risk": lift_too_much_risk,
+    }
+
+    base_metrics = metrics_by_name["base_action"]
+    insert_metrics = metrics_by_name["insert_actor"]
+    retrieve_metrics = metrics_by_name["retrieve"]
+    reveal_candidates = [metrics_by_name[mode_name] for mode_name in REVEAL_MODES]
+    reveal_access = max(candidate["candidate_actor_feasibility_auc"] for candidate in reveal_candidates)
+    reveal_reveal = max(candidate["candidate_reveal_achieved"] for candidate in reveal_candidates)
+    reveal_hold = max(candidate["candidate_hold_persistence"] for candidate in reveal_candidates)
+    reveal_visibility = max(candidate["candidate_visibility_integral"] for candidate in reveal_candidates)
+
+    reveal_corridor = float(
+        np.clip(
+            0.45 * opening_quality
+            + 0.30 * reveal_access
+            + 0.15 * reveal_reveal
+            + 0.10 * reveal_visibility
+            - 0.10 * current_disturbance,
+            0.0,
+            1.0,
+        )
+    )
+    transfer_corridor = float(
+        np.clip(
+            0.45 * insertable_actor_corridor
+            + 0.30 * insert_metrics["candidate_actor_feasibility_auc"]
+            + 0.15 * insert_metrics["candidate_reveal_achieved"]
+            + 0.10 * insert_metrics["candidate_visibility_integral"]
+            - 0.15 * current_disturbance,
+            0.0,
+            1.0,
+        )
+    )
+    passive_corridor = float(
+        np.clip(
+            0.55 * retrieve_metrics["candidate_retrieval_success"]
+            + 0.20 * retrieve_metrics["candidate_actor_feasibility_auc"]
+            + 0.15 * current_progress
+            + 0.10 * current_clearance
+            - 0.10 * current_disturbance,
+            0.0,
+            1.0,
+        )
+    )
+    corridor_feasible = np.stack(
+        [
+            np.full((NUM_APPROACH_TEMPLATES,), reveal_corridor, dtype=np.float32),
+            np.full((NUM_APPROACH_TEMPLATES,), transfer_corridor, dtype=np.float32),
+            np.full((NUM_APPROACH_TEMPLATES,), passive_corridor, dtype=np.float32),
+        ],
+        axis=0,
+    )
+    persistence_horizon = np.asarray(
+        [
+            ROLL_OUT_HORIZON
+            * float(np.clip(0.35 * hold_quality + 0.35 * reveal_hold + 0.30 * reveal_corridor, 0.0, 1.0)),
+            ROLL_OUT_HORIZON
+            * float(
+                np.clip(
+                    0.30 * hold_quality
+                    + 0.35 * insert_metrics["candidate_hold_persistence"]
+                    + 0.35 * transfer_corridor,
+                    0.0,
+                    1.0,
+                )
+            ),
+            ROLL_OUT_HORIZON
+            * float(
+                np.clip(
+                    0.25 * hold_quality
+                    + 0.35 * retrieve_metrics["candidate_hold_persistence"]
+                    + 0.40 * passive_corridor,
+                    0.0,
+                    1.0,
+                )
+            ),
+        ],
+        dtype=np.float32,
+    )
+
+    retrieve_margin = float(retrieve_metrics["candidate_utility"] - base_metrics["candidate_utility"])
+    insert_margin = float(insert_metrics["candidate_utility"] - base_metrics["candidate_utility"])
+    if selected_mode == "retrieve" or (retrieve_metrics["candidate_retrieval_success"] >= 0.5 and retrieve_margin >= 0.15):
+        support_mode = SUPPORT_MODE_PASSIVE
+    elif selected_mode == "insert_actor" or (insert_margin >= 0.15 and transfer_corridor >= 0.40):
+        support_mode = SUPPORT_MODE_TRANSFER
+    elif selected_mode in REVEAL_MODES or selected_mode == "maintain_gap":
+        support_mode = SUPPORT_MODE_HOLD
+    elif selected_mode == "base_action":
+        support_mode = SUPPORT_MODE_PASSIVE if passive_corridor >= 0.65 and retrieve_margin >= 0.05 else SUPPORT_MODE_HOLD
+    else:
+        support_mode = SUPPORT_MODE_HOLD
+
+    best_non_base_utility = max(float(payload["candidate_utility"]) for payload in candidate_metrics[1:])
+    intervention_warranted = selected_mode != "base_action" and best_non_base_utility >= float(base_metrics["candidate_utility"]) + 0.15
+
+    return {
+        "support_mode": int(support_mode),
+        "corridor_feasible": corridor_feasible,
+        "persistence_horizon": persistence_horizon,
+        "disturbance_cost": np.float32(current_disturbance),
+        "state_confidence_target": np.float32(1.0 if intervention_warranted else 0.0),
+        "task_metric_mask": STATE_METRIC_MASK.copy(),
+        **{metric_name: np.float32(metric_value) for metric_name, metric_value in task_metrics.items()},
+    }
+
+
+def _mode_support_mode(mode_name: str, current_support_mode: int) -> int:
+    if mode_name in REVEAL_MODES or mode_name == "maintain_gap":
+        return SUPPORT_MODE_HOLD
+    if mode_name in TRANSFER_MODES:
+        return SUPPORT_MODE_TRANSFER
+    if mode_name in RETRIEVE_MODES:
+        return SUPPORT_MODE_PASSIVE
+    return int(current_support_mode)
+
+
+def _mode_progress_schedule(mode_name: str) -> np.ndarray:
+    if mode_name in REVEAL_MODES:
+        return np.asarray([0.18, 0.38, 0.62, 0.84, 1.0], dtype=np.float32)
+    if mode_name in TRANSFER_MODES:
+        return np.asarray([0.22, 0.44, 0.66, 0.86, 1.0], dtype=np.float32)
+    if mode_name in RETRIEVE_MODES:
+        return np.asarray([0.34, 0.56, 0.76, 0.92, 1.0], dtype=np.float32)
+    return np.asarray([0.10, 0.22, 0.34, 0.44, 0.54], dtype=np.float32)
+
+
+def _scalar_rollout(start: float, end: float, schedule: np.ndarray) -> np.ndarray:
+    return np.clip((1.0 - schedule) * float(start) + schedule * float(end), 0.0, 1.0).astype(np.float32)
+
+
+def _candidate_rollout_targets(
+    *,
+    mode_name: str,
+    state_targets: dict[str, Any],
+    candidate_payload: dict[str, float],
+) -> dict[str, np.ndarray]:
+    schedule = _mode_progress_schedule(mode_name)
+    start_visibility = float(state_targets["target_visibility_confidence"])
+    start_access = float(state_targets["actor_feasibility_score"])
+    start_persistence = float(np.clip(state_targets["hold_quality"], 0.0, 1.0))
+    start_support = float(np.clip(state_targets["top_layer_stability"], 0.0, 1.0))
+    start_reocclusion = float(np.clip(state_targets["release_collapse_rate"], 0.0, 1.0))
+    start_disturbance = float(np.clip(state_targets["disturbance_cost"], 0.0, 1.0))
+    start_clearance = float(np.clip(state_targets["actor_feasibility_score"], 0.0, 1.0))
+    start_grasp = float(np.clip(max(start_visibility, start_access), 0.0, 1.0))
+
+    end_visibility = float(np.clip(candidate_payload["candidate_immediate_visibility"], 0.0, 1.0))
+    end_access = float(np.clip(candidate_payload["candidate_immediate_access"], 0.0, 1.0))
+    end_progress = float(np.clip(candidate_payload["candidate_immediate_progress"], 0.0, 1.0))
+    end_disturbance = float(np.clip(candidate_payload["candidate_immediate_disturbance"], 0.0, 1.0))
+    end_support = float(np.clip(candidate_payload["candidate_immediate_support_stability"], 0.0, 1.0))
+    end_persistence = float(np.clip(candidate_payload["candidate_immediate_hold_persistence"], 0.0, 1.0))
+    end_reocclusion = float(np.clip(candidate_payload["candidate_immediate_reocclusion"], 0.0, 1.0))
+    end_clearance = float(np.clip(max(end_access, end_progress), 0.0, 1.0))
+    end_grasp = float(np.clip(max(end_visibility, 0.5 * end_access + 0.5 * end_progress), 0.0, 1.0))
+
+    if mode_name in TRANSFER_MODES:
+        start_visibility = max(start_visibility, 0.35 * end_visibility)
+        start_access = max(start_access, 0.40 * end_access)
+        start_persistence = max(start_persistence, 0.45 * end_persistence)
+        start_support = max(start_support, 0.50 * end_support)
+    elif mode_name in RETRIEVE_MODES:
+        start_visibility = max(start_visibility, 0.55 * end_visibility)
+        start_access = max(start_access, 0.70 * end_access)
+        start_persistence = max(start_persistence, 0.65 * end_persistence)
+        start_support = max(start_support, 0.65 * end_support)
+        start_reocclusion = min(start_reocclusion, max(0.4 * end_reocclusion, 0.0))
+
+    visibility = _scalar_rollout(start_visibility, end_visibility, schedule)
+    access = _scalar_rollout(start_access, end_access, schedule)
+    persistence = _scalar_rollout(start_persistence, end_persistence, schedule)
+    support = _scalar_rollout(start_support, end_support, schedule)
+    reocclusion = _scalar_rollout(start_reocclusion, end_reocclusion, schedule)
+    disturbance = _scalar_rollout(start_disturbance, end_disturbance, schedule)
+    clearance = _scalar_rollout(start_clearance, end_clearance, schedule)
+    grasp = _scalar_rollout(start_grasp, end_grasp, schedule)
+
+    reveal_corridor = np.clip(
+        0.38 * visibility + 0.34 * access + 0.22 * support - 0.12 * disturbance,
+        0.0,
+        1.0,
+    )
+    transfer_corridor = np.clip(
+        0.30 * visibility + 0.38 * access + 0.18 * persistence + 0.14 * support - 0.12 * disturbance,
+        0.0,
+        1.0,
+    )
+    passive_corridor = np.clip(
+        0.22 * visibility + 0.42 * access + 0.20 * persistence + 0.16 * grasp - 0.14 * disturbance - 0.10 * reocclusion,
+        0.0,
+        1.0,
+    )
+    if mode_name in REVEAL_MODES:
+        reveal_corridor = np.clip(reveal_corridor + 0.14, 0.0, 1.0)
+        passive_corridor = np.clip(0.75 * passive_corridor, 0.0, 1.0)
+    elif mode_name in TRANSFER_MODES:
+        transfer_corridor = np.clip(transfer_corridor + 0.16, 0.0, 1.0)
+    elif mode_name in RETRIEVE_MODES:
+        passive_corridor = np.clip(passive_corridor + 0.20, 0.0, 1.0)
+        reveal_corridor = np.clip(0.60 * reveal_corridor, 0.0, 1.0)
+    else:
+        reveal_corridor = np.clip(0.85 * reveal_corridor, 0.0, 1.0)
+        transfer_corridor = np.clip(0.75 * transfer_corridor, 0.0, 1.0)
+        passive_corridor = np.clip(0.80 * passive_corridor, 0.0, 1.0)
+
+    corridor_feasible = np.stack(
+        [
+            np.repeat(reveal_corridor[:, None], NUM_APPROACH_TEMPLATES, axis=1),
+            np.repeat(transfer_corridor[:, None], NUM_APPROACH_TEMPLATES, axis=1),
+            np.repeat(passive_corridor[:, None], NUM_APPROACH_TEMPLATES, axis=1),
+        ],
+        axis=1,
+    ).astype(np.float32)
+    persistence_horizon = np.stack(
+        [
+            np.clip(ROLL_OUT_HORIZON * (0.55 * reveal_corridor + 0.45 * support), 0.0, float(ROLL_OUT_HORIZON)),
+            np.clip(ROLL_OUT_HORIZON * (0.50 * transfer_corridor + 0.50 * persistence), 0.0, float(ROLL_OUT_HORIZON)),
+            np.clip(ROLL_OUT_HORIZON * (0.55 * passive_corridor + 0.45 * persistence), 0.0, float(ROLL_OUT_HORIZON)),
+        ],
+        axis=1,
+    ).astype(np.float32)
+    support_mode = np.full(
+        (ROLL_OUT_HORIZON,),
+        _mode_support_mode(mode_name, int(state_targets["support_mode"])),
+        dtype=np.int64,
+    )
+    if mode_name == "base_action":
+        support_mode[:] = int(state_targets["support_mode"])
+
+    return {
+        "candidate_rollout_support_mode": support_mode,
+        "candidate_rollout_corridor_feasible": corridor_feasible,
+        "candidate_rollout_persistence_horizon": persistence_horizon,
+        "candidate_rollout_disturbance_cost": disturbance.astype(np.float32),
+        "candidate_rollout_belief_map": visibility[:, None, None].astype(np.float32),
+        "candidate_rollout_visibility_map": visibility[:, None, None].astype(np.float32),
+        "candidate_rollout_clearance_map": np.repeat(clearance[:, None, None, None], 2, axis=1).astype(np.float32),
+        "candidate_rollout_support_stability": support[:, None, None, None].astype(np.float32),
+        "candidate_rollout_reocclusion_target": reocclusion[:, None, None].astype(np.float32),
+        "candidate_rollout_occluder_contact_map": np.clip(access * support, 0.0, 1.0)[:, None, None].astype(np.float32),
+        "candidate_rollout_grasp_affordance_map": grasp[:, None, None].astype(np.float32),
+    }
+
+
+def _evaluate_candidate(
+    sim_env: PickClutterRevealEnv,
+    obs_env: PickClutterRevealEnv,
+    snapshot: dict[str, Any],
+    mode_name: str,
+) -> dict[str, float]:
+    _restore_env(sim_env, snapshot)
+    start_positions = _all_positions(sim_env)
+    _execute_mode(sim_env, mode_name)
+    _sync_env_state(sim_env, obs_env)
+    after_bundle = _extract_sensor_bundle(obs_env.get_obs(obs_env.get_info()))
+    immediate = _candidate_metrics(sim_env, start_positions=start_positions, current_obs_bundle=after_bundle)
+    if not immediate["retrieval_success"] and mode_name != "retrieve":
+        _execute_mode(sim_env, "retrieve")
+        _sync_env_state(sim_env, obs_env)
+        follow_bundle = _extract_sensor_bundle(obs_env.get_obs(obs_env.get_info()))
+        final_metrics = _candidate_metrics(sim_env, start_positions=start_positions, current_obs_bundle=follow_bundle)
+    else:
+        final_metrics = immediate
+    _restore_env(obs_env, snapshot)
+    utility = (
+        2.5 * final_metrics["retrieval_success"]
+        + 1.0 * final_metrics["progress"]
+        + 0.5 * final_metrics["clearance"]
+        + 0.25 * final_metrics["visibility"]
+        - 0.5 * final_metrics["disturbance"]
+    )
+    return {
+        "candidate_retrieval_success": final_metrics["retrieval_success"],
+        "candidate_risk": float(np.clip(final_metrics["disturbance"], 0.0, 1.0)),
+        "candidate_utility": float(utility),
+        "candidate_final_disturbance_cost": final_metrics["disturbance"],
+        "candidate_reocclusion_rate": float(np.clip(1.0 - final_metrics["clearance"], 0.0, 1.0)),
+        "candidate_visibility_integral": final_metrics["visibility"],
+        "candidate_actor_feasibility_auc": final_metrics["clearance"],
+        "candidate_reveal_achieved": float(final_metrics["progress"] > 0.15 or final_metrics["clearance"] > 0.35),
+        "candidate_hold_persistence": float(1.0 - final_metrics["disturbance"]),
+        "candidate_support_stability_auc": float(1.0 - 0.5 * final_metrics["disturbance"]),
+        "candidate_disturbance_auc": final_metrics["disturbance"],
+        "candidate_immediate_retrieval_success": immediate["retrieval_success"],
+        "candidate_immediate_visibility": immediate["visibility"],
+        "candidate_immediate_access": immediate["clearance"],
+        "candidate_immediate_progress": immediate["progress"],
+        "candidate_immediate_reocclusion": float(np.clip(1.0 - immediate["clearance"], 0.0, 1.0)),
+        "candidate_immediate_hold_persistence": float(1.0 - immediate["disturbance"]),
+        "candidate_immediate_support_stability": float(1.0 - 0.5 * immediate["disturbance"]),
+        "candidate_immediate_disturbance": immediate["disturbance"],
+    }
+
+
+def _build_episode_splits(spec: SmokeSpec) -> dict[str, list[int]]:
+    return {
+        "train": [spec.dataset_seed * 10_000 + index for index in range(spec.train_episodes)],
+        "val": [spec.dataset_seed * 10_000 + 1_000 + index for index in range(spec.val_episodes)],
+        "eval": [spec.dataset_seed * 10_000 + 2_000 + index for index in range(spec.eval_episodes)],
+    }
+
+
+def _save_episode_splits(output_path: Path, payload: dict[str, list[int]]) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def _init_history_entry(obs_bundle: dict[str, np.ndarray], proprio: np.ndarray, action_chunk: np.ndarray) -> dict[str, Any]:
+    return {
+        "images": obs_bundle["images"].copy(),
+        "depths": obs_bundle["depths"].copy(),
+        "depth_valid": obs_bundle["depth_valid"].copy(),
+        "camera_intrinsics": obs_bundle["camera_intrinsics"].copy(),
+        "camera_extrinsics": obs_bundle["camera_extrinsics"].copy(),
+        "proprio": proprio.copy(),
+        "action": action_chunk.mean(axis=0).astype(np.float32, copy=False),
+    }
+
+
+def _history_stack(
+    history: Sequence[dict[str, Any]],
+    key: str,
+    *,
+    pad_shape: tuple[int, ...],
+    dtype: np.dtype,
+    history_steps: int,
+) -> np.ndarray:
+    history = list(history)[-history_steps:]
+    pad_count = history_steps - len(history)
+    chunks = [np.zeros(pad_shape, dtype=dtype) for _ in range(pad_count)]
+    chunks.extend(np.asarray(item[key], dtype=dtype) for item in history)
+    return np.stack(chunks, axis=0).astype(dtype, copy=False)
+
+
+class ManiSkillPickClutterDataset(Dataset[dict[str, Any]]):
+    def __init__(self, samples: Sequence[dict[str, Any]]) -> None:
+        self.samples = list(samples)
+
+    def __len__(self) -> int:
+        return len(self.samples)
+
+    def __getitem__(self, index: int) -> dict[str, Any]:
+        sample = self.samples[index]
+        item = {
+            "images": torch.from_numpy(sample["images"]).permute(0, 3, 1, 2).float() / 255.0,
+            "depths": torch.from_numpy(sample["depths"]).float(),
+            "depth_valid": torch.from_numpy(sample["depth_valid"]).float(),
+            "camera_intrinsics": torch.from_numpy(sample["camera_intrinsics"]).float(),
+            "camera_extrinsics": torch.from_numpy(sample["camera_extrinsics"]).float(),
+            "history_images": torch.from_numpy(sample["history_images"]).permute(0, 1, 4, 2, 3).float() / 255.0,
+            "history_depths": torch.from_numpy(sample["history_depths"]).float(),
+            "history_depth_valid": torch.from_numpy(sample["history_depth_valid"]).float(),
+            "history_camera_intrinsics": torch.from_numpy(sample["history_camera_intrinsics"]).float(),
+            "history_camera_extrinsics": torch.from_numpy(sample["history_camera_extrinsics"]).float(),
+            "history_proprio": torch.from_numpy(sample["history_proprio"]).float(),
+            "history_actions": torch.from_numpy(sample["history_actions"]).float(),
+            "proprio": torch.from_numpy(sample["proprio"]).float(),
+            "texts": sample["language_goal"],
+            "task_name": sample["task_name"],
+            "task_id": torch.as_tensor(sample["task_id"], dtype=torch.long),
+            "action_chunk": torch.from_numpy(sample["action_chunk"]).float(),
+            "candidate_action_chunks": torch.from_numpy(sample["candidate_action_chunks"]).float(),
+            "candidate_retrieval_success": torch.from_numpy(sample["candidate_retrieval_success"]).float(),
+            "candidate_final_disturbance_cost": torch.from_numpy(sample["candidate_final_disturbance_cost"]).float(),
+            "candidate_reocclusion_rate": torch.from_numpy(sample["candidate_reocclusion_rate"]).float(),
+            "candidate_visibility_integral": torch.from_numpy(sample["candidate_visibility_integral"]).float(),
+            "candidate_actor_feasibility_auc": torch.from_numpy(sample["candidate_actor_feasibility_auc"]).float(),
+            "candidate_reveal_achieved": torch.from_numpy(sample["candidate_reveal_achieved"]).float(),
+            "candidate_hold_persistence": torch.from_numpy(sample["candidate_hold_persistence"]).float(),
+            "candidate_support_stability_auc": torch.from_numpy(sample["candidate_support_stability_auc"]).float(),
+            "candidate_disturbance_auc": torch.from_numpy(sample["candidate_disturbance_auc"]).float(),
+            "candidate_risk": torch.from_numpy(sample["candidate_risk"]).float(),
+            "candidate_utility": torch.from_numpy(sample["candidate_utility"]).float(),
+            "proposal_target_action_chunks": torch.from_numpy(sample["candidate_action_chunks"]).float(),
+            "proposal_target_retrieval_success": torch.from_numpy(sample["candidate_retrieval_success"]).float(),
+            "proposal_target_risk": torch.from_numpy(sample["candidate_risk"]).float(),
+            "proposal_target_utility": torch.from_numpy(sample["candidate_utility"]).float(),
+            "episode_seed": sample["episode_seed"],
+            "decision_step": sample["decision_step"],
+            "selected_mode": sample["selected_mode"],
+        }
+        if "support_mode" in sample:
+            item["support_mode"] = torch.as_tensor(sample["support_mode"], dtype=torch.long)
+        if "corridor_feasible" in sample:
+            item["corridor_feasible"] = torch.from_numpy(sample["corridor_feasible"]).float()
+        if "persistence_horizon" in sample:
+            item["persistence_horizon"] = torch.from_numpy(sample["persistence_horizon"]).float()
+        if "disturbance_cost" in sample:
+            item["disturbance_cost"] = torch.as_tensor(sample["disturbance_cost"], dtype=torch.float32)
+        if "state_confidence_target" in sample:
+            item["state_confidence_target"] = torch.as_tensor(sample["state_confidence_target"], dtype=torch.float32)
+        if "task_metric_mask" in sample:
+            item["task_metric_mask"] = torch.from_numpy(sample["task_metric_mask"]).to(dtype=torch.bool)
+        for metric_name in STATE_SUPERVISION_METRICS:
+            if metric_name in sample:
+                item[metric_name] = torch.as_tensor(sample[metric_name], dtype=torch.float32)
+        for key in (
+            "candidate_rollout_support_mode",
+            "proposal_target_rollout_support_mode",
+        ):
+            if key in sample:
+                item[key] = torch.from_numpy(sample[key]).long()
+        for key in (
+            "candidate_rollout_corridor_feasible",
+            "candidate_rollout_persistence_horizon",
+            "candidate_rollout_disturbance_cost",
+            "candidate_rollout_belief_map",
+            "candidate_rollout_visibility_map",
+            "candidate_rollout_clearance_map",
+            "candidate_rollout_support_stability",
+            "candidate_rollout_reocclusion_target",
+            "candidate_rollout_occluder_contact_map",
+            "candidate_rollout_grasp_affordance_map",
+            "proposal_target_rollout_corridor_feasible",
+            "proposal_target_rollout_persistence_horizon",
+            "proposal_target_rollout_disturbance_cost",
+            "proposal_target_rollout_belief_map",
+            "proposal_target_rollout_visibility_map",
+            "proposal_target_rollout_clearance_map",
+            "proposal_target_rollout_support_stability",
+            "proposal_target_rollout_reocclusion_target",
+            "proposal_target_rollout_occluder_contact_map",
+            "proposal_target_rollout_grasp_affordance_map",
+        ):
+            if key in sample:
+                item[key] = torch.from_numpy(sample[key]).float()
+        return item
+
+
+def _make_loader(samples: Sequence[dict[str, Any]], *, batch_size: int, num_workers: int, shuffle: bool) -> DataLoader:
+    return DataLoader(
+        ManiSkillPickClutterDataset(samples),
+        batch_size=batch_size,
+        shuffle=shuffle,
+        num_workers=num_workers,
+        pin_memory=torch.cuda.is_available(),
+    )
+
+
+def _load_init_bundle() -> tuple[PolicyConfig, dict[str, Any], dict[str, Any]]:
+    checkpoint = torch.load(DEFAULT_INIT_CHECKPOINT, map_location="cpu", weights_only=False)
+    policy_config = PolicyConfig(
+        backbone=FrozenVLBackboneConfig(**checkpoint["policy_config"]["backbone"]),
+        fusion=MultiViewFusionConfig(**checkpoint["policy_config"]["fusion"]),
+        memory=ObservationMemoryConfig(**checkpoint["policy_config"]["memory"]),
+        decoder=ChunkDecoderConfig(**checkpoint["policy_config"]["decoder"]),
+        reveal_head=RevealHeadConfig(**checkpoint["policy_config"]["reveal_head"]),
+        world_model=RevealWMConfig(**checkpoint["policy_config"]["world_model"]),
+        planner=PlannerConfig(**checkpoint["policy_config"]["planner"]),
+    )
+    return _apply_smoke_planner_overrides(policy_config), checkpoint["trainer_config"], checkpoint["loss_weights"]
+
+
+def _trainer_config_for_variant(variant: str) -> TrainerConfig:
+    if variant == "trunk_only_ft":
+        return TrainerConfig(
+            policy_type="foundation_trunk",
+            use_bf16=True,
+            grad_clip_norm=1.0,
+            freeze_backbone=True,
+            gradient_checkpointing=False,
+            trainable_parameter_prefixes=("fusion", "memory", "decoder"),
+        )
+    if variant == "adapter_active_ft":
+        return TrainerConfig(
+            policy_type="adapter_wrapped",
+            use_bf16=True,
+            grad_clip_norm=1.0,
+            freeze_backbone=True,
+            gradient_checkpointing=False,
+            eval_mode="adapter_active",
+            trainable_parameter_prefixes=(
+                "trunk.fusion",
+                "trunk.memory",
+                "trunk.decoder",
+                "adapter.state_head",
+                "adapter.transition_model",
+                "adapter.proposal_prior",
+                "adapter.planner",
+            ),
+            adapter_mode="adapter_active",
+            adapter_use_transition_model=True,
+            adapter_use_task_conditioning=True,
+            adapter_action_supervision_source="trunk",
+        )
+    raise KeyError(f"Unsupported variant: {variant}")
+
+
+def _loss_weights_for_smoke() -> LossWeights:
+    return LossWeights(
+        action=1.0,
+        support_mode=0.15,
+        corridor=0.15,
+        persistence=0.08,
+        disturbance=0.08,
+        planner_success=0.20,
+        planner_risk=0.08,
+        planner_ranking=0.20,
+        proposal_reconstruction=0.10,
+        proposal_success=0.12,
+        proposal_ranking=0.15,
+        proposal_mode=0.10,
+        proposal_diversity=0.02,
+        task_metrics=0.15,
+        transition=0.25,
+        gate=0.25,
+        calibration=0.10,
+        proposal_mode_task_filter=[TASK_NAME],
+    )
+
+
+def _save_training_checkpoint(
+    *,
+    output_dir: Path,
+    experiment_name: str,
+    model: torch.nn.Module,
+    policy_config: PolicyConfig,
+    trainer_config: TrainerConfig,
+    loss_weights: LossWeights,
+    history: list[dict[str, Any]],
+    best_val: float,
+    train_spec: dict[str, Any],
+) -> Path:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint_path = output_dir / "checkpoint_best.pt"
+    torch.save(
+        {
+            "experiment_name": experiment_name,
+            "policy_config": asdict(policy_config),
+            "trainer_config": asdict(trainer_config),
+            "loss_weights": asdict(loss_weights),
+            "state_dict": model.state_dict(),
+            "history": history,
+            "best_val_total": best_val,
+            "train_spec": train_spec,
+        },
+        checkpoint_path,
+    )
+    return checkpoint_path
+
+
+def _aggregate_epoch(loss_records: Sequence[dict[str, float]]) -> dict[str, float]:
+    keys = sorted({key for record in loss_records for key in record})
+    return {
+        key: float(np.mean([record.get(key, 0.0) for record in loss_records])) if loss_records else 0.0
+        for key in keys
+    }
+
+
+def _train_variant(
+    *,
+    variant: str,
+    train_samples: Sequence[dict[str, Any]],
+    val_samples: Sequence[dict[str, Any]],
+    spec: SmokeSpec,
+    output_dir: Path,
+) -> tuple[Path, dict[str, Any]]:
+    policy_config, _init_trainer_cfg, _init_loss_weights = _load_init_bundle()
+    trainer_config = _trainer_config_for_variant(variant)
+    loss_weights = _loss_weights_for_smoke()
+    model = build_policy(policy_config, trainer_config)
+    init_info = _load_init_checkpoint(model, str(DEFAULT_INIT_CHECKPOINT), False)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    torch.manual_seed(spec.train_seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(spec.train_seed)
+        torch.backends.cuda.matmul.allow_tf32 = True
+    matched = apply_trainable_parameter_prefixes(model, trainer_config)
+    optimizer = torch.optim.AdamW(
+        [parameter for parameter in model.parameters() if parameter.requires_grad],
+        lr=spec.learning_rate,
+        weight_decay=spec.weight_decay,
+    )
+    trainer = BimanualTrainer(model=model, optimizer=optimizer, config=trainer_config)
+    train_loader = _make_loader(train_samples, batch_size=spec.batch_size, num_workers=spec.num_workers, shuffle=True)
+    val_loader = _make_loader(val_samples, batch_size=spec.batch_size, num_workers=spec.num_workers, shuffle=False)
+
+    best_val = math.inf
+    history: list[dict[str, Any]] = []
+    train_spec = build_target_training_spec(
+        track_id="occlusion_track",
+        model_variant=variant,
+        seed=spec.train_seed,
+        train_demos=spec.train_episodes,
+        val_demos=spec.val_episodes,
+        init_checkpoint_group=str(DEFAULT_INIT_CHECKPOINT),
+        optimizer="adamw",
+        learning_rate=spec.learning_rate,
+        lr_schedule="constant",
+        batch_size=spec.batch_size,
+        augmentations="none",
+        early_stopping_metric="val_total",
+        max_gradient_steps=len(train_loader) * spec.epochs,
+        unfreeze_scope="fusion_memory_decoder",
+        dataset_split_id=(
+            f"pickclutter_{SMOKE_VERSION}_seed{spec.dataset_seed}"
+            if int(spec.dataset_seed) == DEFAULT_SEED
+            else f"pickclutter_{SMOKE_VERSION}_dataset_seed{spec.dataset_seed}"
+        ),
+    )
+
+    for epoch in range(spec.epochs):
+        model.train()
+        train_losses: list[dict[str, float]] = []
+        for batch in train_loader:
+            moved = _move_batch_to_device(batch, device)
+            loss_dict = trainer.training_step(moved, loss_weights=loss_weights)
+            train_losses.append({key: float(value.detach().cpu()) for key, value in loss_dict.items()})
+
+        model.eval()
+        val_losses: list[dict[str, float]] = []
+        with torch.no_grad():
+            for batch in val_loader:
+                moved = _move_batch_to_device(batch, device)
+                forward_kwargs = {
+                    "images": moved["images"],
+                    "proprio": moved["proprio"],
+                    "texts": moved["texts"],
+                    "task_names": moved.get("task_name"),
+                    "task_ids": moved.get("task_id"),
+                    "history_images": moved.get("history_images"),
+                    "history_proprio": moved.get("history_proprio"),
+                    "history_actions": moved.get("history_actions"),
+                    "depths": moved.get("depths"),
+                    "depth_valid": moved.get("depth_valid"),
+                    "camera_intrinsics": moved.get("camera_intrinsics"),
+                    "camera_extrinsics": moved.get("camera_extrinsics"),
+                    "history_depths": moved.get("history_depths"),
+                    "history_depth_valid": moved.get("history_depth_valid"),
+                    "history_camera_intrinsics": moved.get("history_camera_intrinsics"),
+                    "history_camera_extrinsics": moved.get("history_camera_extrinsics"),
+                }
+                if variant == "adapter_active_ft":
+                    forward_kwargs["adapter_mode"] = "adapter_active"
+                    forward_kwargs["use_transition_model"] = True
+                    forward_kwargs["use_task_conditioning"] = True
+                outputs = model(**forward_kwargs)
+                from train.losses import compute_total_loss
+
+                losses = compute_total_loss(outputs, moved, weights=loss_weights)
+                val_losses.append({key: float(value.detach().cpu()) for key, value in losses.items()})
+
+        train_summary = _aggregate_epoch(train_losses)
+        val_summary = _aggregate_epoch(val_losses)
+        history.append({"epoch": epoch, "train": train_summary, "val": val_summary})
+        print(
+            json.dumps(
+                {
+                    "phase": "epoch_complete",
+                    "variant": variant,
+                    "epoch": epoch,
+                    "train_total": train_summary.get("total", 0.0),
+                    "val_total": val_summary.get("total", 0.0),
+                }
+            ),
+            flush=True,
+        )
+        if val_summary.get("total", math.inf) <= best_val:
+            best_val = val_summary["total"]
+            checkpoint_path = _save_training_checkpoint(
+                output_dir=output_dir,
+                experiment_name=f"{variant}_seed{spec.train_seed}",
+                model=model,
+                policy_config=policy_config,
+                trainer_config=trainer_config,
+                loss_weights=loss_weights,
+                history=history,
+                best_val=best_val,
+                train_spec=train_spec,
+            )
+            (output_dir / "summary.json").write_text(
+                json.dumps(
+                    {
+                        "variant": variant,
+                        "checkpoint_path": str(checkpoint_path),
+                        "init_info": init_info,
+                        "trainable_parameter_names": matched,
+                        "best_val_total": best_val,
+                        "history": history,
+                        "train_spec": train_spec,
+                    },
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+    return output_dir / "checkpoint_best.pt", train_spec
+
+
+def _load_checkpoint(
+    checkpoint_path: Path,
+    *,
+    adapter_mode: str | None = None,
+    planner_overrides: dict[str, float] | None = None,
+) -> tuple[torch.nn.Module, dict[str, Any]]:
+    checkpoint = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+    policy_config = PolicyConfig(
+        backbone=FrozenVLBackboneConfig(**checkpoint["policy_config"]["backbone"]),
+        fusion=MultiViewFusionConfig(**checkpoint["policy_config"]["fusion"]),
+        memory=ObservationMemoryConfig(**checkpoint["policy_config"]["memory"]),
+        decoder=ChunkDecoderConfig(**checkpoint["policy_config"]["decoder"]),
+        reveal_head=RevealHeadConfig(**checkpoint["policy_config"]["reveal_head"]),
+        world_model=RevealWMConfig(**checkpoint["policy_config"]["world_model"]),
+        planner=PlannerConfig(**checkpoint["policy_config"]["planner"]),
+    )
+    policy_config = _apply_smoke_planner_overrides(policy_config, planner_overrides=planner_overrides)
+    trainer_config = TrainerConfig(**checkpoint["trainer_config"])
+    if adapter_mode is not None and trainer_config.policy_type == "adapter_wrapped":
+        trainer_config.adapter_mode = adapter_mode
+        trainer_config.eval_mode = adapter_mode
+    model = build_policy(policy_config, trainer_config)
+    filtered_state_dict, skipped, _remapped = filter_compatible_state_dict(model.state_dict(), checkpoint["state_dict"])
+    incompatible = model.load_state_dict(filtered_state_dict, strict=False)
+    if incompatible.unexpected_keys:
+        raise RuntimeError(f"Unexpected checkpoint keys for {checkpoint_path}: {list(incompatible.unexpected_keys)}")
+    if skipped:
+        checkpoint["_shape_skipped_keys"] = skipped
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    model.eval()
+    return model, checkpoint
+
+
+def _collect_split(
+    *,
+    split_name: str,
+    seeds: Sequence[int],
+    spec: SmokeSpec,
+    output_path: Path,
+) -> dict[str, Any]:
+    obs_env = PickClutterRevealEnv(
+        obs_mode="rgb+depth+segmentation",
+        control_mode="pd_ee_delta_pos",
+        render_mode="rgb_array",
+    )
+    sim_env = PickClutterRevealEnv(
+        obs_mode="none",
+        control_mode="pd_ee_delta_pos",
+        render_mode="rgb_array",
+    )
+    samples: list[dict[str, Any]] = []
+    episode_records: list[dict[str, Any]] = []
+    try:
+        for episode_seed in seeds:
+            obs, _ = obs_env.reset(seed=int(episode_seed))
+            sim_env.reset(seed=int(episode_seed))
+            _sync_env_state(obs_env, sim_env)
+            episode_start_positions = _all_positions(obs_env)
+            history: deque[dict[str, Any]] = deque(maxlen=spec.history_steps)
+            episode_success = False
+            for decision_step in range(spec.max_macro_steps):
+                obs_bundle = _extract_sensor_bundle(obs)
+                proprio = _build_proprio(obs_env)
+                snapshot = _snapshot_env(obs_env)
+                candidate_metrics = [_evaluate_candidate(sim_env, obs_env, snapshot, mode_name) for mode_name in MODE_ORDER]
+                candidate_chunks = np.stack([CANONICAL_CHUNKS[mode_name] for mode_name in MODE_ORDER], axis=0).astype(np.float32)
+                utilities = np.asarray([payload["candidate_utility"] for payload in candidate_metrics], dtype=np.float32)
+                best_index = int(utilities.argmax())
+                selected_mode = MODE_ORDER[best_index]
+                state_targets = _current_state_targets(
+                    obs_env,
+                    obs_bundle=obs_bundle,
+                    candidate_metrics=candidate_metrics,
+                    episode_start_positions=episode_start_positions,
+                    selected_mode=selected_mode,
+                )
+                rollout_targets_by_mode = [
+                    _candidate_rollout_targets(
+                        mode_name=mode_name,
+                        state_targets=state_targets,
+                        candidate_payload=payload,
+                    )
+                    for mode_name, payload in zip(MODE_ORDER, candidate_metrics)
+                ]
+                sample = {
+                    "images": obs_bundle["images"].copy(),
+                    "depths": obs_bundle["depths"].copy(),
+                    "depth_valid": obs_bundle["depth_valid"].copy(),
+                    "camera_intrinsics": obs_bundle["camera_intrinsics"].copy(),
+                    "camera_extrinsics": obs_bundle["camera_extrinsics"].copy(),
+                    "history_images": _history_stack(history, "images", pad_shape=obs_bundle["images"].shape, dtype=np.uint8, history_steps=spec.history_steps),
+                    "history_depths": _history_stack(history, "depths", pad_shape=obs_bundle["depths"].shape, dtype=np.float32, history_steps=spec.history_steps),
+                    "history_depth_valid": _history_stack(history, "depth_valid", pad_shape=obs_bundle["depth_valid"].shape, dtype=np.float32, history_steps=spec.history_steps),
+                    "history_camera_intrinsics": _history_stack(history, "camera_intrinsics", pad_shape=obs_bundle["camera_intrinsics"].shape, dtype=np.float32, history_steps=spec.history_steps),
+                    "history_camera_extrinsics": _history_stack(history, "camera_extrinsics", pad_shape=obs_bundle["camera_extrinsics"].shape, dtype=np.float32, history_steps=spec.history_steps),
+                    "history_proprio": _history_stack(history, "proprio", pad_shape=(PROPRIO_DIM,), dtype=np.float32, history_steps=spec.history_steps),
+                    "history_actions": _history_stack(history, "action", pad_shape=(14,), dtype=np.float32, history_steps=spec.history_steps),
+                    "proprio": proprio.astype(np.float32),
+                    "language_goal": TEXT_PROMPT,
+                    "task_name": TASK_NAME,
+                    "task_id": TASK_ID,
+                    "action_chunk": CANONICAL_CHUNKS[selected_mode].copy(),
+                    "candidate_action_chunks": candidate_chunks,
+                    "candidate_retrieval_success": np.asarray([payload["candidate_retrieval_success"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_final_disturbance_cost": np.asarray([payload["candidate_final_disturbance_cost"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_reocclusion_rate": np.asarray([payload["candidate_reocclusion_rate"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_visibility_integral": np.asarray([payload["candidate_visibility_integral"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_actor_feasibility_auc": np.asarray([payload["candidate_actor_feasibility_auc"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_reveal_achieved": np.asarray([payload["candidate_reveal_achieved"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_hold_persistence": np.asarray([payload["candidate_hold_persistence"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_support_stability_auc": np.asarray([payload["candidate_support_stability_auc"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_disturbance_auc": np.asarray([payload["candidate_disturbance_auc"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_risk": np.asarray([payload["candidate_risk"] for payload in candidate_metrics], dtype=np.float32),
+                    "candidate_utility": utilities,
+                    "candidate_rollout_support_mode": np.stack(
+                        [payload["candidate_rollout_support_mode"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.int64),
+                    "candidate_rollout_corridor_feasible": np.stack(
+                        [payload["candidate_rollout_corridor_feasible"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_persistence_horizon": np.stack(
+                        [payload["candidate_rollout_persistence_horizon"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_disturbance_cost": np.stack(
+                        [payload["candidate_rollout_disturbance_cost"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_belief_map": np.stack(
+                        [payload["candidate_rollout_belief_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_visibility_map": np.stack(
+                        [payload["candidate_rollout_visibility_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_clearance_map": np.stack(
+                        [payload["candidate_rollout_clearance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_support_stability": np.stack(
+                        [payload["candidate_rollout_support_stability"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_reocclusion_target": np.stack(
+                        [payload["candidate_rollout_reocclusion_target"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_occluder_contact_map": np.stack(
+                        [payload["candidate_rollout_occluder_contact_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "candidate_rollout_grasp_affordance_map": np.stack(
+                        [payload["candidate_rollout_grasp_affordance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_support_mode": np.stack(
+                        [payload["candidate_rollout_support_mode"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.int64),
+                    "proposal_target_rollout_corridor_feasible": np.stack(
+                        [payload["candidate_rollout_corridor_feasible"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_persistence_horizon": np.stack(
+                        [payload["candidate_rollout_persistence_horizon"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_disturbance_cost": np.stack(
+                        [payload["candidate_rollout_disturbance_cost"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_belief_map": np.stack(
+                        [payload["candidate_rollout_belief_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_visibility_map": np.stack(
+                        [payload["candidate_rollout_visibility_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_clearance_map": np.stack(
+                        [payload["candidate_rollout_clearance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_support_stability": np.stack(
+                        [payload["candidate_rollout_support_stability"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_reocclusion_target": np.stack(
+                        [payload["candidate_rollout_reocclusion_target"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_occluder_contact_map": np.stack(
+                        [payload["candidate_rollout_occluder_contact_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "proposal_target_rollout_grasp_affordance_map": np.stack(
+                        [payload["candidate_rollout_grasp_affordance_map"] for payload in rollout_targets_by_mode],
+                        axis=0,
+                    ).astype(np.float32),
+                    "episode_seed": int(episode_seed),
+                    "decision_step": int(decision_step),
+                    "selected_mode": selected_mode,
+                    **state_targets,
+                }
+                samples.append(sample)
+                _execute_mode(obs_env, selected_mode)
+                obs = obs_env.get_obs(obs_env.get_info())
+                history.append(_init_history_entry(obs_bundle, proprio, CANONICAL_CHUNKS[selected_mode]))
+                if _success_from_state(obs_env):
+                    episode_success = True
+                    break
+            episode_records.append(
+                {
+                    "episode_seed": int(episode_seed),
+                    "success": episode_success,
+                    "steps": len(history),
+                }
+            )
+            print(
+                json.dumps(
+                    {
+                        "phase": "collect_episode_complete",
+                        "split": split_name,
+                        "episode_seed": int(episode_seed),
+                        "success": episode_success,
+                        "steps": len(history),
+                        "samples_collected": len(samples),
+                    }
+                ),
+                flush=True,
+            )
+    finally:
+        obs_env.close()
+        sim_env.close()
+
+    payload = {
+        "split_name": split_name,
+        "resolution": spec.resolution,
+        "history_steps": spec.history_steps,
+        "samples": samples,
+        "episode_records": episode_records,
+    }
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(payload, output_path)
+    return payload
+
+
+def _load_split(path: Path) -> dict[str, Any]:
+    return torch.load(path, map_location="cpu", weights_only=False)
+
+
+def _print_split_supervision_summary(split_name: str, samples: Sequence[dict[str, Any]]) -> None:
+    mode_counter = collections.Counter(str(sample.get("selected_mode", "unknown")) for sample in samples)
+    support_counter = collections.Counter(int(sample.get("support_mode", -1)) for sample in samples if "support_mode" in sample)
+    confidence_values = [float(sample.get("state_confidence_target", 0.0)) for sample in samples if "state_confidence_target" in sample]
+    payload = {
+        "phase": "split_supervision_summary",
+        "split": split_name,
+        "samples": len(samples),
+        "selected_modes": dict(mode_counter),
+        "support_modes": dict(support_counter),
+        "mean_state_confidence_target": float(np.mean(confidence_values)) if confidence_values else None,
+    }
+    print(json.dumps(payload, sort_keys=True), flush=True)
+
+
+def _batch_from_obs(obs_bundle: dict[str, np.ndarray], proprio: np.ndarray, history: Sequence[dict[str, Any]], device: torch.device) -> dict[str, Any]:
+    return {
+        "images": torch.from_numpy(obs_bundle["images"]).permute(0, 3, 1, 2).unsqueeze(0).float().div(255.0).to(device),
+        "depths": torch.from_numpy(obs_bundle["depths"]).unsqueeze(0).float().to(device),
+        "depth_valid": torch.from_numpy(obs_bundle["depth_valid"]).unsqueeze(0).float().to(device),
+        "camera_intrinsics": torch.from_numpy(obs_bundle["camera_intrinsics"]).unsqueeze(0).float().to(device),
+        "camera_extrinsics": torch.from_numpy(obs_bundle["camera_extrinsics"]).unsqueeze(0).float().to(device),
+        "history_images": torch.from_numpy(
+            _history_stack(history, "images", pad_shape=obs_bundle["images"].shape, dtype=np.uint8, history_steps=HISTORY_STEPS)
+        ).permute(0, 1, 4, 2, 3).unsqueeze(0).float().div(255.0).to(device),
+        "history_depths": torch.from_numpy(
+            _history_stack(history, "depths", pad_shape=obs_bundle["depths"].shape, dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "history_depth_valid": torch.from_numpy(
+            _history_stack(history, "depth_valid", pad_shape=obs_bundle["depth_valid"].shape, dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "history_camera_intrinsics": torch.from_numpy(
+            _history_stack(history, "camera_intrinsics", pad_shape=obs_bundle["camera_intrinsics"].shape, dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "history_camera_extrinsics": torch.from_numpy(
+            _history_stack(history, "camera_extrinsics", pad_shape=obs_bundle["camera_extrinsics"].shape, dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "history_proprio": torch.from_numpy(
+            _history_stack(history, "proprio", pad_shape=(PROPRIO_DIM,), dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "history_actions": torch.from_numpy(
+            _history_stack(history, "action", pad_shape=(14,), dtype=np.float32, history_steps=HISTORY_STEPS)
+        ).unsqueeze(0).float().to(device),
+        "proprio": torch.from_numpy(proprio).unsqueeze(0).float().to(device),
+        "texts": [TEXT_PROMPT],
+        "task_names": [TASK_NAME],
+        "task_ids": torch.as_tensor([TASK_ID], dtype=torch.long, device=device),
+    }
+
+
+def _eval_mode_name(
+    model_output: dict[str, Any],
+    checkpoint_mode: str,
+) -> tuple[str, bool, bool]:
+    if checkpoint_mode == "adapter_active_ft" and "proposal_mode_names" in model_output and "best_candidate_indices" in model_output:
+        active_mask = bool(_np(model_output.get("adapter_active_mask", np.asarray([False]))).reshape(-1)[0])
+        if not active_mask:
+            mode_name = _classify_mode_from_chunk(_np(model_output["action_mean"])[0])
+            return mode_name, False, False
+        best_index = int(_np(model_output["best_candidate_indices"])[0])
+        proposal_mode_names = model_output["proposal_mode_names"][0]
+        mode_name = str(proposal_mode_names[best_index]) if best_index < len(proposal_mode_names) else _classify_mode_from_chunk(
+            _np(model_output["action_mean"])[0]
+        )
+        non_base = bool(best_index > 0)
+        return mode_name, active_mask, non_base
+    mode_name = _classify_mode_from_chunk(_np(model_output["action_mean"])[0])
+    return mode_name, False, False
+
+
+def _evaluate_checkpoint(
+    *,
+    checkpoint_path: Path,
+    adapter_mode: str,
+    result_mode_name: str,
+    seeds: Sequence[int],
+    report_path: Path,
+    train_spec: dict[str, Any] | None,
+    dataset_seed: int,
+    planner_overrides: dict[str, float] | None = None,
+) -> dict[str, Any]:
+    model, checkpoint = _load_checkpoint(
+        checkpoint_path,
+        adapter_mode=adapter_mode if adapter_mode != "trunk_only" else None,
+        planner_overrides=planner_overrides,
+    )
+    device = next(model.parameters()).device
+    obs_env = PickClutterRevealEnv(
+        obs_mode="rgb+depth+segmentation",
+        control_mode="pd_ee_delta_pos",
+        render_mode="rgb_array",
+    )
+    sim_env = PickClutterRevealEnv(
+        obs_mode="none",
+        control_mode="pd_ee_delta_pos",
+        render_mode="rgb_array",
+    )
+    successes: list[int] = []
+    episode_records: list[dict[str, Any]] = []
+    reveal_steps: list[int] = []
+    retrieve_steps: list[int] = []
+    disturbance_values: list[float] = []
+    intervention_events = 0
+    non_base_events = 0
+    total_decisions = 0
+    try:
+        for episode_seed in seeds:
+            obs, _ = obs_env.reset(seed=int(episode_seed))
+            sim_env.reset(seed=int(episode_seed))
+            _sync_env_state(obs_env, sim_env)
+            history: deque[dict[str, Any]] = deque(maxlen=HISTORY_STEPS)
+            success = False
+            first_reveal_step: int | None = None
+            first_retrieve_step: int | None = None
+            episode_disturbance: list[float] = []
+            for decision_step in range(MAX_MACRO_STEPS):
+                obs_bundle = _extract_sensor_bundle(obs)
+                proprio = _build_proprio(obs_env)
+                batch = _batch_from_obs(obs_bundle, proprio, list(history), device)
+                with torch.no_grad():
+                    if adapter_mode == "trunk_only":
+                        outputs = model(**batch)
+                    else:
+                        outputs = model(
+                            **batch,
+                            adapter_mode=adapter_mode,
+                            use_transition_model=True,
+                            use_task_conditioning=True,
+                        )
+                selected_mode, active_mask, non_base = _eval_mode_name(outputs, result_mode_name)
+                start_positions = _all_positions(obs_env)
+                _sync_env_state(obs_env, sim_env)
+                _execute_mode(sim_env, selected_mode)
+                end_metrics = _candidate_metrics(sim_env, start_positions=start_positions, current_obs_bundle=None)
+                _sync_env_state(sim_env, obs_env)
+                obs = obs_env.get_obs(obs_env.get_info())
+                history.append(_init_history_entry(obs_bundle, proprio, CANONICAL_CHUNKS.get(selected_mode, CANONICAL_CHUNKS["base_action"])))
+                total_decisions += 1
+                intervention_events += int(active_mask)
+                non_base_events += int(non_base)
+                episode_disturbance.append(end_metrics["disturbance"])
+                if selected_mode != "retrieve" and selected_mode not in {"base_action", "maintain_gap"} and first_reveal_step is None:
+                    first_reveal_step = decision_step + 1
+                if selected_mode == "retrieve" and first_retrieve_step is None:
+                    first_retrieve_step = decision_step + 1
+                if _success_from_state(obs_env):
+                    success = True
+                    break
+            successes.append(int(success))
+            if first_reveal_step is not None:
+                reveal_steps.append(first_reveal_step)
+            if first_retrieve_step is not None:
+                retrieve_steps.append(first_retrieve_step)
+            disturbance_values.append(float(np.mean(episode_disturbance)) if episode_disturbance else 0.0)
+            episode_records.append(
+                {
+                    "episode_seed": int(episode_seed),
+                    "success": success,
+                    "steps": len(history),
+                    "first_reveal_step": first_reveal_step,
+                    "first_retrieve_step": first_retrieve_step,
+                    "episode_disturbance": float(np.mean(episode_disturbance)) if episode_disturbance else 0.0,
+                }
+            )
+            print(
+                json.dumps(
+                    {
+                        "phase": "eval_episode_complete",
+                        "adapter_mode": result_mode_name,
+                        "episode_seed": int(episode_seed),
+                        "success": success,
+                        "steps": len(history),
+                    }
+                ),
+                flush=True,
+            )
+    finally:
+        obs_env.close()
+        sim_env.close()
+
+    eval_protocol = build_public_eval_protocol(
+        track_id="occlusion_track",
+        eval_mode=result_mode_name,
+        seed=int(dataset_seed),
+        episodes=len(seeds),
+        resolution=224,
+        cameras=CAMERA_NAMES,
+    )
+    payload = {
+        "track_id": "occlusion_track",
+        "suite": "maniskill3",
+        "benchmark_task": "PickClutterYCB-v1",
+        "role": "target",
+        "adapter_mode": result_mode_name,
+        "episodes": len(seeds),
+        "successes": successes,
+        "success_rate": float(np.mean(successes)) if successes else 0.0,
+        "intervention_rate": float(intervention_events / max(1, total_decisions)),
+        "non_base_selection_rate": float(non_base_events / max(1, total_decisions)),
+        "steps_to_first_reveal_or_access": float(np.mean(reveal_steps)) if reveal_steps else float(MAX_MACRO_STEPS),
+        "steps_to_retrieve": float(np.mean(retrieve_steps)) if retrieve_steps else float(MAX_MACRO_STEPS),
+        "disturbance_proxy": float(np.mean(disturbance_values)) if disturbance_values else 0.0,
+        "episode_records": episode_records,
+        "eval_protocol": eval_protocol,
+    }
+    if train_spec is not None:
+        payload["train_spec"] = train_spec
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    return payload
+
+
+def _summarize_smoke(results: Sequence[dict[str, Any]], output_dir: Path) -> dict[str, Any]:
+    summary = summarize_public_benchmark_package(list(results), allow_partial=True)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    json_path = output_dir / "public_benchmark_package_summary.json"
+    md_path = output_dir / "public_benchmark_package_summary.md"
+    json_path.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    lines = [
+        "# ManiSkill PickClutter Smoke Summary",
+        "",
+        f"- available_tracks: {summary['available_tracks']}",
+        f"- target_macro_average_delta: {summary['target_macro_average_delta']:.3f}",
+        f"- headline_pass: {summary['headline_pass']}",
+        f"- sign_of_life_pass: {summary['sign_of_life_pass']}",
+        "",
+    ]
+    for track_id, payload in summary["tracks"].items():
+        lines.append(f"## {track_id}")
+        lines.append(f"- delta_active_vs_trunk: {payload.get('delta_active_vs_trunk', 0.0):.3f}")
+        lines.append(f"- delta_noop_vs_trunk: {payload.get('delta_noop_vs_trunk', 0.0):.3f}")
+        lines.append(f"- signs_of_life: {payload.get('signs_of_life', False)}")
+        for mode, mode_payload in payload["modes"].items():
+            lines.append(f"- {mode}: mean_success={mode_payload['mean_success']:.3f}")
+        lines.append("")
+    md_path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
+    return summary
+
+
+def _default_paths() -> SmokePaths:
+    return SmokePaths()
+
+
+def _dataset_artifact_path(data_dir: Path, basename: str, *, dataset_seed: int) -> Path:
+    if int(dataset_seed) == DEFAULT_SEED:
+        return data_dir / basename
+    artifact = Path(basename)
+    return data_dir / f"{artifact.stem}_seed{int(dataset_seed)}{artifact.suffix}"
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Minimum-sign-of-life ManiSkill PickClutter smoke run.")
+    parser.add_argument("--stage", choices=("collect", "train", "eval", "all"), default="all")
+    parser.add_argument("--data-dir", type=Path, default=_default_paths().data_dir)
+    parser.add_argument("--output-dir", type=Path, default=_default_paths().output_dir)
+    parser.add_argument("--report-dir", type=Path, default=_default_paths().report_dir)
+    parser.add_argument("--seed", type=int, default=None, help="Deprecated alias for train/eval dataset seed.")
+    parser.add_argument("--train-seed", type=int, default=None)
+    parser.add_argument("--dataset-seed", type=int, default=None)
+    parser.add_argument("--eval-split", choices=("val", "eval"), default="eval")
+    parser.add_argument("--adapter-confidence-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-access-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-persistence-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-support-threshold", type=float, default=None)
+    parser.add_argument("--retrieve-reocclusion-threshold", type=float, default=None)
+    parser.add_argument("--planner-mode-preference-bonus", type=float, default=None)
+    parser.add_argument("--planner-premature-retrieve-penalty", type=float, default=None)
+    parser.add_argument("--planner-premature-insert-penalty", type=float, default=None)
+    parser.add_argument("--planner-premature-occlusion-sweep-penalty", type=float, default=None)
+    parser.add_argument("--planner-premature-maintain-penalty", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-access-threshold", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-reveal-threshold", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-persistence-threshold", type=float, default=None)
+    parser.add_argument("--planner-retrieve-stage-support-threshold", type=float, default=None)
+    parser.add_argument("--planner-insert-stage-access-threshold", type=float, default=None)
+    parser.add_argument("--planner-insert-stage-visibility-threshold", type=float, default=None)
+    parser.add_argument("--planner-insert-stage-support-threshold", type=float, default=None)
+    parser.add_argument("--planner-occlusion-maintain-gap-min-access", type=float, default=None)
+    parser.add_argument("--planner-occlusion-maintain-gap-min-visibility", type=float, default=None)
+    return parser.parse_args()
+
+
+def _planner_overrides_from_args(args: argparse.Namespace) -> dict[str, float]:
+    override_pairs = (
+        ("adapter_confidence_threshold", args.adapter_confidence_threshold),
+        ("retrieve_access_threshold", args.retrieve_access_threshold),
+        ("retrieve_persistence_threshold", args.retrieve_persistence_threshold),
+        ("retrieve_support_threshold", args.retrieve_support_threshold),
+        ("retrieve_reocclusion_threshold", args.retrieve_reocclusion_threshold),
+        ("mode_preference_bonus", args.planner_mode_preference_bonus),
+        ("premature_retrieve_penalty", args.planner_premature_retrieve_penalty),
+        ("premature_insert_penalty", args.planner_premature_insert_penalty),
+        ("premature_occlusion_sweep_penalty", args.planner_premature_occlusion_sweep_penalty),
+        ("premature_maintain_penalty", args.planner_premature_maintain_penalty),
+        ("retrieve_stage_access_threshold", args.planner_retrieve_stage_access_threshold),
+        ("retrieve_stage_reveal_threshold", args.planner_retrieve_stage_reveal_threshold),
+        ("retrieve_stage_persistence_threshold", args.planner_retrieve_stage_persistence_threshold),
+        ("retrieve_stage_support_threshold", args.planner_retrieve_stage_support_threshold),
+        ("insert_stage_access_threshold", args.planner_insert_stage_access_threshold),
+        ("insert_stage_visibility_threshold", args.planner_insert_stage_visibility_threshold),
+        ("insert_stage_support_threshold", args.planner_insert_stage_support_threshold),
+        ("occlusion_maintain_gap_min_access", args.planner_occlusion_maintain_gap_min_access),
+        ("occlusion_maintain_gap_min_visibility", args.planner_occlusion_maintain_gap_min_visibility),
+    )
+    return {key: value for key, value in override_pairs if value is not None}
+
+
+def main() -> None:
+    args = _parse_args()
+    planner_overrides = _planner_overrides_from_args(args)
+    base_seed = DEFAULT_SEED if args.seed is None else int(args.seed)
+    train_seed = int(args.train_seed) if args.train_seed is not None else base_seed
+    dataset_seed = int(args.dataset_seed) if args.dataset_seed is not None else base_seed
+    spec = SmokeSpec(dataset_seed=dataset_seed, train_seed=train_seed)
+    splits = _build_episode_splits(spec)
+    split_path = _dataset_artifact_path(args.data_dir, "episode_splits.json", dataset_seed=spec.dataset_seed)
+    train_path = _dataset_artifact_path(args.data_dir, "train.pt", dataset_seed=spec.dataset_seed)
+    val_path = _dataset_artifact_path(args.data_dir, "val.pt", dataset_seed=spec.dataset_seed)
+
+    if args.stage in {"collect", "all"}:
+        _save_episode_splits(split_path, splits)
+        if not train_path.exists():
+            print(json.dumps({"phase": "collect_train_start", "episodes": len(splits["train"])}), flush=True)
+            _collect_split(split_name="train", seeds=splits["train"], spec=spec, output_path=train_path)
+        if not val_path.exists():
+            print(json.dumps({"phase": "collect_val_start", "episodes": len(splits["val"])}), flush=True)
+            _collect_split(split_name="val", seeds=splits["val"], spec=spec, output_path=val_path)
+
+    if args.stage == "collect":
+        return
+
+    train_bundle = _load_split(train_path)
+    val_bundle = _load_split(val_path)
+    train_samples = train_bundle["samples"]
+    val_samples = val_bundle["samples"]
+    _print_split_supervision_summary("train", train_samples)
+    _print_split_supervision_summary("val", val_samples)
+
+    trunk_checkpoint = args.output_dir / f"trunk_only_ft_seed{spec.train_seed}" / "checkpoint_best.pt"
+    adapter_checkpoint = args.output_dir / f"adapter_active_ft_seed{spec.train_seed}" / "checkpoint_best.pt"
+    trunk_train_spec: dict[str, Any] | None = None
+    adapter_train_spec: dict[str, Any] | None = None
+
+    if args.stage in {"train", "all"}:
+        if not trunk_checkpoint.exists():
+            print(json.dumps({"phase": "train_variant_start", "variant": "trunk_only_ft"}), flush=True)
+            trunk_checkpoint, trunk_train_spec = _train_variant(
+                variant="trunk_only_ft",
+                train_samples=train_samples,
+                val_samples=val_samples,
+                spec=spec,
+                output_dir=args.output_dir / f"trunk_only_ft_seed{spec.train_seed}",
+            )
+        else:
+            trunk_payload = torch.load(trunk_checkpoint, map_location="cpu", weights_only=False)
+            trunk_train_spec = trunk_payload.get("train_spec")
+        if not adapter_checkpoint.exists():
+            print(json.dumps({"phase": "train_variant_start", "variant": "adapter_active_ft"}), flush=True)
+            adapter_checkpoint, adapter_train_spec = _train_variant(
+                variant="adapter_active_ft",
+                train_samples=train_samples,
+                val_samples=val_samples,
+                spec=spec,
+                output_dir=args.output_dir / f"adapter_active_ft_seed{spec.train_seed}",
+            )
+        else:
+            adapter_payload = torch.load(adapter_checkpoint, map_location="cpu", weights_only=False)
+            adapter_train_spec = adapter_payload.get("train_spec")
+
+    if args.stage == "train":
+        return
+
+    if trunk_train_spec is None and trunk_checkpoint.exists():
+        trunk_payload = torch.load(trunk_checkpoint, map_location="cpu", weights_only=False)
+        trunk_train_spec = trunk_payload.get("train_spec")
+    if adapter_train_spec is None and adapter_checkpoint.exists():
+        adapter_payload = torch.load(adapter_checkpoint, map_location="cpu", weights_only=False)
+        adapter_train_spec = adapter_payload.get("train_spec")
+
+    eval_seeds = splits[args.eval_split]
+    print(json.dumps({"phase": "eval_start", "episodes": len(eval_seeds)}), flush=True)
+    trunk_result = _evaluate_checkpoint(
+        checkpoint_path=trunk_checkpoint,
+        adapter_mode="trunk_only",
+        result_mode_name="trunk_only_ft",
+        seeds=eval_seeds,
+        report_path=args.report_dir / f"trunk_only_ft_seed{spec.train_seed}.json",
+        train_spec=trunk_train_spec,
+        dataset_seed=spec.dataset_seed,
+        planner_overrides=planner_overrides,
+    )
+    noop_result = _evaluate_checkpoint(
+        checkpoint_path=adapter_checkpoint,
+        adapter_mode="adapter_noop",
+        result_mode_name="adapter_noop",
+        seeds=eval_seeds,
+        report_path=args.report_dir / f"adapter_noop_seed{spec.train_seed}.json",
+        train_spec=adapter_train_spec,
+        dataset_seed=spec.dataset_seed,
+        planner_overrides=planner_overrides,
+    )
+    active_result = _evaluate_checkpoint(
+        checkpoint_path=adapter_checkpoint,
+        adapter_mode="adapter_active",
+        result_mode_name="adapter_active_ft",
+        seeds=eval_seeds,
+        report_path=args.report_dir / f"adapter_active_ft_seed{spec.train_seed}.json",
+        train_spec=adapter_train_spec,
+        dataset_seed=spec.dataset_seed,
+        planner_overrides=planner_overrides,
+    )
+    summary = _summarize_smoke([trunk_result, noop_result, active_result], args.report_dir)
+    print(json.dumps({"phase": "complete", "summary": summary}, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests4/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/run_public_benchmark_package.py

@@ -0,0 +1,369 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from eval.public_benchmark_package import (
+    ANCHOR_ROLE,
+    DEFAULT_ANCHOR_TOLERANCE,
+    DEFAULT_SIGN_OF_LIFE_GAIN,
+    DEFAULT_SIGN_OF_LIFE_INTERVENTION,
+    DEFAULT_SIGN_OF_LIFE_NON_BASE,
+    TARGET_ROLE,
+    build_public_eval_protocol,
+    build_target_training_spec,
+    default_public_benchmark_manifest,
+    expected_eval_modes,
+    public_benchmark_tracks,
+    public_protocol_identity_signature,
+    public_track_by_id,
+    training_fairness_signature,
+    write_default_public_benchmark_manifest,
+)
+
+
+def _load_json(path: str | Path) -> dict[str, Any]:
+    with Path(path).open("r", encoding="utf-8") as handle:
+        payload = json.load(handle)
+    if not isinstance(payload, dict):
+        raise TypeError(f"Expected a JSON object in {path!s}, got {type(payload)!r}.")
+    return payload
+
+
+def _normalize_success_samples(payload: dict[str, Any]) -> np.ndarray:
+    if "successes" in payload:
+        raw = np.asarray(payload["successes"], dtype=np.float32).reshape(-1)
+        return raw
+    if "success_rate" in payload:
+        return np.asarray([float(payload["success_rate"])], dtype=np.float32)
+    raise KeyError("Each result payload must include either `successes` or `success_rate`.")
+
+
+def _mean_optional(records: list[dict[str, Any]], key: str) -> float | None:
+    values = [float(record[key]) for record in records if key in record]
+    if not values:
+        return None
+    return float(np.mean(values))
+
+
+def _bootstrap_delta_ci(
+    lhs: np.ndarray,
+    rhs: np.ndarray,
+    *,
+    bootstrap_samples: int,
+    bootstrap_seed: int,
+) -> tuple[float, float]:
+    if lhs.size == 0 or rhs.size == 0:
+        return 0.0, 0.0
+    rng = np.random.default_rng(int(bootstrap_seed))
+    deltas = np.empty(int(bootstrap_samples), dtype=np.float32)
+    for index in range(int(bootstrap_samples)):
+        lhs_sample = lhs[rng.integers(0, lhs.shape[0], size=lhs.shape[0])]
+        rhs_sample = rhs[rng.integers(0, rhs.shape[0], size=rhs.shape[0])]
+        deltas[index] = float(lhs_sample.mean() - rhs_sample.mean())
+    low, high = np.percentile(deltas, [2.5, 97.5])
+    return float(low), float(high)
+
+
+def _normalize_record(payload: dict[str, Any]) -> dict[str, Any]:
+    if "track_id" not in payload:
+        raise KeyError("Missing required field `track_id`.")
+    if "adapter_mode" not in payload:
+        raise KeyError("Missing required field `adapter_mode`.")
+    track = public_track_by_id(str(payload["track_id"]))
+    success_samples = _normalize_success_samples(payload)
+    success_rate = float(payload.get("success_rate", float(success_samples.mean())))
+    episodes = int(payload.get("episodes", success_samples.shape[0]))
+    record = dict(payload)
+    record["track_id"] = track.track_id
+    record["suite"] = payload.get("suite", track.suite)
+    record["benchmark_task"] = payload.get("benchmark_task", track.benchmark_task)
+    record["role"] = payload.get("role", track.role)
+    record["adapter_mode"] = str(payload["adapter_mode"])
+    record["successes"] = success_samples.tolist()
+    record["success_rate"] = success_rate
+    record["episodes"] = episodes
+    return record
+
+
+def _validate_protocols(records: list[dict[str, Any]]) -> None:
+    by_track: dict[str, list[dict[str, Any]]] = {}
+    for record in records:
+        by_track.setdefault(record["track_id"], []).append(record)
+    for track_id, grouped in by_track.items():
+        signatures = []
+        for record in grouped:
+            protocol = record.get("eval_protocol")
+            if protocol is None:
+                raise ValueError(
+                    f"Missing eval_protocol for track {track_id!r}, mode {record['adapter_mode']!r}."
+                )
+            signatures.append(public_protocol_identity_signature(protocol))
+        if any(signature != signatures[0] for signature in signatures[1:]):
+            raise ValueError(f"Protocol identity mismatch detected for track {track_id!r}.")
+
+
+def _validate_training_fairness(records: list[dict[str, Any]]) -> None:
+    grouped: dict[tuple[str, str], list[dict[str, Any]]] = {}
+    for record in records:
+        grouped.setdefault((record["track_id"], record["adapter_mode"]), []).append(record)
+    for track in public_benchmark_tracks(TARGET_ROLE):
+        trunk_records = grouped.get((track.track_id, "trunk_only_ft"), [])
+        active_records = grouped.get((track.track_id, "adapter_active_ft"), [])
+        if not trunk_records or not active_records:
+            continue
+        if len(trunk_records) != len(active_records):
+            raise ValueError(
+                f"Training fairness mismatch for {track.track_id!r}: different run counts "
+                f"between trunk_only_ft ({len(trunk_records)}) and adapter_active_ft ({len(active_records)})."
+            )
+        if any(record.get("train_spec") is None for record in trunk_records + active_records):
+            raise ValueError(
+                f"Training fairness mismatch for {track.track_id!r}: missing train_spec on a target-track result."
+            )
+        trunk_by_seed = {
+            int(record["train_spec"]["seed"]): training_fairness_signature(record["train_spec"])
+            for record in trunk_records
+        }
+        active_by_seed = {
+            int(record["train_spec"]["seed"]): training_fairness_signature(record["train_spec"])
+            for record in active_records
+        }
+        if set(trunk_by_seed) != set(active_by_seed):
+            raise ValueError(f"Training fairness mismatch for {track.track_id!r}: seed sets differ.")
+        for seed, trunk_signature in trunk_by_seed.items():
+            if trunk_signature != active_by_seed[seed]:
+                raise ValueError(
+                    f"Training fairness mismatch for {track.track_id!r} at seed {seed}: "
+                    "trunk_only_ft and adapter_active_ft do not share the same data/init signature."
+                )
+
+
+def _aggregate_mode(records: list[dict[str, Any]]) -> dict[str, Any]:
+    success_rates = np.asarray([float(record["success_rate"]) for record in records], dtype=np.float32)
+    success_samples = np.concatenate(
+        [np.asarray(record["successes"], dtype=np.float32).reshape(-1) for record in records],
+        axis=0,
+    )
+    payload: dict[str, Any] = {
+        "num_runs": len(records),
+        "mean_success": float(success_rates.mean()) if success_rates.size else 0.0,
+        "success_samples": success_samples.tolist(),
+    }
+    for key in (
+        "intervention_rate",
+        "non_base_selection_rate",
+        "steps_to_first_reveal_or_access",
+        "steps_to_retrieve",
+        "disturbance_proxy",
+    ):
+        mean_value = _mean_optional(records, key)
+        if mean_value is not None:
+            payload[key] = mean_value
+    return payload
+
+
+def summarize_public_benchmark_package(
+    result_payloads: list[dict[str, Any]],
+    *,
+    bootstrap_samples: int = 2000,
+    bootstrap_seed: int = 0,
+    allow_partial: bool = False,
+) -> dict[str, Any]:
+    records = [_normalize_record(payload) for payload in result_payloads]
+    _validate_protocols(records)
+    _validate_training_fairness(records)
+
+    grouped: dict[tuple[str, str], list[dict[str, Any]]] = {}
+    for record in records:
+        grouped.setdefault((record["track_id"], record["adapter_mode"]), []).append(record)
+
+    track_summaries: dict[str, Any] = {}
+    target_deltas: list[float] = []
+    anchor_pass = True
+    sign_of_life_tracks: list[str] = []
+    ci_above_zero_tracks: list[str] = []
+    available_tracks: list[str] = []
+
+    for track in public_benchmark_tracks():
+        track_modes = expected_eval_modes(track.track_id)
+        mode_payloads: dict[str, Any] = {}
+        missing_modes: list[str] = []
+        for mode in track_modes:
+            mode_records = grouped.get((track.track_id, mode), [])
+            if not mode_records:
+                missing_modes.append(mode)
+                continue
+            mode_payloads[mode] = _aggregate_mode(mode_records)
+        if missing_modes:
+            if allow_partial:
+                continue
+            raise ValueError(f"Missing results for track {track.track_id!r}, mode(s) {missing_modes!r}.")
+        available_tracks.append(track.track_id)
+
+        track_summary: dict[str, Any] = {
+            "suite": track.suite,
+            "benchmark_task": track.benchmark_task,
+            "role": track.role,
+            "task_family": track.task_family,
+            "target_behavior": track.target_behavior,
+            "public_source": track.public_source,
+            "notes": track.notes,
+            "modes": {
+                mode: {
+                    key: value
+                    for key, value in payload.items()
+                    if key != "success_samples"
+                }
+                for mode, payload in mode_payloads.items()
+            },
+        }
+
+        if track.role == TARGET_ROLE:
+            trunk = mode_payloads["trunk_only_ft"]
+            active = mode_payloads["adapter_active_ft"]
+            noop = mode_payloads["adapter_noop"]
+            delta_active = float(active["mean_success"] - trunk["mean_success"])
+            delta_noop = float(noop["mean_success"] - trunk["mean_success"])
+            target_deltas.append(delta_active)
+            ci_low, ci_high = _bootstrap_delta_ci(
+                np.asarray(active["success_samples"], dtype=np.float32),
+                np.asarray(trunk["success_samples"], dtype=np.float32),
+                bootstrap_samples=bootstrap_samples,
+                bootstrap_seed=bootstrap_seed + len(target_deltas),
+            )
+            sign_of_life = bool(
+                float(active.get("intervention_rate", 0.0)) >= DEFAULT_SIGN_OF_LIFE_INTERVENTION
+                and float(active.get("non_base_selection_rate", 0.0)) >= DEFAULT_SIGN_OF_LIFE_NON_BASE
+                and delta_active >= DEFAULT_SIGN_OF_LIFE_GAIN
+            )
+            if sign_of_life:
+                sign_of_life_tracks.append(track.track_id)
+            if ci_low > 0.0:
+                ci_above_zero_tracks.append(track.track_id)
+            track_summary.update(
+                {
+                    "delta_active_vs_trunk": delta_active,
+                    "delta_noop_vs_trunk": delta_noop,
+                    "delta_active_vs_trunk_ci95": [ci_low, ci_high],
+                    "signs_of_life": sign_of_life,
+                }
+            )
+        else:
+            trunk = mode_payloads["trunk_only"]
+            active = mode_payloads["adapter_active"]
+            noop = mode_payloads["adapter_noop"]
+            active_delta = float(active["mean_success"] - trunk["mean_success"])
+            noop_delta = float(noop["mean_success"] - trunk["mean_success"])
+            within_tolerance = bool(
+                abs(active_delta) <= DEFAULT_ANCHOR_TOLERANCE
+                and abs(noop_delta) <= DEFAULT_ANCHOR_TOLERANCE
+            )
+            anchor_pass = anchor_pass and within_tolerance
+            track_summary.update(
+                {
+                    "delta_active_vs_trunk": active_delta,
+                    "delta_noop_vs_trunk": noop_delta,
+                    "anchor_within_tolerance": within_tolerance,
+                }
+            )
+
+        track_summaries[track.track_id] = track_summary
+
+    headline_pass = bool(
+        target_deltas
+        and all(delta > 0.0 for delta in target_deltas)
+        and len(ci_above_zero_tracks) >= 1
+    )
+    sign_of_life_pass = len(sign_of_life_tracks) >= 2
+
+    return {
+        "package_name": default_public_benchmark_manifest()["package_name"],
+        "tracks": track_summaries,
+        "available_tracks": available_tracks,
+        "target_macro_average_delta": float(np.mean(target_deltas)) if target_deltas else 0.0,
+        "headline_pass": headline_pass,
+        "sign_of_life_pass": sign_of_life_pass,
+        "sign_of_life_track_count": len(sign_of_life_tracks),
+        "sign_of_life_tracks": sign_of_life_tracks,
+        "ci_above_zero_tracks": ci_above_zero_tracks,
+        "anchor_pass": anchor_pass,
+    }
+
+
+def _write_markdown(output_path: Path, summary: dict[str, Any]) -> None:
+    lines = [
+        "# Hybrid Public Benchmark Package Summary",
+        "",
+        f"- package_name: {summary['package_name']}",
+        f"- headline_pass: {summary['headline_pass']}",
+        f"- sign_of_life_pass: {summary['sign_of_life_pass']}",
+        f"- sign_of_life_track_count: {summary['sign_of_life_track_count']}",
+        f"- anchor_pass: {summary['anchor_pass']}",
+        f"- target_macro_average_delta: {summary['target_macro_average_delta']:.3f}",
+        "",
+    ]
+    for track_id, payload in summary["tracks"].items():
+        lines.append(f"## {track_id}")
+        lines.append(f"- suite: {payload['suite']}")
+        lines.append(f"- benchmark_task: {payload['benchmark_task']}")
+        lines.append(f"- role: {payload['role']}")
+        for mode, mode_payload in payload["modes"].items():
+            lines.append(f"- {mode}: mean_success={mode_payload['mean_success']:.3f}, num_runs={mode_payload['num_runs']}")
+        if "delta_active_vs_trunk" in payload:
+            lines.append(f"- delta_active_vs_trunk: {payload['delta_active_vs_trunk']:.3f}")
+        if "delta_noop_vs_trunk" in payload:
+            lines.append(f"- delta_noop_vs_trunk: {payload['delta_noop_vs_trunk']:.3f}")
+        if "delta_active_vs_trunk_ci95" in payload:
+            low, high = payload["delta_active_vs_trunk_ci95"]
+            lines.append(f"- delta_active_vs_trunk_ci95: [{low:.3f}, {high:.3f}]")
+        if "signs_of_life" in payload:
+            lines.append(f"- signs_of_life: {payload['signs_of_life']}")
+        if "anchor_within_tolerance" in payload:
+            lines.append(f"- anchor_within_tolerance: {payload['anchor_within_tolerance']}")
+        lines.append("")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate and summarize the public benchmark package results.")
+    parser.add_argument("--result", action="append", default=[], help="Path to a normalized benchmark result JSON.")
+    parser.add_argument("--output-dir", type=Path, default=Path("/workspace") / "reports" / "public_hybrid_benchmark_v1")
+    parser.add_argument("--bootstrap-samples", type=int, default=2000)
+    parser.add_argument("--bootstrap-seed", type=int, default=0)
+    parser.add_argument("--write-default-manifest", type=Path, default=None)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    if args.write_default_manifest is not None:
+        path = write_default_public_benchmark_manifest(args.write_default_manifest)
+        print(json.dumps({"wrote_manifest": str(path)}, indent=2))
+        if not args.result:
+            return
+    if not args.result:
+        raise SystemExit("No results provided. Pass one or more --result files or use --write-default-manifest.")
+
+    payloads = [_load_json(path) for path in args.result]
+    summary = summarize_public_benchmark_package(
+        payloads,
+        bootstrap_samples=args.bootstrap_samples,
+        bootstrap_seed=args.bootstrap_seed,
+    )
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    json_path = args.output_dir / "public_benchmark_package_summary.json"
+    md_path = args.output_dir / "public_benchmark_package_summary.md"
+    json_path.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    _write_markdown(md_path, summary)
+    print(json.dumps({"summary_json": str(json_path), "summary_md": str(md_path)}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

code/VLAarchtests4/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/eval/run_rlbench_hybrid_smoke.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from eval.public_benchmark_package import (
+    build_public_eval_protocol,
+    build_target_training_spec,
+    public_track_by_id,
+)
+
+
+WORKSPACE_ROOT = Path("/workspace")
+DEFAULT_REPORT_DIR = WORKSPACE_ROOT / "reports" / "public_hybrid_benchmark_smoke_v1" / "rlbench2"
+DEFAULT_COPPELIASIM_ROOT = WORKSPACE_ROOT / "assets" / "coppeliasim_v4_1_0"
+
+
+def _configure_runtime_env() -> None:
+    coppeliasim_root = Path(os.environ.get("COPPELIASIM_ROOT", str(DEFAULT_COPPELIASIM_ROOT)))
+    os.environ.setdefault("COPPELIASIM_ROOT", str(coppeliasim_root))
+    os.environ["LD_LIBRARY_PATH"] = f"{coppeliasim_root}:{os.environ.get('LD_LIBRARY_PATH', '')}".rstrip(":")
+    os.environ.setdefault("QT_QPA_PLATFORM_PLUGIN_PATH", str(coppeliasim_root))
+    os.environ.setdefault("QT_PLUGIN_PATH", str(coppeliasim_root))
+    os.environ.setdefault("XDG_RUNTIME_DIR", "/tmp/runtime-root")
+    Path(os.environ["XDG_RUNTIME_DIR"]).mkdir(parents=True, exist_ok=True)
+
+
+_configure_runtime_env()
+
+from rlbench.action_modes.action_mode import BimanualMoveArmThenGripper  # noqa: E402
+from rlbench.action_modes.arm_action_modes import BimanualEndEffectorPoseViaPlanning  # noqa: E402
+from rlbench.action_modes.gripper_action_modes import BimanualDiscrete  # noqa: E402
+from rlbench.environment import Environment  # noqa: E402
+from rlbench.observation_config import CameraConfig, ObservationConfig  # noqa: E402
+from rlbench.bimanual_tasks.bimanual_lift_tray import BimanualLiftTray  # noqa: E402
+from rlbench.bimanual_tasks.bimanual_put_bottle_in_fridge import BimanualPutBottleInFridge  # noqa: E402
+from rlbench.bimanual_tasks.bimanual_take_shoes_out_of_box import BimanualTakeShoesOutOfBox  # noqa: E402
+from rlbench.bimanual_tasks.bimanual_straighten_rope import BimanualStraightenRope  # noqa: E402
+from rlbench.bimanual_tasks.bimanual_sweep_to_dustpan import BimanualSweepToDustpan  # noqa: E402
+from rlbench.bimanual_tasks.bimanual_take_tray_out_of_oven import BimanualTakeTrayOutOfOven  # noqa: E402
+
+
+@dataclass(frozen=True)
+class RLBenchTaskSpec:
+    track_id: str
+    task_cls: type
+
+
+RLBENCH_TASKS: tuple[RLBenchTaskSpec, ...] = (
+    RLBenchTaskSpec("rlbench2_put_bottle_in_fridge", BimanualPutBottleInFridge),
+    RLBenchTaskSpec("rlbench2_take_out_tray", BimanualTakeTrayOutOfOven),
+    RLBenchTaskSpec("rlbench2_take_shoes_out_of_box", BimanualTakeShoesOutOfBox),
+    RLBenchTaskSpec("rlbench2_lift_tray", BimanualLiftTray),
+    RLBenchTaskSpec("rlbench2_straighten_rope", BimanualStraightenRope),
+    RLBenchTaskSpec("rlbench2_sweep_to_dustpan", BimanualSweepToDustpan),
+)
+
+
+def _camera_configs(resolution: int) -> dict[str, CameraConfig]:
+    disabled = CameraConfig(
+        rgb=False,
+        depth=False,
+        point_cloud=False,
+        mask=False,
+        image_size=(resolution, resolution),
+    )
+    return {
+        "over_shoulder_left": disabled,
+        "over_shoulder_right": disabled,
+        "overhead": disabled,
+        "wrist_right": disabled,
+        "wrist_left": disabled,
+        "front": disabled,
+    }
+
+
+def _obs_config(resolution: int) -> ObservationConfig:
+    return ObservationConfig(
+        camera_configs=_camera_configs(resolution),
+        joint_velocities=False,
+        joint_positions=False,
+        joint_forces=False,
+        gripper_open=True,
+        gripper_pose=True,
+        gripper_matrix=False,
+        gripper_joint_positions=False,
+        gripper_touch_forces=False,
+        wrist_camera_matrix=False,
+        task_low_dim_state=True,
+        record_ignore_collisions=True,
+        robot_name="dual_panda",
+    )
+
+
+def _nudge_action(obs: Any, z_delta: float) -> np.ndarray:
+    right_pose = np.asarray(obs.right.gripper_pose, dtype=np.float32).reshape(-1)[:7].copy()
+    left_pose = np.asarray(obs.left.gripper_pose, dtype=np.float32).reshape(-1)[:7].copy()
+    right_pose[2] += np.float32(z_delta)
+    left_pose[2] += np.float32(z_delta)
+    return np.concatenate(
+        [
+            right_pose,
+            np.asarray([1.0, 1.0], dtype=np.float32),
+            left_pose,
+            np.asarray([1.0, 1.0], dtype=np.float32),
+        ],
+        axis=0,
+    )
+
+
+def _mode_train_variant(adapter_mode: str) -> str:
+    return "adapter_active_ft" if adapter_mode == "adapter_noop" else adapter_mode
+
+
+def _run_task(
+    spec: RLBenchTaskSpec,
+    *,
+    adapter_mode: str,
+    seed: int,
+    resolution: int,
+    z_delta: float,
+) -> dict[str, Any]:
+    track = public_track_by_id(spec.track_id)
+    env = Environment(
+        action_mode=BimanualMoveArmThenGripper(
+            BimanualEndEffectorPoseViaPlanning(),
+            BimanualDiscrete(),
+        ),
+        obs_config=_obs_config(resolution),
+        headless=True,
+        robot_setup="dual_panda",
+    )
+    started_at = time.time()
+    try:
+        env.launch()
+        task = env.get_task(spec.task_cls)
+        descriptions, obs = task.reset()
+        action = _nudge_action(obs, z_delta)
+        _, reward, terminate = task.step(action)
+        right_pose_norm = float(np.linalg.norm(np.asarray(obs.right.gripper_pose, dtype=np.float32)[:3]))
+        left_pose_norm = float(np.linalg.norm(np.asarray(obs.left.gripper_pose, dtype=np.float32)[:3]))
+        action_translation_norm = float(np.linalg.norm(action[[0, 1, 2, 9, 10, 11]]))
+        smoke_pass = bool(
+            np.isfinite(right_pose_norm)
+            and np.isfinite(left_pose_norm)
+            and np.isfinite(action_translation_norm)
+            and max(right_pose_norm, left_pose_norm, action_translation_norm) > 0.0
+        )
+        result = {
+            "track_id": track.track_id,
+            "suite": track.suite,
+            "benchmark_task": track.benchmark_task,
+            "adapter_mode": adapter_mode,
+            "seed": seed,
+            "episodes": 1,
+            "successes": [int(smoke_pass)],
+            "success_rate": float(smoke_pass),
+            "eval_protocol": build_public_eval_protocol(
+                track_id=track.track_id,
+                eval_mode=adapter_mode,
+                seed=seed,
+                episodes=1,
+                resolution=resolution,
+            ),
+            "train_spec": build_target_training_spec(
+                track_id=track.track_id,
+                model_variant=_mode_train_variant(adapter_mode),
+                seed=seed,
+            ),
+            "smoke_pass": smoke_pass,
+            "task_success": bool(float(reward) > 0.0),
+            "reward": float(reward),
+            "terminate": bool(terminate),
+            "description_count": len(descriptions),
+            "right_pose_norm": right_pose_norm,
+            "left_pose_norm": left_pose_norm,
+            "action_translation_norm": action_translation_norm,
+            "runtime_sec": float(time.time() - started_at),
+        }
+    finally:
+        env.shutdown()
+    return result
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run minimal RLBench2 smoke checks for the hybrid public benchmark.")
+    parser.add_argument("--output-dir", type=Path, default=DEFAULT_REPORT_DIR)
+    parser.add_argument("--adapter-mode", type=str, default="trunk_only_ft")
+    parser.add_argument("--seed", type=int, default=17)
+    parser.add_argument("--resolution", type=int, default=256)
+    parser.add_argument("--z-delta", type=float, default=0.01)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    results: list[dict[str, Any]] = []
+    failures: list[str] = []
+    for spec in RLBENCH_TASKS:
+        track = public_track_by_id(spec.track_id)
+        try:
+            result = _run_task(
+                spec,
+                adapter_mode=args.adapter_mode,
+                seed=args.seed,
+                resolution=args.resolution,
+                z_delta=args.z_delta,
+            )
+        except Exception as exc:  # pragma: no cover - exercised in live smoke runs only
+            result = {
+                "track_id": track.track_id,
+                "suite": track.suite,
+                "benchmark_task": track.benchmark_task,
+                "adapter_mode": args.adapter_mode,
+                "seed": args.seed,
+                "episodes": 1,
+                "successes": [0],
+                "success_rate": 0.0,
+                "eval_protocol": build_public_eval_protocol(
+                    track_id=track.track_id,
+                    eval_mode=args.adapter_mode,
+                    seed=args.seed,
+                    episodes=1,
+                    resolution=args.resolution,
+                ),
+                "train_spec": build_target_training_spec(
+                    track_id=track.track_id,
+                    model_variant=_mode_train_variant(args.adapter_mode),
+                    seed=args.seed,
+                ),
+                "smoke_pass": False,
+                "error": repr(exc),
+            }
+            failures.append(track.track_id)
+        results.append(result)
+        output_path = args.output_dir / f"{track.track_id}__{args.adapter_mode}_seed{args.seed}.json"
+        output_path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    summary = {
+        "suite": "rlbench2",
+        "adapter_mode": args.adapter_mode,
+        "seed": args.seed,
+        "tracks": [result["track_id"] for result in results],
+        "smoke_pass_count": sum(int(result.get("smoke_pass", False)) for result in results),
+        "task_success_count": sum(int(result.get("task_success", False)) for result in results),
+        "failures": failures,
+        "result_files": [
+            str(args.output_dir / f"{result['track_id']}__{args.adapter_mode}_seed{args.seed}.json")
+            for result in results
+        ],
+    }
+    summary_path = args.output_dir / "rlbench_hybrid_smoke_summary.json"
+    summary_path.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps({"summary_path": str(summary_path), "smoke_pass_count": summary["smoke_pass_count"]}, indent=2))
+    if failures:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

third_party/AnyBimanual/third_party/PyRep/.gitignore

@@ -0,0 +1,102 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+./idea
+.idea/
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+pyrep/backend/_sim_cffi*
+

third_party/AnyBimanual/third_party/PyRep/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Stephen James
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

third_party/AnyBimanual/third_party/PyRep/README.md

@@ -0,0 +1,284 @@
+# PyRep [![Build Status](https://github.com/stepjam/PyRep/workflows/Build/badge.svg)](https://github.com/stepjam/PyRep/actions) [![Discord](https://img.shields.io/discord/694945313638842378.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/eTMsa5Y)
+
+
+__PyRep is a toolkit for robot learning research, built on top of [CoppeliaSim](http://www.coppeliarobotics.com/) (previously called V-REP).__
+
+
+- [Install](#install)
+- [Running Headless](#running-headless)
+- [Getting Started](#getting-started)
+- [Usage](#usage)
+- [Supported Robots](#supported-robots)
+- [Adding Robots](#adding-robots)
+- [Contributing](#contributing)
+- [Projects Using PyRep](#projects-using-pyrep)
+- [What Happened to V-REP?](#what-happened-to-v-rep)
+- [Citation](#citation)
+
+
+## Install
+
+PyRep requires version **4.1** of CoppeliaSim. Download: 
+- [Ubuntu 16.04](https://www.coppeliarobotics.com/files/CoppeliaSim_Edu_V4_1_0_Ubuntu16_04.tar.xz)
+- [Ubuntu 18.04](https://www.coppeliarobotics.com/files/CoppeliaSim_Edu_V4_1_0_Ubuntu18_04.tar.xz)
+- [Ubuntu 20.04](https://www.coppeliarobotics.com/files/CoppeliaSim_Edu_V4_1_0_Ubuntu20_04.tar.xz)
+
+Once you have downloaded CoppeliaSim, you can pull PyRep from git:
+
+```bash
+git clone https://github.com/stepjam/PyRep.git
+cd PyRep
+```
+
+Add the following to your *~/.bashrc* file: (__NOTE__: the 'EDIT ME' in the first line)
+
+```bash
+export COPPELIASIM_ROOT=EDIT/ME/PATH/TO/COPPELIASIM/INSTALL/DIR
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$COPPELIASIM_ROOT
+export QT_QPA_PLATFORM_PLUGIN_PATH=$COPPELIASIM_ROOT
+```
+
+__Remember to source your bashrc (`source ~/.bashrc`) or 
+zshrc (`source ~/.zshrc`) after this.
+
+Finally install the python library:
+
+```bash
+pip3 install -r requirements.txt
+pip3 install .
+```
+
+You should be good to go!
+Try running one of the examples in the *examples/* folder.
+
+_Although you can use CoppeliaSim on any platform, communication via PyRep is currently only supported on Linux._
+
+#### Troubleshooting
+
+Below are some problems you may encounter during installation. If none of these solve your problem, please raise an issue.
+
+- ModuleNotFoundError: No module named 'pyrep.backend._v_rep_cffi'
+  - If you are getting this error, then please check that you are not running the interpreter from the project root. If you are, then your Python interpreter will try to import those files rather the installed files.
+- error: command 'x86_64-linux-gnu-gcc' failed
+  - You may be missing packages needed for building python extensions. Try: `sudo apt-get install python3-dev`, and then re-run the installation.
+
+## Running Headless
+
+You can run PyRep/CoppeliaSim headlessly with VirtualGL. VirtualGL is an open source toolkit that gives any Unix or Linux remote display software the ability to run OpenGL applications **with full 3D hardware acceleration**.
+First insure that you have the nVidia proprietary driver installed. I.e. you should get an output when running `nvidia-smi`. Now run the following commands:
+```bash
+sudo apt-get install xorg libxcb-randr0-dev libxrender-dev libxkbcommon-dev libxkbcommon-x11-0 libavcodec-dev libavformat-dev libswscale-dev
+sudo nvidia-xconfig -a --use-display-device=None --virtual=1280x1024
+# Install VirtualGL
+wget https://sourceforge.net/projects/virtualgl/files/2.5.2/virtualgl_2.5.2_amd64.deb/download -O virtualgl_2.5.2_amd64.deb
+sudo dpkg -i virtualgl*.deb
+rm virtualgl*.deb
+```
+You will now need to reboot, and then start the X server:
+```bash
+sudo reboot
+nohup sudo X &
+```
+Now we are good to go! To render the application with the first GPU, you can do the following:
+```bash
+export DISPLAY=:0.0
+python my_pyrep_app.py
+```
+To render with the second GPU, you will insetad set display as: `export DISPLAY=:0.1`, and so on.
+
+**Acknowledgement**: Special thanks to Boyuan Chen (UC Berkeley) for bringing VirtualGL to my attention!
+
+## Getting Started
+
+1. First take a look at [Usage](#usage) and the examples in the *examples/* folder to see if PyRep might be able to accelerate your research.
+2. Take a look at the CoppeliaSim [tutorials](http://www.coppeliarobotics.com/helpFiles/en/tutorials.htm).
+
+## Usage
+
+The best way to see how PyRep can help in your research is to look at the examples in the *examples/* folder!
+
+#### Launching the simulation
+
+```python
+from pyrep import PyRep
+
+pr = PyRep()
+# Launch the application with a scene file in headless mode
+pr.launch('scene.ttt', headless=True) 
+pr.start()  # Start the simulation
+
+# Do some stuff
+
+pr.stop()  # Stop the simulation
+pr.shutdown()  # Close the application
+```
+
+
+#### Modifying the Scene
+
+```python
+from pyrep.objects.shape import Shape
+from pyrep.const import PrimitiveShape
+
+object = Shape.create(type=PrimitiveShape.CYLINDER, 
+                      color=[r,g,b], size=[w, h, d],
+                      position=[x, y, z])
+object.set_color([r, g, b])
+object.set_position([x, y, z])
+```
+
+#### Using Robots
+
+Robots are designed to be modular; arms are treated separately to grippers.
+
+Use the robot ttm files defined in robots/ttms. These have been altered slightly from the original ones shipped with CoppeliaSim to allow them to be used with motional planning out of the box. 
+The 'tip' of the robot may not be where you want it, so feel free to play around with this.
+
+```python
+from pyrep import PyRep
+from pyrep.robots.arms.panda import Panda
+from pyrep.robots.end_effectors.panda_gripper import PandaGripper
+
+pr = PyRep()
+# Launch the application with a scene file that contains a robot
+pr.launch('scene_with_panda.ttt') 
+pr.start()  # Start the simulation
+
+arm = Panda()  # Get the panda from the scene
+gripper = PandaGripper()  # Get the panda gripper from the scene
+
+velocities = [.1, .2, .3, .4, .5, .6, .7]
+arm.set_joint_target_velocities(velocities)
+pr.step()  # Step physics simulation
+
+done = False
+# Open the gripper halfway at a velocity of 0.04.
+while not done:
+    done = gripper.actuate(0.5, velocity=0.04)
+    pr.step()
+    
+pr.stop()  # Stop the simulation
+pr.shutdown()  # Close the application
+```
+
+We recommend constructing your robot in a dictionary or a small structure, e.g.
+
+
+```python
+class MyRobot(object):
+  def __init__(self, arm, gripper):
+    self.arm = arm
+    self.gripper = gripper
+
+arm = Panda()  # Get the panda from the scene
+gripper = PandaGripper()  # Get the panda gripper from the scene
+
+# Create robot structure
+my_robot_1 = MyRobot(arm, gripper)
+# OR
+my_robot_2 = {
+  'arm': arm,
+  'gripper': gripper
+}
+```
+
+#### Running Multiple PyRep Instances
+
+Each PyRep instance needs its own process. This can be achieved using Pythons [multiprocessing](https://docs.python.org/3.6/library/multiprocessing.html) module. Here is a simple example:
+
+```python
+from multiprocessing import Process
+
+PROCESSES = 10
+
+def run():
+  pr = PyRep()
+  pr.launch('my_scene.ttt', headless=True)
+  pr.start()
+  # Do stuff...
+  pr.stop()
+  pr.shutdown()
+
+processes = [Process(target=run, args=()) for i in range(PROCESSES)]
+[p.start() for p in processes]
+[p.join() for p in processes]
+```
+
+## Supported Robots
+
+Here is a list of robots currently supported by PyRep:
+
+#### Arms
+
+- Kinova Mico
+- Kinova Jaco
+- Rethink Baxter
+- Rethink Sawyer
+- Franka Emika Panda
+- Kuka LBR iiwa 7 R800
+- Kuka LBR iiwa 14 R820
+- Universal Robots UR3
+- Universal Robots UR5
+- Universal Robots UR10
+
+#### Grippers
+
+- Kinova Mico Hand
+- Kinova Jaco Hand
+- Rethink Baxter Gripper
+- Franka Emika Panda Gripper
+
+#### Mobile Robots
+
+- Kuka YouBot
+- Turtle Bot
+- Line Tracer
+
+Feel free to send pull requests for new robots!
+
+## Adding Robots
+
+If the robot you want is not currently supported, then why not add it in!
+
+[Here is a tutorial for adding robots.](tutorials/adding_robots.md)
+
+## Contributing
+
+We want to make PyRep the best tool for rapid robot learning research. If you would like to get involved, then please [get in contact](https://www.doc.ic.ac.uk/~slj12/)!
+
+Pull requests welcome for bug fixes!
+
+## Projects Using PyRep
+
+If you use PyRep in your work, then get in contact and we can add you to the list!
+
+- [RLBench: The Robot Learning Benchmark & Learning Environment, arxiv 2019](https://arxiv.org/abs/1909.12271)
+- [Learning One-Shot Imitation from Humans without Humans, arxiv 2019](https://arxiv.org/abs/1911.01103)
+- [Task-Embedded Control Networks for Few-Shot Imitation Learning, CoRL 2018](https://arxiv.org/abs/1810.03237)
+- [Transferring End-to-End Visuomotor Control from Simulation to Real World for a Multi-Stage Task
+, CoRL 2017](https://arxiv.org/abs/1707.02267)
+
+## Acknowledgements
+
+- Georges Nomicos (Imperial College London) for the addition of mobile platforms.
+- Boyuan Chen (UC Berkeley) for bringing VirtualGL to my attention.
+
+## What Happened to V-REP?
+
+Coppelia Robotics discontinued development of __V-REP__. Instead, they now focus
+their efforts on __CoppeliaSim__. CoppeliaSim is 100% compatible with V-REP.
+See more information [here](http://coppeliarobotics.com/helpFiles/en/versionInfo.htm#coppeliaSim4.0.0).
+
+PyRep is fully compatible with both V-REP and CoppeliaSim.
+
+
+## Citation
+
+```
+@article{james2019pyrep,
+  title={PyRep: Bringing V-REP to Deep Robot Learning},
+  author={James, Stephen and Freese, Marc and Davison, Andrew J.},
+  journal={arXiv preprint arXiv:1906.11176},
+  year={2019}
+}
+```

third_party/AnyBimanual/third_party/PyRep/pyrep/__init__.py

@@ -0,0 +1,5 @@
+__version__ = '4.1.0.3'
+
+testing = False
+
+from .pyrep import PyRep

third_party/AnyBimanual/third_party/PyRep/pyrep/const.py

@@ -0,0 +1,110 @@
+from pyrep.backend import sim
+from enum import Enum
+
+
+class PrimitiveShape(Enum):
+    CUBOID = 0
+    SPHERE = 1
+    CYLINDER = 2
+    CONE = 3
+
+
+class ObjectType(Enum):
+    ALL = sim.sim_handle_all
+    SHAPE = sim.sim_object_shape_type
+    JOINT = sim.sim_object_joint_type
+    DUMMY = sim.sim_object_dummy_type
+    PROXIMITY_SENSOR = sim.sim_object_proximitysensor_type
+    GRAPH = sim.sim_object_graph_type
+    CAMERA = sim.sim_object_camera_type
+    PATH = sim.sim_object_path_type
+    VISION_SENSOR = sim.sim_object_visionsensor_type
+    VOLUME = sim.sim_object_volume_type
+    MILl = sim.sim_object_mill_type
+    FORCE_SENSOR = sim.sim_object_forcesensor_type
+    LIGHT = sim.sim_object_light_type
+    MIRROR = sim.sim_object_mirror_type
+    OCTREE = sim.sim_object_octree_type
+
+
+class JointType(Enum):
+    REVOLUTE = sim.sim_joint_revolute_subtype
+    PRISMATIC = sim.sim_joint_prismatic_subtype
+    SPHERICAL = sim.sim_joint_spherical_subtype
+
+
+class JointMode(Enum):
+    PASSIVE = sim.sim_jointmode_passive
+    IK = sim.sim_jointmode_ik
+    IK_DEPENDENT = sim.sim_jointmode_ikdependent
+    DEPENDENT = sim.sim_jointmode_dependent
+    FORCE = sim.sim_jointmode_force
+
+
+class ConfigurationPathAlgorithms(Enum):
+    BiTRRT = 'BiTRRT'
+    BITstar = 'BITstar'
+    BKPIECE1 = 'BKPIECE1'
+    CForest = 'CForest'
+    EST = 'EST'
+    FMT = 'FMT'
+    KPIECE1 = 'KPIECE1'
+    LazyPRM = 'LazyPRM'
+    LazyPRMstar = 'LazyPRMstar'
+    LazyRRT = 'LazyRRT'
+    LBKPIECE1 = 'LBKPIECE1'
+    LBTRRT = 'LBTRRT'
+    PDST = 'PDST'
+    PRM = 'PRM'
+    PRMstar = 'PRMstar'
+    pRRT = 'pRRT'
+    pSBL = 'pSBL'
+    RRT = 'RRT'
+    RRTConnect = 'RRTConnect'
+    RRTstar = 'RRTstar'
+    SBL = 'SBL'
+    SPARS = 'SPARS'
+    SPARStwo = 'SPARStwo'
+    STRIDE = 'STRIDE'
+    TRRT = 'TRRT'
+
+
+class TextureMappingMode(Enum):
+    PLANE = sim.sim_texturemap_plane
+    CYLINDER = sim.sim_texturemap_cylinder
+    SPHERE = sim.sim_texturemap_sphere
+    CUBE = sim.sim_texturemap_cube
+
+
+class PerspectiveMode(Enum):
+    ORTHOGRAPHIC = 0
+    PERSPECTIVE = 1
+
+
+class RenderMode(Enum):
+    OPENGL = sim.sim_rendermode_opengl
+    OPENGL_AUXILIARY = sim.sim_rendermode_auxchannels
+    OPENGL_COLOR_CODED = sim.sim_rendermode_colorcoded
+    POV_RAY = sim.sim_rendermode_povray
+    EXTERNAL = sim.sim_rendermode_extrenderer
+    EXTERNAL_WINDOWED = sim.sim_rendermode_extrendererwindowed
+    OPENGL3 = sim.sim_rendermode_opengl3
+    OPENGL3_WINDOWED = sim.sim_rendermode_opengl3windowed
+
+
+class Verbosity(Enum):
+    NONE = 'none'
+    ERRORS = 'errors'
+    WARNINGS = 'warnings'
+    LOAD_INFOS = 'loadinfos'
+    SCRIPT_ERRORS = 'scripterrors'
+    SCRIPT_WARNINGS = 'scriptwarnings'
+    SCRIPT_INFOS = 'scriptinfos'
+    INFOS = 'infos'
+    DEBUG = 'debug'
+    TRACE = 'trace'
+    TRACE_LUA = 'tracelua'
+    TYRACE_ALL = 'traceall'
+
+
+PYREP_SCRIPT_TYPE = sim.sim_scripttype_addonscript

third_party/AnyBimanual/third_party/PyRep/pyrep/errors.py

@@ -0,0 +1,30 @@
+class PyRepError(Exception):
+    pass
+
+
+class WrongObjectTypeError(Exception):
+    pass
+
+
+class ObjectAlreadyRemovedError(Exception):
+    pass
+
+
+class ObjectIsNotModelError(Exception):
+    pass
+
+
+class ConfigurationError(Exception):
+    pass
+
+
+class ConfigurationPathError(Exception):
+    pass
+
+
+class GripperError(Exception):
+    pass
+
+
+class IKError(Exception):
+    pass

third_party/AnyBimanual/third_party/PyRep/pyrep/misc/__init__.py

@@ -0,0 +1 @@
+"""Compatibility placeholder for PyRep packaging."""

third_party/AnyBimanual/third_party/PyRep/pyrep/pyrep.py

@@ -0,0 +1,332 @@
+import numpy as np
+from contextlib import contextmanager
+from pyrep.backend import sim, utils
+from pyrep.const import Verbosity
+from pyrep.objects.object import Object
+from pyrep.objects.shape import Shape
+from pyrep.textures.texture import Texture
+from pyrep.errors import PyRepError
+from pyrep.backend import sim
+import os
+import sys
+import time
+import threading
+from typing import Tuple, List
+import warnings
+
+
+class PyRep(object):
+    """Used for interfacing with the CoppeliaSim simulation.
+
+    Can be used for starting, stopping, and stepping the simulation. As well
+    as getting, and creating scene objects and robots.
+    """
+
+    def __init__(self):
+        self.running = False
+        self._process = None
+        self._robot_to_count = {}
+        self.connected = False
+
+        self._ui_thread = None
+        self._responsive_ui_thread = None
+
+        self._init_thread_id = None
+        self._shutting_down = False
+
+        self._handles_to_objects = {}
+
+        if 'COPPELIASIM_ROOT' not in os.environ:
+            raise PyRepError(
+                'COPPELIASIM_ROOT not defined. See installation instructions.')
+        self._vrep_root = os.environ['COPPELIASIM_ROOT']
+        if not os.path.exists(self._vrep_root):
+            raise PyRepError(
+                'COPPELIASIM_ROOT was not a correct path. '
+                'See installation instructions')
+
+    def _run_ui_thread(self, scene_file: str, headless: bool,
+                       verbosity: Verbosity) -> None:
+        # Need this otherwise extensions will not be loaded
+        os.chdir(self._vrep_root)
+        options = sim.sim_gui_headless if headless else sim.sim_gui_all
+        sim.simSetStringParameter(
+            sim.sim_stringparam_verbosity, verbosity.value)
+        sim.simExtLaunchUIThread(
+            options=options, scene=scene_file, pyrep_root=self._vrep_root)
+
+    def _run_responsive_ui_thread(self) -> None:
+        while True:
+            if not self.running:
+                with utils.step_lock:
+                    if self._shutting_down or sim.simExtGetExitRequest():
+                        break
+                    sim.simExtStep(False)
+            time.sleep(0.01)
+        # If the exit request was from the UI, then call shutdown, otherwise
+        # shutdown caused this thread to terminate.
+        if not self._shutting_down:
+            self.shutdown()
+
+    def launch(self, scene_file: str = "", headless: bool = False,
+               responsive_ui: bool = False, blocking: bool = False,
+               verbosity: Verbosity = Verbosity.NONE) -> None:
+        """Launches CoppeliaSim.
+
+        Launches the UI thread, waits until the UI thread has finished, this
+        results in the current thread becoming the simulation thread.
+
+        :param scene_file: The scene file to load. Empty string for empty scene.
+        :param headless: Run CoppeliaSim in simulation mode.
+        :param responsive_ui: If True, then a separate thread will be created to
+            asynchronously step the UI of CoppeliaSim. Note, that will reduce
+            the responsiveness of the simulation thread.
+        :param blocking: Causes CoppeliaSim to launch as if running the default
+            c++ client application. This is causes the function to block.
+            For most users, this will be set to False.
+        :param verbosity: The verbosity level for CoppeliaSim.
+            Usually Verbosity.NONE or Verbosity.LOAD_INFOS.
+        """
+        abs_scene_file = os.path.abspath(scene_file)
+        if len(scene_file) > 0 and not os.path.isfile(abs_scene_file):
+            raise PyRepError('Scene file does not exist: %s' % scene_file)
+        cwd = os.getcwd()
+        self._ui_thread = threading.Thread(
+            target=self._run_ui_thread,
+            args=(abs_scene_file, headless, verbosity))
+        self._ui_thread.daemon = True
+        self._ui_thread.start()
+
+        while not sim.simExtCanInitSimThread():
+            time.sleep(0.1)
+
+        sim.simExtSimThreadInit()
+        time.sleep(0.2)  # Stops CoppeliaSim crashing if restarted too quickly.
+
+        if blocking:
+            while not sim.simExtGetExitRequest():
+                sim.simExtStep()
+            self.shutdown()
+        elif responsive_ui:
+            self._responsive_ui_thread = threading.Thread(
+                target=self._run_responsive_ui_thread)
+            self._responsive_ui_thread.daemon = True
+            try:
+                self._responsive_ui_thread.start()
+            except (KeyboardInterrupt, SystemExit):
+                if not self._shutting_down:
+                    self.shutdown()
+                sys.exit()
+            self.step()
+        else:
+            self.step()
+        os.chdir(cwd)  # Go back to the previous cwd
+
+    def script_call(self, function_name_at_script_name: str,
+                    script_handle_or_type: int,
+                    ints=(), floats=(), strings=(), bytes='') -> (
+            Tuple[List[int], List[float], List[str], str]):
+        """Calls a script function (from a plugin, the main client application,
+        or from another script). This represents a callback inside of a script.
+
+        :param function_name_at_script_name: A string representing the function
+            name and script name, e.g. myFunctionName@theScriptName. When the
+            script is not associated with an object, then just specify the
+            function name.
+        :param script_handle_or_type: The handle of the script, otherwise the
+            type of the script.
+        :param ints: The input ints to the script.
+        :param floats: The input floats to the script.
+        :param strings: The input strings to the script.
+        :param bytes: The input bytes to the script (as a string).
+        :return: Any number of return values from the called Lua function.
+        """
+        return utils.script_call(
+            function_name_at_script_name, script_handle_or_type, ints, floats,
+            strings, bytes)
+
+    def shutdown(self) -> None:
+        """Shuts down the CoppeliaSim simulation.
+        """
+        if self._ui_thread is None:
+            raise PyRepError(
+                'CoppeliaSim has not been launched. Call launch first.')
+        if self._ui_thread is not None:
+            self._shutting_down = True
+            self.stop()
+            self.step_ui()
+            sim.simExtPostExitRequest()
+            sim.simExtSimThreadDestroy()
+            self._ui_thread.join()
+            if self._responsive_ui_thread is not None:
+                self._responsive_ui_thread.join()
+            # CoppeliaSim crashes if new instance opened too quickly after shutdown.
+            # TODO: A small sleep stops this for now.
+            time.sleep(0.1)
+        self._ui_thread = None
+        self._shutting_down = False
+
+    def start(self) -> None:
+        """Starts the physics simulation if it is not already running.
+        """
+        if self._ui_thread is None:
+            raise PyRepError(
+                'CoppeliaSim has not been launched. Call launch first.')
+        if not self.running:
+            sim.simStartSimulation()
+            self.running = True
+
+    def stop(self) -> None:
+        """Stops the physics simulation if it is running.
+        """
+        if self._ui_thread is None:
+            raise PyRepError(
+                'CoppeliaSim has not been launched. Call launch first.')
+        if self.running:
+            sim.simStopSimulation()
+            self.running = False
+            # Need this so the UI updates
+            [self.step() for _ in range(5)]  # type: ignore
+
+    def step(self) -> None:
+        """Execute the next simulation step.
+
+        If the physics simulation is not running, then this will only update
+        the UI.
+        """
+        with utils.step_lock:
+            sim.simExtStep()
+
+    def step_ui(self) -> None:
+        """Update the UI.
+
+        This will not execute the next simulation step, even if the physics
+        simulation is running.
+        This is only applicable when PyRep was launched without a responsive UI.
+        """
+        with utils.step_lock:
+            sim.simExtStep(False)
+
+    def set_simulation_timestep(self, dt: float) -> None:
+        """Sets the simulation time step. Default is 0.05.
+
+        :param dt: The time step value in seconds.
+        """
+        sim.simSetFloatParameter(sim.sim_floatparam_simulation_time_step, dt)
+        if not np.allclose(self.get_simulation_timestep(), dt):
+            warnings.warn('Could not change simulation timestep. You may need '
+                          'to change it to "custom dt" using simulation '
+                          'settings dialog.')
+
+    def get_simulation_timestep(self) -> float:
+        """Gets the simulation time step.
+
+        :return: The time step value in seconds.
+        """
+        return sim.simGetSimulationTimeStep()
+
+    def set_configuration_tree(self, config_tree: bytes) -> None:
+        """Restores configuration information previously retrieved.
+
+        Configuration information (object relative positions/orientations,
+        joint/path values) can be retrieved with
+        :py:meth:`Object.get_configuration_tree`. Dynamically simulated
+        objects will implicitly be reset before the command is applied
+        (i.e. similar to calling :py:meth:`Object.reset_dynamic_object` just
+        before).
+
+        :param config_tree: The configuration tree to restore.
+        """
+        sim.simSetConfigurationTree(config_tree)
+
+    def group_objects(self, objects: List[Shape]) -> Shape:
+        """Groups several shapes into a compound shape (or simple shape).
+
+        :param objects: The list of shapes to group.
+        :return: A single grouped shape.
+        """
+        handles = [o.get_handle() for o in objects]
+        handle = sim.simGroupShapes(handles)
+        return Shape(handle)
+
+    def merge_objects(self, objects: List[Shape]) -> Shape:
+        """Merges several shapes into a compound shape (or simple shape).
+
+        :param objects: The list of shapes to group.
+        :return: A single merged shape.
+        """
+        handles = [o.get_handle() for o in objects]
+        # FIXME: sim.simGroupShapes(merge=True) won't return correct handle,
+        # so we use name to find correct handle of the merged shape.
+        name = objects[-1].get_name()
+        sim.simGroupShapes(handles, merge=True)
+        return Shape(name)
+
+    def export_scene(self, filename: str) -> None:
+        """Saves the current scene.
+
+        :param filename: scene filename. The filename extension is required
+            ("ttt").
+        """
+        sim.simSaveScene(filename)
+
+    def import_model(self, filename: str) -> Object:
+        """	Loads a previously saved model.
+
+        :param filename: model filename. The filename extension is required
+            ("ttm"). An optional "@copy" can be appended to the filename, in
+            which case the model's objects will be named/renamed as if an
+            associated script was attached to the model.
+        :return: The imported model.
+        """
+        handle = sim.simLoadModel(filename)
+        return utils.to_type(handle)
+
+    def create_texture(self, filename: str, interpolate=True, decal_mode=False,
+                       repeat_along_u=False, repeat_along_v=False
+                       ) -> Tuple[Shape, Texture]:
+        """Creates a planar shape that is textured.
+
+        :param filename: Path to the texture to load.
+        :param interpolate: Adjacent texture pixels are not interpolated.
+        :param decal_mode: Texture is applied as a decal (its appearance
+            won't be influenced by light conditions).
+        :param repeat_along_u: Texture will be repeated along the U direction.
+        :param repeat_along_v: Texture will be repeated along the V direction.
+        :return: A tuple containing the textured plane and the texture.
+        """
+        options = 0
+        if not interpolate:
+            options |= 1
+        if decal_mode:
+            options |= 2
+        if repeat_along_u:
+            options |= 3
+        if repeat_along_v:
+            options |= 4
+        handle = sim.simCreateTexture(filename, options)
+        s = Shape(handle)
+        return s, s.get_texture()
+
+    def get_objects_in_tree(self, root_object=None, *args, **kwargs
+                            ) -> List[Object]:
+        """Retrieves the objects in a given hierarchy tree.
+
+        :param root_object: The root object in the tree. Pass None to retrieve
+            all objects in the configuration tree. :py:class:`Object` or `int`.
+        :param object_type: The object type to retrieve.
+            One of :py:class:`.ObjectType`.
+        :param exclude_base: Exclude the tree base from the returned list.
+        :param first_generation_only: Include in the returned list only the
+            object's first children. Otherwise, entire hierarchy is returned.
+        :return: A list of objects in the hierarchy tree.
+        """
+        return Object._get_objects_in_tree(root_object, *args, **kwargs)
+
+    def get_collection_handle_by_name(self, collection_name: str) -> int:
+        """Retrieves the integer handle for a given collection.
+
+        :param collection_name: Name of the collection to retrieve the integer handle for
+        :return: An integer handle for the collection
+        """
+        return sim.simGetCollectionHandle(collection_name)

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/end_effectors/xarm_gripper.py

@@ -0,0 +1,13 @@
+from pyrep.robots.end_effectors.gripper import Gripper
+
+
+class XArmGripper(Gripper):
+
+    def __init__(self, count: int = 0):
+        super().__init__(count, 'xarm_gripper',
+                         ['xarm_left_inner_knuckle_joint',
+                          'xarm_right_inner_knuckle_joint',
+                          'xarm_drive_joint',
+                          'xarm_left_finger_joint',
+                          'xarm_right_outer_knuckle_joint',
+                          'xarm_right_finger_joint'])

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/mobiles/holonomic_base.py

@@ -0,0 +1,215 @@
+from pyrep.robots.mobiles.mobile_base import MobileBase
+from pyrep.robots.configuration_paths.holonomic_configuration_path import (
+    HolonomicConfigurationPath)
+from pyrep.backend import utils
+from pyrep.const import PYREP_SCRIPT_TYPE
+from pyrep.const import ConfigurationPathAlgorithms as Algos
+from pyrep.errors import ConfigurationPathError
+from typing import List
+from pyrep.objects.joint import Joint
+from math import pi, sqrt
+
+
+class HolonomicBase(MobileBase):
+
+    def __init__(self,
+                 count: int,
+                 num_wheels: int,
+                 distance_from_target: float,
+                 name: str,
+                 max_velocity: float = 4,
+                 max_velocity_rotation: float = 6,
+                 max_acceleration: float = 0.035):
+        """Init.
+
+        :param count: used for multiple copies of robots.
+        :param num_wheels: number of actuated wheels.
+        :param distance_from_target: offset from target.
+        :param name: string with robot name (same as base in vrep model).
+        :param max_velocity: bounds x,y velocity for motion planning.
+        :param max_velocity_rotation: bounds yaw velocity for motion planning.
+        :param max_acceleration: bounds acceleration for motion planning.
+        """
+
+        super().__init__(count, num_wheels, name)
+
+        suffix = '' if count == 0 else '#%d' % (count - 1)
+
+        self.paramP = 20
+        self.paramO = 10
+        # self.paramO = 30
+        self.previous_forw_back_vel = 0
+        self.previous_left_right_vel = 0
+        self.previous_rot_vel = 0
+        self.accelF = max_acceleration
+        self.maxV = max_velocity
+        self.max_v_rot = max_velocity_rotation
+        self.dist1 = distance_from_target
+
+        joint_slipping_names = [
+            '%s_slipping_m_joint%s%s' % (name, str(i + 1), suffix) for i in
+            range(self.num_wheels)]
+        self.joints_slipping = [Joint(jsname)
+                                for jsname in joint_slipping_names]
+
+    def set_base_angular_velocites(self, velocity: List[float]):
+        """Calls required functions to achieve desired omnidirectional effect.
+
+        :param velocity: A List with forwardBackward, leftRight and rotation
+            velocity (in radian/s)
+        """
+        # self._reset_wheel()
+        fBVel = velocity[0]
+        lRVel = velocity[1]
+        rVel = velocity[2]
+        self.set_joint_target_velocities(
+            [-fBVel - lRVel - rVel, -fBVel + lRVel - rVel,
+             -fBVel - lRVel + rVel, -fBVel + lRVel + rVel])
+
+    def get_linear_path(self, position: List[float],
+                        angle=0) -> HolonomicConfigurationPath:
+        """Initialize linear path and check for collision along it.
+
+        Must specify either rotation in euler or quaternions, but not both!
+
+        :param position: The x, y position of the target.
+        :param angle: The z orientation of the target (in radians).
+        :raises: ConfigurationPathError if no path could be created.
+
+        :return: A linear path in the 2d space.
+        """
+        position_base = self.get_position()
+        angle_base = self.get_orientation()[-1]
+
+        self.target_base.set_position(
+            [position[0], position[1], self.target_z])
+        self.target_base.set_orientation([0, 0, angle])
+
+        handle_base = self.get_handle()
+        handle_target_base = self.target_base.get_handle()
+        _, ret_floats, _, _ = utils.script_call(
+            'getBoxAdjustedMatrixAndFacingAngle@PyRep', PYREP_SCRIPT_TYPE,
+            ints=[handle_base, handle_target_base])
+
+        m = ret_floats[:-1]
+        angle = ret_floats[-1]
+        self.intermediate_target_base.set_position(
+            [m[3] - m[0] * self.dist1, m[7] - m[4] * self.dist1,
+             self.target_z])
+        self.intermediate_target_base.set_orientation([0, 0, angle])
+        self.target_base.set_orientation([0, 0, angle])
+
+        path = [[position_base[0], position_base[1], angle_base],
+                [position[0], position[1], angle]]
+
+        if self._check_collision_linear_path(path):
+            raise ConfigurationPathError(
+                'Could not create path. '
+                'An object was detected on the linear path.')
+
+        return HolonomicConfigurationPath(self, path)
+
+    def get_nonlinear_path(self, position: List[float],
+                           angle=0,
+                           boundaries=2,
+                           path_pts=600,
+                           ignore_collisions=False,
+                           algorithm=Algos.RRTConnect
+                            ) -> HolonomicConfigurationPath:
+        """Gets a non-linear (planned) configuration path given a target pose.
+
+        :param position: The x, y, z position of the target.
+        :param angle: The z orientation of the target (in radians).
+        :param boundaries: A float defining the path search in x and y direction
+            [[-boundaries,boundaries],[-boundaries,boundaries]].
+        :param path_pts: The number of sampled points returned from the
+            computed path
+        :param ignore_collisions: If collision checking should be disabled.
+        :param algorithm: Algorithm used to compute path
+        :raises: ConfigurationPathError if no path could be created.
+
+        :return: A non-linear path (x,y,angle) in the xy configuration space.
+        """
+
+        path = self._get_nonlinear_path_points(
+            position, angle, boundaries, path_pts, ignore_collisions, algorithm)
+
+        return HolonomicConfigurationPath(self, path)
+
+    def get_base_actuation(self):
+        """Proportional controller.
+
+        :return: A list with left and right joint velocity,
+            and a bool representing target is reached.
+        """
+
+        handleBase = self.get_handle()
+        handle_inter_target_base = self.intermediate_target_base.get_handle()
+        pos_v = self.target_base.get_position(relative_to=self)
+        or_v = self.target_base.get_orientation(relative_to=self)
+
+        pos_inter = self.intermediate_target_base.get_position(
+            relative_to=self)
+        or_inter = self.intermediate_target_base.get_orientation(
+            relative_to=self)
+
+        if (sqrt((pos_v[0]) ** 2 + (
+        pos_v[1]) ** 2) - self.dist1) < 0.001 and or_v[-1] < 0.1 * pi / 180:
+            return [self.previous_forw_back_vel, self.previous_left_right_vel,
+                    self.previous_rot_vel], True
+
+        forw_back_vel = pos_inter[1] * self.paramP
+        left_right_vel = pos_inter[0] * self.paramP
+        rot_vel = - or_inter[2] * self.paramO
+
+        v = sqrt(forw_back_vel * forw_back_vel +
+                 left_right_vel * left_right_vel)
+        if v > self.maxV:
+            forw_back_vel = forw_back_vel * self.maxV / v
+            left_right_vel = left_right_vel * self.maxV / v
+
+        if (abs(rot_vel) > self.max_v_rot):
+            rot_vel = self.max_v_rot * rot_vel / abs(rot_vel)
+
+        df = forw_back_vel - self.previous_forw_back_vel
+        ds = left_right_vel - self.previous_left_right_vel
+        dr = rot_vel - self.previous_rot_vel
+
+        if abs(df) > self.maxV * self.accelF:
+            df = abs(df) * (self.maxV * self.accelF) / df
+
+        if abs(ds) > self.maxV * self.accelF:
+            ds = abs(ds) * (self.maxV * self.accelF) / ds
+
+        if abs(dr) > self.max_v_rot * self.accelF:
+            dr = abs(dr) * (self.max_v_rot * self.accelF) / dr
+
+        forw_back_vel = self.previous_forw_back_vel + df
+        left_right_vel = self.previous_left_right_vel + ds
+        rot_vel = self.previous_rot_vel + dr
+
+        self.previous_forw_back_vel = forw_back_vel
+        self.previous_left_right_vel = left_right_vel
+        self.previous_rot_vel = rot_vel
+
+        return [forw_back_vel, left_right_vel, rot_vel], False
+
+    def _reset_wheel(self):
+        """Required to achieve desired omnidirectional wheel effect.
+        """
+        [j.reset_dynamic_object() for j in self.wheels]
+
+        p = [[-pi / 4, 0, 0], [pi / 4, 0, pi], [-pi / 4, 0, 0], [pi / 4, 0, pi]]
+
+        for i in range(self.num_wheels):
+            self.joints_slipping[i].set_position([0, 0, 0],
+                                                 relative_to=self.joints[i],
+                                                 reset_dynamics=False)
+            self.joints_slipping[i].set_orientation(p[i],
+                                                    relative_to=self.joints[i],
+                                                    reset_dynamics=False)
+            self.wheels[i].set_position([0, 0, 0], relative_to=self.joints[i],
+                                        reset_dynamics=False)
+            self.wheels[i].set_orientation([0, 0, 0],
+                                           relative_to=self.joints[i],
+                                           reset_dynamics=False)

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/mobiles/line_tracer.py

@@ -0,0 +1,6 @@
+from pyrep.robots.mobiles.mobile_base import MobileBase
+
+
+class LineTracer(MobileBase):
+    def __init__(self, count: int = 0):
+        super().__init__(count, 2, 'LineTracer')

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/mobiles/locobot.py

@@ -0,0 +1,6 @@
+from pyrep.robots.mobiles.nonholonomic_base import NonHolonomicBase
+
+
+class LoCoBot(NonHolonomicBase):
+    def __init__(self, count: int = 0):
+        super().__init__(count, 2, 'LoCoBot')

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/mobiles/mobile_base.py

@@ -0,0 +1,202 @@
+from pyrep.backend import sim, utils
+from pyrep.objects.dummy import Dummy
+from pyrep.objects.shape import Shape
+from pyrep.robots.robot_component import RobotComponent
+from pyrep.const import ConfigurationPathAlgorithms as Algos
+from pyrep.errors import ConfigurationPathError
+from pyrep.const import PYREP_SCRIPT_TYPE
+from typing import List, Union
+from math import sqrt
+import numpy as np
+
+
+class MobileBase(RobotComponent):
+    """Base class representing a robot mobile base with path planning support.
+    """
+
+    def __init__(self, count: int, num_wheels: int, name: str):
+        """Count is used for when we have multiple copies of mobile bases.
+
+        :param count: used for multiple copies of robots
+        :param num_wheels: number of actuated wheels
+        :param name: string with robot name (same as base in vrep model).
+        """
+
+        joint_names = ['%s_m_joint%s' % (name, str(i + 1)) for i in
+                       range(num_wheels)]
+        super().__init__(count, name, joint_names)
+
+        self.num_wheels = num_wheels
+        suffix = '' if count == 0 else '#%d' % (count - 1)
+
+        wheel_names = ['%s_wheel%s%s' % (name, str(i + 1), suffix) for i in
+                       range(self.num_wheels)]
+        self.wheels = [Shape(name) for name in wheel_names]
+
+        # Motion planning handles
+        self.intermediate_target_base = Dummy(
+            '%s_intermediate_target_base%s' % (name, suffix))
+        self.target_base = Dummy('%s_target_base%s' % (name, suffix))
+
+        self._collision_collection = sim.simGetCollectionHandle(
+            '%s_base%s' % (name, suffix))
+
+        # Robot parameters and handle
+        self.z_pos = self.get_position()[2]
+        self.target_z = self.target_base.get_position()[-1]
+        self.wheel_radius = self.wheels[0].get_bounding_box()[5]  # Z
+        self.wheel_distance = np.linalg.norm(
+            np.array(self.wheels[0].get_position()) -
+            np.array(self.wheels[1].get_position()))
+
+        # Make sure dummies are orphan if loaded with ttm
+        self.intermediate_target_base.set_parent(None)
+        self.target_base.set_parent(None)
+
+    def get_2d_pose(self) -> np.ndarray:
+        """Gets the 2D (top-down) pose of the robot [x, y, yaw].
+
+        :return: A List containing the x, y, yaw (in radians).
+        """
+        return np.r_[self.get_position()[:2], self.get_orientation()[-1:]]
+
+    def set_2d_pose(self, pose: Union[List[float], np.ndarray]) -> None:
+        """Sets the 2D (top-down) pose of the robot [x, y, yaw]
+
+        :param pose: A List containing the x, y, yaw (in radians).
+        """
+        x, y, yaw = pose
+        self.set_position([x, y, self.z_pos])
+        self.set_orientation([0, 0, yaw])
+
+    def assess_collision(self):
+        """Silent detection of the robot base with all other entities present in the scene.
+
+        :return: True if collision is detected
+        """
+        return sim.simCheckCollision(self._collision_collection,
+                                     sim.sim_handle_all) == 1
+
+    def set_cartesian_position(self, position: List[float]):
+        """Set a delta target position (x,y) and rotation position
+
+        :param position: length 3 list containing x and y position, and angle position
+
+        NOTE: not supported for nonholonomic mobile bases.
+        """
+        vel = [0, 0, 0]
+        vel[-1] = position[-1]
+        for i in range(2):
+            vel[i] = position[i] / (0.05 * self.wheel_radius / 2)  # "0.05 is dt"
+
+        self.set_base_angular_velocites(vel)
+
+    def set_base_angular_velocites(self, velocity: List[float]):
+        """This function has no effect for two_wheels robot. More control is required for omnidirectional robot.
+
+        :param velocity: for two wheels robot: each wheel velocity, for omnidirectional robot forwardBackward, leftRight and rotation velocity
+        """
+        raise NotImplementedError()
+
+    def _get_nonlinear_path_points(self, position: List[float],
+                           angle=0,
+                           boundaries=2,
+                           path_pts=600,
+                           ignore_collisions=False,
+                           algorithm=Algos.RRTConnect) -> List[List[float]]:
+        """Gets a non-linear (planned) configuration path given a target pose.
+
+        :param position: The x, y, z position of the target.
+        :param angle: The z orientation of the target (in radians).
+        :param boundaries: A float defining the path search in x and y direction
+        [[-boundaries,boundaries],[-boundaries,boundaries]].
+        :param path_pts: number of sampled points returned from the computed path
+        :param ignore_collisions: If collision checking should be disabled.
+        :param algorithm: Algorithm used to compute path
+        :raises: ConfigurationPathError if no path could be created.
+
+        :return: A non-linear path (x,y,angle) in the xy configuration space.
+        """
+
+        # Base dummy required to be parent of the robot tree
+        # self.base_ref.set_parent(None)
+        # self.set_parent(self.base_ref)
+
+        # Missing the dist1 for intermediate target
+
+        self.target_base.set_position([position[0], position[1], self.target_z])
+        self.target_base.set_orientation([0, 0, angle])
+
+        handle_base = self.get_handle()
+        handle_target_base = self.target_base.get_handle()
+
+        _, ret_floats, _, _ = utils.script_call(
+            'getNonlinearPathMobile@PyRep', PYREP_SCRIPT_TYPE,
+            ints=[handle_base, handle_target_base,
+                  self._collision_collection,
+                  int(ignore_collisions), path_pts], floats=[boundaries],
+                  strings=[algorithm.value])
+
+        # self.set_parent(None)
+        # self.base_ref.set_parent(self)
+
+        if len(ret_floats) == 0:
+            raise ConfigurationPathError('Could not create path.')
+
+        path = []
+        for i in range(0, len(ret_floats) // 3):
+            inst = ret_floats[3 * i:3 * i + 3]
+            if i > 0:
+                dist_change = sqrt((inst[0] - prev_inst[0]) ** 2 + (
+                inst[1] - prev_inst[1]) ** 2)
+            else:
+                dist_change = 0
+            inst.append(dist_change)
+
+            path.append(inst)
+
+            prev_inst = inst
+
+        return path
+
+    def _check_collision_linear_path(self,path):
+        """Check for collision on a linear path from start to goal
+
+        :param path: A list containing start and goal as [x,y,yaw]
+        :return: A bool, True if collision was detected
+        """
+        start = path[0]
+        end = path[1]
+
+        m = (end[1] - start[1])/(end[0] - start[0])
+        b = start[1] - m * start[0]
+        x_range = [start[0],end[0]]
+        x_span = start[0] - end[0]
+
+        incr = round(abs(x_span)/50, 3)
+        if x_range[1] < x_range[0]:
+            incr = - incr
+
+        x = x_range[0]
+        for k in range(50):
+            x += incr
+            y = m * x + b
+            self.set_2d_pose([x,y,start[-1] if k < 46 else end[-1]])
+            status_collision = self.assess_collision()
+            if status_collision == True:
+                break
+
+        return status_collision
+
+    def get_base_actuation(self):
+        """Controller for mobile bases.
+        """
+        raise NotImplementedError()
+
+    def copy(self) -> RobotComponent:
+        self.intermediate_target_base.set_parent(self)
+        self.target_base.set_parent(self)
+        c = super().copy()
+        self.intermediate_target_base.set_parent(None)
+        self.target_base.set_parent(None)
+        return c

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/mobiles/nonholonomic_base.py

@@ -0,0 +1,140 @@
+from math import atan2
+from math import cos
+from math import sin
+from math import sqrt
+from typing import List
+
+from pyrep.const import ConfigurationPathAlgorithms as Algos
+from pyrep.errors import ConfigurationPathError
+from pyrep.robots.configuration_paths.nonholonomic_configuration_path import (
+    NonHolonomicConfigurationPath)
+from pyrep.robots.mobiles.mobile_base import MobileBase
+
+
+class NonHolonomicBase(MobileBase):
+    """Currently only differential drive robots.
+    Can be refactored to include other types of non-holonomic bases in future.
+    """
+
+    def __init__(self,
+                 count: int,
+                 num_wheels: int,
+                 name: str):
+
+        super().__init__(count, num_wheels, name)
+
+        self.cummulative_error = 0
+        self.prev_error = 0
+
+        # PID controller values.
+        # TODO: expose to user through constructor.
+        self.Kp = 1.0
+        self.Ki = 0.01
+        self.Kd = 0.1
+        self.desired_velocity = 0.05
+
+    def get_base_velocities(self) -> List[float]:
+        """Gets linear and angular velocities of the mobile robot base
+        calculated from kinematics equations. Left joint should have index 1,
+        right joint should have index.
+
+        :return: A list with linear and angular velocity of the robot base.
+        """
+        wv = self.get_joint_velocities()
+
+        lv = sum(wv) * self.wheel_radius / 2.0
+        v_diff = wv[1] - wv[0]
+        av = self.wheel_radius * v_diff / self.wheel_distance
+
+        return [lv, av]
+
+    def get_linear_path(self, position: List[float],
+                        angle=0) -> NonHolonomicConfigurationPath:
+        """Initialize linear path and check for collision along it.
+
+        Must specify either rotation in euler or quaternions, but not both!
+
+        :param position: The x, y position of the target.
+        :param angle: The z orientation of the target (in radians).
+        :raises: ConfigurationPathError if no path could be created.
+
+        :return: A linear path in the 2d space.
+        """
+        position_base = self.get_position()
+        angle_base = self.get_orientation()[-1]
+
+        self.target_base.set_position(
+            [position[0], position[1], self.target_z])
+        self.target_base.set_orientation([0, 0, angle])
+        self.intermediate_target_base.set_position(
+            [position[0], position[1], self.target_z])
+        self.intermediate_target_base.set_orientation([0, 0, angle])
+
+        path = [[position_base[0], position_base[1], angle_base],
+                [position[0], position[1], angle]]
+
+        if self._check_collision_linear_path(path):
+            raise ConfigurationPathError(
+                'Could not create path. '
+                'An object was detected on the linear path.')
+
+        return NonHolonomicConfigurationPath(self, path)
+
+    def get_nonlinear_path(self, position: List[float],
+                           angle=0,
+                           boundaries=2,
+                           path_pts=600,
+                           ignore_collisions=False,
+                           algorithm=Algos.RRTConnect
+                           ) -> NonHolonomicConfigurationPath:
+        """Gets a non-linear (planned) configuration path given a target pose.
+
+        :param position: The x, y, z position of the target.
+        :param angle: The z orientation of the target (in radians).
+        :param boundaries: A float defining the path search in x and y direction
+        [[-boundaries,boundaries],[-boundaries,boundaries]].
+        :param path_pts: number of sampled points returned from the computed path
+        :param ignore_collisions: If collision checking should be disabled.
+        :param algorithm: Algorithm used to compute path
+        :raises: ConfigurationPathError if no path could be created.
+
+        :return: A non-linear path (x,y,angle) in the xy configuration space.
+        """
+
+        path = self._get_nonlinear_path_points(
+            position, angle, boundaries, path_pts, ignore_collisions, algorithm)
+
+        return NonHolonomicConfigurationPath(self, path)
+
+    def get_base_actuation(self):
+        """A controller using PID.
+
+        :return: A list with left and right joint velocity, and bool if target is reached.
+        """
+
+        d_x, d_y, _ = self.intermediate_target_base.get_position(
+            relative_to=self)
+
+        d_x_final, d_y_final, _ = self.target_base.get_position(
+            relative_to=self)
+
+        if sqrt((d_x_final) ** 2 + (d_y_final) ** 2) < 0.1:
+            return [0., 0.], True
+
+        alpha = atan2(d_y, d_x)
+        e = atan2(sin(alpha), cos(alpha))
+        e_P = e
+        e_I = self.cummulative_error + e
+        e_D = e - self.prev_error
+        w = self.Kp * e_P + self.Ki * e_I + self.Kd * e_D
+        w = atan2(sin(w), cos(w))
+
+        self.cummulative_error = self.cummulative_error + e
+        self.prev_error = e
+
+        vr = ((2. * self.desired_velocity + w * self.wheel_distance) /
+              (2. * self.wheel_radius))
+        vl = ((2. * self.desired_velocity - w * self.wheel_distance) /
+              (2. * self.wheel_radius))
+
+        return [vl, vr], False

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/mobiles/turtlebot.py

@@ -0,0 +1,6 @@
+from pyrep.robots.mobiles.nonholonomic_base import NonHolonomicBase
+
+
+class TurtleBot(NonHolonomicBase):
+    def __init__(self, count: int = 0):
+        super().__init__(count, 2, 'turtlebot')

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/mobiles/youbot.py

@@ -0,0 +1,7 @@
+from pyrep.robots.mobiles.holonomic_base import HolonomicBase
+
+
+class YouBot(HolonomicBase):
+    def __init__(self, count: int = 0, distance_from_target: float = 0):
+        super().__init__(
+            count, 4, distance_from_target, 'youBot', 4, 6, 0.035)

third_party/AnyBimanual/third_party/PyRep/pyrep/robots/robot_component.py

@@ -0,0 +1,290 @@
+from typing import List, Tuple
+
+from pyrep.objects.shape import Shape
+
+from pyrep.backend import sim, utils
+from pyrep.const import JointType
+from pyrep.objects.object import Object
+from pyrep.objects.joint import Joint
+from pyrep.const import ObjectType, JointMode
+
+
+class RobotComponent(Object):
+    """Collection of joints representing arms, end effectors, mobile bases, etc.
+    """
+
+    def __init__(self, count: int, name: str, joint_names: List[str],
+                 base_name: str = None):
+        self.name = name
+        suffix = '' if count == 0 else '#%d' % (count - 1)
+        super().__init__(
+            name + suffix if base_name is None else base_name + suffix)
+        self._num_joints = len(joint_names)
+
+        # Joint handles
+        self.joints = [Joint(jname + suffix)
+                       for jname in joint_names]
+        self._joint_handles = [j.get_handle() for j in self.joints]
+
+    def copy(self) -> 'RobotComponent':
+        """Copy and pastes the arm in the scene.
+
+        The arm is copied together with all its associated calculation
+        objects and associated scripts.
+
+        :return: The new pasted arm.
+        """
+        # Copy whole model
+        handle = sim.simCopyPasteObjects([self._handle], 1)[0]
+        name = sim.simGetObjectName(handle)
+        # Find the number of this arm
+        num = name[name.rfind('#') + 1:]
+        if len(num) > 0:
+            num = int(num) + 1
+        else:
+            num = 0
+        # FIXME: Pass valid name and joint_names.
+        return self.__class__(num)  # type: ignore
+
+    def _get_requested_type(self) -> ObjectType:
+        """Gets the type of the object.
+
+        :return: Type of the object.
+        """
+        return ObjectType(sim.simGetObjectType(self.get_handle()))
+
+    def get_joint_count(self) -> int:
+        """Gets the number of joints in this component.
+
+        :return: The number of joints.
+        """
+        return self._num_joints
+
+    def get_joint_types(self) -> List[JointType]:
+        """Retrieves the type of the joints in this component.
+
+        :return: A list containing the types of the joints.
+        """
+        return [j.get_joint_type() for j in self.joints]
+
+    def get_joint_positions(self) -> List[float]:
+        """Retrieves the intrinsic position of the joints.
+
+        See :py:meth:`Joint.get_joint_position` for more information.
+
+        :return: A list of intrinsic position of the joints.
+        """
+        return [j.get_joint_position() for j in self.joints]
+
+    def set_joint_positions(self, positions: List[float],
+                            disable_dynamics: bool = False) -> None:
+        """Sets the intrinsic position of the joints.
+
+        See :py:meth:`Joint.set_joint_position` for more information.
+
+        :param disable_dynamics: If True, then the position can be set even
+            when the joint mode is in Force mode. It will disable dynamics,
+            move the joint, and then re-enable dynamics.
+
+        :param positions: A list of positions of the joints (angular or linear
+            values depending on the joint type).
+        """
+        self._assert_len(positions)
+        if not disable_dynamics:
+            [sim.simSetJointPosition(jh, p)  # type: ignore
+             for jh, p in zip(self._joint_handles, positions)]
+            return
+
+        is_model = self.is_model()
+        if not is_model:
+            self.set_model(True)
+
+        prior = sim.simGetModelProperty(self.get_handle())
+        p = prior | sim.sim_modelproperty_not_dynamic
+        # Disable the dynamics
+        sim.simSetModelProperty(self._handle, p)
+        with utils.step_lock:
+            sim.simExtStep(True)  # Have to step for changes to take effect
+
+        [sim.simSetJointPosition(jh, p)  # type: ignore
+         for jh, p in zip(self._joint_handles, positions)]
+        [j.set_joint_target_position(p)  # type: ignore
+         for j, p in zip(self.joints, positions)]
+        with utils.step_lock:
+            sim.simExtStep(True)  # Have to step for changes to take effect
+        # Re-enable the dynamics
+        sim.simSetModelProperty(self._handle, prior)
+        self.set_model(is_model)
+
+    def get_joint_target_positions(self) -> List[float]:
+        """Retrieves the target positions of the joints.
+
+        :return: A list of target position of the joints (angular or linear
+            values depending on the joint type).
+        """
+        return [j.get_joint_target_position() for j in self.joints]
+
+    def set_joint_target_positions(self, positions: List[float]) -> None:
+        """Sets the target positions of the joints.
+
+        See :py:meth:`Joint.set_joint_target_position` for more information.
+
+        :param positions: List of target position of the joints (angular or
+            linear values depending on the joint type).
+        """
+        self._assert_len(positions)
+        [j.set_joint_target_position(p)  # type: ignore
+         for j, p in zip(self.joints, positions)]
+
+    def get_joint_target_velocities(self) -> List[float]:
+        """Retrieves the intrinsic target velocities of the joints.
+
+         :return: List of the target velocity of the joints (linear or angular
+            velocity depending on the joint-type).
+         """
+        return [j.get_joint_target_velocity()  # type: ignore
+                for j in self.joints]
+
+    def set_joint_target_velocities(self, velocities: List[float]) -> None:
+        """Sets the intrinsic target velocities of the joints.
+
+        :param velocities: List of the target velocity of the joints (linear
+            or angular velocities depending on the joint-type).
+        """
+        self._assert_len(velocities)
+        [j.set_joint_target_velocity(v)  # type: ignore
+         for j, v in zip(self.joints, velocities)]
+
+    def get_joint_forces(self) -> List[float]:
+        """Retrieves the forces or torques of the joints.
+
+        See :py:meth:`Joint.get_joint_force` for more information.
+
+        :return: A list of the forces or the torques applied to the joints
+            along/about their z-axis.
+        """
+        return [j.get_joint_force() for j in self.joints]
+
+    def set_joint_forces(self, forces: List[float]) -> None:
+        """Sets the maximum force or torque that the joints can exert.
+
+        See :py:meth:`Joint.set_joint_force` for more information.
+
+        :param forces: The maximum force or torque that the joints can exert.
+            These cannot be negative values.
+        """
+        self._assert_len(forces)
+        [j.set_joint_force(f)  # type: ignore
+         for j, f in zip(self.joints, forces)]
+
+    def get_joint_velocities(self) -> List[float]:
+        """Get the current joint velocities.
+
+        :return: List containing the velocities of the joints (linear or
+            angular velocities depending on the joint-type).
+        """
+        return [j.get_joint_velocity() for j in self.joints]
+
+    def get_joint_intervals(self) -> Tuple[List[bool], List[List[float]]]:
+        """Retrieves the interval parameters of the joints.
+
+        See :py:meth:`Joint.get_joint_interval` for more information.
+
+        :return: A tuple containing a list of bools indicates whether the joint
+            is cyclic (the joint varies between -pi and +pi in a cyclic manner),
+            and a 2D list containing the interval of the joints.
+        """
+        cyclics, intervals = [], []
+        for j in self.joints:
+            c, i = j.get_joint_interval()
+            cyclics.append(c)
+            intervals.append(i)
+        return cyclics, intervals
+
+    def set_joint_intervals(self, cyclic: List[bool],
+                            intervals: List[List[float]]) -> None:
+        """Sets the interval parameters of the joints (i.e. range values).
+
+        See :py:meth:`Joint.set_joint_interval` for more information.
+
+        :param cyclic: List of bools indicates whether the joint is cyclic.
+            Only revolute joints with a pitch of 0 can be cyclic.
+        :param intervals: 2D list containing the intervals of the joints.
+        """
+        self._assert_len(cyclic)
+        self._assert_len(intervals)
+        [j.set_joint_interval(c, i)  # type: ignore
+         for j, c, i in zip( self.joints, cyclic, intervals)]
+
+    def get_joint_upper_velocity_limits(self) -> List[float]:
+        """Gets upper velocity limits of the joints.
+
+         :return: List of the upper velocity limits.
+         """
+        return [j.get_joint_upper_velocity_limit() for j in self.joints]
+
+    def set_control_loop_enabled(self, value: bool) -> None:
+        """Sets whether the control loop is enable for all joints.
+
+        :param value: The new value for the control loop state.
+        """
+        [j.set_control_loop_enabled(value)  # type: ignore
+         for j in self.joints]
+
+    def set_motor_locked_at_zero_velocity(self, value: bool) -> None:
+        """Sets if motor is locked when target velocity is zero for all joints.
+
+        When enabled in velocity mode and its target velocity is zero, then the
+        joint is locked in place.
+
+        :param value: If the motors should be locked at zero velocity.
+        """
+        [j.set_motor_locked_at_zero_velocity(value)  # type: ignore
+         for j in self.joints]
+
+    def set_joint_mode(self, value: JointMode) -> None:
+        """Sets the operation mode of the joint group.
+
+        :param value: The new joint mode value.
+        """
+        [j.set_joint_mode(value)  # type: ignore
+         for j in self.joints]
+
+    def get_joint_modes(self) -> List[JointMode]:
+        """Gets the operation mode of the joint group.
+
+        :return: A list of joint modes.
+        """
+        return [j.get_joint_mode() for j in self.joints]
+
+    def get_visuals(self) -> List[Object]:
+        """Gets a list of the visual elements of this component.
+
+        Can be useful for methods such as domain randomization.
+        Should ideally be overridden for each robot.
+
+        :return: A list of visual shapes.
+        """
+        tree = self.get_objects_in_tree(ObjectType.SHAPE, exclude_base=False)
+        return [obj for obj in tree if 'visual' in obj.get_name()]
+
+    def _assert_len(self, inputs: list) -> None:
+        if len(self.joints) != len(inputs):
+            raise RuntimeError(
+                'Tried to set values for %d joints, but joint group consists '
+                'of %d joints.' % (len(inputs), len(self.joints)))
+        
+    def colorize(self, color: List[float]):
+        for v in self.get_visuals():
+            if v.get_name().startswith(self.name):
+                v.set_color(color)
+
+    def hide(self):
+        for v in self.get_visuals():
+            if v.get_name().startswith(self.name):
+                v.set_renderable(False)
+
+    def show(self):
+        for v in self.get_visuals():
+            if v.get_name().startswith(self.name):
+                v.set_renderable(True)

third_party/AnyBimanual/third_party/PyRep/pyrep/sensors/accelerometer.py

@@ -0,0 +1,30 @@
+from typing import List
+
+from pyrep.backend import sim
+from pyrep.const import ObjectType
+from pyrep.objects.force_sensor import ForceSensor
+from pyrep.objects.object import Object
+from pyrep.objects.shape import Shape
+
+
+class Accelerometer(Object):
+    """An object able to measure accelerations that are applied to it.
+    """
+
+    def __init__(self, name):
+        super().__init__(name)
+        self._mass_object = Shape('%s_mass' % (self.get_name()))
+        self._sensor = ForceSensor('%s_force_sensor' % (self.get_name()))
+
+    def _get_requested_type(self) -> ObjectType:
+        return ObjectType(sim.simGetObjectType(self.get_handle()))
+
+    def read(self) -> List[float]:
+        """Reads the acceleration applied to accelerometer.
+
+        :return: A list containing applied accelerations along
+            the sensor's x, y and z-axes
+        """
+        forces, _ = self._sensor.read()
+        accel = [force / self._mass_object.get_mass() for force in forces]
+        return accel

third_party/AnyBimanual/third_party/PyRep/pyrep/sensors/gyroscope.py

@@ -0,0 +1,40 @@
+from pyrep.backend import sim
+from pyrep.const import ObjectType
+from pyrep.objects.object import Object
+
+
+class Gyroscope(Object):
+    """An object able to measure angular velocities that are applied to it.
+    """
+    def __init__(self, name):
+        super().__init__(name)
+        self._ref = '%s_reference' % (self.get_name())
+
+        self._last_time = sim.simGetSimulationTime()
+        self._old_transformation_matrix = self.get_matrix()[:3, :4].reshape(
+            (12, )).tolist()
+
+    def _get_requested_type(self) -> ObjectType:
+        return ObjectType(sim.simGetObjectType(self.get_handle()))
+
+    def read(self):
+        """Reads the angular velocities applied to gyroscope.
+
+        :return: A list containing applied angular velocities along
+            the sensor's x, y and z-axes.
+        """
+        current_time = sim.simGetSimulationTime()
+        dt = current_time - self._last_time
+
+        inv_old_matrix = sim.simInvertMatrix(self._old_transformation_matrix)
+        transformation_matrix = self.get_matrix()[:3, :4].reshape(
+            (12, )).tolist()
+        mat = sim.simMultiplyMatrices(inv_old_matrix, transformation_matrix)
+        euler_angles = sim.simGetEulerAnglesFromMatrix(mat)
+
+        self._last_time = current_time
+        self._old_transformation_matrix = transformation_matrix
+
+        if dt != 0:
+            return [euler_angle / dt for euler_angle in euler_angles]
+        return [0.0, 0.0, 0.0]

third_party/AnyBimanual/third_party/PyRep/pyrep/sensors/spherical_vision_sensor.py

@@ -0,0 +1,296 @@
+import numpy as np
+from typing import List, Sequence
+
+from pyrep.backend import sim, utils
+from pyrep.objects.object import Object
+from pyrep.objects.vision_sensor import VisionSensor
+from pyrep.const import PYREP_SCRIPT_TYPE, RenderMode, ObjectType
+
+MIN_DIVISOR = 1e-12
+
+
+class SphericalVisionSensor(Object):
+    """An object able capture 360 degree omni-directional images.
+    """
+
+    def __init__(self, name):
+        super().__init__(name)
+
+        # final omni-directional sensors
+        self._sensor_depth = VisionSensor('%s_sensorDepth' % (self.get_name()))
+        self._sensor_rgb = VisionSensor('%s_sensorRGB' % (self.get_name()))
+
+        # directed sub-sensors
+        names = ['front', 'top', 'back', 'bottom', 'left', 'right']
+        self._six_sensors = [VisionSensor('%s_%s' % (self.get_name(), n)) for n in names]
+        self._front = self._six_sensors[0]
+
+        # directed sub-sensor handles list
+        self._six_sensor_handles = [vs.get_handle() for vs in self._six_sensors]
+
+        # set all to explicit handling
+        self._set_all_to_explicit_handling()
+
+        # assert sensor properties are matching
+        self._assert_matching_resolutions()
+        self._assert_matching_render_modes()
+        self._assert_matching_entities_to_render()
+        self._assert_matching_window_sizes()
+        self._assert_matching_near_clipping_planes()
+        self._assert_matching_far_clipping_planes()
+
+        # omni resolution
+        self._omni_resolution = self._sensor_rgb.get_resolution()
+
+        # near and far clipping plane
+        self._near_clipping_plane = self.get_near_clipping_plane()
+        self._far_clipping_plane = self.get_far_clipping_plane()
+        self._clipping_plane_diff = self._far_clipping_plane - self._near_clipping_plane
+
+        # projective cam region image
+        self._planar_to_radial_depth_scalars = self._get_planar_to_radial_depth_scalars()
+
+    # Private #
+    # --------#
+
+    def _set_all_to_explicit_handling(self):
+        self._sensor_depth.set_explicit_handling(1)
+        self._sensor_rgb.set_explicit_handling(1)
+        for sensor in self._six_sensors:
+            sensor.set_explicit_handling(1)
+
+    def _assert_matching_resolutions(self):
+        assert self._sensor_depth.get_resolution() == self._sensor_rgb.get_resolution()
+        front_sensor_res = self._front.get_resolution()
+        for sensor in self._six_sensors[1:]:
+            assert sensor.get_resolution() == front_sensor_res
+
+    def _assert_matching_render_modes(self):
+        assert self._sensor_depth.get_render_mode() == self._sensor_rgb.get_render_mode()
+        front_sensor_render_mode = self._front.get_render_mode()
+        for sensor in self._six_sensors[1:]:
+            assert sensor.get_render_mode() == front_sensor_render_mode
+
+    def _assert_matching_entities_to_render(self):
+        assert self._sensor_depth.get_entity_to_render() == self._sensor_rgb.get_entity_to_render()
+        front_sensor_entity_to_render = self._front.get_entity_to_render()
+        for sensor in self._six_sensors[1:]:
+            assert sensor.get_entity_to_render() == front_sensor_entity_to_render
+
+    def _assert_matching_window_sizes(self):
+        assert self._sensor_depth.get_windowed_size() == self._sensor_rgb.get_windowed_size()
+
+    def _assert_matching_near_clipping_planes(self):
+        front_sensor_near = self._front.get_near_clipping_plane()
+        for sensor in self._six_sensors[1:]:
+            assert sensor.get_near_clipping_plane() == front_sensor_near
+
+    def _assert_matching_far_clipping_planes(self):
+        front_sensor_far = self._front.get_far_clipping_plane()
+        for sensor in self._six_sensors[1:]:
+            assert sensor.get_far_clipping_plane() == front_sensor_far
+
+    def _get_requested_type(self) -> ObjectType:
+        return ObjectType(sim.simGetObjectType(self.get_handle()))
+
+    @staticmethod
+    def _create_uniform_pixel_coords_image(image_dims):
+        pixel_x_coords = np.reshape(np.tile(np.arange(image_dims[1]), [image_dims[0]]),
+                                    (image_dims[0], image_dims[1], 1)).astype(np.float32)
+        pixel_y_coords_ = np.reshape(np.tile(np.arange(image_dims[0]), [image_dims[1]]),
+                                     (image_dims[1], image_dims[0], 1)).astype(np.float32)
+        pixel_y_coords = np.transpose(pixel_y_coords_, (1, 0, 2))
+        return np.concatenate((pixel_x_coords, pixel_y_coords), -1)
+
+    def _get_planar_to_radial_depth_scalars(self):
+
+        # reference: https://en.wikipedia.org/wiki/Spherical_coordinate_system#Cartesian_coordinates
+
+        # polar coord image
+        coord_img = self._create_uniform_pixel_coords_image([self._omni_resolution[1], self._omni_resolution[0]])
+        pixels_per_rad = self._omni_resolution[1] / np.pi
+        polar_angles = coord_img / pixels_per_rad
+        phi = polar_angles[..., 0:1]
+        theta = polar_angles[..., 1:2]
+
+        # image borders wrt the 6 projective cameras
+        phis_rel = ((phi + np.pi/4) % (np.pi/2)) / (np.pi/2)
+        lower_borders = np.arccos(1/((phis_rel*2-1)**2 + 2)**0.5)
+        upper_borders = np.pi - lower_borders
+
+        # omni image regions from the 6 projective cameras
+        xy_region = np.logical_and(theta <= upper_borders, theta >= lower_borders)
+        pos_x = np.logical_and(xy_region, np.logical_or(phi <= 45 * np.pi/180, phi >= (45 + 270) * np.pi/180))
+        pos_y = np.logical_and(xy_region,
+                               np.logical_and(phi >= 45 * np.pi/180, phi <= (45 + 90) * np.pi/180))
+        neg_x = np.logical_and(xy_region,
+                               np.logical_and(phi >= (45 + 90) * np.pi/180, phi <= (45 + 180) * np.pi/180))
+        neg_y = np.logical_and(xy_region,
+                               np.logical_and(phi >= (45 + 180) * np.pi/180, phi <= (45 + 270) * np.pi/180))
+        pos_z = theta <= lower_borders
+        neg_z = theta >= upper_borders
+
+        # trig terms for conversion
+        sin_theta = np.sin(theta)
+        cos_theta = np.cos(theta)
+        sin_phi = np.sin(phi)
+        cos_phi = np.cos(phi)
+
+        # reciprocal terms
+        recip_sin_theta_cos_phi = 1/(sin_theta * cos_phi + MIN_DIVISOR)
+        recip_sin_theta_sin_phi = 1/(sin_theta * sin_phi + MIN_DIVISOR)
+        recip_cos_theta = 1/(cos_theta + MIN_DIVISOR)
+
+        # planar to radial depth scalars
+        return np.where(pos_x, recip_sin_theta_cos_phi,
+                        np.where(neg_x, -recip_sin_theta_cos_phi,
+                                 np.where(pos_y, recip_sin_theta_sin_phi,
+                                          np.where(neg_y, -recip_sin_theta_sin_phi,
+                                                   np.where(pos_z, recip_cos_theta,
+                                                            np.where(neg_z, -recip_cos_theta,
+                                                                     np.zeros_like(recip_cos_theta)))))))[..., 0]
+
+    # Public #
+    # -------#
+
+    def handle_explicitly(self) -> None:
+        """Handle spherical vision sensor explicitly.
+
+          This enables capturing image (e.g., capture_rgb())
+          without PyRep.step().
+        """
+        utils.script_call('handleSpherical@PyRep', PYREP_SCRIPT_TYPE,
+                          [self._sensor_depth._handle, self._sensor_rgb._handle] + self._six_sensor_handles, [], [], [])
+
+    def capture_rgb(self) -> np.ndarray:
+        """Retrieves the rgb-image of a spherical vision sensor.
+
+        :return: A numpy array of size (width, height, 3)
+        """
+        return self._sensor_rgb.capture_rgb()
+
+    def capture_depth(self, in_meters=False) -> np.ndarray:
+        """Retrieves the depth-image of a spherical vision sensor.
+
+        :param in_meters: Whether the depth should be returned in meters.
+        :return: A numpy array of size (width, height)
+        """
+        planar_depth = self._sensor_depth.capture_rgb()[:, :, 0]*self._clipping_plane_diff + self._near_clipping_plane
+        radial_depth = planar_depth * self._planar_to_radial_depth_scalars
+        if in_meters:
+            return radial_depth
+        return (radial_depth - self._near_clipping_plane)/self._clipping_plane_diff
+
+    def get_resolution(self) -> List[int]:
+        """ Return the spherical vision sensor's resolution.
+
+        :return: Resolution [x, y]
+        """
+        return self._sensor_depth.get_resolution()
+
+    def set_resolution(self, resolution: List[int]) -> None:
+        """ Set the spherical vision sensor's resolution.
+
+        :param resolution: New resolution [x, y]
+        """
+        if resolution[0] != 2*resolution[1]:
+            raise Exception('Spherical vision sensors must have an X resolution 2x the Y resolution')
+        if resolution[1] % 2 != 0:
+            raise Exception('Spherical vision sensors must have an even Y resolution')
+        box_sensor_resolution = [int(resolution[1]/2), int(resolution[1]/2)]
+        for sensor in self._six_sensors:
+            sensor.set_resolution(box_sensor_resolution)
+        self._sensor_depth.set_resolution(resolution)
+        self._sensor_rgb.set_resolution(resolution)
+
+    def get_render_mode(self) -> RenderMode:
+        """ Retrieves the spherical vision sensor's rendering mode
+
+        :return: RenderMode for the current rendering mode.
+        """
+        return self._sensor_depth.get_render_mode()
+
+    def set_render_mode(self, render_mode: RenderMode) -> None:
+        """ Set the spherical vision sensor's rendering mode
+
+        :param render_mode: The new sensor rendering mode, one of:
+            RenderMode.OPENGL
+            RenderMode.OPENGL_AUXILIARY
+            RenderMode.OPENGL_COLOR_CODED
+            RenderMode.POV_RAY
+            RenderMode.EXTERNAL
+            RenderMode.EXTERNAL_WINDOWED
+            RenderMode.OPENGL3
+            RenderMode.OPENGL3_WINDOWED
+        """
+        self._sensor_depth.set_render_mode(render_mode)
+        self._sensor_rgb.set_render_mode(render_mode)
+        for sensor in self._six_sensors:
+            sensor.set_render_mode(render_mode)
+
+    def get_windowed_size(self) -> Sequence[int]:
+        """Get the size of windowed rendering for the omni-directional image.
+
+        :return: The (x, y) resolution of the window. 0 for full-screen.
+        """
+        return self._sensor_depth.get_windowed_size()
+
+    def set_windowed_size(self, resolution: Sequence[int] = (0, 0)) -> None:
+        """Set the size of windowed rendering for the omni-directional image.
+
+        :param resolution: The (x, y) resolution of the window.
+            0 for full-screen.
+        """
+        self._sensor_depth.set_windowed_size(resolution)
+        self._sensor_rgb.set_windowed_size(resolution)
+
+    def get_near_clipping_plane(self) -> float:
+        """ Get the spherical depth sensor's near clipping plane.
+
+        :return: Near clipping plane (metres)
+        """
+        return self._front.get_near_clipping_plane()
+
+    def set_near_clipping_plane(self, near_clipping: float) -> None:
+        """ Set the spherical depth sensor's near clipping plane.
+
+        :param near_clipping: New near clipping plane (in metres)
+        """
+        self._near_clipping_plane = near_clipping
+        self._clipping_plane_diff = self._far_clipping_plane - near_clipping
+        for sensor in self._six_sensors:
+            sensor.set_near_clipping_plane(near_clipping)
+
+    def get_far_clipping_plane(self) -> float:
+        """ Get the Sensor's far clipping plane.
+
+        :return: Near clipping plane (metres)
+        """
+        return self._front.get_far_clipping_plane()
+
+    def set_far_clipping_plane(self, far_clipping: float) -> None:
+        """ Set the spherical depth sensor's far clipping plane.
+
+        :param far_clipping: New far clipping plane (in metres)
+        """
+        self._far_clipping_plane = far_clipping
+        self._clipping_plane_diff = far_clipping - self._near_clipping_plane
+        for sensor in self._six_sensors:
+            sensor.set_far_clipping_plane(far_clipping)
+
+    def set_entity_to_render(self, entity_to_render: int) -> None:
+        """ Set the entity to render to the spherical vision sensor,
+        this can be an object or more usefully a collection. -1 to render all objects in scene.
+
+        :param entity_to_render: Handle of the entity to render
+        """
+        self._sensor_depth.set_entity_to_render(entity_to_render)
+        self._sensor_rgb.set_entity_to_render(entity_to_render)
+
+    def get_entity_to_render(self) -> None:
+        """ Get the entity to render to the spherical vision sensor,
+        this can be an object or more usefully a collection. -1 if all objects in scene are rendered.
+
+        :return: Handle of the entity to render
+        """
+        return self._sensor_depth.get_entity_to_render()

third_party/AnyBimanual/third_party/PyRep/pyrep/textures/texture.py

@@ -0,0 +1,18 @@
+class Texture(object):
+    """Base class for V-REP textures."""
+
+    def __init__(self, texture_id: int):
+        self._texture_id = texture_id
+
+    def __eq__(self, other: object):
+        if not isinstance(other, Texture):
+            raise NotImplementedError
+        return self.get_texture_id() == other.get_texture_id()
+
+    def get_texture_id(self) -> int:
+        """Gets the texture id.
+
+        :return: The internal texture id.
+        """
+        return self._texture_id
+

third_party/AnyBimanual/third_party/PyRep/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+cffi==1.14.2

third_party/AnyBimanual/third_party/PyRep/robot_ttms/README.md

@@ -0,0 +1,5 @@
+Here are a number of modified model files (.ttm) ready to be used.
+
+If using the ```pyrep.robots``` module, then use these models.
+
+Models have been adapted from V-REP.

third_party/AnyBimanual/third_party/PyRep/setup.py

@@ -0,0 +1,64 @@
+import codecs
+import os
+import os.path
+from os.path import join
+
+from setuptools import setup
+
+import cffi_build.cffi_build as cffi_build
+
+
+def read(rel_path):
+    here = os.path.abspath(os.path.dirname(__file__))
+    with codecs.open(os.path.join(here, rel_path), 'r') as fp:
+        return fp.read()
+
+
+def get_version(rel_path):
+    for line in read(rel_path).splitlines():
+        if line.startswith('__version__'):
+            delim = '"' if '"' in line else "'"
+            return line.split(delim)[1]
+    else:
+        raise RuntimeError("Unable to find version string.")
+
+
+# Temp fix for CoppeliaSim 4.1
+if 'COPPELIASIM_ROOT' not in os.environ:
+    raise RuntimeError('COPPELIASIM_ROOT not defined.')
+
+usrset_file = os.path.join(os.environ['COPPELIASIM_ROOT'], 'system', 'usrset.txt')
+usrset = ''
+if os.path.isfile(usrset_file):
+    with open(usrset_file, 'r') as f:
+        usrset = f.read()
+
+if 'allowOldEduRelease' not in usrset:
+    with open(usrset_file, 'a+') as f:
+        f.write('\nallowOldEduRelease=7501\n')
+
+
+setup(name='PyRep',
+      # Version A.B.C.D.
+      # A.B.C info corresponds to the CoppeliaSim version needed.
+      # D info corresponds to the PyRep version.
+      version=get_version("pyrep/__init__.py"),
+      description='Python CoppeliaSim wrapper',
+      author='Stephen James',
+      author_email='slj12@ic.ac.uk',
+      url='https://www.doc.ic.ac.uk/~slj12',
+      packages=['pyrep',
+                'pyrep.backend',
+                'pyrep.objects',
+                'pyrep.sensors',
+                'pyrep.robots',
+                'pyrep.robots.arms',
+                'pyrep.robots.end_effectors',
+                'pyrep.robots.mobiles',
+                'pyrep.robots.configuration_paths',
+                'pyrep.textures',
+                'pyrep.misc',
+                ],
+      ext_modules=[cffi_build.ffibuilder.distutils_extension(
+          join('build', 'pyrep', 'backend'))],
+      )

third_party/AnyBimanual/third_party/PyRep/system/usrset.txt

@@ -0,0 +1,199 @@
+// Debugging
+// =================================================
+alwaysShowConsole = false
+debugInternalFunctionAccess = false // will also heavily slow down CoppeliaSim
+debugCApiAccess = false // will also drastically slow down CoppeliaSim
+debugLuaApiAccess = false // will also slow down CoppeliaSim
+sendDebugInformationToFile = false // if true, debug info is sent to debugLog.txt
+
+
+// Rendering
+// =================================================
+idleFps = 8
+threadedRenderingDuringSimulation = 0 // recommended to keep 0 (-1=disabled, 0=pre-enabled, 1=enabled).
+desiredOpenGlMajor = -1 // recommended to keep -1.
+desiredOpenGlMinor = -1 // recommended to keep -1.
+offscreenContextType = -1 // recommended to keep -1 (-1=default, 0=Qt offscreen, 1=QGLWidget/QOpenGLWidget visible, 2=QGLWidget/QOpenGLWidget invisible).
+fboType = -1 // recommended to keep -1 (-1=default, 0=native, 1=QOpenGLFramebufferObject).
+forceFboViaExt = false // recommended to keep false.
+vboOperation = -1 // recommended to keep -1 (-1=default, 0=always off, 1=on when available).
+vboPersistenceInMs = 5000 // recommended to keep 5000.
+oglCompatibilityTweak1 = false // recommended to keep false since it causes small memory leaks.
+visionSensorsUseGuiThread_windowed = -1 // recommended to keep -1 (-1=default, 0=GUI when not otherwise possible, 1=always GUI).
+visionSensorsUseGuiThread_headless = -1 // recommended to keep -1 (-1=default, 0=GUI when not otherwise possible, 1=always GUI).
+useGlFinish = false // recommended to keep false. Graphic card dependent.
+useGlFinish_visionSensors = false // recommended to keep false. Graphic card dependent.
+vsync = 0 // recommended to keep at 0. Graphic card dependent.
+debugOpenGl = false
+stereoDist = 0 // 0=no stereo, otherwise the intra occular distance (0.0635 for the human eyes).
+highResDisplay = -1 // -1=automatic, 0=disabled, 1=enabled.
+noEdgesWhenMouseDownInCameraView = false // if true, rendering is faster during mouse/view interaction
+noTexturesWhenMouseDownInCameraView = false // if true, rendering is faster during mouse/view interaction
+noCustomUisWhenMouseDownInCameraView = true // if true, rendering is faster during mouse/view interaction
+hierarchyRefreshCnt = 3
+
+
+// Visual
+// =================================================
+renderingSurfaceVShift = 0
+renderingSurfaceVResize = 0
+displayWorldRef = true
+antialiasing = false
+displayBoundingBoxeWhenObjectSelected = true
+guiFontSize_Win = -1 // -1=default
+guiFontSize_Mac = -1 // -1=default
+guiFontSize_Linux = 13 // -1=default
+statusbarInitiallyVisible = true
+modelBrowserInitiallyVisible = true
+sceneHierarchyInitiallyVisible = true
+sceneHierarchyHiddenDuringSimulation = false
+scriptEditorFont =  // empty=default.
+scriptEditorFontSize = -1 // -1=default.
+auxConsoleFont =  // empty=default
+auxConsoleFontSize = -1 // -1=default.
+mainScriptColor_background = 190,175,175
+mainScriptColor_selection = 128,128,255
+mainScriptColor_comment = 0,140,0
+mainScriptColor_number = 220,0,220
+mainScriptColor_string = 255,255,0
+mainScriptColor_character = 255,255,0
+mainScriptColor_operator = 0,0,0
+mainScriptColor_preprocessor = 0,128,128
+mainScriptColor_identifier = 64,64,64
+mainScriptColor_word = 0,0,255
+mainScriptColor_word2 = 152,0,0
+mainScriptColor_word3 = 220,80,20
+mainScriptColor_word4 = 152,64,0
+nonThreadedChildScriptColor_background = 190,190,190
+nonThreadedChildScriptColor_selection = 128,128,255
+nonThreadedChildScriptColor_comment = 0,140,0
+nonThreadedChildScriptColor_number = 220,0,220
+nonThreadedChildScriptColor_string = 255,255,0
+nonThreadedChildScriptColor_character = 255,255,0
+nonThreadedChildScriptColor_operator = 0,0,0
+nonThreadedChildScriptColor_preprocessor = 0,128,128
+nonThreadedChildScriptColor_identifier = 64,64,64
+nonThreadedChildScriptColor_word = 0,0,255
+nonThreadedChildScriptColor_word2 = 152,0,0
+nonThreadedChildScriptColor_word3 = 220,80,20
+nonThreadedChildScriptColor_word4 = 152,64,0
+threadedChildScriptColor_background = 180,190,190
+threadedChildScriptColor_selection = 128,128,255
+threadedChildScriptColor_comment = 0,140,0
+threadedChildScriptColor_number = 220,0,220
+threadedChildScriptColor_string = 255,255,0
+threadedChildScriptColor_character = 255,255,0
+threadedChildScriptColor_operator = 0,0,0
+threadedChildScriptColor_preprocessor = 0,128,128
+threadedChildScriptColor_identifier = 64,64,64
+threadedChildScriptColor_word = 0,0,255
+threadedChildScriptColor_word2 = 152,0,0
+threadedChildScriptColor_word3 = 220,80,20
+threadedChildScriptColor_word4 = 152,64,0
+customizationScriptColor_background = 150,150,150
+customizationScriptColor_selection = 128,128,255
+customizationScriptColor_comment = 0,120,0
+customizationScriptColor_number = 220,0,220
+customizationScriptColor_string = 205,205,0
+customizationScriptColor_character = 205,205,0
+customizationScriptColor_operator = 0,0,0
+customizationScriptColor_preprocessor = 0,128,128
+customizationScriptColor_identifier = 70,70,70
+customizationScriptColor_word = 0,0,255
+customizationScriptColor_word2 = 152,0,0
+customizationScriptColor_word3 = 220,80,20
+customizationScriptColor_word4 = 152,64,0
+
+
+// Directories
+// =================================================
+defaultDirectoryForScenes =  // absolute path, e.g. d:/myScenes (or leave empty for default path)
+defaultDirectoryForModels =  // absolute path, e.g. d:/myModels (or leave empty for default path)
+defaultDirectoryForCadFiles =  // absolute path, e.g. d:/myCadFiles (or leave empty for default path)
+defaultDirectoryForMiscFiles =  // absolute path, e.g. d:/myMiscFiles (or leave empty for default path)
+defaultDirectoryForExternalScriptEditor =  // absolute path, e.g. d:/myScriptTempFiles (or leave empty for default path)
+defaultDirectoryForRemoteApiFiles =  // absolute path, e.g. d:/myRemoteApiTransfers (or leave empty for default path)
+
+
+// Serialization
+// =================================================
+autoSaveDelay = 2 // in minutes. 0 to disable.
+doNotWritePersistentData = false
+compressFiles = true
+saveApproxNormals = true
+packIndices = true
+fileDialogs = -1 // recommended to keep -1 (-1=default, 0=native dialogs, 1=Qt dialogs).
+bulletSerializationBuffer = 10000000
+
+
+// Undo/Redo
+// =================================================
+undoRedoEnabled = true
+undoRedoOnlyPartialWithCameras = true
+undoRedoLevelCount = 16
+undoRedoMaxBufferSize = 80000000
+timeInMsForUndoRedoTooLongWarning = 200
+
+
+// Messaging
+// =================================================
+doNotShowCrashRecoveryMessage = false
+doNotShowUpdateCheckMessage = false
+doNotShowSceneSelectionThumbnails = false
+doNotShowProgressBars = false
+doNotShowAcknowledgmentMessages = false
+doNotShowVideoCompressionLibraryLoadError = false
+redirectStatusbarMsgToConsoleInHeadlessMode = false
+suppressStartupDialogs = false
+suppressXmlOverwriteMsg = false
+
+
+// Compatibility
+// =================================================
+middleMouseButtonSwitchesModes = false // has only an effect if navigationBackwardCompatibility is true.
+navigationBackwardCompatibility = false // recommended to keep false.
+colorAdjust_backCompatibility = 1 // recommended to keep 1.0
+specificGpuTweak = false
+enableOldCalcModuleGuis = false
+useAlternateSerialPortRoutines = false
+enableOpenGlBasedCustomUiEditor = false
+changeScriptCodeForNewApiNotation = 1 // 1=enabled, 0=disabled.
+supportOldApiNotation = true
+enableOldMillObjects = false
+enableOldMirrorObjects = false
+
+
+// Various
+// =================================================
+mouseWheelZoomFactor = 1
+dynamicActivityRange = 1000
+objectTranslationStepSize = 0.0250000004
+objectRotationStepSize = 5
+processorCoreAffinity = 0 // recommended to keep 0 (-1:os default, 0:all threads on same core, m: affinity mask (bit1=core1, bit2=core2, etc.))
+freeServerPortStart = 20000
+freeServerPortRange = 2000
+abortScriptExecutionButton = 3 // in seconds. Zero to disable.
+triCountInOBB = 8
+removeIdenticalVertices = true
+identicalVerticesTolerance = 9.99999975e-05
+removeIdenticalTriangles = true
+triangleWindingCheck = true
+runCustomizationScripts = true
+test1 = false // recommended to keep false.
+orderHierarchyAlphabetically = false
+macChildDialogType = -1 // -1=default.
+useExternalLuaLibrary = false // if true, will call all Lua functions via the simLua library ('simLua.dll', 'libsimLua.so' or 'libsimLua.dylib')
+additionalLuaPath =  // e.g. d:/myLuaRoutines
+desktopRecordingIndex = 0
+desktopRecordingWidth = -1 // -1=default.
+externalScriptEditor = 
+xmlExportSplitSize = 0 // 0=generate a single file.
+xmlExportKnownFormats = true // true=if several files are generated, mesh and image files are saved under known formats.
+
+
+// Floating license / dongle license
+// =================================================
+floatingLicenseEnabled = false
+floatingLicenseServer = 127.0.0.1
+floatingLicensePort = 20249
+keepDongleOpen = false

third_party/AnyBimanual/third_party/PyRep/tests/assets/cracker_box/textured_simple.obj.mtl

@@ -0,0 +1,14 @@
+#
+# Wavefront material file
+# Converted by Meshlab Group
+#
+
+newmtl material_0
+Ka 0.200000 0.200000 0.200000
+Kd 0.639216 0.639216 0.639216
+Ks 1.000000 1.000000 1.000000
+Tr 1.000000
+illum 2
+Ns 0.000000
+map_Kd texture_map.png
+

third_party/AnyBimanual/third_party/PyRep/tests/core.py

@@ -0,0 +1,21 @@
+import unittest
+import pyrep
+from pyrep import PyRep
+from os import path
+
+ASSET_DIR = path.join(path.dirname(path.abspath(__file__)), 'assets')
+pyrep.testing = True
+
+
+class TestCore(unittest.TestCase):
+
+    def setUp(self):
+        self.pyrep = PyRep()
+        self.pyrep.launch(path.join(ASSET_DIR, 'test_scene.ttt'), headless=True)
+        self.pyrep.step()
+        self.pyrep.start()
+
+    def tearDown(self):
+        self.pyrep.stop()
+        self.pyrep.step_ui()
+        self.pyrep.shutdown()

third_party/AnyBimanual/third_party/PyRep/tests/test_accelerometer.py

@@ -0,0 +1,18 @@
+import unittest
+from tests.core import TestCore
+from pyrep.sensors.accelerometer import Accelerometer
+
+
+class TestAccelerometer(TestCore):
+
+    def setUp(self):
+        super().setUp()
+        self.sensor = Accelerometer('accelerometer')
+
+    def test_read(self):
+        accelerations = self.sensor.read()
+        self.assertEqual(len(accelerations), 3)
+
+
+if __name__ == '__main__':
+    unittest.main()

third_party/AnyBimanual/third_party/PyRep/tests/test_arms_and_configuration_paths.py

@@ -0,0 +1,188 @@
+import unittest
+from tests.core import TestCore
+from pyrep import PyRep
+from pyrep.objects.cartesian_path import CartesianPath
+from pyrep.objects.dummy import Dummy
+import numpy as np
+from os import path
+from pyrep.errors import ConfigurationPathError
+
+from pyrep.robots.arms.panda import Panda
+from pyrep.robots.arms.mico import Mico
+from pyrep.robots.arms.jaco import Jaco
+from pyrep.robots.arms.sawyer import Sawyer
+from pyrep.robots.arms.baxter import BaxterLeft, BaxterRight
+from pyrep.robots.arms.lbr_iiwa_7_r800 import LBRIwaa7R800
+from pyrep.robots.arms.lbr_iiwa_14_r820 import LBRIwaa14R820
+from pyrep.robots.arms.ur3 import UR3
+from pyrep.robots.arms.ur5 import UR5
+from pyrep.robots.arms.ur10 import UR10
+from pyrep.robots.arms.dobot import Dobot
+from pyrep.robots.arms.xarm7 import XArm7
+
+ASSET_DIR = path.join(path.dirname(path.abspath(__file__)), 'assets')
+
+
+ARMS = [
+    ('Panda', Panda),
+    ('Sawyer', Sawyer),
+    ('Mico', Mico),
+    ('Jaco', Jaco),
+    ('Baxter_leftArm', BaxterLeft),
+    ('Baxter_rightArm', BaxterRight),
+    ('LBR_iiwa_7_R800', LBRIwaa7R800),
+    ('LBR_iiwa_14_R820', LBRIwaa14R820),
+    ('UR3', UR3),
+    ('UR5', UR5),
+    ('UR10', UR10),
+    ('Dobot', Dobot),
+    ('XArm7', XArm7),
+]
+
+
+class TestArmsAndConfigurationPaths(TestCore):
+
+    def setUp(self):
+        self.pyrep = PyRep()
+        self.pyrep.launch(path.join(
+            ASSET_DIR, 'test_scene_robots.ttt'), headless=True)
+        self.pyrep.step()
+        self.pyrep.start()
+
+    # It is enough to only test the constructor of each arm (in there we make
+    # assumptions about the structure of the arm model). All other tests
+    # can be run on one arm.
+    def test_get_arm(self):
+        for arm_name, arm_type in ARMS:
+            with self.subTest(arm=arm_name):
+                arm = arm_type()
+                self.assertIsInstance(arm, arm_type)
+
+    def test_set_ik_element_properties(self):
+        arm = Panda()
+        arm.set_ik_element_properties(constraint_gamma=False)
+        arm.set_ik_element_properties()
+
+    def test_set_ik_group_properties(self):
+        arm = Panda()
+        arm.set_ik_group_properties('damped_least_squares')
+        arm.set_ik_group_properties('pseudo_inverse')
+
+    def test_solve_ik_via_jacobian(self):
+        arm = Panda()
+        waypoint = Dummy('Panda_waypoint')
+        new_config = arm.solve_ik_via_jacobian(
+            waypoint.get_position(), waypoint.get_orientation())
+        arm.set_joint_positions(new_config)
+        self.assertTrue(np.allclose(
+            arm.get_tip().get_pose(), waypoint.get_pose(), atol=0.001))
+
+    def test_solve_ik_via_sampling(self):
+        arm = Panda()
+        waypoint = Dummy('Panda_waypoint')
+        configs = arm.solve_ik_via_sampling(
+            waypoint.get_position(), waypoint.get_orientation(), max_configs=5)
+        self.assertIsNotNone(configs)
+        self.assertEqual(len(configs), 5)
+        current_config = arm.get_joint_positions()
+        # Checks correct config (last)
+        arm.set_joint_positions(configs[-1])
+        self.assertTrue(np.allclose(
+            arm.get_tip().get_pose(), waypoint.get_pose(), atol=0.001))
+        # Checks correct config (first)
+        arm.set_joint_positions(configs[0])
+        self.assertTrue(np.allclose(
+            arm.get_tip().get_pose(), waypoint.get_pose(), atol=0.001))
+        # Checks order
+        prev_config_dist = 0
+        for config in configs:
+            config_dist = sum(
+                [(c - f)**2 for c, f in zip(current_config, config)])
+            # This test requires that the metric scale for each joint remains at
+            # 1.0 in _getConfigDistance lua function
+            self.assertLessEqual(prev_config_dist, config_dist)
+            prev_config_dist = config_dist
+
+    def test_get_path_from_cartesian_path(self):
+        arm = Panda()
+        cartesian_path = CartesianPath('Panda_cartesian_path')
+        path = arm.get_path_from_cartesian_path(cartesian_path)
+        self.assertIsNotNone(path)
+
+    def test_get_linear_path(self):
+        arm = Panda()
+        waypoint = Dummy('Panda_waypoint')
+        path = arm.get_linear_path(
+            waypoint.get_position(), waypoint.get_orientation())
+        self.assertIsNotNone(path)
+
+    def test_get_linear_path_relative(self):
+        arm = Panda()
+        path = arm.get_linear_path([0, 0, 0.01], [0, 0, 0],
+                                   relative_to=arm.get_tip())
+        self.assertIsNotNone(path)
+
+    def test_get_nonlinear_path(self):
+        arm = Panda()
+        waypoint = Dummy('Panda_waypoint')
+        path = arm.get_nonlinear_path(
+            waypoint.get_position(), waypoint.get_orientation())
+        self.assertIsNotNone(path)
+
+    def test_get_nonlinear_path_out_of_reach(self):
+        arm = Panda()
+        with self.assertRaises(ConfigurationPathError):
+            arm.get_nonlinear_path([99, 99, 99], [0.] * 3)
+
+    def test_get_linear_path_out_of_reach(self):
+        arm = Panda()
+        with self.assertRaises(ConfigurationPathError):
+            arm.get_linear_path([99, 99, 99], [0.] * 3)
+
+    def test_get_linear_path_and_step(self):
+        arm = Panda()
+        waypoint = Dummy('Panda_waypoint')
+        path = arm.get_linear_path(
+            waypoint.get_position(), waypoint.get_orientation())
+        self.assertIsNotNone(path)
+        done = False
+        while not done:
+            done = path.step()
+            self.pyrep.step()
+        self.assertTrue(np.allclose(
+            arm.get_tip().get_position(), waypoint.get_position(), atol=0.01))
+
+    def test_get_linear_path_and_get_end(self):
+        arm = Panda()
+        waypoint = Dummy('Panda_waypoint')
+        path = arm.get_linear_path(
+            waypoint.get_position(), waypoint.get_orientation())
+        path.set_to_end()
+        self.assertTrue(np.allclose(
+            arm.get_tip().get_position(), waypoint.get_position(), atol=0.001))
+
+    def test_get_linear_path_visualize(self):
+        arm = Panda()
+        waypoint = Dummy('Panda_waypoint')
+        path = arm.get_linear_path(
+            waypoint.get_position(), waypoint.get_orientation())
+        # Check that it does not error
+        path.visualize()
+
+    def test_get_duplicate_arm(self):
+        arm = UR3(1)
+        self.assertIsInstance(arm, UR3)
+
+    def test_copy_arm(self):
+        arm = UR10()
+        new_arm = arm.copy()
+        self.assertNotEqual(arm, new_arm)
+
+    def test_get_jacobian(self):
+        arm = Panda()
+        jacobian = arm.get_jacobian()
+        self.assertEqual(jacobian.shape, (7, 6))
+
+
+if __name__ == '__main__':
+    unittest.main()

third_party/AnyBimanual/third_party/PyRep/tests/test_cameras.py

@@ -0,0 +1,38 @@
+import unittest
+from tests.core import TestCore
+from pyrep.const import ObjectType
+from pyrep.objects.camera import Camera
+from pyrep.objects.dummy import Dummy
+from pyrep.objects.object import Object
+import numpy as np
+
+
+class TestCameras(TestCore):
+
+    def setUp(self):
+        super().setUp()
+        self.camera = Camera('DefaultCamera')
+        self.dummy = Dummy('dummy')
+
+    def test_create(self):
+        with self.assertRaises(NotImplementedError):
+            _ = Camera.create()
+
+    def test_get_set_position(self):
+        position = self.camera.get_position()
+        self.assertIsInstance(position, np.ndarray)
+        self.assertEqual(position.shape, (3,))
+
+        self.camera.set_position([0.1, 0.1, 0.1], self.dummy)
+        self.assertTrue(np.allclose(
+            self.camera.get_position(self.dummy), [0.1, 0.1, 0.1]))
+        self.camera.set_position([0.2, 0.2, 0.2])
+        self.assertTrue(np.allclose(self.camera.get_position(), [0.2, 0.2, 0.2]))
+
+    def test_get_object_type(self):
+        self.assertEqual(Object.get_object_type('DefaultCamera'),
+                         ObjectType.CAMERA)
+
+
+if __name__ == '__main__':
+    unittest.main()

third_party/AnyBimanual/third_party/PyRep/tests/test_cartesian_paths.py

@@ -0,0 +1,28 @@
+import unittest
+from tests.core import TestCore
+from pyrep.objects.cartesian_path import CartesianPath
+
+
+class TestCartesianPaths(TestCore):
+
+    def setUp(self):
+        super().setUp()
+        self.cart_path = CartesianPath('cartesian_path')
+
+    def test_create_cartesian_path(self):
+        p = CartesianPath.create()
+        self.assertIsInstance(p, CartesianPath)
+
+    def test_get_pose_on_path(self):
+        pos, ori = self.cart_path.get_pose_on_path(0.5)
+        self.assertEqual(len(pos), 3)
+        self.assertEqual(len(ori), 3)
+
+    def test_insert_control_points(self):
+        points = [[0.1] * 6]
+        # Just check that it does not throw an exception.
+        self.cart_path.insert_control_points(points)
+
+
+if __name__ == '__main__':
+    unittest.main()

third_party/AnyBimanual/third_party/PyRep/tests/test_dummies.py

@@ -0,0 +1,17 @@
+import unittest
+from tests.core import TestCore
+from pyrep.objects.dummy import Dummy
+
+
+class TestDummies(TestCore):
+
+    def test_get_dummy(self):
+        Dummy('dummy')
+
+    def test_create_dummy(self):
+        d = Dummy.create(0.01)
+        self.assertIsInstance(d, Dummy)
+
+
+if __name__ == '__main__':
+    unittest.main()

third_party/AnyBimanual/third_party/PyRep/tests/test_force_sensors.py

@@ -0,0 +1,23 @@
+import unittest
+from tests.core import TestCore
+from pyrep.objects.force_sensor import ForceSensor
+
+
+class TestForceSensors(TestCore):
+
+    def setUp(self):
+        super().setUp()
+        self.sensor = ForceSensor('force_sensor')
+
+    def test_read(self):
+        force_vector, torque_vector = self.sensor.read()
+        self.assertEqual(len(force_vector), 3)
+        self.assertEqual(len(torque_vector), 3)
+
+    def test_create(self):
+        sensor = ForceSensor.create()
+        sensor.remove()
+
+
+if __name__ == '__main__':
+    unittest.main()