Add files using upload-large-folder tool

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/README.md

@@ -0,0 +1,114 @@
+# reveal_vla_bimanual
+
+Simulation-first prototype for a language-conditioned bimanual reveal-and-retrieve policy under elastic occlusion.
+
+This repo is not a generalist VLA backbone in the RT-2 / OpenVLA / Octo sense. The current contribution is the reveal-state machinery layered on top of a frozen vision-language encoder.
+
+This repo is structured around five top-level modules:
+
+- `sim_rlbench/`: RLBench2 / PerAct2 wrappers, dataset hooks, camera setup, and benchmark evaluation helpers.
+- `sim_reveal/`: reveal-proxy environments, scripted teachers, and privileged label extraction.
+- `models/`: shared backbone wrappers, multi-view fusion, bimanual decoder, reveal-state head, world model, and planner.
+- `train/`: trainers, losses, checkpointing, and Hydra/YAML configs.
+- `eval/`: benchmark scripts, ablations, metrics, plots, and report generation.
+
+Current bootstrap priorities:
+
+1. Reproduce the RLBench2 / PerAct2 stack with a fixed 3-camera interface.
+2. Stand up a backbone-only 3-camera policy in the same training/eval harness.
+3. Add reveal-state supervision and short-horizon planning for synthetic reveal proxies.
+
+## Public benchmark package
+
+The repo now includes a concrete public-benchmark package definition for the next-stage fair comparison:
+
+- `eval/public_benchmark_package.py`
+  - track registry for bag, dense occluded retrieval, cloth retrieval, and the generic anchor
+  - same-protocol signatures across `trunk_only`, `adapter_noop`, and `adapter_active`
+  - same-data / same-init fairness signatures for `trunk_only_ft` vs `adapter_active_ft`
+
+- `eval/run_public_benchmark_package.py`
+  - validates normalized result files from multiple public suites
+  - checks protocol identity and training fairness
+  - aggregates per-track gains, sign-of-life diagnostics, and anchor regressions
+
+Write the default manifest to `~/workspace` with:
+
+```bash
+python -m eval.run_public_benchmark_package \
+  --write-default-manifest ~/workspace/public_benchmark_package_v1.json
+```
+
+Summarize normalized result files with:
+
+```bash
+python -m eval.run_public_benchmark_package \
+  --result /abs/path/result_a.json \
+  --result /abs/path/result_b.json \
+  --output-dir ~/workspace/reports/public_benchmark_package_v1
+```
+
+Upstream dependencies are kept in `/workspace/third_party` and pinned in `docs/upstream_pins.md`.
+
+## RLBench env A
+
+The RLBench / PerAct2 stack is pinned to Python 3.10 and lives in `/workspace/envs/rlbench`.
+
+Bring it up with:
+
+```bash
+/workspace/reveal_vla_bimanual/scripts/setup_env_a_rlbench.sh
+/workspace/reveal_vla_bimanual/scripts/setup_rlbench_headless_x.sh
+/workspace/reveal_vla_bimanual/scripts/start_rlbench_x.sh
+```
+
+Verify GPU GL on the headless display:
+
+```bash
+DISPLAY=:99 glxinfo -B
+```
+
+Run the RLBench launch/reset/step smoke test:
+
+```bash
+env \
+  DISPLAY=:99 \
+  XDG_RUNTIME_DIR=/tmp/runtime-root \
+  COPPELIASIM_ROOT=/workspace/assets/coppeliasim_v4_1_0 \
+  LD_LIBRARY_PATH=/workspace/system_shims/nvidia$(nvidia-smi --query-gpu=driver_version --format=csv,noheader | head -n1 | cut -d. -f1)/usr/lib/x86_64-linux-gnu:/workspace/system_shims/nvidia$(nvidia-smi --query-gpu=driver_version --format=csv,noheader | head -n1 | cut -d. -f1)/usr/lib/x86_64-linux-gnu/nvidia:/workspace/assets/coppeliasim_v4_1_0 \
+  QT_QPA_PLATFORM_PLUGIN_PATH=/workspace/assets/coppeliasim_v4_1_0 \
+  /workspace/.tools/micromamba/bin/micromamba run \
+    -r /workspace/.micromamba \
+    -p /workspace/envs/rlbench \
+    python -m sim_rlbench.launch_smoke --headless
+```
+
+The working benchmark interface is fixed to three cameras only:
+
+- `front`
+- `wrist_left`
+- `wrist_right`
+
+The smoke test covers launch, bimanual task reset, canonical observation extraction, and one bimanual action step in `headless=True`, which is the same mode used by the upstream PerAct2-style training stack.
+
+Generate the PerAct2-compatible train command for the fixed 3-camera interface with:
+
+```bash
+micromamba run -r /workspace/.micromamba -p /workspace/envs/rlbench \
+  python -m sim_rlbench.smoke_test --print-train-command
+```
+
+Download the published PerAct2 demos into `/workspace/data/rlbench2` with checksum verification:
+
+```bash
+micromamba run -r /workspace/.micromamba -p /workspace/envs/rlbench \
+  python -m sim_rlbench.dataset_download --resolution 256 --splits train
+```
+
+If you want the archives unpacked directly into the demo root expected by RLBench, add `--extract`:
+
+```bash
+apt-get install -y squashfs-tools
+micromamba run -r /workspace/.micromamba -p /workspace/envs/rlbench \
+  python -m sim_rlbench.dataset_download --resolution 256 --splits train --extract
+```

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/docs/adapter_stack.md

@@ -0,0 +1,87 @@
+# Adapter Stack
+
+This repo now contains a no-op-safe `trunk + adapter` path alongside the legacy monolithic policies.
+
+## Main classes
+
+- `models/policy.py`
+  - `FoundationTrunkPolicy`
+  - `ElasticOcclusionAdapter`
+  - `AdapterWrappedPolicy`
+
+- `models/backbones.py`
+  - `NoOpAdapterCompatibleTrunkOutput`
+  - `TrunkInterface`
+
+- `models/action_decoder.py`
+  - `TaskRoutedProposalPrior`
+
+- `models/planner.py`
+  - `ElasticFeasibilityGate`
+  - `ResidualActionReranker`
+  - `AdapterPlanner`
+
+- `models/world_model.py`
+  - `LightweightRevealStateTransitionModel`
+
+- `models/observation_memory.py`
+  - `RevealStateCache`
+
+## Trainer modes
+
+`train/trainer.py` now supports:
+
+- `policy_type: adapter_wrapped`
+- `policy_type: foundation_trunk`
+
+Relevant trainer fields:
+
+- `training_regime`
+- `eval_mode`
+- `adapter_mode`
+- `adapter_use_transition_model`
+- `adapter_use_task_conditioning`
+
+## Guardrail tests
+
+New tests:
+
+- `tests/test_trunk_noop_equivalence.py`
+- `tests/test_adapter_gate_blocks_unsafe_retrieve.py`
+- `tests/test_task_specific_loss_masking.py`
+- `tests/test_cloth_specific_metrics_affect_selection.py`
+- `tests/test_general_eval_protocol_is_identical.py`
+
+## Config templates
+
+- `train/configs/proxy_adapter_wrapped_clip_base.yaml`
+- `train/configs/proxy_adapter_wrapped_clip_rank_only.yaml`
+- `train/configs/proxy_adapter_wrapped_clip_noop_eval.yaml`
+
+## Benchmark wrappers
+
+- `scripts/run_anchor_adapter_ablations.sh`
+- `scripts/run_proxy_adapter_ablations.sh`
+- `scripts/run_target_like_adapter_subset.sh`
+- `eval/public_benchmark_package.py`
+- `eval/run_public_benchmark_package.py`
+
+All new configs and scripts default to `~/workspace` outputs and reports.
+
+## Public benchmark package
+
+The public benchmark package is the current fair-comparison contract for real benchmarks:
+
+- target tracks:
+  - `bag_track` -> `BEHAVIOR-1K/unpacking_childs_bag-0`
+  - `occlusion_track` -> `ManiSkill/PickClutterYCB-v1`
+  - `cloth_track` -> `GarmentLab/grasp_protocol_stacked_garment`
+- anchor track:
+  - `anchor_track` -> `AnyBimanual/dual_push_buttons`
+
+The package code enforces:
+
+- mode-invariant eval protocols per track
+- same-data / same-init fairness for `trunk_only_ft` vs `adapter_active_ft`
+- sign-of-life thresholds on intervention and non-base proposal selection
+- no-regression tolerance on the trusted generic anchor

code/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/docs/public_benchmark_package.md

@@ -0,0 +1,73 @@
+# Public Benchmark Package
+
+This repo now contains a concrete public-benchmark package for the real-sim phase.
+
+## Tracks
+
+- `bag_track`
+  - suite: `BEHAVIOR-1K`
+  - task: `unpacking_childs_bag-0`
+- `occlusion_track`
+  - suite: `ManiSkill 3`
+  - task: `PickClutterYCB-v1`
+- `cloth_track`
+  - suite: `GarmentLab`
+  - task slice: `grasp_protocol_stacked_garment`
+- `anchor_track`
+  - suite: `AnyBimanual`
+  - task: `dual_push_buttons`
+
+## Enforced fairness
+
+- `trunk_only_ft` and `adapter_active_ft` must share:
+  - train demos
+  - val demos
+  - init checkpoint group
+  - optimizer
+  - LR schedule
+  - batch size
+  - augmentations
+  - early stopping metric
+  - max gradient steps
+  - unfrozen trunk scope
+  - dataset split id
+- all modes on a track must share the same eval protocol signature
+- anchor regressions are bounded by an absolute tolerance of `0.02`
+
+## Normalized result schema
+
+Each external benchmark run should be converted to one JSON object with:
+
+- `track_id`
+- `adapter_mode`
+- `successes` or `success_rate`
+- `episodes`
+- `seed`
+- `eval_protocol`
+- for target tracks: `train_spec`
+- optional diagnostics:
+  - `intervention_rate`
+  - `non_base_selection_rate`
+  - `steps_to_first_reveal_or_access`
+  - `steps_to_retrieve`
+  - `disturbance_proxy`
+
+## Commands
+
+Write the default manifest:
+
+```bash
+python -m eval.run_public_benchmark_package \
+  --write-default-manifest ~/workspace/public_benchmark_package_v1.json
+```
+
+Summarize results:
+
+```bash
+python -m eval.run_public_benchmark_package \
+  --result /abs/path/behavior_bag_adapter_active_seed17.json \
+  --result /abs/path/behavior_bag_trunk_seed17.json \
+  --result /abs/path/maniskill_occlusion_adapter_active_seed17.json \
+  --result /abs/path/maniskill_occlusion_trunk_seed17.json \
+  --output-dir ~/workspace/reports/public_benchmark_package_v1
+```

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

@@ -0,0 +1,266 @@
+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"
+
+
+PUBLIC_BENCHMARK_TRACKS: tuple[PublicBenchmarkTrack, ...] = (
+    PublicBenchmarkTrack(
+        track_id="bag_track",
+        suite="behavior1k",
+        benchmark_task="unpacking_childs_bag-0",
+        role=TARGET_ROLE,
+        task_family="bag_retrieval",
+        target_behavior="retrieve target objects from an opened compliant bag or backpack",
+        public_source="https://behavior.stanford.edu/knowledgebase/tasks/",
+        notes=(
+            "Closest public bag retrieval task. Treat as the benchmark-standard bag opening / "
+            "retrieval slice."
+        ),
+    ),
+    PublicBenchmarkTrack(
+        track_id="occlusion_track",
+        suite="maniskill3",
+        benchmark_task="PickClutterYCB-v1",
+        role=TARGET_ROLE,
+        task_family="dense_occluded_retrieval",
+        target_behavior="retrieve a target object from dense occluding clutter",
+        public_source="https://maniskill.readthedocs.io/en/latest/tasks/table_top_gripper/index.html",
+        notes=(
+            "Closest maintained public occluded retrieval task. Treat as the canopy / dense "
+            "occlusion proxy."
+        ),
+    ),
+    PublicBenchmarkTrack(
+        track_id="cloth_track",
+        suite="garmentlab",
+        benchmark_task="grasp_protocol_stacked_garment",
+        role=TARGET_ROLE,
+        task_family="cloth_retrieval",
+        target_behavior="retrieve a hidden or partially covered object from stacked or cluttered garments",
+        public_source="https://garmentlab.readthedocs.io/en/latest/tutorial/realworldbenchmark/index.html",
+        notes=(
+            "Use the GarmentLab grasp protocol in stacked/clutter layouts as the closest public "
+            "cloth retrieval benchmark slice."
+        ),
+    ),
+    PublicBenchmarkTrack(
+        track_id="anchor_track",
+        suite="anybimanual",
+        benchmark_task="dual_push_buttons",
+        role=ANCHOR_ROLE,
+        task_family="generic_anchor",
+        target_behavior="generic bimanual control regression anchor",
+        public_source="https://arxiv.org/abs/2412.06779",
+        notes="Trusted public anchor on this setup. Keep as a no-regression track only.",
+    ),
+)
+
+
+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] = ("front", "left_wrist", "right_wrist"),
+) -> 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
+    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": tuple(str(camera) for camera in cameras),
+        "observation_stack": "rgbd_3cam",
+        "action_horizon": 8,
+        "action_space": "bimanual_delta_pose",
+        "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_reveal_retrieve_package_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/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/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/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 = [
+        "# 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.home() / "workspace" / "reports" / "public_benchmark_package_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/VLAarchtests2_code/VLAarchtests/code/reveal_vla_bimanual/models/planner.py

@@ -0,0 +1,887 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import torch
+from torch import Tensor, nn
+
+
+@dataclass
+class PlannerConfig:
+    hidden_dim: int = 512
+    num_candidates: int = 8
+    action_dim: int = 14
+    num_support_modes: int = 3
+    utility_margin: float = 0.1
+    corridor_weight: float = 1.0
+    persistence_weight: float = 0.5
+    proposal_weight: float = 0.5
+    task_progress_weight: float = 0.75
+    disturbance_weight: float = 0.75
+    reocclusion_weight: float = 0.5
+    visibility_weight: float = 0.25
+    num_heads: int = 4
+    num_layers: int = 2
+    num_phases: int = 5
+    num_arm_roles: int = 4
+    top_k: int = 4
+    belief_gain_weight: float = 1.0
+    visibility_gain_weight: float = 0.75
+    clearance_weight: float = 0.75
+    occluder_contact_weight: float = 0.5
+    grasp_affordance_weight: float = 0.75
+    support_stability_weight: float = 0.5
+    residual_weight: float = 0.5
+    retrieve_access_threshold: float = 0.15
+    retrieve_persistence_threshold: float = 0.15
+    retrieve_support_threshold: float = 0.25
+    retrieve_reocclusion_threshold: float = 0.6
+    adapter_confidence_threshold: float = 0.55
+    mode_preference_bonus: float = 3.0
+    premature_retrieve_penalty: float = 1.5
+    premature_insert_penalty: float = 0.75
+    premature_occlusion_sweep_penalty: float = 0.75
+    premature_maintain_penalty: float = 0.0
+    retrieve_stage_access_threshold: float = 0.45
+    retrieve_stage_reveal_threshold: float = 0.40
+    retrieve_stage_persistence_threshold: float = 0.20
+    retrieve_stage_support_threshold: float = 0.25
+    insert_stage_access_threshold: float = 0.40
+    insert_stage_visibility_threshold: float = 0.30
+    insert_stage_support_threshold: float = 0.25
+    occlusion_maintain_gap_min_access: float = 0.0
+    occlusion_maintain_gap_min_visibility: float = 0.0
+
+
+class RevealPlanner(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        self.config = config
+        summary_dim = (
+            config.action_dim * 2
+            + 3
+            + 3
+            + 1
+            + 3
+            + 1
+        )
+        self.trunk = nn.Sequential(
+            nn.LayerNorm(summary_dim),
+            nn.Linear(summary_dim, config.hidden_dim),
+            nn.GELU(),
+            nn.Linear(config.hidden_dim, config.hidden_dim),
+            nn.GELU(),
+        )
+        self.success_head = nn.Linear(config.hidden_dim, 1)
+        self.risk_head = nn.Linear(config.hidden_dim, 1)
+
+    def summarize_candidates(self, candidate_chunks: Tensor, rollout_state: dict[str, Tensor]) -> Tensor:
+        candidate_mean = candidate_chunks.mean(dim=2)
+        candidate_terminal = candidate_chunks[:, :, -1]
+        corridor_prob = rollout_state["corridor_logits"].sigmoid().amax(dim=-1).mean(dim=-2)
+        persistence = rollout_state["persistence_horizon"].mean(dim=-2)
+        disturbance = rollout_state["disturbance_cost"].mean(dim=-1, keepdim=True)
+        reocclusion = rollout_state["reocclusion_logit"].sigmoid().mean(dim=-2)
+        uncertainty = rollout_state["uncertainty"].mean(dim=-1, keepdim=True)
+        return torch.cat(
+            [
+                candidate_mean,
+                candidate_terminal,
+                corridor_prob,
+                persistence,
+                disturbance,
+                reocclusion,
+                uncertainty,
+            ],
+            dim=-1,
+        )
+
+    def score_rollouts(self, rollout_state: dict[str, Tensor], candidate_chunks: Tensor) -> dict[str, Tensor]:
+        features = self.summarize_candidates(candidate_chunks, rollout_state)
+        hidden = self.trunk(features)
+        success_logits = self.success_head(hidden).squeeze(-1)
+        risk_values = torch.sigmoid(self.risk_head(hidden)).squeeze(-1)
+        utility_scores = success_logits.sigmoid() - risk_values
+        return {
+            "planner_features": features,
+            "planner_hidden": hidden,
+            "success_logits": success_logits,
+            "risk_values": risk_values,
+            "utility_scores": utility_scores,
+        }
+
+    def select_best(self, candidate_chunks: Tensor, rollout_state: dict[str, Tensor]) -> dict[str, Tensor]:
+        outputs = self.score_rollouts(rollout_state=rollout_state, candidate_chunks=candidate_chunks)
+        best_idx = outputs["utility_scores"].argmax(dim=-1)
+        batch_indices = torch.arange(candidate_chunks.shape[0], device=candidate_chunks.device)
+        return {
+            **outputs,
+            "best_indices": best_idx,
+            "best_chunk": candidate_chunks[batch_indices, best_idx],
+        }
+
+
+class InteractionPlanner(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        self.config = config
+        step_dim = (
+            config.action_dim
+            + config.num_phases
+            + (2 * config.num_arm_roles)
+            + config.num_support_modes
+            + 7
+        )
+        self.step_proj = nn.Sequential(
+            nn.LayerNorm(step_dim),
+            nn.Linear(step_dim, config.hidden_dim),
+            nn.GELU(),
+        )
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=config.hidden_dim,
+            nhead=config.num_heads,
+            dim_feedforward=config.hidden_dim * 4,
+            batch_first=True,
+            norm_first=True,
+        )
+        self.sequence_encoder = nn.TransformerEncoder(encoder_layer, num_layers=config.num_layers)
+        self.cls_token = nn.Parameter(torch.randn(1, 1, config.hidden_dim) * 0.02)
+        self.success_head = nn.Linear(config.hidden_dim, 1)
+        self.risk_head = nn.Linear(config.hidden_dim, 1)
+        self.score_head = nn.Linear(config.hidden_dim, 1)
+
+    def _mean_field(self, tensor: Tensor) -> Tensor:
+        return tensor.mean(dim=(-1, -2))
+
+    def summarize_trajectory(self, candidate_chunks: Tensor, rollout_state: dict[str, Tensor]) -> Tensor:
+        horizon = min(candidate_chunks.shape[2], rollout_state["phase_logits"].shape[2])
+        candidate_steps = candidate_chunks[:, :, :horizon]
+        phase_probs = rollout_state["phase_logits"][:, :, :horizon].softmax(dim=-1)
+        support_probs = rollout_state["support_mode_logits"][:, :, :horizon].softmax(dim=-1)
+        arm_role_probs = rollout_state["arm_role_logits"][:, :, :horizon].softmax(dim=-1).flatten(start_dim=-2)
+        target_mean = self._mean_field(rollout_state["target_field"][:, :, :horizon].sigmoid())
+        feasibility_mean = self._mean_field(rollout_state["actor_feasibility_field"][:, :, :horizon].sigmoid())
+        persistence_mean = self._mean_field(rollout_state["persistence_field"][:, :, :horizon])
+        risk_mean = self._mean_field(rollout_state["risk_field"][:, :, :horizon])
+        uncertainty_mean = self._mean_field(rollout_state["uncertainty_field"][:, :, :horizon])
+        role_gap = (
+            rollout_state["arm_role_logits"][:, :, :horizon, 0].softmax(dim=-1)
+            - rollout_state["arm_role_logits"][:, :, :horizon, 1].softmax(dim=-1)
+        ).abs().mean(dim=-1, keepdim=True)
+        return torch.cat(
+            [
+                candidate_steps,
+                phase_probs,
+                arm_role_probs,
+                support_probs,
+                target_mean,
+                feasibility_mean,
+                persistence_mean,
+                risk_mean,
+                uncertainty_mean,
+                role_gap,
+            ],
+            dim=-1,
+        )
+
+    def score_rollouts(
+        self,
+        rollout_state: dict[str, Tensor],
+        candidate_chunks: Tensor,
+        proposal_logits: Tensor | None = None,
+    ) -> dict[str, Tensor]:
+        features = self.summarize_trajectory(candidate_chunks, rollout_state)
+        batch_size, num_candidates, horizon, _ = features.shape
+        flat_features = features.view(batch_size * num_candidates, horizon, -1)
+        hidden_steps = self.step_proj(flat_features)
+        cls = self.cls_token.expand(batch_size * num_candidates, -1, -1)
+        encoded = self.sequence_encoder(torch.cat([cls, hidden_steps], dim=1))
+        pooled = encoded[:, 0]
+        success_logits = self.success_head(pooled).view(batch_size, num_candidates).squeeze(-1)
+        risk_values = torch.sigmoid(self.risk_head(pooled)).view(batch_size, num_candidates).squeeze(-1)
+        utility_scores = self.score_head(pooled).view(batch_size, num_candidates).squeeze(-1)
+        utility_scores = utility_scores + success_logits.sigmoid() - risk_values
+        if proposal_logits is not None and proposal_logits.shape == utility_scores.shape:
+            utility_scores = utility_scores + self.config.proposal_weight * proposal_logits.sigmoid()
+        return {
+            "planner_features": features.mean(dim=2),
+            "planner_hidden": pooled.view(batch_size, num_candidates, -1),
+            "success_logits": success_logits,
+            "risk_values": risk_values,
+            "utility_scores": utility_scores,
+        }
+
+    def select_best(
+        self,
+        candidate_chunks: Tensor,
+        rollout_state: dict[str, Tensor],
+        proposal_logits: Tensor | None = None,
+    ) -> dict[str, Tensor]:
+        outputs = self.score_rollouts(
+            rollout_state=rollout_state,
+            candidate_chunks=candidate_chunks,
+            proposal_logits=proposal_logits,
+        )
+        best_idx = outputs["utility_scores"].argmax(dim=-1)
+        batch_indices = torch.arange(candidate_chunks.shape[0], device=candidate_chunks.device)
+        return {
+            **outputs,
+            "best_indices": best_idx,
+            "best_chunk": candidate_chunks[batch_indices, best_idx],
+        }
+
+
+class StructuredElasticUtility(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        self.config = config
+
+    def _field_mean(self, tensor: Tensor) -> Tensor:
+        if tensor.ndim == 6:
+            return tensor.mean(dim=(-1, -2, -3))
+        if tensor.ndim == 5:
+            return tensor.mean(dim=(-1, -2))
+        if tensor.ndim == 4:
+            return tensor.mean(dim=(-1, -2))
+        return tensor
+
+    def _initial_scalar(self, state: dict[str, Tensor], key: str) -> Tensor:
+        value = state[key]
+        if value.ndim >= 4:
+            return value.mean(dim=tuple(range(1, value.ndim)))
+        if value.ndim == 3:
+            return value.mean(dim=(-1, -2))
+        if value.ndim == 2:
+            return value.mean(dim=-1)
+        return value
+
+    def forward(
+        self,
+        initial_state: dict[str, Tensor],
+        rollout_state: dict[str, Tensor],
+        candidate_chunks: Tensor,
+    ) -> dict[str, Tensor]:
+        initial_belief = self._initial_scalar(initial_state, "target_belief_field").unsqueeze(1)
+        initial_visibility = self._initial_scalar(initial_state, "visibility_field").unsqueeze(1)
+        belief_future = self._field_mean(rollout_state["target_belief_field"]).mean(dim=-1)
+        visibility_future = self._field_mean(rollout_state["visibility_field"]).mean(dim=-1)
+        clearance = self._field_mean(rollout_state["clearance_field"]).mean(dim=-1)
+        occluder_contact = self._field_mean(rollout_state["occluder_contact_field"]).mean(dim=-1)
+        grasp_affordance = self._field_mean(rollout_state["grasp_affordance_field"]).mean(dim=-1)
+        support_stability = torch.sigmoid(self._field_mean(rollout_state["support_stability_field"])).mean(dim=-1)
+        persistence_traj = self._field_mean(rollout_state["persistence_field"])
+        reocclusion_traj = self._field_mean(rollout_state["reocclusion_field"])
+        disturbance_traj = self._field_mean(rollout_state["disturbance_field"])
+        access_traj = torch.sigmoid(self._field_mean(rollout_state["access_field"]))
+        persistence = persistence_traj.mean(dim=-1)
+        reocclusion = reocclusion_traj.mean(dim=-1)
+        disturbance = disturbance_traj.mean(dim=-1)
+        access_quality = access_traj.mean(dim=-1)
+        access_floor = access_traj.amin(dim=-1)
+        persistence_floor = persistence_traj.amin(dim=-1)
+        support_floor = torch.sigmoid(self._field_mean(rollout_state["support_stability_field"])).amin(dim=-1)
+        reocclusion_worst = reocclusion_traj.amax(dim=-1)
+        retrieve_progress = torch.sigmoid(candidate_chunks[:, :, :, -1]).mean(dim=-1)
+        utility = (
+            self.config.belief_gain_weight * (belief_future - initial_belief)
+            + self.config.visibility_gain_weight * (visibility_future - initial_visibility)
+            + self.config.clearance_weight * clearance
+            + self.config.occluder_contact_weight * occluder_contact
+            + self.config.grasp_affordance_weight * grasp_affordance
+            + self.config.persistence_weight * persistence
+            + self.config.support_stability_weight * support_stability
+            + self.config.corridor_weight * access_quality
+            + self.config.task_progress_weight * retrieve_progress
+            - self.config.reocclusion_weight * reocclusion
+            - self.config.disturbance_weight * disturbance
+            - self.config.visibility_weight * (1.0 - visibility_future)
+        )
+        return {
+            "belief_gain": belief_future - initial_belief,
+            "visibility_gain": visibility_future - initial_visibility,
+            "clearance": clearance,
+            "occluder_contact_quality": occluder_contact,
+            "grasp_affordance": grasp_affordance,
+            "persistence": persistence,
+            "support_stability": support_stability,
+            "reocclusion_penalty": reocclusion,
+            "reocclusion_worst": reocclusion_worst,
+            "disturbance_penalty": disturbance,
+            "access_quality": access_quality,
+            "access_floor": access_floor,
+            "persistence_floor": persistence_floor,
+            "support_floor": support_floor,
+            "task_progress": retrieve_progress,
+            "utility_structured": utility,
+        }
+
+
+class ResidualPlannerScorer(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        feature_dim = (config.action_dim * 2) + 11
+        self.trunk = nn.Sequential(
+            nn.LayerNorm(feature_dim),
+            nn.Linear(feature_dim, config.hidden_dim),
+            nn.GELU(),
+            nn.Linear(config.hidden_dim, config.hidden_dim),
+            nn.GELU(),
+        )
+        self.success_head = nn.Linear(config.hidden_dim, 1)
+        self.risk_head = nn.Linear(config.hidden_dim, 1)
+        self.residual_head = nn.Linear(config.hidden_dim, 1)
+
+    def forward(
+        self,
+        candidate_chunks: Tensor,
+        structured: dict[str, Tensor],
+        proposal_logits: Tensor | None = None,
+    ) -> dict[str, Tensor]:
+        candidate_mean = candidate_chunks.mean(dim=2)
+        candidate_terminal = candidate_chunks[:, :, -1]
+        components = torch.stack(
+            [
+                structured["belief_gain"],
+                structured["visibility_gain"],
+                structured["clearance"],
+                structured["occluder_contact_quality"],
+                structured["grasp_affordance"],
+                structured["persistence"],
+                structured["support_stability"],
+                structured["reocclusion_penalty"],
+                structured["disturbance_penalty"],
+                structured["access_quality"],
+                structured["task_progress"],
+            ],
+            dim=-1,
+        )
+        features = torch.cat([candidate_mean, candidate_terminal, components], dim=-1)
+        hidden = self.trunk(features)
+        success_logits = self.success_head(hidden).squeeze(-1)
+        risk_values = torch.sigmoid(self.risk_head(hidden)).squeeze(-1)
+        residual = self.residual_head(hidden).squeeze(-1)
+        if proposal_logits is not None and proposal_logits.shape == residual.shape:
+            residual = residual + 0.25 * proposal_logits.sigmoid()
+        return {
+            "planner_hidden": hidden,
+            "success_logits": success_logits,
+            "risk_values": risk_values,
+            "utility_residual": residual,
+        }
+
+
+class CascadePlanner(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        self.config = config
+        self.structured = StructuredElasticUtility(config)
+        self.residual = ResidualPlannerScorer(config)
+
+    def shortlist(
+        self,
+        proposal_logits: Tensor | None,
+        candidate_chunks: Tensor,
+        proposal_mode_assignments: Tensor | None = None,
+    ) -> Tensor:
+        batch_size, num_candidates = candidate_chunks.shape[:2]
+        top_k = min(max(1, self.config.top_k), num_candidates)
+        if proposal_logits is None:
+            cheap_scores = -candidate_chunks.square().mean(dim=(-1, -2))
+        else:
+            cheap_scores = proposal_logits
+        if proposal_mode_assignments is None:
+            return cheap_scores.topk(top_k, dim=-1).indices
+        if proposal_mode_assignments.ndim == 1:
+            proposal_mode_assignments = proposal_mode_assignments.unsqueeze(0).expand(batch_size, -1)
+
+        shortlisted = []
+        for batch_idx in range(batch_size):
+            scores = cheap_scores[batch_idx]
+            mode_ids = proposal_mode_assignments[batch_idx]
+            mode_best: list[tuple[float, int]] = []
+            for mode_id in torch.unique(mode_ids):
+                mode_indices = torch.nonzero(mode_ids == mode_id, as_tuple=False).squeeze(-1)
+                best_local = mode_indices[scores[mode_indices].argmax()]
+                mode_best.append((float(scores[best_local].detach()), int(best_local)))
+            mode_best.sort(key=lambda item: item[0], reverse=True)
+            chosen = [index for _, index in mode_best[:top_k]]
+            if len(chosen) < top_k:
+                for candidate_idx in scores.argsort(descending=True).tolist():
+                    if candidate_idx not in chosen:
+                        chosen.append(candidate_idx)
+                    if len(chosen) >= top_k:
+                        break
+            shortlisted.append(torch.as_tensor(chosen[:top_k], device=candidate_chunks.device, dtype=torch.long))
+        return torch.stack(shortlisted, dim=0)
+
+    def select_best(
+        self,
+        initial_state: dict[str, Tensor],
+        candidate_chunks: Tensor,
+        rollout_state: dict[str, Tensor],
+        proposal_logits: Tensor | None = None,
+        candidate_indices: Tensor | None = None,
+        proposal_mode_names: list[list[str]] | None = None,
+    ) -> dict[str, Tensor]:
+        structured = self.structured(
+            initial_state=initial_state,
+            rollout_state=rollout_state,
+            candidate_chunks=candidate_chunks,
+        )
+        residual = self.residual(
+            candidate_chunks=candidate_chunks,
+            structured=structured,
+            proposal_logits=proposal_logits,
+        )
+        utility_total = structured["utility_structured"] + self.config.residual_weight * residual["utility_residual"]
+        utility_total = utility_total + residual["success_logits"].sigmoid() - residual["risk_values"]
+        feasibility_penalty = torch.zeros_like(utility_total)
+        if proposal_mode_names is not None:
+            retrieve_like = torch.zeros_like(utility_total, dtype=torch.bool)
+            for batch_idx, names in enumerate(proposal_mode_names):
+                for candidate_idx, name in enumerate(names[: utility_total.shape[1]]):
+                    retrieve_like[batch_idx, candidate_idx] = any(
+                        token in name for token in ("retrieve", "insert_actor", "probe_inside")
+                    )
+            blocked = (
+                (structured["access_floor"] < 0.15)
+                | (structured["persistence_floor"] < 0.15)
+                | (structured["support_floor"] < 0.25)
+                | (structured["reocclusion_worst"] > 0.6)
+            )
+            feasibility_penalty = retrieve_like.to(dtype=utility_total.dtype) * blocked.to(dtype=utility_total.dtype) * 2.0
+            utility_total = utility_total - feasibility_penalty
+        best_local = utility_total.argmax(dim=-1)
+        batch_indices = torch.arange(candidate_chunks.shape[0], device=candidate_chunks.device)
+        if candidate_indices is None:
+            best_indices = best_local
+        else:
+            best_indices = candidate_indices[batch_indices, best_local]
+        return {
+            **structured,
+            **residual,
+            "utility_total": utility_total,
+            "utility_scores": utility_total,
+            "feasibility_penalty": feasibility_penalty,
+            "best_indices": best_indices,
+            "best_chunk": candidate_chunks[batch_indices, best_local],
+            "ranking_diagnostics": {
+                "topk_indices": candidate_indices if candidate_indices is not None else best_local.unsqueeze(-1),
+                "best_local_indices": best_local,
+            },
+        }
+
+
+def _summary_scalar(state: dict[str, Tensor], key: str, fallback_keys: tuple[str, ...] = ()) -> Tensor:
+    for candidate in (key, *fallback_keys):
+        value = state.get(candidate)
+        if value is None:
+            continue
+        if value.ndim >= 5:
+            return value.mean(dim=tuple(range(value.ndim - 2, value.ndim))).mean(dim=-1)
+        if value.ndim == 4:
+            return value.mean(dim=(-1, -2))
+        if value.ndim == 3:
+            return value
+        if value.ndim == 2:
+            return value
+        return value.unsqueeze(-1)
+    raise KeyError(f"Missing summary key {key} and fallbacks {fallback_keys}.")
+
+
+def _optional_summary_scalar(
+    state: dict[str, Tensor],
+    key: str,
+    *,
+    reference: Tensor,
+    fallback_keys: tuple[str, ...] = (),
+) -> Tensor:
+    try:
+        return _summary_scalar(state, key, fallback_keys)
+    except KeyError:
+        return torch.zeros_like(reference)
+
+
+class ElasticFeasibilityGate(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        self.config = config
+
+    def forward(
+        self,
+        *,
+        rollout_state: dict[str, Tensor],
+        proposal_mode_names: list[list[str]],
+    ) -> dict[str, Tensor | list[list[dict[str, float | bool | str]]]]:
+        access = _summary_scalar(rollout_state, "access_summary", ("access_quality",))
+        persistence = _summary_scalar(rollout_state, "persistence_summary", ("persistence", "persistence_horizon"))
+        support = _summary_scalar(rollout_state, "support_summary", ("support_stability",))
+        reocclusion = _summary_scalar(rollout_state, "reocclusion_summary", ("reocclusion_penalty",))
+        disturbance = _summary_scalar(rollout_state, "disturbance_summary", ("disturbance_penalty",))
+        access_floor = access.amin(dim=-1)
+        persistence_floor = persistence.amin(dim=-1)
+        support_floor = support.amin(dim=-1)
+        reocclusion_worst = reocclusion.amax(dim=-1)
+        disturbance_worst = disturbance.amax(dim=-1)
+
+        blocked = (
+            (access_floor < self.config.retrieve_access_threshold)
+            | (persistence_floor < self.config.retrieve_persistence_threshold)
+            | (support_floor < self.config.retrieve_support_threshold)
+            | (reocclusion_worst > self.config.retrieve_reocclusion_threshold)
+        )
+        penalties = blocked.to(dtype=access.dtype) * 2.0
+        allowed_mask = torch.ones_like(access_floor, dtype=torch.bool)
+        reject_diagnostics: list[list[dict[str, float | bool | str]]] = []
+        for batch_idx, names in enumerate(proposal_mode_names):
+            sample_records: list[dict[str, float | bool | str]] = []
+            for candidate_idx, name in enumerate(names[: access_floor.shape[1]]):
+                retrieve_like = any(token in name for token in ("retrieve", "insert_actor", "probe_inside"))
+                candidate_blocked = bool(retrieve_like and blocked[batch_idx, candidate_idx])
+                if candidate_blocked:
+                    allowed_mask[batch_idx, candidate_idx] = False
+                sample_records.append(
+                    {
+                        "mode_name": name,
+                        "retrieve_like": retrieve_like,
+                        "blocked": candidate_blocked,
+                        "access_floor": float(access_floor[batch_idx, candidate_idx].detach()),
+                        "persistence_floor": float(persistence_floor[batch_idx, candidate_idx].detach()),
+                        "support_floor": float(support_floor[batch_idx, candidate_idx].detach()),
+                        "reocclusion_worst": float(reocclusion_worst[batch_idx, candidate_idx].detach()),
+                        "disturbance_worst": float(disturbance_worst[batch_idx, candidate_idx].detach()),
+                    }
+                )
+            reject_diagnostics.append(sample_records)
+
+        confidence = torch.sigmoid(
+            2.0 * access.mean(dim=-1)
+            + 1.5 * persistence.mean(dim=-1)
+            + 1.5 * support.mean(dim=-1)
+            - 1.5 * reocclusion.mean(dim=-1)
+            - disturbance.mean(dim=-1)
+        )
+        return {
+            "allowed_mask": allowed_mask,
+            "penalties": penalties,
+            "blocked_mask": blocked,
+            "adapter_confidence": confidence,
+            "gate_access_floor": access_floor,
+            "gate_persistence_floor": persistence_floor,
+            "gate_support_floor": support_floor,
+            "gate_reocclusion_worst": reocclusion_worst,
+            "reject_diagnostics": reject_diagnostics,
+        }
+
+
+class ResidualActionReranker(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        feature_dim = (config.action_dim * 2) + 8
+        self.network = nn.Sequential(
+            nn.LayerNorm(feature_dim),
+            nn.Linear(feature_dim, config.hidden_dim),
+            nn.GELU(),
+            nn.Linear(config.hidden_dim, config.hidden_dim),
+            nn.GELU(),
+        )
+        self.score_head = nn.Linear(config.hidden_dim, 1)
+        self.success_head = nn.Linear(config.hidden_dim, 1)
+        self.risk_head = nn.Linear(config.hidden_dim, 1)
+
+    def forward(
+        self,
+        *,
+        candidate_chunks: Tensor,
+        rollout_state: dict[str, Tensor],
+        proposal_logits: Tensor | None,
+    ) -> dict[str, Tensor]:
+        candidate_mean = candidate_chunks.mean(dim=2)
+        candidate_terminal = candidate_chunks[:, :, -1]
+        visibility = _summary_scalar(rollout_state, "visibility_summary", ("visibility_gain",))
+        access = _summary_scalar(rollout_state, "access_summary", ("access_quality",))
+        persistence = _summary_scalar(rollout_state, "persistence_summary", ("persistence", "persistence_horizon"))
+        support = _summary_scalar(rollout_state, "support_summary", ("support_stability",))
+        reocclusion = _summary_scalar(rollout_state, "reocclusion_summary", ("reocclusion_penalty",))
+        disturbance = _summary_scalar(rollout_state, "disturbance_summary", ("disturbance_penalty",))
+        fold_preservation = _optional_summary_scalar(
+            rollout_state,
+            "fold_preservation_summary",
+            reference=visibility,
+            fallback_keys=("fold_preservation",),
+        )
+        lift_risk = _optional_summary_scalar(
+            rollout_state,
+            "lift_too_much_risk_summary",
+            reference=visibility,
+            fallback_keys=("lift_too_much_risk",),
+        )
+        features = torch.cat(
+            [
+                candidate_mean,
+                candidate_terminal,
+                visibility.mean(dim=-1, keepdim=True),
+                access.mean(dim=-1, keepdim=True),
+                persistence.mean(dim=-1, keepdim=True),
+                support.mean(dim=-1, keepdim=True),
+                reocclusion.mean(dim=-1, keepdim=True),
+                disturbance.mean(dim=-1, keepdim=True),
+                fold_preservation.mean(dim=-1, keepdim=True),
+                lift_risk.mean(dim=-1, keepdim=True),
+            ],
+            dim=-1,
+        )
+        hidden = self.network(features)
+        residual = self.score_head(hidden).squeeze(-1)
+        success = self.success_head(hidden).squeeze(-1)
+        risk = torch.sigmoid(self.risk_head(hidden).squeeze(-1))
+        if proposal_logits is not None and proposal_logits.shape == residual.shape:
+            residual = residual + 0.25 * proposal_logits.sigmoid()
+        return {
+            "residual_scores": residual,
+            "planner_success_logits": success,
+            "planner_risk_values": risk,
+        }
+
+
+class AdapterPlanner(nn.Module):
+    def __init__(self, config: PlannerConfig) -> None:
+        super().__init__()
+        self.config = config
+        self.gate = ElasticFeasibilityGate(config)
+        self.reranker = ResidualActionReranker(config)
+
+    def select_best(
+        self,
+        *,
+        candidate_chunks: Tensor,
+        rollout_state: dict[str, Tensor],
+        proposal_mode_names: list[list[str]],
+        proposal_logits: Tensor | None = None,
+        planning_mode: str = "adapter_active",
+    ) -> dict[str, Tensor | list[list[dict[str, float | bool | str]]]]:
+        batch_size = candidate_chunks.shape[0]
+        batch_indices = torch.arange(batch_size, device=candidate_chunks.device)
+        if planning_mode in {"identity", "trunk_only", "adapter_noop"}:
+            zero_scores = candidate_chunks.new_zeros((batch_size, candidate_chunks.shape[1]))
+            return {
+                "best_indices": torch.zeros(batch_size, dtype=torch.long, device=candidate_chunks.device),
+                "best_chunk": candidate_chunks[:, 0],
+                "utility_scores": zero_scores,
+                "utility_total": zero_scores,
+                "planner_success_logits": zero_scores,
+                "planner_risk_values": zero_scores,
+                "adapter_confidence": candidate_chunks.new_ones((batch_size, candidate_chunks.shape[1])),
+                "reject_diagnostics": [[] for _ in range(batch_size)],
+                "planning_mode": planning_mode,
+            }
+
+        gate_outputs = self.gate(rollout_state=rollout_state, proposal_mode_names=proposal_mode_names)
+        reranker = self.reranker(
+            candidate_chunks=candidate_chunks,
+            rollout_state=rollout_state,
+            proposal_logits=proposal_logits,
+        )
+        utility = reranker["residual_scores"] + reranker["planner_success_logits"].sigmoid() - reranker["planner_risk_values"]
+        visibility = _summary_scalar(rollout_state, "visibility_summary", ("visibility_gain",)).mean(dim=-1)
+        access = _summary_scalar(rollout_state, "access_summary", ("access_quality",)).mean(dim=-1)
+        persistence = _summary_scalar(rollout_state, "persistence_summary", ("persistence", "persistence_horizon")).mean(dim=-1)
+        support = _summary_scalar(rollout_state, "support_summary", ("support_stability",)).mean(dim=-1)
+        reocclusion = _summary_scalar(rollout_state, "reocclusion_summary", ("reocclusion_penalty",)).mean(dim=-1)
+        disturbance = _summary_scalar(rollout_state, "disturbance_summary", ("disturbance_penalty",)).mean(dim=-1)
+        fold_preservation = _optional_summary_scalar(
+            rollout_state,
+            "fold_preservation_summary",
+            reference=_summary_scalar(rollout_state, "access_summary", ("access_quality",)),
+            fallback_keys=("fold_preservation",),
+        ).mean(dim=-1)
+        mouth_aperture = _optional_summary_scalar(
+            rollout_state,
+            "mouth_aperture_summary",
+            reference=_summary_scalar(rollout_state, "access_summary", ("access_quality",)),
+            fallback_keys=("mouth_aperture",),
+        ).mean(dim=-1)
+        layer_separation = _optional_summary_scalar(
+            rollout_state,
+            "layer_separation_summary",
+            reference=_summary_scalar(rollout_state, "access_summary", ("access_quality",)),
+            fallback_keys=("layer_separation_quality",),
+        ).mean(dim=-1)
+        lift_risk = _optional_summary_scalar(
+            rollout_state,
+            "lift_too_much_risk_summary",
+            reference=_summary_scalar(rollout_state, "access_summary", ("access_quality",)),
+            fallback_keys=("lift_too_much_risk",),
+        ).mean(dim=-1)
+        mode_bias = utility.new_zeros(utility.shape)
+        stage_penalty = utility.new_zeros(utility.shape)
+        unresolved_reveal = (1.0 - visibility) + (1.0 - access)
+        stabilized_reveal = 0.5 * (access + persistence + support)
+        # Use optimistic scene readiness summaries for stage switching.
+        # Candidate-level safety is still enforced by the retrieve gate below, so
+        # we should not let one poor candidate keep the entire scene stuck in
+        # "reveal forever" mode when another candidate already makes retrieve feasible.
+        batch_visibility = visibility.amax(dim=1)
+        batch_access = access.amax(dim=1)
+        batch_persistence = persistence.amax(dim=1)
+        batch_support = support.amax(dim=1)
+        batch_reocclusion = reocclusion.amin(dim=1)
+        batch_disturbance = disturbance.amin(dim=1)
+        batch_fold = fold_preservation.amax(dim=1)
+        batch_mouth = mouth_aperture.amax(dim=1)
+        batch_layer = layer_separation.amax(dim=1)
+        batch_lift = lift_risk.amin(dim=1)
+        batch_reveal_readiness = torch.maximum(batch_visibility, batch_access)
+        for batch_idx, names in enumerate(proposal_mode_names):
+            is_bag = any(any(token in name for token in ("mouth", "rim", "probe_inside")) for name in names)
+            is_cloth = any(any(token in name for token in ("fold", "lift", "layer")) for name in names)
+            can_retrieve = (
+                batch_access[batch_idx] >= self.config.retrieve_stage_access_threshold
+                and batch_reveal_readiness[batch_idx] >= self.config.retrieve_stage_reveal_threshold
+                and batch_persistence[batch_idx] >= self.config.retrieve_stage_persistence_threshold
+                and batch_support[batch_idx] >= self.config.retrieve_stage_support_threshold
+                and batch_reocclusion[batch_idx] <= self.config.retrieve_reocclusion_threshold
+            )
+            if is_bag:
+                can_retrieve = bool(
+                    can_retrieve
+                    and batch_mouth[batch_idx] >= 0.30
+                    and batch_persistence[batch_idx] >= 0.55
+                )
+            elif is_cloth:
+                can_retrieve = bool(
+                    can_retrieve
+                    and batch_layer[batch_idx] >= 0.18
+                    and batch_fold[batch_idx] >= 0.60
+                    and batch_lift[batch_idx] <= 0.30
+                    and batch_support[batch_idx] >= 0.70
+                )
+            can_insert = (
+                batch_access[batch_idx] >= self.config.insert_stage_access_threshold
+                and batch_visibility[batch_idx] >= self.config.insert_stage_visibility_threshold
+                and batch_support[batch_idx] >= self.config.insert_stage_support_threshold
+                and batch_reocclusion[batch_idx] <= 0.65
+            )
+            maintain_ready = (
+                batch_access[batch_idx] >= self.config.occlusion_maintain_gap_min_access
+                and batch_visibility[batch_idx] >= self.config.occlusion_maintain_gap_min_visibility
+            )
+            if can_retrieve:
+                preferred_tokens = ("retrieve",)
+            elif can_insert:
+                preferred_tokens = ("probe_inside", "insert_actor") if is_bag else ("insert_actor",)
+            elif is_bag:
+                if batch_access[batch_idx] < 0.15 or batch_visibility[batch_idx] < 0.20:
+                    preferred_tokens = ("widen_mouth", "maintain_mouth")
+                else:
+                    preferred_tokens = ("maintain_mouth", "widen_mouth")
+            elif is_cloth:
+                if batch_access[batch_idx] < 0.15 or batch_visibility[batch_idx] < 0.20:
+                    preferred_tokens = ("lift_edge", "separate_layer")
+                elif batch_lift[batch_idx] > 0.15 or batch_disturbance[batch_idx] > 0.25:
+                    preferred_tokens = ("stabilize_fold", "maintain_lift")
+                else:
+                    preferred_tokens = ("maintain_lift", "stabilize_fold")
+            else:
+                if not maintain_ready:
+                    preferred_tokens = ("widen_gap", "pin_canopy", "sweep_left", "sweep_right")
+                elif batch_visibility[batch_idx] < 0.20 or batch_access[batch_idx] < 0.25:
+                    preferred_tokens = ("widen_gap", "pin_canopy")
+                elif batch_disturbance[batch_idx] > 0.25 or batch_reocclusion[batch_idx] > 0.40:
+                    preferred_tokens = ("maintain_gap", "pin_canopy")
+                else:
+                    preferred_tokens = ("pin_canopy", "widen_gap")
+            for candidate_idx, name in enumerate(names[: utility.shape[1]]):
+                if name == "base_action":
+                    continue
+                if any(token in name for token in ("retrieve",)):
+                    bonus = (
+                        0.85 * visibility[batch_idx, candidate_idx]
+                        + 0.85 * access[batch_idx, candidate_idx]
+                        + 0.65 * persistence[batch_idx, candidate_idx]
+                        + 0.50 * support[batch_idx, candidate_idx]
+                        - 0.60 * reocclusion[batch_idx, candidate_idx]
+                        - 0.25 * disturbance[batch_idx, candidate_idx]
+                    )
+                elif any(token in name for token in ("insert_actor", "probe_inside")):
+                    bonus = (
+                        0.70 * visibility[batch_idx, candidate_idx]
+                        + 0.70 * access[batch_idx, candidate_idx]
+                        + 0.35 * persistence[batch_idx, candidate_idx]
+                        - 0.35 * reocclusion[batch_idx, candidate_idx]
+                        - 0.15 * disturbance[batch_idx, candidate_idx]
+                    )
+                elif any(token in name for token in ("maintain", "stabilize", "pin_canopy")):
+                    bonus = (
+                        0.85 * stabilized_reveal[batch_idx, candidate_idx]
+                        + 0.25 * visibility[batch_idx, candidate_idx]
+                        - 0.20 * reocclusion[batch_idx, candidate_idx]
+                        - 0.10 * disturbance[batch_idx, candidate_idx]
+                    )
+                else:
+                    bonus = (
+                        0.95 * unresolved_reveal[batch_idx, candidate_idx]
+                        + 0.20 * (1.0 - persistence[batch_idx, candidate_idx])
+                        - 0.10 * disturbance[batch_idx, candidate_idx]
+                    )
+                if any(token in name for token in ("fold", "lift", "layer")):
+                    bonus = bonus + 0.35 * fold_preservation[batch_idx, candidate_idx] - 0.35 * lift_risk[batch_idx, candidate_idx]
+                if any(token in name for token in preferred_tokens):
+                    bonus = bonus + self.config.mode_preference_bonus
+                elif "retrieve" in name and not can_retrieve:
+                    bonus = bonus - self.config.premature_retrieve_penalty
+                    stage_penalty[batch_idx, candidate_idx] = (
+                        stage_penalty[batch_idx, candidate_idx] + self.config.premature_retrieve_penalty
+                    )
+                elif is_cloth and any(token in name for token in ("stabilize", "maintain")) and any(
+                    token in preferred_tokens for token in ("lift_edge", "separate_layer")
+                ):
+                    bonus = bonus - 1.0
+                    stage_penalty[batch_idx, candidate_idx] = stage_penalty[batch_idx, candidate_idx] + 1.0
+                elif (not is_bag and not is_cloth) and any(token in name for token in ("sweep_left", "sweep_right")) and any(
+                    token in preferred_tokens for token in ("pin_canopy", "widen_gap", "maintain_gap")
+                ):
+                    bonus = bonus - self.config.premature_occlusion_sweep_penalty
+                elif any(token in name for token in ("probe_inside", "insert_actor", "retrieve")) and not can_insert:
+                    bonus = bonus - self.config.premature_insert_penalty
+                    stage_penalty[batch_idx, candidate_idx] = (
+                        stage_penalty[batch_idx, candidate_idx] + self.config.premature_insert_penalty
+                    )
+                if (
+                    (not is_bag and not is_cloth)
+                    and "maintain_gap" in name
+                    and not maintain_ready
+                    and self.config.premature_maintain_penalty > 0.0
+                ):
+                    bonus = bonus - self.config.premature_maintain_penalty
+                    stage_penalty[batch_idx, candidate_idx] = (
+                        stage_penalty[batch_idx, candidate_idx] + self.config.premature_maintain_penalty
+                    )
+                if is_bag and (batch_mouth[batch_idx] < 0.18 or batch_access[batch_idx] < 0.15) and "widen_mouth" in name:
+                    stage_penalty[batch_idx, candidate_idx] = stage_penalty[batch_idx, candidate_idx] + 1.5
+                if is_cloth and (batch_layer[batch_idx] < 0.12 or batch_visibility[batch_idx] < 0.05) and any(
+                    token in name for token in ("lift_edge", "separate_layer")
+                ):
+                    stage_penalty[batch_idx, candidate_idx] = stage_penalty[batch_idx, candidate_idx] + 1.5
+                mode_bias[batch_idx, candidate_idx] = bonus
+        utility = utility + mode_bias
+        utility = utility + 0.5 * fold_preservation - 0.5 * lift_risk
+        utility = utility - stage_penalty
+        utility = utility - gate_outputs["penalties"]
+        allowed_mask = gate_outputs["allowed_mask"]
+        assert isinstance(allowed_mask, Tensor)
+        utility = utility.masked_fill(~allowed_mask, -1e6)
+        best_indices = utility.argmax(dim=-1)
+        best_chunk = candidate_chunks[batch_indices, best_indices]
+        return {
+            "best_indices": best_indices,
+            "best_chunk": best_chunk,
+            "utility_scores": utility,
+            "utility_total": utility,
+            "planner_success_logits": reranker["planner_success_logits"],
+            "planner_risk_values": reranker["planner_risk_values"],
+            "adapter_confidence": gate_outputs["adapter_confidence"],
+            "allowed_mask": gate_outputs["allowed_mask"],
+            "reject_diagnostics": gate_outputs["reject_diagnostics"],
+            "planning_mode": planning_mode,
+        }